diff --git a/0011-Bump-version-from-1.0.4-to-1.0.5.patch b/0001-Bump-kubeos-version-to-1.0.6.patch similarity index 59% rename from 0011-Bump-version-from-1.0.4-to-1.0.5.patch rename to 0001-Bump-kubeos-version-to-1.0.6.patch index aaebee05331b688383db4ff5426bd6adfe720452..eb3ccd744061acc1f04342dfae76680080d0de3c 100644 --- a/0011-Bump-version-from-1.0.4-to-1.0.5.patch +++ b/0001-Bump-kubeos-version-to-1.0.6.patch @@ -1,116 +1,134 @@ +From dbabd83278e84e21a4e3493150add216012ba230 Mon Sep 17 00:00:00 2001 +From: Yuhang Wei +Date: Mon, 17 Jun 2024 10:30:52 +0800 +Subject: [PATCH 1/2] Bump kubeos version to 1.0.6 + +Signed-off-by: Yuhang Wei +--- + KubeOS-Rust/Cargo.lock | 8 ++++---- + KubeOS-Rust/agent/Cargo.toml | 2 +- + KubeOS-Rust/cli/Cargo.toml | 2 +- + KubeOS-Rust/manager/Cargo.toml | 2 +- + KubeOS-Rust/proxy/Cargo.toml | 6 +++--- + VERSION | 2 +- + 6 files changed, 11 insertions(+), 11 deletions(-) + diff --git a/KubeOS-Rust/Cargo.lock b/KubeOS-Rust/Cargo.lock -index 2087339..c44c152 100644 +index 4e1619aa..93e3d07d 100644 --- a/KubeOS-Rust/Cargo.lock +++ b/KubeOS-Rust/Cargo.lock @@ -189,7 +189,7 @@ dependencies = [ [[package]] name = "cli" --version = "0.1.0" -+version = "1.0.5" +-version = "1.0.5" ++version = "1.0.6" dependencies = [ "anyhow", "jsonrpc", -@@ -1092,7 +1092,7 @@ dependencies = [ +@@ -1226,7 +1226,7 @@ dependencies = [ [[package]] name = "manager" --version = "0.1.0" -+version = "1.0.5" +-version = "1.0.5" ++version = "1.0.6" dependencies = [ "anyhow", "env_logger", -@@ -1335,7 +1335,7 @@ dependencies = [ +@@ -1438,7 +1438,7 @@ dependencies = [ [[package]] name = "os-agent" --version = "0.1.0" -+version = "1.0.5" +-version = "1.0.5" ++version = "1.0.6" dependencies = [ "anyhow", "env_logger", -@@ -1498,7 +1498,7 @@ dependencies = [ +@@ -1601,7 +1601,7 @@ dependencies = [ [[package]] name = "proxy" --version = "0.1.0" -+version = "1.0.5" +-version = "1.0.5" ++version = "1.0.6" dependencies = [ "anyhow", "assert-json-diff", diff --git a/KubeOS-Rust/agent/Cargo.toml b/KubeOS-Rust/agent/Cargo.toml -index 6db4df4..739bbbc 100644 +index 739bbbc7..83e1b7c0 100644 --- a/KubeOS-Rust/agent/Cargo.toml +++ b/KubeOS-Rust/agent/Cargo.toml @@ -3,7 +3,7 @@ description = "KubeOS os-agent" edition = "2021" license = "MulanPSL-2.0" name = "os-agent" --version = "0.1.0" -+version = "1.0.5" +-version = "1.0.5" ++version = "1.0.6" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] diff --git a/KubeOS-Rust/cli/Cargo.toml b/KubeOS-Rust/cli/Cargo.toml -index 1c46db3..c3c14c6 100644 +index c3c14c6f..78d5fd51 100644 --- a/KubeOS-Rust/cli/Cargo.toml +++ b/KubeOS-Rust/cli/Cargo.toml @@ -3,7 +3,7 @@ description = "KubeOS os-agent client" edition = "2021" license = "MulanPSL-2.0" name = "cli" --version = "0.1.0" -+version = "1.0.5" +-version = "1.0.5" ++version = "1.0.6" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] diff --git a/KubeOS-Rust/manager/Cargo.toml b/KubeOS-Rust/manager/Cargo.toml -index 9431fba..311a87c 100644 +index e694090c..f60a7c08 100644 --- a/KubeOS-Rust/manager/Cargo.toml +++ b/KubeOS-Rust/manager/Cargo.toml @@ -3,7 +3,7 @@ description = "KubeOS os-agent manager" edition = "2021" license = "MulanPSL-2.0" name = "manager" --version = "0.1.0" -+version = "1.0.5" +-version = "1.0.5" ++version = "1.0.6" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dev-dependencies] diff --git a/KubeOS-Rust/proxy/Cargo.toml b/KubeOS-Rust/proxy/Cargo.toml -index 72eb6b9..fe657af 100644 +index 3b5d96d1..d804ac77 100644 --- a/KubeOS-Rust/proxy/Cargo.toml +++ b/KubeOS-Rust/proxy/Cargo.toml @@ -3,7 +3,7 @@ description = "KubeOS os-proxy" edition = "2021" license = "MulanPSL-2.0" name = "proxy" --version = "0.1.0" -+version = "1.0.5" +-version = "1.0.5" ++version = "1.0.6" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [lib] -@@ -18,14 +18,14 @@ path = "src/main.rs" +@@ -17,14 +17,14 @@ path = "src/main.rs" + [dependencies] anyhow = "1.0.44" async-trait = "0.1" - chrono = { version = "0.4", default-features = false, features = ["std"] } --cli = { version = "0.1.0", path = "../cli" } -+cli = { version = "1.0.5", path = "../cli" } +-cli = { version = "1.0.5", path = "../cli" } ++cli = { version = "1.0.6", path = "../cli" } env_logger = "0.9.0" futures = "0.3.17" h2 = "=0.3.16" k8s-openapi = { version = "0.13.1", features = ["v1_22"] } kube = { version = "0.66.0", features = ["derive", "runtime"] } log = "=0.4.15" --manager = { version = "0.1.0", path = "../manager" } -+manager = { version = "1.0.5", path = "../manager" } +-manager = { version = "1.0.5", path = "../manager" } ++manager = { version = "1.0.6", path = "../manager" } regex = "=1.7.3" - reqwest = { version = "=0.11.18", default-features = false, features = [ + reqwest = { version = "=0.12.2", default-features = false, features = [ "json", diff --git a/VERSION b/VERSION -index ee90284..90a27f9 100644 +index 90a27f9c..af0b7ddb 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ --1.0.4 -+1.0.5 +-1.0.5 ++1.0.6 +-- +2.39.3 (Apple Git-146) + diff --git a/0001-build-rust-os-agent-remove-useless-dependency.patch b/0001-build-rust-os-agent-remove-useless-dependency.patch deleted file mode 100644 index c6270b09a1bb632570c12c0b63408dce3dccc1fd..0000000000000000000000000000000000000000 --- a/0001-build-rust-os-agent-remove-useless-dependency.patch +++ /dev/null @@ -1,56 +0,0 @@ -From 6e62adfa80c33d9b1fc4445487cc15e721db07bc Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Wed, 10 Jan 2024 15:53:26 +0800 -Subject: [PATCH] build(rust os-agent): remove useless dependency - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/Cargo.lock | 11 ----------- - KubeOS-Rust/manager/Cargo.toml | 2 +- - 2 files changed, 1 insertion(+), 12 deletions(-) - -diff --git a/KubeOS-Rust/Cargo.lock b/KubeOS-Rust/Cargo.lock -index 4b7fc12..2087339 100644 ---- a/KubeOS-Rust/Cargo.lock -+++ b/KubeOS-Rust/Cargo.lock -@@ -199,16 +199,6 @@ dependencies = [ - "serde_json", - ] - --[[package]] --name = "colored" --version = "2.1.0" --source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8" --dependencies = [ -- "lazy_static", -- "windows-sys", --] -- - [[package]] - name = "core-foundation" - version = "0.9.3" -@@ -1209,7 +1199,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" - checksum = "80f9fece9bd97ab74339fe19f4bcaf52b76dcc18e5364c7977c1838f76b38de9" - dependencies = [ - "assert-json-diff", -- "colored", - "httparse", - "lazy_static", - "log", -diff --git a/KubeOS-Rust/manager/Cargo.toml b/KubeOS-Rust/manager/Cargo.toml -index 40672cc..9431fba 100644 ---- a/KubeOS-Rust/manager/Cargo.toml -+++ b/KubeOS-Rust/manager/Cargo.toml -@@ -8,7 +8,7 @@ version = "0.1.0" - # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [dev-dependencies] - mockall = { version = "=0.11.3" } --mockito = { version = "0.31.1" } -+mockito = { version = "0.31.1", default-features = false } - predicates = { version = "=2.0.1" } - tempfile = { version = "3.6.0" } - --- -2.34.1 - diff --git a/0002-docs-Add-the-content-of-the-user-guide.patch b/0002-docs-Add-the-content-of-the-user-guide.patch deleted file mode 100644 index e057f37f2ab9611dc2bad34b6c4a694bea1e3632..0000000000000000000000000000000000000000 --- a/0002-docs-Add-the-content-of-the-user-guide.patch +++ /dev/null @@ -1,617 +0,0 @@ -From f34fe043179aec4bd2a9270fc25cef3f4377c152 Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Thu, 11 Jan 2024 20:25:05 +0800 -Subject: [PATCH 02/13] docs:Add the content of the user guide. - -Modify the format of the user guide, -add precautions, and add configuration information. - -Signed-off-by: liyuanr ---- - docs/quick-start.md | 399 +++++++++++++++++++++++++++----------------- - 1 file changed, 243 insertions(+), 156 deletions(-) - -diff --git a/docs/quick-start.md b/docs/quick-start.md -index 0d4dc4b..9656fb9 100644 ---- a/docs/quick-start.md -+++ b/docs/quick-start.md -@@ -1,18 +1,22 @@ - # 快速使用指导 - --## 编译及部署 -+[TOC] - --### 编译指导 -+## 编译指导 - - * 编译环境：openEuler Linux x86/AArch64 -+ - * 进行编译需要以下包： - * golang(大于等于1.15版本) - * make - * git -+ * rust(大于等于1.57版本) -+ * cargo(大于等于1.57版本) -+ * openssl-devel - - ``` shell -- sudo yum install golang make git -- ``` -+ sudo yum install golang make git rust cargo openssl-devel -+ ``` - - * 使用git获取本项目的源码 - -@@ -27,76 +31,101 @@ - - ```shell - cd KubeOS -- sudo make -- ``` -- -- * proxy及operator容器镜像构建 -- * proxy及operator容器镜像构建使用docker，请先确保docker已经安装和配置完毕 -- * 请用户自行编写Dockerfile来构建镜像，请注意 -- * operator和proxy需要基于baseimage进行构建，用户保证baseimage的安全性 -- * 需将operator和proxy拷贝到baseimage上 -- * 请确保proxy属主和属组为root，文件权限为500 -- * 请确保operator属主和属组为在容器内运行operator的用户，文件权限为500 -- * operator和proxy的在容器内的位置和容器启动时运行的命令需与部署operator的yaml中指定的字段相对应 -- * 首先指定镜像仓库地址、镜像名及版本，Dockerfile路径，然后构建并推送镜像到镜像仓库 -- * Dockerfile参考如下, Dockerfile也可以使用多阶段构建: -- -- ``` dockerfile -- FROM your_baseimage -- COPY ./bin/proxy /proxy -- ENTRYPOINT ["/proxy"] -- FROM your_baseimage -- COPY --chown=6552:6552 ./bin/operator /operator -- ENTRYPOINT ["/operator"] -- ``` -+ sudo make -+ # 编译生成的二进制在bin目录下，查看二进制 -+ tree bin -+ bin -+ ├── operator -+ ├── os-agent -+ ├── proxy -+ ├── rust -+ │   ├── ... -+ │   └── release -+ │   ├── ... -+ │   ├── os-agent -+ │   └── proxy -+ ``` - -- ```shell -- # 指定proxy的镜像仓库，镜像名及版本 -- export IMG_PROXY=your_imageRepository/proxy_imageName:version -- # 指定proxy的Dockerfile地址 -- export DOCKERFILE_PROXY=your_dockerfile_proxy -- # 指定operator的镜像仓库，镜像名及版本 -- export IMG_OPERATOR=your_imageRepository/operator_imageName:version -- # 指定operator的Dockerfile路径 -- export DOCKERFILE_OPERATOR=your_dockerfile_operator -- -- # 镜像构建 -- docker build -t ${IMG_OPERATOR} -f ${DOCKERFILE_OPERATOR} . -- docker build -t ${IMG_PROXY} -f ${DOCKERFILE_PROXY} . -- # 推送镜像到镜像仓库 -- docker push ${IMG_OPERATOR} -- docker push ${IMG_PROXY} -- ``` -+ * ```bin/proxy```、```bin/os-agent```为go语言编写的proxy和os-agent，```bin/rust/release/proxy```、```bin/rust/release/os-agent```为rust语言编写的proxy和os-agent，二者功能一致。 -+ -+## 镜像构建指导 -+ -+### proxy及operator镜像构建指导 -+ -+* proxy及operator容器镜像构建使用docker，请先确保docker已经安装和配置完毕 -+ -+* 请用户自行编写Dockerfile来构建镜像，请注意 -+ * operator和proxy需要基于baseimage进行构建，用户保证baseimage的安全性 -+ * 需将operator和proxy拷贝到baseimage上 -+ * 请确保proxy属主和属组为root，文件权限为500 -+ * 请确保operator属主和属组为在容器内运行operator的用户，文件权限为500 -+ * operator和proxy的在容器内的位置和容器启动时运行的命令需与部署operator的yaml中指定的字段相对应 -+ -+* 首先指定镜像仓库地址、镜像名及版本，Dockerfile路径，然后构建并推送镜像到镜像仓库 -+ -+* Dockerfile参考如下, Dockerfile也可以使用多阶段构建: -+ -+ ``` dockerfile -+ FROM your_baseimage -+ COPY ./bin/proxy /proxy -+ ENTRYPOINT ["/proxy"] -+ FROM your_baseimage -+ COPY --chown=6552:6552 ./bin/operator /operator -+ ENTRYPOINT ["/operator"] -+ ``` - --* OS虚拟机镜像制作 -- * 制作注意事项 -- * 请确保已安装qemu-img，bc，parted，tar，yum，docker -- * 容器OS镜像制作需要使用root权限 -- * 容器OS 镜像制作工具的 rpm 包源为 openEuler 具体版本的 everything 仓库和 EPOL 仓库。制作镜像时提供的 repo 文件中，yum 源建议同时配置 openEuler 具体版本的 everything 仓库和 EPOL 仓库 -- * 容器OS镜像制作之前需要先将当前机器上的selinux关闭或者设为允许模式 -- * 使用默认rpmlist进行容器OS镜像制作出来的镜像默认和制作工具保存在相同路径，该分区至少有25G的剩余空间 -- * 容器镜像制作时不支持用户自定义配置挂载文件 -- * 容器OS镜像制作工具执行异常中断，可能会残留文件、目录或挂载，需用户手动清理，对于可能残留的rootfs目录，该目录虽然权限为555，但容器OS镜像制作在开发环境进行，不会对生产环境产生影响。 -- * 请确保os-agent属主和属组为root，建议os-agent文件权限为500 -- * 容器OS虚拟机镜像制作 -- 进入scripts目录，执行脚本 -- -- ```shell -- cd scripts -- bash kbimg.sh create vm-image -p xxx.repo -v v1 -b ../bin/os-agent -e '''$1$xyz$RdLyKTL32WEvK3lg8CXID0''' -- ``` -- -- * 其中 xx.repo 为制作镜像所需要的 yum 源，yum 源建议配置为 openEuler 具体版本的 everything 仓库和 EPOL 仓库。 -- * 容器 OS 镜像制作完成后，会在 scripts 目录下生成： -- * raw格式的系统镜像system.img，system.img大小默认为20G，支持的根文件系统分区大小<2020MiB，持久化分区<16GB。 -- * qcow2 格式的系统镜像 system.qcow2。 -- * 可用于升级的根文件系统分区镜像 update.img 。 -- * 制作出来的容器 OS 虚拟机镜像目前只能用于 CPU 架构为 x86 和 AArch64 的虚拟机场景，x86 架构的虚拟机使用 legacy 启动模式启动需制作镜像时指定-l参数 -- * 容器OS运行底噪<150M (不包含k8s组件及相关依赖kubernetes-kubeadm，kubernetes-kubelet， containernetworking-plugins，socat，conntrack-tools，ebtables，ethtool) -- * 本项目不提供容器OS镜像，仅提供裁剪工具，裁剪出来的容器OS内部的安全性由OS发行商保证。 -- * 声明： os-agent使用本地unix socket进行通信，因此不会新增端口。下载镜像的时候会新增一个客户端的随机端口，1024~65535使用完后关闭。proxy和operator与api-server通信时作为客户端也会有一个随机端口，基于kubernetes的operator框架，必须使用端口。他们部署在容器里。 -- --### 部署指导 -+ ```shell -+ # 指定proxy的镜像仓库，镜像名及版本 -+ export IMG_PROXY=your_imageRepository/proxy_imageName:version -+ # 指定proxy的Dockerfile地址 -+ export DOCKERFILE_PROXY=your_dockerfile_proxy -+ # 指定operator的镜像仓库，镜像名及版本 -+ export IMG_OPERATOR=your_imageRepository/operator_imageName:version -+ # 指定operator的Dockerfile路径 -+ export DOCKERFILE_OPERATOR=your_dockerfile_operator -+ -+ # 镜像构建 -+ docker build -t ${IMG_OPERATOR} -f ${DOCKERFILE_OPERATOR} . -+ docker build -t ${IMG_PROXY} -f ${DOCKERFILE_PROXY} . -+ # 推送镜像到镜像仓库 -+ docker push ${IMG_OPERATOR} -+ docker push ${IMG_PROXY} -+ ``` -+ -+### KubeOS虚拟机镜像制作指导 -+ -+* 制作注意事项 -+ * 请确保已安装qemu-img，bc，parted，tar，yum，docker -+ * 容器OS镜像制作需要使用root权限 -+ * 容器OS 镜像制作工具的 rpm 包源为 openEuler 具体版本的 everything 仓库和 EPOL 仓库。制作镜像时提供的 repo 文件中，yum 源建议同时配置 openEuler 具体版本的 everything 仓库和 EPOL 仓库 -+ * 容器OS镜像制作之前需要先将当前机器上的selinux关闭或者设为允许模式 -+ * 使用默认rpmlist进行容器OS镜像制作出来的镜像默认和制作工具保存在相同路径，该分区至少有25G的剩余空间 -+ * 容器镜像制作时不支持用户自定义配置挂载文件 -+ * 容器OS镜像制作工具执行异常中断，可能会残留文件、目录或挂载，需用户手动清理，对于可能残留的rootfs目录，该目录虽然权限为555，但容器OS镜像制作在开发环境进行，不会对生产环境产生影响。 -+ * 请确保os-agent属主和属组为root，建议os-agent文件权限为500 -+ -+* 容器OS虚拟机镜像制作 -+ 进入scripts目录，执行脚本 -+ -+ ```shell -+ cd scripts -+ bash kbimg.sh create vm-image -p xxx.repo -v v1 -b ../bin/os-agent -e '''$1$xyz$RdLyKTL32WEvK3lg8CXID0''' -+ ``` -+ -+ * 其中 xx.repo 为制作镜像所需要的 yum 源，yum 源建议配置为 openEuler 具体版本的 everything 仓库和 EPOL 仓库。 -+ * 容器 OS 镜像制作完成后，会在 scripts 目录下生成： -+ * raw格式的系统镜像system.img，system.img大小默认为20G，支持的根文件系统分区大小<2020MiB，持久化分区<16GB。 -+ * qcow2 格式的系统镜像 system.qcow2。 -+ * 可用于升级的根文件系统分区镜像 update.img 。 -+ * 制作出来的容器 OS 虚拟机镜像目前只能用于 CPU 架构为 x86 和 AArch64 的虚拟机场景，x86 架构的虚拟机使用 legacy 启动模式启动需制作镜像时指定-l参数 -+ * 容器OS运行底噪<150M (不包含k8s组件及相关依赖kubernetes-kubeadm，kubernetes-kubelet， containernetworking-plugins，socat，conntrack-tools，ebtables，ethtool) -+ * 本项目不提供容器OS镜像，仅提供裁剪工具，裁剪出来的容器OS内部的安全性由OS发行商保证。 -+ -+* 声明： os-agent使用本地unix socket进行通信，因此不会新增端口。下载镜像的时候会新增一个客户端的随机端口，1024~65535使用完后关闭。proxy和operator与api-server通信时作为客户端也会有一个随机端口，基于kubernetes的operator框架，必须使用端口。他们部署在容器里。 -+ -+## 部署指导 -+ -+### os-operator和os-proxy部署指导 - - * 环境要求 - * openEuler Linux x86/AArch64系统 -@@ -142,18 +171,35 @@ - kubectl get pods -A - ``` - --### 使用指导 -+## 使用指导 - - #### 注意事项 - --* 容器OS升级为所有软件包原子升级，默认不在容器OS内提供单包升级能力。 --* 容器OS升级为双区升级的方式，不支持更多分区数量。 --* 单节点的升级过程的日志可在节点的/var/log/message文件查看。 --* 请严格按照提供的升级和回退流程进行操作，异常调用顺序可能会导致系统无法升级或回退。 --* 使用docker镜像升级和mtls双向认证仅支持 openEuler 22.09 及之后的版本 --* 不支持跨大版本升级 -- --#### 参数说明 -+* 公共注意事项 -+ * 仅支持虚拟机x86和arm64 UEFI场景。 -+ * 当前不支持集群节点OS多版本管理，即集群中OS的CR只能为一个。 -+ * 使用kubectl apply通过YAML创建或更新OS的CR时，不建议并发apply，当并发请求过多时，kube-apiserver会无法处理请求导致失败。 -+ * 如用户配置了容器镜像仓的证书或密钥，请用户保证证书或密钥文件的权限最小。 -+* 升级注意事项 -+ * 升级为所有软件包原子升级，默认不提供单包升级能力。 -+ * 升级为双区升级的方式，不支持更多分区数量。 -+ * 当前暂不支持跨大版本升级。 -+ * 单节点的升级过程的日志可在节点的 /var/log/messages 文件查看。 -+ * 请严格按照提供的升级和回退流程进行操作，异常调用顺序可能会导致系统无法升级或回退。 -+ * 节点上containerd如需配置ctr使用的私有镜像，请将配置文件host.toml按照ctr指导放在/etc/containerd/certs.d目录下。 -+ -+* 配置注意事项 -+ * 用户自行指定配置内容，用户需保证配置内容安全可靠 ，尤其是持久化配置（kernel.sysctl.persist、grub.cmdline.current、grub.cmdline.next），KubeOS不对参数有效性进行检验。 -+ * opstype=config时，若osversion与当前集群节点的OS版本不一致，配置不会进行。 -+ * 当前仅支持kernel参数临时配置（kernel.sysctl）、持久化配置（kernel.sysctl.persist）和grub cmdline配置（grub.cmdline.current和grub.cmdline.next）。 -+ * 持久化配置会写入persist持久化分区，升级重启后配置保留；kernel参数临时配置重启后不保留。 -+ * 配置grub.cmdline.current或grub.cmdline.next时，如为单个参数（非key=value格式参数），请指定key为该参数，value为空。 -+ * 进行配置删除（operation=delete）时，key=value形式的配置需保证key、value和实际配置一致。 -+ * 配置不支持回退，如需回退，请修改配置版本和配置内容，重新下发配置。 -+ * 配置出现错误，节点状态陷入config时，请将配置版本恢复成上一版本并重新下发配置，从而使节点恢复至idel状态。 但是请注意：出现错误前已经配置完成的参数无法恢复。 -+ * 在配置grub.cmdline.current或grub.cmdline.next时，若需要将已存在的“key=value”格式的参数更新为只有key无value格式，比如将“rd.info=0”更新成rd.info，需要先删除“key=value”，然后在下一次配置时，添加key。不支持直接更新或者更新删除动作在同一次完成。 -+ -+#### OS CR参数说明 - - 在集群中创建类别为OS的定制对象，设置相应字段。类别OS来自于安装和部署章节创建的CRD对象，字段及说明如下： - -@@ -163,21 +209,21 @@ - - | 参数 |参数类型 | 参数说明 | 使用说明 | 是否必选 | - | -------------- | ------ | ------------------------------------------------------------ | ----- | ---------------- | -- | imagetype | string | 使用的升级镜像的类型 | 需为 docker ，containerd ，或者是 disk，其他值无效，且该参数仅在升级场景有效。
**注意**：若使用containerd，agent优先使用crictl工具拉取镜像，没有crictl时才会使用ctr命令拉取镜像。使用ctr拉取镜像时，镜像如果在私有仓内，需按照[官方文档](https://github.com/containerd/containerd/blob/main/docs/hosts.md)在/etc/containerd/certs.d目录下配置私有仓主机信息，才能成功拉取镜像。|是 | -- | opstype | string | 进行的操作，升级,回退或者配置 | 需为 upgrade ，config 或者 rollback ，其他值无效 |是 | -- | osversion | string | 用于升级或回退的镜像的OS版本 | 需为 KubeOS version , 例如: KubeOS 1.0.0|是 | -- | maxunavailable | int | 同时进行升级或回退的节点数 | maxunavailable值设置为大于实际集群的节点数时也可正常部署，升级或回退时会按照集群内实际节点数进行|是 | -- | containerimage | string | 用于升级的容器镜像 | 需要为容器镜像格式：[REPOSITORY/NAME[:TAG@DIGEST]](https://docs.docker.com/engine/reference/commandline/tag/#extended-description)，仅在使用容器镜像升级场景下有效|是 | -- | imageurl | string | 用于升级的磁盘镜像的地址 | imageurl中包含协议，只支持http或https协议，例如： 仅在使用磁盘镜像升级场景下有效|是 | -+ | imagetype | string | 升级镜像的类型 | 仅支持docker ，containerd ，或者是 disk，仅在升级场景有效。
**注意**：若使用containerd，agent优先使用crictl工具拉取镜像，没有crictl时才会使用ctr命令拉取镜像。使用ctr拉取镜像时，镜像如果在私有仓内，需按照[官方文档](https://github.com/containerd/containerd/blob/main/docs/hosts.md)在/etc/containerd/certs.d目录下配置私有仓主机信息，才能成功拉取镜像。 |是 | -+ | opstype | string | 操作类型：升级,回退或者配置 | 仅支持upgrade ，config 或者 rollback |是 | -+ | osversion | string | 升级/回退的目标版本 | osversion需与节点的目标os版本对应（节点上/etc/os-release中PRETTY_NAME字段或k8s检查到的节点os版本） 例如：KubeOS 1.0.0。 |是 | -+ | maxunavailable | int | 每批同时进行升级/回退/配置的节点数。 | maxunavailable值大于实际节点数时，取实际节点数进行升级/回退/配置。 |是 | -+ | containerimage | string | 用于升级的容器镜像 | 仅在imagetype是容器类型时生效，仅支持以下3种格式的容器镜像地址： repository/name repository/name@sha256:xxxx repository/name:tag |是 | -+ | imageurl | string | 用于升级的磁盘镜像的地址 | imageurl中包含协议，只支持http或https协议，例如： ，仅在使用磁盘镜像升级场景下有效 |是 | - | checksum | string | 用于升级的磁盘镜像校验的checksum(SHA-256)值或者是用于升级的容器镜像的digests值 | 仅在升级场景下有效 |是 | - | flagSafe | bool | 当imageurl的地址使用http协议表示是否是安全的 | 需为 true 或者 false ，仅在imageurl使用http协议时有效 |是 | - | mtls | bool | 用于表示与imageurl连接是否采用https双向认证 | 需为 true 或者 false ，仅在imageurl使用https协议时有效|是 | - | cacert | string | https或者https双向认证时使用的根证书文件 | 仅在imageurl使用https协议时有效| imageurl使用https协议时必选 | - | clientcert | string | https双向认证时使用的客户端证书文件 | 仅在使用https双向认证时有效|mtls为true时必选 | - | clientkey | string | https双向认证时使用的客户端公钥 | 仅在使用https双向认证时有效|mtls为true时必选 | -- | evictpodforce | bool | 用于表示升级/回退时是否强制驱逐pod | 需为 true 或者 false ，仅在升级或者回退时有效| 必选 | -- | sysconfigs | / | 需要进行配置的参数值 | 在配置或者升级或者回退机器时有效，在升级或者回退操作之后即机器重启之后起效，详细字段说明请见```配置（Settings）指导```| 可选 | -- | upgradeconfigs | / | 需要升级前进行的配置的参数值 | 在升级或者回退时有效，在升级或者回退操作之前起效，详细字段说明请见```配置（Settings）指导```| 可选 | -+ | evictpodforce | bool | 升级/回退时是否强制驱逐pod | 需为 true 或者 false ，仅在升级或者回退时有效| 必选 | -+ | sysconfigs | / | 配置设置 | 1. “opstype=config”时只进行配置。 2.“opstype=upgrade/rollback”时，代表升级/回退后配置，即在升级/回退重启后进行配置。```配置（Settings）指导``` | “opstype=config”时必选 | -+ | upgradeconfigs | / | 升级前配置设置 | 在升级或者回退时有效，在升级或者回退操作之前起效，详细字段说明请见```配置（Settings）指导```| 可选 | - - #### 升级指导 - -@@ -271,13 +317,13 @@ - sysconfigs: - version: edit.os.version - configs: -- - model: kernel.systcl -+ - model: kernel.sysctl - contents: - - key: kernel param key1 - value: kernel param value1 - - key: kernel param key2 - value: kernel param value2 -- - model: kernel.systcl.persist -+ - model: kernel.sysctl.persist - configpath: persist file path - contents: - - key: kernel param key3 -@@ -287,7 +333,7 @@ - upgradeconfigs: - version: 1.0.0 - configs: -- - model: kernel.systcl -+ - model: kernel.sysctl - contents: - - key: kernel param key4 - value: kernel param value4 -@@ -311,12 +357,13 @@ - kubectl get nodes -o custom-columns='NAME:.metadata.name,OS:.status.nodeInfo.osImage' - ``` - --* 如果后续需要再次升级，与上面相同对 upgrade_v1alpha1_os.yaml 的 imageurl, osversion, checksum, maxunavailable, flagSafe 或者containerimage字段进行相应修改。 -+* 如果后续需要再次升级，与上面相同，对upgrade_v1alpha1_os.yaml的相应字段进行修改 - - #### 配置（Settings）指导 - - * Settings参数说明: -- 以进行配置时的示例yaml为例对配置的参数进行说明，示例yaml如下： -+ -+ 基于示例YAML对配置的参数进行说明，示例YAML如下，配置的格式（缩进）需和示例保持一致： - - ```yaml - apiVersion: upgrade.openeuler.org/v1alpha1 -@@ -330,72 +377,97 @@ - maxunavailable: edit.node.config.number - containerimage: "" - evictpodforce: false -- imageurl: "" - checksum: "" -- flagSafe: false -- mtls: false - sysconfigs: -- version: 1.0.0 -+ version: edit.sysconfigs.version - configs: -- - model: kernel.systcl -- contents: -+ - model: kernel.sysctl -+ contents: - - key: kernel param key1 - value: kernel param value1 - - key: kernel param key2 - value: kernel param value2 - operation: delete -- - model: kernel.systcl.persist -+ - model: kernel.sysctl.persist - configpath: persist file path - contents: - - key: kernel param key3 -- value: kernel param value3 -+ value: kernel param value3 -+ - model: grub.cmdline.current -+ contents: -+ - key: boot param key1 -+ - key: boot param key2 -+ value: boot param value2 -+ - key: boot param key3 -+ value: boot param value3 -+ operation: delete -+ - model: grub.cmdline.next -+ contents: -+ - key: boot param key4 -+ - key: boot param key5 -+ value: boot param value5 -+ - key: boot param key6 -+ value: boot param value6 -+ operation: delete - ``` - -- * 配置的参数说明如下： -- * version: 配置的版本,通过版本差异触发配置，请修改配置后更新 version -- * configs: 具体配置内容 -- * model: 进行的配置的类型，支持的配置类型请看[Settings 列表](#setting-列表) -- * configpath: 如为持久化配置，配置文件路径 -- * contents: 配置参数的 key / value 和对参数的操作。 -- * key / value: 请看[Settings 列表](#setting-列表)对支持的配置的 key / value的说明。 -- * operation: 若不指定operation，则默认为添加或更新。若指定为delete，代表删除目前OS中已配置的参数。 -- **注意：** 当operation为delete时，yaml中的key/value必须和OS上想删除参数的key/value**一致**，否则删除失败。 -- * upgradeconfigs与sysconfig参数相同，upgradeconfig为升级前进行的配置，仅在升级/回滚场景起效，在升级/回滚操作执行前进行配置，只进行配置或者需要升级/回滚重启后执行配置，使用sysconfigs -+ 配置的参数说明如下： -+ -+ | 参数 | 参数类型 | 参数说明 | 使用说明 | 配置中是否必选 | -+ | ---------- | -------- | --------------------------- | ------------------------------------------------------------ | ----------------------- | -+ | version | string | 配置的版本 | 通过version是否相等来判断配置是否触发，version为空（为""或者没有值）时同样进行判断，所以不配置sysconfigs/upgradeconfigs时，继存的version值会被清空并触发配置。 | 是 | -+ | configs | / | 具体配置内容 | 包含具体配置项列表。 | 是 | -+ | model | string | 配置的类型 | 支持的配置类型请看附录下的```Settings列表``` | 是 | -+ | configpath | string | 配置文件路径 | 仅在kernel.sysctl.persist配置类型中生效，请看附录下的```Settings列表```对配置文件路径的说明。 | 否 | -+ | contents | / | 具体key/value的值及操作类型 | 包含具体配置参数列表。 | 是 | -+ | key | string | 参数名称 | key不能为空，不能包含"="，不建议配置含空格、tab键的字符串，具体请看附录下的```Settings列表```中每种配置类型对key的说明。 | 是 | -+ | value | string | 参数值 | key=value形式的参数中，value不能为空，不建议配置含空格、tab键的字符串，具体请看附录下的```Settings列表```中对每种配置类型对value的说明。 | key=value形式的参数必选 | -+ | operation | string | 对参数进行的操作 | 仅对kernel.sysctl.persist、grub.cmdline.current、grub.cmdline.next类型的参数生效。默认为添加或更新。仅支持配置为delete，代表删除已存在的参数（key=value需完全一致才能删除）。 | 否 | -+ -+ -+ -+ * upgradeconfigs与sysconfigs参数相同，upgradeconfigs为升级/回退前进行的配置，仅在upgrade/rollback场景起效，sysconfigs既支持只进行配置，也支持在升级/回退重启后进行配置 -+ - * 使用说明 -+ - * 编写YAML文件，在集群中部署 OS 的cr实例，用于部署cr实例的YAML示例如上，假定将上面的YAML保存到upgrade_v1alpha1_os.yaml -+ - * 查看配置之前的节点的配置的版本和节点状态（NODESTATUS状态为idle） - - ```shell -- kubectl get osinstances -o custom-columns='NAME:.metadata.name,NODESTATUS:.spec.nodestatus,SYSCONFIG:status.sysconfigs.version,UPGRADESYSCONFIG:status.upgradesysconfigs.version' -+ kubectl get osinstances -o custom-columns='NAME:.metadata.name,NODESTATUS:.spec.nodestatus,SYSCONFIG:status.sysconfigs.version,UPGRADECONFIG:status.upgradeconfigs.version' - ``` - - * 执行命令，在集群中部署cr实例后，节点会根据配置的参数信息进行配置，再次查看节点状态(NODESTATUS变成config) - - ```shell - kubectl apply -f upgrade_v1alpha1_os.yaml -- kubectl get osinstances -o custom-columns='NAME:.metadata.name,NODESTATUS:.spec.nodestatus,SYSCONFIG:status.sysconfigs.version,UPGRADESYSCONFIG:status.upgradesysconfigs.version' -+ kubectl get osinstances -o custom-columns='NAME:.metadata.name,NODESTATUS:.spec.nodestatus,SYSCONFIG:status.sysconfigs.version,UPGRADECONFIG:status.upgradeconfigs.version' - ``` - - * 再次查看节点的配置的版本确认节点是否配置完成(NODESTATUS恢复为idle) - - ```shell -- kubectl get osinstances -o custom-columns='NAME:.metadata.name,NODESTATUS:.spec.nodestatus,SYSCONFIG:status.sysconfigs.version,UPGRADESYSCONFIG:status.upgradesysconfigs.version' -+ kubectl get osinstances -o custom-columns='NAME:.metadata.name,NODESTATUS:.spec.nodestatus,SYSCONFIG:status.sysconfigs.version,UPGRADECONFIG:status.upgradeconfigs.version' - ``` - --* 如果后续需要再次升级，与上面相同对 upgrade_v1alpha1_os.yaml 的相应字段进行相应修改。 -+* 如果后续需要再次配置，与上面相同对 upgrade_v1alpha1_os.yaml 的相应字段进行相应修改。 - - #### 回退指导 - - * 回退场景 -- * 虚拟机无法正常启动时，需要退回到上一可以启动的版本时进行回退操作，仅支持手动回退容器 OS 。 -- * 虚拟机能够正常启动并且进入系统，需要将当前版本退回到老版本时进行回退操作，支持工具回退（类似升级方式）和手动回退，建议使用工具回退。 -- * 配置出现错误，节点状态陷入config时，可以回退至上一个配置版本以恢复节点至idle状态。 -- **注意**：在配置新版本时，出现错误前已经配置的参数无法回退。 -+ * 虚拟机无法正常启动时，可在grub启动项页面手动切换启动项，使系统回退至上一版本（即手动回退）。 -+ * 虚拟机能够正常启动并且进入系统时，支持工具回退和手动回退，建议使用工具回退。 -+ * 工具回退有两种方式： -+ 1. rollback模式直接回退至上一版本。 -+ 2. upgrade模式重新升级至上一版本 - * 手动回退指导 -- * 手动重启虚拟机，选择第二启动项进行回退，手动回退仅支持回退到本次升级之前的版本。 -+ -+ * 手动重启虚拟机，进入启动项页面后，选择第二启动项进行回退，手动回退仅支持回退到上一个版本。 - * 工具回退指导 - * 回退至任意版本 -- * 修改 OS 的cr实例的YAML 配置文件（例如 upgrade_v1alpha1_os.yaml），设置相应字段为期望回退的老版本镜像信息。类别OS来自于安装和部署章节创建的CRD对象，字段说明及示例请见上一节升级指导。 -+ * 修改 OS 的cr实例的YAML 配置文件（例如 upgrade_v1alpha1_os.yaml），设置相应字段为期望回退的老版本镜像信息。类别OS来自于安装和部署章节创建的CRD对象，字段说明及示例请见上一节升级指导。 -+ - * YAML修改完成后执行更新命令，在集群中更新定制对象后，节点会根据配置的字段信息进行回退 - - ```shell -@@ -444,13 +516,13 @@ - sysconfigs: - version: previous config version - configs: -- - model: kernel.systcl -+ - model: kernel.sysctl - contents: - - key: kernel param key1 - value: kernel param value1 - - key: kernel param key2 - value: kernel param value2 -- - model: kernel.systcl.persist -+ - model: kernel.sysctl.persist - configpath: persist file path - contents: - - key: kernel param key3 -@@ -467,23 +539,21 @@ - * 查看节点容器 OS 版本(回退OS版本)或节点config版本&节点状态为idle(回退config版本)，确认回退是否成功。 - - ```shell -- kubectl get nodes -o custom-columns='NAME:.metadata.name,OS:.status.nodeInfo.osImage' -- -- kubectl get osinstances -o custom-columns='NAME:.metadata.name,NODESTATUS:.spec.nodestatus,SYSCONFIG:status.sysconfigs.version,UPGRADESYSCONFIG:status.upgradesysconfigs.version' -+ kubectl get osinstances -o custom-columns='NAME:.metadata.name,NODESTATUS:.spec.nodestatus,SYSCONFIG:status.sysconfigs.version,UPGRADECONFIG:status.upgradeconfigs.version' - ``` - --#### Admin容器 -+## Admin容器镜像制作、部署和使用 - - KubeOS提供一个分离的包含sshd服务和hostshell工具的Admin容器，来帮助管理员在必要情况下登录KubeOS，其中的sshd服务由[sysmaster](https://gitee.com/openeuler/sysmaster)/systemd拉起。Admin容器部署后用户可通过ssh连接到节点的Admin容器，进入Admin容器后执行hostshell命令获取host的root shell。 - --##### 部署方法 -+### admin容器镜像制作 - --以sysmaster为例，根据系统版本和架构，获取对应的sysmaster RPM包，如获取openEuler-22.03-LTS-aarch64版本的[sysmaster](https://repo.openeuler.org/openEuler-22.03-LTS-SP2/everything/aarch64/Packages/)到scripts/admin-container目录下。 -+以sysmaster为例，根据系统版本和架构，获取对应的sysmaster RPM包，如获取openEuler-22.03-LTS-SP1-aarch64版本的[sysmaster](https://repo.openeuler.org/openEuler-22.03-LTS-SP1/update/aarch64/Packages/)到scripts/admin-container目录下。 - --**修改**admin-container目录下的Dockerfile，指定sysmaster RPM包的路径，其中的openeuler-22.03-lts可在[openEuler Repo](https://repo.openeuler.org/openEuler-22.03-LTS-SP2/docker_img)下载。 -+修改admin-container目录下的Dockerfile，指定sysmaster RPM包的路径，其中的openeuler-22.03-lts-sp1可在[openEuler Repo](https://repo.openeuler.org/openEuler-22.03-LTS-SP1/docker_img)下载。 - - ```Dockerfile --FROM openeuler-22.03-lts -+FROM openeuler-22.03-lts-sp1 - - RUN yum -y install openssh-clients util-linux - -@@ -514,7 +584,9 @@ bash -x kbimg.sh create admin-image -f admin-container/Dockerfile -d your_imageR - docker push your_imageRepository/admin_imageName:version - ``` - --在master节点上部署Admin容器，需要提供ssh公钥来免密登录，**修改**并应用如下示例yaml文件: -+### admin容器部署 -+ -+在master节点上部署Admin容器，需要提供ssh公钥来免密登录，修改并应用如下示例yaml文件: - - ```yaml - apiVersion: v1 -@@ -583,6 +655,8 @@ spec: - control-plane: admin-container-sysmaster - ``` - -+### admin容器使用 -+ - ssh到Admin容器，然后执行hostshell命令进入host root shell, 如： - - ```shell -@@ -590,7 +664,7 @@ ssh -p your-exposed-port root@your.worker.node.ip - hostshell - ``` - --##### hostshell -+#### hostshell说明 - - 为了保证KubeOS的轻便性，许多工具或命令没有安装在KubeOS内。因此，用户可以在制作Admin容器时，将期望使用的二进制文件放在容器内的如/usr/bin目录下。hostshell工具在执行时会将容器下的/usr/bin, /usr/sbin, /usr/local/bin, /usr/local/sbin路径添加到host root shell的环境变量。 - -@@ -605,11 +679,10 @@ hostshell - - #### kernel Settings - --* kenerl.sysctl: 设置内核参数，key/value 表示内核参数的 key/value, 示例如下: -- -+* kenerl.sysctl：临时设置内核参数，重启后无效，key/value 表示内核参数的 key/value， key与value均不能为空且key不能包含“=”，该参数不支持删除操作（operation=delete）示例如下: - ```yaml - configs: -- - model: kernel.systcl -+ - model: kernel.sysctl - contents: - - key: user.max_user_namespaces - value: 16384 -@@ -617,12 +690,10 @@ hostshell - value: 0 - operation: delete - ``` -- --* kernel.sysctl.persist: 设置持久化内核参数，key/value 表示内核参数的 key/value, configpath为配置修改/新建的文件路径，如不指定configpath默认修改/etc/sysctl.conf -- -+* kenerl.sysctl：临时设置内核参数，重启后无效，key/value 表示内核参数的 key/value， key与value均不能为空且key不能包含“=”，该参数不支持删除操作（operation=delete）示例如下: - ```yaml - configs: -- - model: kernel.systcl.persist -+ - model: kernel.sysctl.persist - configpath : /etc/persist.conf - contents: - - key: user.max_user_namespaces -@@ -637,22 +708,38 @@ hostshell - * grub.cmdline: 设置grub.cfg文件中的内核引导参数，该行参数在grub.cfg文件中类似如下示例： - - ```shell -- linux /boot/vmlinuz root=UUID=5b1aaf5d-5b25-4e4b-a0d3-3d4c8d2e6a6e ro consoleblank=600 console=tty0 console=ttyS0,115200n8 selinux=1 panic=3 -- ``` -+ linux /boot/vmlinuz root=/dev/sda2 ro rootfstype=ext4 nomodeset quiet oops=panic softlockup_panic=1 nmi_watchdog=1 rd.shell=0 selinux=0 crashkernel=256M panic=3 -+ ``` - -- key/value 表示如上示例中内核引导参数的 key=value。 -- **注意：** 当该参数有多个等号，如root=UUID=some-uuid时，配置时的key为第一个等号前的所有字符，value为第一个等号后的所有字符。 -- 配置方法示例如下： -+* KubeOS使用双分区，grub.cmdline支持对当前分区或下一分区进行配置： -+ -+ - grub.cmdline.current：对当前分区的启动项参数进行配置。 -+ - grub.cmdline.next：对下一分区的启动项参数进行配置。 -+ -+* 注意：升级/回退前后的配置，始终基于升级/回退操作下发时的分区位置进行current/next的区分。假设当前分区为A分区，下发升级操作并在sysconfigs（升级重启后配置）中配置grub.cmdline.current，重启后进行配置时仍修改A分区对应的grub cmdline。 -+ -+* grub.cmdline.current/next支持“key=value”（value不能为空），也支持单key。若value中有“=”，例如“root=UUID=some-uuid”，key应设置为第一个“=”前的所有字符，value为第一个“=”后的所有字符。 配置方法示例如下： - - ```yaml - configs: -- - model: grub.cmdline -- contents: -- - key: selinux -- value: 0 -- - key: root -- value: UUID=e4f1b0a0-590e-4c5f-9d8a-3a2c7b8e2d94 -- - key: panic -- value: 3 -- operation: delete -+ - model: grub.cmdline.current -+ contents: -+ - key: selinux -+ value: "0" -+ - key: root -+ value: UUID=e4f1b0a0-590e-4c5f-9d8a-3a2c7b8e2d94 -+ - key: panic -+ value: "3" -+ operation: delete -+ - key: crash_kexec_post_notifiers -+ - model: grub.cmdline.next -+ contents: -+ - key: selinux -+ value: "0" -+ - key: root -+ value: UUID=e4f1b0a0-590e-4c5f-9d8a-3a2c7b8e2d94 -+ - key: panic -+ value: "3" -+ operation: delete -+ - key: crash_kexec_post_notifiers - ``` --- -2.34.1 - diff --git a/0002-fix-update-bootloader.sh-paths-for-EFI-boot.patch b/0002-fix-update-bootloader.sh-paths-for-EFI-boot.patch new file mode 100644 index 0000000000000000000000000000000000000000..aac10404c1b4fe4fee281af2101596499b6960e7 --- /dev/null +++ b/0002-fix-update-bootloader.sh-paths-for-EFI-boot.patch @@ -0,0 +1,35 @@ +From e77d86d37c9320547b98b5639dfa328f1b0542fb Mon Sep 17 00:00:00 2001 +From: Yuhang Wei +Date: Mon, 17 Jun 2024 10:34:37 +0800 +Subject: [PATCH 2/2] fix: update bootloader.sh paths for EFI boot + +Signed-off-by: Yuhang Wei +--- + scripts/bootloader.sh | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/scripts/bootloader.sh b/scripts/bootloader.sh +index 75096a38..df4be329 100644 +--- a/scripts/bootloader.sh ++++ b/scripts/bootloader.sh +@@ -19,7 +19,7 @@ function install_grub2_x86 () + cp -r /usr/lib/grub/x86_64-efi boot/efi/EFI/openEuler + eval "grub2-mkimage -d /usr/lib/grub/x86_64-efi -O x86_64-efi --output=/boot/efi/EFI/openEuler/grubx64.efi '--prefix=(,gpt1)/EFI/openEuler' fat part_gpt part_msdos linux" + +- mkdir -p /boot/EFI/BOOT/ ++ mkdir -p /boot/efi/EFI/BOOT/ + cp -f /boot/efi/EFI/openEuler/grubx64.efi /boot/efi/EFI/BOOT/BOOTX64.EFI + fi + } +@@ -29,7 +29,7 @@ function install_grub2_efi () + cp -r /usr/lib/grub/arm64-efi /boot/efi/EFI/openEuler/ + eval "grub2-mkimage -d /usr/lib/grub/arm64-efi -O arm64-efi --output=/boot/efi/EFI/openEuler/grubaa64.efi '--prefix=(,gpt1)/EFI/openEuler' fat part_gpt part_msdos linux" + +- mkdir -p /boot/EFI/BOOT/ ++ mkdir -p /boot/efi/EFI/BOOT/ + cp -f /boot/efi/EFI/openEuler/grubaa64.efi /boot/efi/EFI/BOOT/BOOTAA64.EFI + } + +-- +2.39.3 (Apple Git-146) + diff --git a/0003-Remove-cleanup-method-and-related-code.patch b/0003-Remove-cleanup-method-and-related-code.patch deleted file mode 100644 index 257e82ba85c0d160e8b286f09ff686ac6edcf18f..0000000000000000000000000000000000000000 --- a/0003-Remove-cleanup-method-and-related-code.patch +++ /dev/null @@ -1,143 +0,0 @@ -From 8cd9d4dd70ec0601490d0b1fd997ba4e05aff420 Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Tue, 16 Jan 2024 17:25:17 +0800 -Subject: [PATCH 03/13] Remove cleanup method and related code - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/agent/src/rpc/agent.rs | 3 --- - KubeOS-Rust/agent/src/rpc/agent_impl.rs | 14 +--------- - KubeOS-Rust/cli/src/method/cleanup.rs | 29 --------------------- - KubeOS-Rust/cli/src/method/mod.rs | 1 - - KubeOS-Rust/manager/src/api/agent_status.rs | 11 +------- - 5 files changed, 2 insertions(+), 56 deletions(-) - delete mode 100644 KubeOS-Rust/cli/src/method/cleanup.rs - -diff --git a/KubeOS-Rust/agent/src/rpc/agent.rs b/KubeOS-Rust/agent/src/rpc/agent.rs -index 13775af..2496bfb 100644 ---- a/KubeOS-Rust/agent/src/rpc/agent.rs -+++ b/KubeOS-Rust/agent/src/rpc/agent.rs -@@ -22,9 +22,6 @@ pub trait Agent { - #[rpc(name = "upgrade")] - fn upgrade(&self) -> RpcResult; - -- #[rpc(name = "cleanup")] -- fn cleanup(&self) -> RpcResult; -- - #[rpc(name = "configure")] - fn configure(&self, req: ConfigureRequest) -> RpcResult; - -diff --git a/KubeOS-Rust/agent/src/rpc/agent_impl.rs b/KubeOS-Rust/agent/src/rpc/agent_impl.rs -index 7101d0d..bc1eabd 100644 ---- a/KubeOS-Rust/agent/src/rpc/agent_impl.rs -+++ b/KubeOS-Rust/agent/src/rpc/agent_impl.rs -@@ -17,7 +17,7 @@ use log::{debug, error, info}; - use manager::{ - api::{AgentStatus, ConfigureRequest, ImageType, Response, UpgradeRequest}, - sys_mgmt::{CtrImageHandler, DiskImageHandler, DockerImageHandler, CONFIG_TEMPLATE, DEFAULT_GRUBENV_PATH}, -- utils::{clean_env, get_partition_info, switch_boot_menuentry, PreparePath, RealCommandExecutor}, -+ utils::{get_partition_info, switch_boot_menuentry, RealCommandExecutor}, - }; - use nix::{sys::reboot::RebootMode, unistd::sync}; - -@@ -40,10 +40,6 @@ impl Agent for AgentImpl { - RpcFunction::call(|| self.upgrade_impl()) - } - -- fn cleanup(&self) -> RpcResult { -- RpcFunction::call(|| self.cleanup_impl()) -- } -- - fn configure(&self, req: ConfigureRequest) -> RpcResult { - RpcFunction::call(|| self.configure_impl(req)) - } -@@ -94,14 +90,6 @@ impl AgentImpl { - Ok(Response { status: AgentStatus::Upgraded }) - } - -- pub fn cleanup_impl(&self) -> Result { -- let _lock = self.mutex.lock().unwrap(); -- info!("Start to cleanup"); -- let paths = PreparePath::default(); -- clean_env(paths.update_path, paths.mount_path, paths.image_path)?; -- Ok(Response { status: AgentStatus::CleanedUp }) -- } -- - pub fn configure_impl(&self, mut req: ConfigureRequest) -> Result { - let _lock = self.mutex.lock().unwrap(); - debug!("Received a 'configure' request: {:?}", req); -diff --git a/KubeOS-Rust/cli/src/method/cleanup.rs b/KubeOS-Rust/cli/src/method/cleanup.rs -deleted file mode 100644 -index d1d7dbe..0000000 ---- a/KubeOS-Rust/cli/src/method/cleanup.rs -+++ /dev/null -@@ -1,29 +0,0 @@ --/* -- * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. -- * KubeOS is licensed under the Mulan PSL v2. -- * You can use this software according to the terms and conditions of the Mulan PSL v2. -- * You may obtain a copy of Mulan PSL v2 at: -- * http://license.coscl.org.cn/MulanPSL2 -- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR -- * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR -- * PURPOSE. -- * See the Mulan PSL v2 for more details. -- */ -- --use kubeos_manager::api; --use serde_json::value::RawValue; -- --use crate::method::callable_method::RpcMethod; -- --#[derive(Default)] --pub struct CleanupMethod {} -- --impl RpcMethod for CleanupMethod { -- type Response = api::Response; -- fn command_name(&self) -> &'static str { -- "cleanup" -- } -- fn command_params(&self) -> Vec> { -- vec![] -- } --} -diff --git a/KubeOS-Rust/cli/src/method/mod.rs b/KubeOS-Rust/cli/src/method/mod.rs -index b04b0fd..e1f38bc 100644 ---- a/KubeOS-Rust/cli/src/method/mod.rs -+++ b/KubeOS-Rust/cli/src/method/mod.rs -@@ -11,7 +11,6 @@ - */ - - pub mod callable_method; --pub mod cleanup; - pub mod configure; - pub mod prepare_upgrade; - pub mod request; -diff --git a/KubeOS-Rust/manager/src/api/agent_status.rs b/KubeOS-Rust/manager/src/api/agent_status.rs -index e466a50..bb16e6b 100644 ---- a/KubeOS-Rust/manager/src/api/agent_status.rs -+++ b/KubeOS-Rust/manager/src/api/agent_status.rs -@@ -12,19 +12,10 @@ - - use serde::{Deserialize, Serialize}; - --#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] -+#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Debug)] - pub enum AgentStatus { -- Unknown, -- NotApplied, - UpgradeReady, - Upgraded, - Rollbacked, - Configured, -- CleanedUp, --} -- --impl Default for AgentStatus { -- fn default() -> Self { -- Self::Unknown -- } - } --- -2.34.1 - diff --git a/0004-test-rust-proxy-add-drain-integration-test.patch b/0004-test-rust-proxy-add-drain-integration-test.patch deleted file mode 100644 index 35afe1e43e7be7398b442901e7d5941ea9327fe3..0000000000000000000000000000000000000000 --- a/0004-test-rust-proxy-add-drain-integration-test.patch +++ /dev/null @@ -1,459 +0,0 @@ -From 916ca24576d33dc024944a7ed18aaa39e95753f9 Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Thu, 18 Jan 2024 11:13:20 +0800 -Subject: [PATCH 04/13] test(rust proxy):add drain integration test - -move drain into a lib for integration test. -use kind to deploy a cluster for integration test. - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/proxy/Cargo.toml | 7 ++ - .../proxy/src/controller/controller.rs | 4 +- - KubeOS-Rust/proxy/src/controller/mod.rs | 1 - - KubeOS-Rust/proxy/src/controller/values.rs | 12 --- - .../proxy/src/{controller => }/drain.rs | 12 ++- - KubeOS-Rust/proxy/tests/common/mod.rs | 63 +++++++++++ - KubeOS-Rust/proxy/tests/drain_test.rs | 41 +++++++ - .../proxy/tests/setup/kind-config.yaml | 5 + - KubeOS-Rust/proxy/tests/setup/resources.yaml | 102 ++++++++++++++++++ - .../proxy/tests/setup/setup_test_env.sh | 81 ++++++++++++++ - 10 files changed, 309 insertions(+), 19 deletions(-) - rename KubeOS-Rust/proxy/src/{controller => }/drain.rs (97%) - create mode 100644 KubeOS-Rust/proxy/tests/common/mod.rs - create mode 100644 KubeOS-Rust/proxy/tests/drain_test.rs - create mode 100644 KubeOS-Rust/proxy/tests/setup/kind-config.yaml - create mode 100644 KubeOS-Rust/proxy/tests/setup/resources.yaml - create mode 100644 KubeOS-Rust/proxy/tests/setup/setup_test_env.sh - -diff --git a/KubeOS-Rust/proxy/Cargo.toml b/KubeOS-Rust/proxy/Cargo.toml -index 9a148e8..72eb6b9 100644 ---- a/KubeOS-Rust/proxy/Cargo.toml -+++ b/KubeOS-Rust/proxy/Cargo.toml -@@ -6,6 +6,13 @@ name = "proxy" - version = "0.1.0" - - # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html -+[lib] -+name = "drain" -+path = "src/drain.rs" -+ -+[[bin]] -+name = "proxy" -+path = "src/main.rs" - - [dependencies] - anyhow = "1.0.44" -diff --git a/KubeOS-Rust/proxy/src/controller/controller.rs b/KubeOS-Rust/proxy/src/controller/controller.rs -index e7ee9f9..b2bb332 100644 ---- a/KubeOS-Rust/proxy/src/controller/controller.rs -+++ b/KubeOS-Rust/proxy/src/controller/controller.rs -@@ -13,6 +13,7 @@ - use std::{collections::HashMap, env}; - - use anyhow::Result; -+use drain::drain_os; - use k8s_openapi::api::core::v1::Node; - use kube::{ - api::{Api, PostParams}, -@@ -29,7 +30,6 @@ use super::{ - agentclient::{AgentMethod, ConfigInfo, KeyInfo, Sysconfig, UpgradeInfo}, - apiclient::ApplyApi, - crd::{Configs, Content, OSInstance, OS}, -- drain::drain_os, - utils::{check_version, get_config_version, ConfigOperation, ConfigType}, - values::{ - LABEL_UPGRADING, NODE_STATUS_CONFIG, NODE_STATUS_IDLE, OPERATION_TYPE_ROLLBACK, OPERATION_TYPE_UPGRADE, -@@ -340,7 +340,7 @@ impl ProxyController { - } - - async fn drain_node(&self, node_name: &str, force: bool) -> Result<(), Error> { -- use crate::controller::drain::error::DrainError::*; -+ use drain::error::DrainError::*; - match drain_os(&self.k8s_client.clone(), node_name, force).await { - Err(DeletePodsError { errors, .. }) => Err(Error::DrainNodeError { value: errors.join("; ") }), - _ => Ok(()), -diff --git a/KubeOS-Rust/proxy/src/controller/mod.rs b/KubeOS-Rust/proxy/src/controller/mod.rs -index 384d74b..73be45c 100644 ---- a/KubeOS-Rust/proxy/src/controller/mod.rs -+++ b/KubeOS-Rust/proxy/src/controller/mod.rs -@@ -16,7 +16,6 @@ mod apiclient; - mod apiserver_mock; - mod controller; - mod crd; --mod drain; - mod utils; - mod values; - -diff --git a/KubeOS-Rust/proxy/src/controller/values.rs b/KubeOS-Rust/proxy/src/controller/values.rs -index fe43851..dec905a 100644 ---- a/KubeOS-Rust/proxy/src/controller/values.rs -+++ b/KubeOS-Rust/proxy/src/controller/values.rs -@@ -31,15 +31,3 @@ pub const SOCK_PATH: &str = "/run/os-agent/os-agent.sock"; - pub const REQUEUE_NORMAL: ReconcilerAction = ReconcilerAction { requeue_after: Some(Duration::from_secs(15)) }; - - pub const REQUEUE_ERROR: ReconcilerAction = ReconcilerAction { requeue_after: Some(Duration::from_secs(1)) }; -- --pub const MAX_EVICT_POD_NUM: usize = 5; -- --pub const EVERY_EVICTION_RETRY: Duration = Duration::from_secs(5); -- --pub const EVERY_DELETION_CHECK: Duration = Duration::from_secs(5); -- --pub const TIMEOUT: Duration = Duration::from_secs(u64::MAX); -- --pub const RETRY_BASE_DELAY: Duration = Duration::from_millis(100); --pub const RETRY_MAX_DELAY: Duration = Duration::from_secs(20); --pub const MAX_RETRIES_TIMES: usize = 10; -diff --git a/KubeOS-Rust/proxy/src/controller/drain.rs b/KubeOS-Rust/proxy/src/drain.rs -similarity index 97% -rename from KubeOS-Rust/proxy/src/controller/drain.rs -rename to KubeOS-Rust/proxy/src/drain.rs -index ddc38ae..09cf662 100644 ---- a/KubeOS-Rust/proxy/src/controller/drain.rs -+++ b/KubeOS-Rust/proxy/src/drain.rs -@@ -29,10 +29,14 @@ use self::error::{ - DrainError::{DeletePodsError, GetPodListsError, WaitDeletionError}, - EvictionError::{EvictionErrorNoRetry, EvictionErrorRetry}, - }; --use super::values::{ -- EVERY_DELETION_CHECK, EVERY_EVICTION_RETRY, MAX_EVICT_POD_NUM, MAX_RETRIES_TIMES, RETRY_BASE_DELAY, -- RETRY_MAX_DELAY, TIMEOUT, --}; -+ -+pub const MAX_EVICT_POD_NUM: usize = 5; -+pub const EVERY_EVICTION_RETRY: Duration = Duration::from_secs(5); -+pub const EVERY_DELETION_CHECK: Duration = Duration::from_secs(5); -+pub const TIMEOUT: Duration = Duration::from_secs(u64::MAX); -+pub const RETRY_BASE_DELAY: Duration = Duration::from_millis(100); -+pub const RETRY_MAX_DELAY: Duration = Duration::from_secs(20); -+pub const MAX_RETRIES_TIMES: usize = 10; - - pub async fn drain_os(client: &Client, node_name: &str, force: bool) -> Result<(), error::DrainError> { - let pods_list = get_pods_deleted(client, node_name, force).await?; -diff --git a/KubeOS-Rust/proxy/tests/common/mod.rs b/KubeOS-Rust/proxy/tests/common/mod.rs -new file mode 100644 -index 0000000..8257759 ---- /dev/null -+++ b/KubeOS-Rust/proxy/tests/common/mod.rs -@@ -0,0 +1,63 @@ -+use std::process::{Command, Stdio}; -+ -+use anyhow::Result; -+use k8s_openapi::api::core::v1::Node; -+use kube::{ -+ api::ResourceExt, -+ client::Client, -+ config::{Config, KubeConfigOptions, Kubeconfig}, -+ Api, -+}; -+use manager::utils::{CommandExecutor, RealCommandExecutor}; -+ -+pub const CLUSTER: &str = "kubeos-test"; -+ -+pub fn run_command(cmd: &str, args: &[&str]) -> Result<()> { -+ let output = Command::new(cmd).args(args).stdout(Stdio::inherit()).stderr(Stdio::inherit()).output()?; -+ if !output.status.success() { -+ println!("failed to run command: {} {}\n", cmd, args.join(" ")); -+ } -+ Ok(()) -+} -+ -+pub async fn setup() -> Result { -+ // set PATH variable -+ let path = std::env::var("PATH").unwrap(); -+ let new_path = format!("{}:{}", path, "../../bin"); -+ std::env::set_var("PATH", new_path); -+ -+ // create cluster -+ let executor = RealCommandExecutor {}; -+ println!("Creating cluster"); -+ run_command("bash", &["./tests/setup/setup_test_env.sh"]).expect("failed to create cluster"); -+ -+ // connect to the cluster -+ let kind_config = executor.run_command_with_output("kind", &["get", "kubeconfig", "-n", CLUSTER]).unwrap(); -+ let kubeconfig = Kubeconfig::from_yaml(kind_config.as_str()).expect("failed to parse kubeconfig"); -+ let options = KubeConfigOptions::default(); -+ let config = Config::from_custom_kubeconfig(kubeconfig, &&options).await.expect("failed to create config"); -+ let client = Client::try_from(config).expect("failed to create client"); -+ // list all nodes -+ let nodes: Api = Api::all(client.clone()); -+ let node_list = nodes.list(&Default::default()).await.expect("failed to list nodes"); -+ for n in node_list { -+ println!("Found Node: {}", n.name()); -+ } -+ // check node status -+ let node = nodes.get("kubeos-test-worker").await.unwrap(); -+ let status = node.status.unwrap(); -+ let conditions = status.conditions.unwrap(); -+ for c in conditions { -+ if c.type_ == "Ready" { -+ assert_eq!(c.status, "True"); -+ } -+ } -+ println!("Cluster ready"); -+ Ok(client) -+} -+ -+pub fn clean_env() { -+ let executor = RealCommandExecutor {}; -+ println!("Cleaning cluster"); -+ executor.run_command("kind", &["delete", "clusters", CLUSTER]).expect("failed to clean cluster"); -+} -diff --git a/KubeOS-Rust/proxy/tests/drain_test.rs b/KubeOS-Rust/proxy/tests/drain_test.rs -new file mode 100644 -index 0000000..2f4f150 ---- /dev/null -+++ b/KubeOS-Rust/proxy/tests/drain_test.rs -@@ -0,0 +1,41 @@ -+mod common; -+ -+use common::*; -+use drain::drain_os; -+use k8s_openapi::api::core::v1::{Node, Pod}; -+use kube::Api; -+ -+#[tokio::test] -+#[ignore = "integration test"] -+async fn test_drain() { -+ let client = setup().await.unwrap(); -+ // drain node -+ let nodes: Api = Api::all(client.clone()); -+ let node_name = "kubeos-test-worker"; -+ println!("cordon node"); -+ nodes.cordon(node_name).await.unwrap(); -+ println!("drain node"); -+ drain_os(&client, node_name, true).await.unwrap(); -+ -+ // assert unschedulable -+ println!("check node unschedulable"); -+ let node = nodes.get(node_name).await.unwrap(); -+ if let Some(spec) = node.spec { -+ assert_eq!(spec.unschedulable, Some(true)); -+ } else { -+ panic!("node spec is none"); -+ } -+ // list all pods on kubeos-test-worker node and all pods should belong to daemonset -+ println!("list all pods on kubeos-test-worker node"); -+ let pods: Api = Api::all(client.clone()); -+ let pod_list = pods.list(&Default::default()).await.unwrap(); -+ // check the pod is from daemonset -+ for p in pod_list { -+ if p.spec.unwrap().node_name.unwrap() == node_name { -+ assert_eq!(p.metadata.owner_references.unwrap()[0].kind, "DaemonSet"); -+ } -+ } -+ nodes.uncordon(node_name).await.unwrap(); -+ -+ clean_env() -+} -diff --git a/KubeOS-Rust/proxy/tests/setup/kind-config.yaml b/KubeOS-Rust/proxy/tests/setup/kind-config.yaml -new file mode 100644 -index 0000000..0fe29e7 ---- /dev/null -+++ b/KubeOS-Rust/proxy/tests/setup/kind-config.yaml -@@ -0,0 +1,5 @@ -+kind: Cluster -+apiVersion: kind.x-k8s.io/v1alpha4 -+nodes: -+- role: control-plane -+- role: worker -\ No newline at end of file -diff --git a/KubeOS-Rust/proxy/tests/setup/resources.yaml b/KubeOS-Rust/proxy/tests/setup/resources.yaml -new file mode 100644 -index 0000000..0e449d5 ---- /dev/null -+++ b/KubeOS-Rust/proxy/tests/setup/resources.yaml -@@ -0,0 +1,102 @@ -+apiVersion: apps/v1 -+kind: DaemonSet -+metadata: -+ name: example-daemonset -+spec: -+ selector: -+ matchLabels: -+ name: example-daemonset -+ template: -+ metadata: -+ labels: -+ name: example-daemonset -+ spec: -+ containers: -+ - name: busybox -+ image: busybox:stable -+ command: ["/bin/sh", "-c", "sleep 3600"] -+--- -+apiVersion: v1 -+kind: Pod -+metadata: -+ name: pod-with-local-storage -+spec: -+ containers: -+ - name: busybox -+ image: busybox:stable -+ command: ["/bin/sh", "-c", "sleep 3600"] -+ volumeMounts: -+ - mountPath: "/data" -+ name: local-volume -+ volumes: -+ - name: local-volume -+ emptyDir: {} -+--- -+apiVersion: v1 -+kind: Pod -+metadata: -+ name: standalone-pod -+spec: -+ containers: -+ - name: busybox -+ image: busybox:stable -+ command: ["/bin/sh", "-c", "sleep 3600"] -+--- -+apiVersion: apps/v1 -+kind: Deployment -+metadata: -+ name: example-deployment -+spec: -+ replicas: 2 -+ selector: -+ matchLabels: -+ app: example -+ template: -+ metadata: -+ labels: -+ app: example -+ spec: -+ containers: -+ - name: nginx -+ image: nginx:alpine -+ affinity: -+ nodeAffinity: -+ preferredDuringSchedulingIgnoredDuringExecution: -+ - weight: 1 -+ preference: -+ matchExpressions: -+ - key: "node-role.kubernetes.io/control-plane" -+ operator: DoesNotExist -+ tolerations: -+ - key: "node-role.kubernetes.io/master" -+ operator: "Exists" -+ - key: "node-role.kubernetes.io/control-plane" -+ operator: "Exists" -+--- -+apiVersion: policy/v1 -+kind: PodDisruptionBudget -+metadata: -+ name: example-pdb -+spec: -+ minAvailable: 1 -+ selector: -+ matchLabels: -+ app: example -+--- -+apiVersion: v1 -+kind: Pod -+metadata: -+ name: resource-intensive-pod -+spec: -+ containers: -+ - name: busybox -+ image: busybox:stable -+ command: ["/bin/sh", "-c", "sleep 3600"] -+ resources: -+ requests: -+ memory: "256Mi" -+ cpu: "500m" -+ limits: -+ memory: "512Mi" -+ cpu: "1000m" -+ -diff --git a/KubeOS-Rust/proxy/tests/setup/setup_test_env.sh b/KubeOS-Rust/proxy/tests/setup/setup_test_env.sh -new file mode 100644 -index 0000000..d24d8e0 ---- /dev/null -+++ b/KubeOS-Rust/proxy/tests/setup/setup_test_env.sh -@@ -0,0 +1,81 @@ -+#!/bin/bash -+# this bash script executes in proxy directory -+ -+set -Eeuxo pipefail -+ -+# Define variables -+KIND_VERSION="v0.19.0" -+KUBECTL_VERSION="v1.24.15" -+KIND_CLUSTER_NAME="kubeos-test" -+DOCKER_IMAGES=("busybox:stable" "nginx:alpine" "kindest/node:v1.24.15@sha256:7db4f8bea3e14b82d12e044e25e34bd53754b7f2b0e9d56df21774e6f66a70ab") -+NODE_IMAGE="kindest/node:v1.24.15@sha256:7db4f8bea3e14b82d12e044e25e34bd53754b7f2b0e9d56df21774e6f66a70ab" -+RESOURCE="./tests/setup/resources.yaml" -+KIND_CONFIG="./tests/setup/kind-config.yaml" -+BIN_PATH="../../bin/" -+ARCH=$(uname -m) -+ -+# Install kind and kubectl -+install_bins() { -+ # if bin dir not exist then create -+ if [ ! -d "${BIN_PATH}" ]; then -+ mkdir -p "${BIN_PATH}" -+ fi -+ if [ ! -f "${BIN_PATH}"kind ]; then -+ echo "Installing Kind..." -+ # For AMD64 / x86_64 -+ if [ "$ARCH" = x86_64 ]; then -+ # add proxy if you are behind proxy -+ curl -Lo "${BIN_PATH}"kind https://kind.sigs.k8s.io/dl/"${KIND_VERSION}"/kind-linux-amd64 -+ fi -+ # For ARM64 -+ if [ "$ARCH" = aarch64 ]; then -+ curl -Lo "${BIN_PATH}"kind https://kind.sigs.k8s.io/dl/"${KIND_VERSION}"/kind-linux-arm64 -+ fi -+ chmod +x "${BIN_PATH}"kind -+ fi -+ if [ ! -f "${BIN_PATH}"kubectl ]; then -+ echo "Installing kubectl..." -+ if [ "$ARCH" = x86_64 ]; then -+ curl -Lo "${BIN_PATH}"kubectl "https://dl.k8s.io/release/${KUBECTL_VERSION}/bin/linux/amd64/kubectl" -+ fi -+ if [ "$ARCH" = aarch64 ]; then -+ curl -Lo "${BIN_PATH}"kubectl "https://dl.k8s.io/release/${KUBECTL_VERSION}/bin/linux/arm64/kubectl" -+ fi -+ chmod +x "${BIN_PATH}"kubectl -+ fi -+ export PATH=$PATH:"${BIN_PATH}" -+} -+ -+# Create Kind Cluster -+create_cluster() { -+ echo "Creating Kind cluster..." -+ for image in "${DOCKER_IMAGES[@]}"; do -+ docker pull "$image" -+ done -+ kind create cluster --name "${KIND_CLUSTER_NAME}" --config "${KIND_CONFIG}" --image "${NODE_IMAGE}" -+} -+ -+# Load Docker image into Kind cluster -+load_docker_image() { -+ echo "Loading Docker image into Kind cluster..." -+ DOCKER_IMAGE=$(printf "%s " "${DOCKER_IMAGES[@]:0:2}") -+ kind load docker-image ${DOCKER_IMAGE} --name "${KIND_CLUSTER_NAME}" -+} -+ -+# Apply Kubernetes resource files -+apply_k8s_resources() { -+ echo "Applying Kubernetes resources from ${RESOURCE}..." -+ kubectl apply -f "${RESOURCE}" -+ echo "Waiting for nodes getting ready..." -+ sleep 40s -+} -+ -+main() { -+ export no_proxy=localhost,127.0.0.1 -+ install_bins -+ create_cluster -+ load_docker_image -+ apply_k8s_resources -+} -+ -+main --- -2.34.1 - diff --git a/0005-refactor-rust-os-agent-fix-code-check.patch b/0005-refactor-rust-os-agent-fix-code-check.patch deleted file mode 100644 index 0707ba79b56e04b6af3682e03d13d0e86fbedf79..0000000000000000000000000000000000000000 --- a/0005-refactor-rust-os-agent-fix-code-check.patch +++ /dev/null @@ -1,35 +0,0 @@ -From adb73fcebd1d7698a2fffdb791c2e9d08e949d9c Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Wed, 17 Jan 2024 14:39:34 +0800 -Subject: [PATCH 05/13] refactor(rust os-agent): fix code check - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/cli/src/method/request.rs | 9 ++++----- - 1 file changed, 4 insertions(+), 5 deletions(-) - -diff --git a/KubeOS-Rust/cli/src/method/request.rs b/KubeOS-Rust/cli/src/method/request.rs -index 2dc1ffb..b4a24aa 100644 ---- a/KubeOS-Rust/cli/src/method/request.rs -+++ b/KubeOS-Rust/cli/src/method/request.rs -@@ -36,13 +36,12 @@ pub fn parse_error(error: Error) -> anyhow::Error { - debug!("Json parse error: {:?}", e); - anyhow!("Failed to parse response") - }, -- Error::Rpc(ref e) => match e.message == "Method not found" { -- true => { -+ Error::Rpc(ref e) => { -+ if e.message == "Method not found" { - anyhow!("Method is unimplemented") -- }, -- false => { -+ } else { - anyhow!("{}", e.message) -- }, -+ } - }, - _ => { - debug!("{:?}", error); --- -2.34.1 - diff --git a/0006-fix-agent-proxy-transform-log-timestamp-to-human-rea.patch b/0006-fix-agent-proxy-transform-log-timestamp-to-human-rea.patch deleted file mode 100644 index 8560e393e3df541b97eb4dbaee4289482b5ce3ea..0000000000000000000000000000000000000000 --- a/0006-fix-agent-proxy-transform-log-timestamp-to-human-rea.patch +++ /dev/null @@ -1,245 +0,0 @@ -From 25a856bf7bfa7f2de32ecb7b4c8d6997a2835f76 Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Sat, 25 Nov 2023 15:18:23 +0800 -Subject: [PATCH 06/13] fix(agent, proxy): transform log timestamp to - human-readable format - -Originally, the log of controllers is timestamp which is hard to read. Now, transform the log into more human-readable format. - -Signed-off-by: Yuhang Wei ---- - cmd/operator/controllers/os_controller_test.go | 3 +-- - cmd/operator/controllers/suite_test.go | 12 +++++++++++- - cmd/operator/main.go | 13 +++++++++++++ - cmd/proxy/controllers/suite_test.go | 11 ++++++++++- - cmd/proxy/main.go | 13 +++++++++++++ - go.mod | 3 ++- - go.sum | 8 ++++++++ - 7 files changed, 58 insertions(+), 5 deletions(-) - -diff --git a/cmd/operator/controllers/os_controller_test.go b/cmd/operator/controllers/os_controller_test.go -index 6cc2760..8c5d198 100644 ---- a/cmd/operator/controllers/os_controller_test.go -+++ b/cmd/operator/controllers/os_controller_test.go -@@ -23,7 +23,6 @@ import ( - "github.com/google/uuid" - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" -- corev1 "k8s.io/api/core/v1" - v1 "k8s.io/api/core/v1" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/labels" -@@ -912,7 +911,7 @@ func Test_getNodes(t *testing.T) { - tests := []struct { - name string - args args -- want []corev1.Node -+ want []v1.Node - wantErr bool - }{ - { -diff --git a/cmd/operator/controllers/suite_test.go b/cmd/operator/controllers/suite_test.go -index aa6deea..67fc9e7 100644 ---- a/cmd/operator/controllers/suite_test.go -+++ b/cmd/operator/controllers/suite_test.go -@@ -16,9 +16,13 @@ import ( - "context" - "path/filepath" - "testing" -+ "time" - - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" -+ zaplogfmt "github.com/sykesm/zap-logfmt" -+ uzap "go.uber.org/zap" -+ "go.uber.org/zap/zapcore" - "k8s.io/client-go/kubernetes/scheme" - "k8s.io/client-go/rest" - ctrl "sigs.k8s.io/controller-runtime" -@@ -46,7 +50,13 @@ func TestAPIs(t *testing.T) { - } - - var _ = BeforeSuite(func() { -- logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true))) -+ configLog := uzap.NewProductionEncoderConfig() -+ configLog.EncodeTime = func(ts time.Time, encoder zapcore.PrimitiveArrayEncoder) { -+ encoder.AppendString(ts.UTC().Format(time.RFC3339Nano)) -+ } -+ logfmtEncoder := zaplogfmt.NewEncoder(configLog) -+ logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true), zap.Encoder(logfmtEncoder))) -+ - ctx, cancel = context.WithCancel(context.TODO()) - - By("bootstrapping test environment") -diff --git a/cmd/operator/main.go b/cmd/operator/main.go -index 8249ad2..6b90b26 100644 ---- a/cmd/operator/main.go -+++ b/cmd/operator/main.go -@@ -14,12 +14,17 @@ package main - - import ( - "os" -+ "time" - -+ zaplogfmt "github.com/sykesm/zap-logfmt" -+ uzap "go.uber.org/zap" -+ "go.uber.org/zap/zapcore" - "k8s.io/apimachinery/pkg/runtime" - utilruntime "k8s.io/apimachinery/pkg/util/runtime" - clientgoscheme "k8s.io/client-go/kubernetes/scheme" - _ "k8s.io/client-go/plugin/pkg/client/auth" - ctrl "sigs.k8s.io/controller-runtime" -+ "sigs.k8s.io/controller-runtime/pkg/log/zap" - - upgradev1 "openeuler.org/KubeOS/api/v1alpha1" - "openeuler.org/KubeOS/cmd/operator/controllers" -@@ -41,6 +46,14 @@ func init() { - } - - func main() { -+ configLog := uzap.NewProductionEncoderConfig() -+ configLog.EncodeTime = func(ts time.Time, encoder zapcore.PrimitiveArrayEncoder) { -+ encoder.AppendString(ts.UTC().Format(time.RFC3339Nano)) -+ } -+ logfmtEncoder := zaplogfmt.NewEncoder(configLog) -+ logger := zap.New(zap.UseDevMode(true), zap.WriteTo(os.Stdout), zap.Encoder(logfmtEncoder)) -+ ctrl.SetLogger(logger) -+ - mgr, err := common.NewControllerManager(setupLog, scheme) - if err != nil { - setupLog.Error(err, "unable to start manager") -diff --git a/cmd/proxy/controllers/suite_test.go b/cmd/proxy/controllers/suite_test.go -index 00eebbf..767fe95 100644 ---- a/cmd/proxy/controllers/suite_test.go -+++ b/cmd/proxy/controllers/suite_test.go -@@ -16,9 +16,13 @@ import ( - "context" - "path/filepath" - "testing" -+ "time" - - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" -+ zaplogfmt "github.com/sykesm/zap-logfmt" -+ uzap "go.uber.org/zap" -+ "go.uber.org/zap/zapcore" - "k8s.io/client-go/kubernetes/scheme" - "k8s.io/client-go/rest" - ctrl "sigs.k8s.io/controller-runtime" -@@ -48,7 +52,12 @@ func TestAPIs(t *testing.T) { - } - - var _ = BeforeSuite(func() { -- logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true))) -+ configLog := uzap.NewProductionEncoderConfig() -+ configLog.EncodeTime = func(ts time.Time, encoder zapcore.PrimitiveArrayEncoder) { -+ encoder.AppendString(ts.UTC().Format(time.RFC3339Nano)) -+ } -+ logfmtEncoder := zaplogfmt.NewEncoder(configLog) -+ logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true), zap.Encoder(logfmtEncoder))) - ctx, cancel = context.WithCancel(context.TODO()) - - By("bootstrapping test environment") -diff --git a/cmd/proxy/main.go b/cmd/proxy/main.go -index 3a537d9..e606083 100644 ---- a/cmd/proxy/main.go -+++ b/cmd/proxy/main.go -@@ -15,12 +15,17 @@ package main - import ( - "os" - "path/filepath" -+ "time" - -+ zaplogfmt "github.com/sykesm/zap-logfmt" -+ uzap "go.uber.org/zap" -+ "go.uber.org/zap/zapcore" - "k8s.io/apimachinery/pkg/runtime" - utilruntime "k8s.io/apimachinery/pkg/util/runtime" - clientgoscheme "k8s.io/client-go/kubernetes/scheme" - _ "k8s.io/client-go/plugin/pkg/client/auth" - ctrl "sigs.k8s.io/controller-runtime" -+ "sigs.k8s.io/controller-runtime/pkg/log/zap" - - upgradev1 "openeuler.org/KubeOS/api/v1alpha1" - "openeuler.org/KubeOS/cmd/agent/server" -@@ -44,6 +49,14 @@ func init() { - } - - func main() { -+ configLog := uzap.NewProductionEncoderConfig() -+ configLog.EncodeTime = func(ts time.Time, encoder zapcore.PrimitiveArrayEncoder) { -+ encoder.AppendString(ts.UTC().Format(time.RFC3339Nano)) -+ } -+ logfmtEncoder := zaplogfmt.NewEncoder(configLog) -+ logger := zap.New(zap.UseDevMode(true), zap.WriteTo(os.Stdout), zap.Encoder(logfmtEncoder)) -+ ctrl.SetLogger(logger) -+ - var err error - mgr, err := common.NewControllerManager(setupLog, scheme) - if err != nil { -diff --git a/go.mod b/go.mod -index 057292c..72ca978 100644 ---- a/go.mod -+++ b/go.mod -@@ -9,6 +9,8 @@ require ( - github.com/onsi/ginkgo/v2 v2.1.4 - github.com/onsi/gomega v1.20.0 - github.com/sirupsen/logrus v1.8.1 -+ github.com/sykesm/zap-logfmt v0.0.4 -+ go.uber.org/zap v1.19.1 - google.golang.org/grpc v1.49.0 - google.golang.org/protobuf v1.28.1 - k8s.io/api v0.24.0 -@@ -82,7 +84,6 @@ require ( - go.starlark.net v0.0.0-20200306205701-8dd3e2ee1dd5 // indirect - go.uber.org/atomic v1.7.0 // indirect - go.uber.org/multierr v1.6.0 // indirect -- go.uber.org/zap v1.19.1 // indirect - golang.org/x/crypto v0.0.0-20220214200702-86341886e292 // indirect - golang.org/x/net v0.10.0 // indirect - golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 // indirect -diff --git a/go.sum b/go.sum -index 6bd1ba1..325cd88 100644 ---- a/go.sum -+++ b/go.sum -@@ -516,6 +516,8 @@ github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ - github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= - github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= - github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= -+github.com/sykesm/zap-logfmt v0.0.4 h1:U2WzRvmIWG1wDLCFY3sz8UeEmsdHQjHFNlIdmroVFaI= -+github.com/sykesm/zap-logfmt v0.0.4/go.mod h1:AuBd9xQjAe3URrWT1BBDk2v2onAZHkZkWRMiYZXiZWA= - github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= - github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= - github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= -@@ -559,15 +561,19 @@ go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqe - go.starlark.net v0.0.0-20200306205701-8dd3e2ee1dd5 h1:+FNtrFTmVw0YZGpBGX56XDee331t6JAXeK2bcyhLOOc= - go.starlark.net v0.0.0-20200306205701-8dd3e2ee1dd5/go.mod h1:nmDLcffg48OtT/PSW0Hg7FvpRQsQh5OSqIylirxKC7o= - go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= -+go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= - go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= - go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= - go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= - go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= - go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA= - go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= -+go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= - go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= - go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= -+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= - go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= -+go.uber.org/zap v1.12.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= - go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= - go.uber.org/zap v1.19.0/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= - go.uber.org/zap v1.19.1 h1:ue41HOKd1vGURxrmeKIgELGb3jPW9DMUDGtsinblHwI= -@@ -812,6 +818,8 @@ golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgw - golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= - golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= - golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -+golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -+golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= - golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= - golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= - golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= --- -2.34.1 - diff --git a/0007-build-update-vendor.patch b/0007-build-update-vendor.patch deleted file mode 100644 index a0ca713866185725273146ec1b35285f8815d950..0000000000000000000000000000000000000000 --- a/0007-build-update-vendor.patch +++ /dev/null @@ -1,706 +0,0 @@ -From e1b4b7a7008855920f866d0fa4c16d09f9341baf Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Sat, 25 Nov 2023 15:18:36 +0800 -Subject: [PATCH 07/13] build: update vendor - -use zapfmt to transform timestamp to human-readable format - -Signed-off-by: Yuhang Wei ---- - .../github.com/sykesm/zap-logfmt/.gitignore | 1 + - .../github.com/sykesm/zap-logfmt/.travis.yml | 12 + - vendor/github.com/sykesm/zap-logfmt/LICENSE | 21 + - vendor/github.com/sykesm/zap-logfmt/README.md | 76 +++ - .../github.com/sykesm/zap-logfmt/encoder.go | 527 ++++++++++++++++++ - vendor/modules.txt | 3 + - 6 files changed, 640 insertions(+) - create mode 100644 vendor/github.com/sykesm/zap-logfmt/.gitignore - create mode 100644 vendor/github.com/sykesm/zap-logfmt/.travis.yml - create mode 100644 vendor/github.com/sykesm/zap-logfmt/LICENSE - create mode 100644 vendor/github.com/sykesm/zap-logfmt/README.md - create mode 100644 vendor/github.com/sykesm/zap-logfmt/encoder.go - -diff --git a/vendor/github.com/sykesm/zap-logfmt/.gitignore b/vendor/github.com/sykesm/zap-logfmt/.gitignore -new file mode 100644 -index 0000000..7a6353d ---- /dev/null -+++ b/vendor/github.com/sykesm/zap-logfmt/.gitignore -@@ -0,0 +1 @@ -+.envrc -diff --git a/vendor/github.com/sykesm/zap-logfmt/.travis.yml b/vendor/github.com/sykesm/zap-logfmt/.travis.yml -new file mode 100644 -index 0000000..7ce1f7a ---- /dev/null -+++ b/vendor/github.com/sykesm/zap-logfmt/.travis.yml -@@ -0,0 +1,12 @@ -+language: go -+ -+matrix: -+ include: -+ - go: "1.13.x" -+ install: true -+ - go: "1.14.x" -+ install: true -+ - go: "1.15.x" -+ install: true -+ -+script: go test -race ./... -diff --git a/vendor/github.com/sykesm/zap-logfmt/LICENSE b/vendor/github.com/sykesm/zap-logfmt/LICENSE -new file mode 100644 -index 0000000..43a1c32 ---- /dev/null -+++ b/vendor/github.com/sykesm/zap-logfmt/LICENSE -@@ -0,0 +1,21 @@ -+The MIT License (MIT) -+ -+Copyright (c) 2017 Jonathan Sternberg -+Copyright (c) 2019 Matthew Sykes -+ -+Permission is hereby granted, free of charge, to any person obtaining a copy of -+this software and associated documentation files (the "Software"), to deal in -+the Software without restriction, including without limitation the rights to -+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -+the Software, and to permit persons to whom the Software is furnished to do so, -+subject to the following conditions: -+ -+The above copyright notice and this permission notice shall be included in all -+copies or substantial portions of the Software. -+ -+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -diff --git a/vendor/github.com/sykesm/zap-logfmt/README.md b/vendor/github.com/sykesm/zap-logfmt/README.md -new file mode 100644 -index 0000000..751f288 ---- /dev/null -+++ b/vendor/github.com/sykesm/zap-logfmt/README.md -@@ -0,0 +1,76 @@ -+# Logfmt Encoder -+ -+This package provides a logfmt encoder for [zap][zap]. -+ -+It is a fork of [github.com/jsternberg/zap-logfmt][jsternberg] that improves -+the handling of reflected fields and encodes arrays and objects instead of -+dropping them from logs. While logging simple fields is preferred for many -+reasons, having ugly data is often better than missing data. -+ -+[![Build Status](https://travis-ci.org/sykesm/zap-logfmt.svg?branch=master)](https://travis-ci.org/sykesm/zap-logfmt) -+[![GoDoc](https://godoc.org/github.com/sykesm/zap-logfmt?status.svg)](https://godoc.org/github.com/sykesm/zap-logfmt) -+ -+## Usage -+ -+The encoder is easy to configure. Simply create a new core with an instance of -+the logfmt encoder and use it with your preferred logging interface. -+ -+```go -+package main -+ -+import ( -+ "os" -+ -+ "github.com/sykesm/zap-logfmt" -+ "go.uber.org/zap" -+ "go.uber.org/zap/zapcore" -+) -+ -+func main() { -+ config := zap.NewProductionEncoderConfig() -+ logger := zap.New(zapcore.NewCore( -+ zaplogfmt.NewEncoder(config), -+ os.Stdout, -+ zapcore.DebugLevel, -+ )) -+ logger.Info("Hello World") -+} -+``` -+ -+## Arrays, Objects, and Reflected Fields -+ -+While it's best to avoid complex data types in log fields, there are times -+when they sneak in. When complex fields are included in log records, they will -+be encoded, but they won't be very pretty. -+ -+### Arrays -+ -+Arrays are encoded as a comma separated list of values within square brackets. -+This format is very similar to JSON encoding. Arrays of simple scalars remain -+quite readable but including elements that require quoting will result in very -+ugly records. -+ -+### Objects -+ -+Objects are encoded as a space separated list of _key=value_ pairs. Because -+this format includes an equals sign, the encoded object will require quoting. -+If any value in the object requires quoting, the required escapes will make -+the encoded field pretty difficult for humans to read. -+ -+### Channels and Functions -+ -+Channels and functions are encoded as their type and their address. There -+aren't many meaningful ways to log channels and functions... -+ -+### Maps and Structs -+ -+Maps and structs are encoded as strings that contain the result of `fmt.Sprint`. -+ -+## Namespaces -+ -+Namespaces are supported. If a namespace is opened, all of the keys will -+be prepended with the namespace name. For example, with the namespace -+`foo` and the key `bar`, you would get a key of `foo.bar`. -+ -+[zap]: https://github.com/uber-go/zap -+[jsternberg]: https://github.com/jsternberg/zap-logfmt -diff --git a/vendor/github.com/sykesm/zap-logfmt/encoder.go b/vendor/github.com/sykesm/zap-logfmt/encoder.go -new file mode 100644 -index 0000000..9e960cc ---- /dev/null -+++ b/vendor/github.com/sykesm/zap-logfmt/encoder.go -@@ -0,0 +1,527 @@ -+// Package zaplogfmt provides a zap encoder that formats log entries in -+// "logfmt" format. -+package zaplogfmt -+ -+import ( -+ "bytes" -+ "encoding" -+ "encoding/base64" -+ "encoding/json" -+ "fmt" -+ "math" -+ "reflect" -+ "strings" -+ "sync" -+ "time" -+ "unicode/utf8" -+ -+ "go.uber.org/zap/buffer" -+ "go.uber.org/zap/zapcore" -+) -+ -+var ( -+ logfmtPool = sync.Pool{ -+ New: func() interface{} { return &logfmtEncoder{} }, -+ } -+ bufferpool = buffer.NewPool() -+) -+ -+func getEncoder() *logfmtEncoder { -+ return logfmtPool.Get().(*logfmtEncoder) -+} -+ -+func putEncoder(enc *logfmtEncoder) { -+ enc.EncoderConfig = nil -+ enc.buf = nil -+ enc.namespaces = nil -+ enc.arrayLiteral = false -+ logfmtPool.Put(enc) -+} -+ -+type logfmtEncoder struct { -+ *zapcore.EncoderConfig -+ buf *buffer.Buffer -+ namespaces []string -+ arrayLiteral bool -+} -+ -+// NewEncoder creates an encoder writes logfmt formatted log entries. -+func NewEncoder(cfg zapcore.EncoderConfig) zapcore.Encoder { -+ return &logfmtEncoder{ -+ EncoderConfig: &cfg, -+ buf: bufferpool.Get(), -+ } -+} -+ -+func (enc *logfmtEncoder) AddArray(key string, arr zapcore.ArrayMarshaler) error { -+ enc.addKey(key) -+ return enc.AppendArray(arr) -+} -+ -+func (enc *logfmtEncoder) AddBinary(key string, value []byte) { -+ enc.AddString(key, base64.StdEncoding.EncodeToString(value)) -+} -+ -+func (enc *logfmtEncoder) AddBool(key string, value bool) { -+ enc.addKey(key) -+ enc.AppendBool(value) -+} -+ -+func (enc *logfmtEncoder) AddByteString(key string, value []byte) { -+ enc.addKey(key) -+ enc.AppendByteString(value) -+} -+ -+func (enc *logfmtEncoder) AddComplex64(k string, v complex64) { enc.AddComplex128(k, complex128(v)) } -+func (enc *logfmtEncoder) AddComplex128(key string, value complex128) { -+ enc.addKey(key) -+ enc.AppendComplex128(value) -+} -+ -+func (enc *logfmtEncoder) AddDuration(key string, value time.Duration) { -+ enc.addKey(key) -+ enc.AppendDuration(value) -+} -+ -+func (enc *logfmtEncoder) AddFloat32(key string, value float32) { -+ enc.addKey(key) -+ enc.AppendFloat32(value) -+} -+ -+func (enc *logfmtEncoder) AddFloat64(key string, value float64) { -+ enc.addKey(key) -+ enc.AppendFloat64(value) -+} -+ -+func (enc *logfmtEncoder) AddInt(k string, v int) { enc.AddInt64(k, int64(v)) } -+func (enc *logfmtEncoder) AddInt8(k string, v int8) { enc.AddInt64(k, int64(v)) } -+func (enc *logfmtEncoder) AddInt32(k string, v int32) { enc.AddInt64(k, int64(v)) } -+func (enc *logfmtEncoder) AddInt16(k string, v int16) { enc.AddInt64(k, int64(v)) } -+func (enc *logfmtEncoder) AddInt64(key string, value int64) { -+ enc.addKey(key) -+ enc.AppendInt64(value) -+} -+ -+func (enc *logfmtEncoder) AddObject(key string, obj zapcore.ObjectMarshaler) error { -+ enc.addKey(key) -+ return enc.AppendObject(obj) -+} -+ -+func (enc *logfmtEncoder) AddReflected(key string, value interface{}) error { -+ enc.addKey(key) -+ return enc.AppendReflected(value) -+} -+ -+func (enc *logfmtEncoder) AddString(key, value string) { -+ enc.addKey(key) -+ enc.AppendString(value) -+} -+ -+func (enc *logfmtEncoder) AddTime(key string, value time.Time) { -+ enc.addKey(key) -+ enc.AppendTime(value) -+} -+ -+func (enc *logfmtEncoder) AddUint(k string, v uint) { enc.AddUint64(k, uint64(v)) } -+func (enc *logfmtEncoder) AddUint8(k string, v uint8) { enc.AddUint64(k, uint64(v)) } -+func (enc *logfmtEncoder) AddUint32(k string, v uint32) { enc.AddUint64(k, uint64(v)) } -+func (enc *logfmtEncoder) AddUint16(k string, v uint16) { enc.AddUint64(k, uint64(v)) } -+func (enc *logfmtEncoder) AddUintptr(k string, v uintptr) { enc.AddUint64(k, uint64(v)) } -+func (enc *logfmtEncoder) AddUint64(key string, value uint64) { -+ enc.addKey(key) -+ enc.AppendUint64(value) -+} -+ -+func (enc *logfmtEncoder) AppendArray(arr zapcore.ArrayMarshaler) error { -+ marshaler := enc.clone() -+ marshaler.namespaces = nil -+ marshaler.arrayLiteral = true -+ -+ marshaler.buf.AppendByte('[') -+ err := arr.MarshalLogArray(marshaler) -+ if err == nil { -+ marshaler.buf.AppendByte(']') -+ enc.AppendByteString(marshaler.buf.Bytes()) -+ } else { -+ enc.AppendByteString(nil) -+ } -+ marshaler.buf.Free() -+ putEncoder(marshaler) -+ return err -+} -+ -+func (enc *logfmtEncoder) AppendBool(value bool) { -+ if value { -+ enc.AppendString("true") -+ } else { -+ enc.AppendString("false") -+ } -+} -+ -+func (enc *logfmtEncoder) AppendByteString(value []byte) { -+ enc.addSeparator() -+ -+ needsQuotes := bytes.IndexFunc(value, needsQuotedValueRune) != -1 -+ if needsQuotes { -+ enc.buf.AppendByte('"') -+ } -+ enc.safeAddByteString(value) -+ if needsQuotes { -+ enc.buf.AppendByte('"') -+ } -+} -+ -+func (enc *logfmtEncoder) AppendComplex64(v complex64) { enc.AppendComplex128(complex128(v)) } -+func (enc *logfmtEncoder) AppendComplex128(value complex128) { -+ enc.addSeparator() -+ -+ // Cast to a platform-independent, fixed-size type. -+ r, i := float64(real(value)), float64(imag(value)) -+ enc.buf.AppendFloat(r, 64) -+ enc.buf.AppendByte('+') -+ enc.buf.AppendFloat(i, 64) -+ enc.buf.AppendByte('i') -+} -+ -+func (enc *logfmtEncoder) AppendDuration(value time.Duration) { -+ cur := enc.buf.Len() -+ if enc.EncodeDuration != nil { -+ enc.EncodeDuration(value, enc) -+ } -+ if cur == enc.buf.Len() { -+ enc.AppendInt64(int64(value)) -+ } -+} -+ -+func (enc *logfmtEncoder) AppendFloat32(v float32) { enc.appendFloat(float64(v), 32) } -+func (enc *logfmtEncoder) AppendFloat64(v float64) { enc.appendFloat(v, 64) } -+func (enc *logfmtEncoder) appendFloat(val float64, bitSize int) { -+ enc.addSeparator() -+ -+ switch { -+ case math.IsNaN(val): -+ enc.buf.AppendString(`NaN`) -+ case math.IsInf(val, 1): -+ enc.buf.AppendString(`+Inf`) -+ case math.IsInf(val, -1): -+ enc.buf.AppendString(`-Inf`) -+ default: -+ enc.buf.AppendFloat(val, bitSize) -+ } -+} -+ -+func (enc *logfmtEncoder) AppendInt(v int) { enc.AppendInt64(int64(v)) } -+func (enc *logfmtEncoder) AppendInt8(v int8) { enc.AppendInt64(int64(v)) } -+func (enc *logfmtEncoder) AppendInt16(v int16) { enc.AppendInt64(int64(v)) } -+func (enc *logfmtEncoder) AppendInt32(v int32) { enc.AppendInt64(int64(v)) } -+func (enc *logfmtEncoder) AppendInt64(value int64) { -+ enc.addSeparator() -+ enc.buf.AppendInt(value) -+} -+ -+func (enc *logfmtEncoder) AppendObject(obj zapcore.ObjectMarshaler) error { -+ marshaler := enc.clone() -+ marshaler.namespaces = nil -+ -+ err := obj.MarshalLogObject(marshaler) -+ if err == nil { -+ enc.AppendByteString(marshaler.buf.Bytes()) -+ } else { -+ enc.AppendByteString(nil) -+ } -+ marshaler.buf.Free() -+ putEncoder(marshaler) -+ return err -+} -+ -+func (enc *logfmtEncoder) AppendReflected(value interface{}) error { -+ switch v := value.(type) { -+ case nil: -+ enc.AppendString("null") -+ case error: -+ enc.AppendString(v.Error()) -+ case []byte: -+ enc.AppendByteString(v) -+ case fmt.Stringer: -+ enc.AppendString(v.String()) -+ case encoding.TextMarshaler: -+ b, err := v.MarshalText() -+ if err != nil { -+ return err -+ } -+ enc.AppendString(string(b)) -+ case json.Marshaler: -+ b, err := v.MarshalJSON() -+ if err != nil { -+ return err -+ } -+ enc.AppendString(string(b)) -+ default: -+ rvalue := reflect.ValueOf(value) -+ switch rvalue.Kind() { -+ case reflect.Bool: -+ enc.AppendBool(rvalue.Bool()) -+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: -+ enc.AppendInt64(rvalue.Int()) -+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: -+ enc.AppendUint64(rvalue.Uint()) -+ case reflect.Float32: -+ enc.appendFloat(rvalue.Float(), 32) -+ case reflect.Float64: -+ enc.AppendFloat64(rvalue.Float()) -+ case reflect.String: -+ enc.AppendString(rvalue.String()) -+ case reflect.Complex64, reflect.Complex128: -+ enc.AppendComplex128(rvalue.Complex()) -+ case reflect.Chan, reflect.Func: -+ enc.AppendString(fmt.Sprintf("%T(%p)", value, value)) -+ case reflect.Map, reflect.Struct: -+ enc.AppendString(fmt.Sprint(value)) -+ case reflect.Array, reflect.Slice: -+ enc.AppendArray(zapcore.ArrayMarshalerFunc(func(ae zapcore.ArrayEncoder) error { -+ for i := 0; i < rvalue.Len(); i++ { -+ ae.AppendReflected(rvalue.Index(i).Interface()) -+ } -+ return nil -+ })) -+ case reflect.Interface, reflect.Ptr: -+ return enc.AppendReflected(rvalue.Elem().Interface()) -+ } -+ } -+ return nil -+} -+ -+func (enc *logfmtEncoder) AppendString(value string) { -+ enc.addSeparator() -+ -+ needsQuotes := strings.IndexFunc(value, needsQuotedValueRune) != -1 -+ if needsQuotes { -+ enc.buf.AppendByte('"') -+ } -+ enc.safeAddString(value) -+ if needsQuotes { -+ enc.buf.AppendByte('"') -+ } -+} -+ -+func (enc *logfmtEncoder) AppendTime(value time.Time) { -+ cur := enc.buf.Len() -+ if enc.EncodeTime != nil { -+ enc.EncodeTime(value, enc) -+ } -+ if cur == enc.buf.Len() { -+ enc.AppendInt64(value.UnixNano()) -+ } -+} -+ -+func (enc *logfmtEncoder) AppendUint(v uint) { enc.AppendUint64(uint64(v)) } -+func (enc *logfmtEncoder) AppendUint8(v uint8) { enc.AppendUint64(uint64(v)) } -+func (enc *logfmtEncoder) AppendUint16(v uint16) { enc.AppendUint64(uint64(v)) } -+func (enc *logfmtEncoder) AppendUint32(v uint32) { enc.AppendUint64(uint64(v)) } -+func (enc *logfmtEncoder) AppendUintptr(v uintptr) { enc.AppendUint64(uint64(v)) } -+func (enc *logfmtEncoder) AppendUint64(value uint64) { -+ enc.addSeparator() -+ enc.buf.AppendUint(value) -+} -+ -+func (enc *logfmtEncoder) Clone() zapcore.Encoder { -+ clone := enc.clone() -+ clone.buf.Write(enc.buf.Bytes()) -+ return clone -+} -+ -+func (enc *logfmtEncoder) clone() *logfmtEncoder { -+ clone := getEncoder() -+ clone.EncoderConfig = enc.EncoderConfig -+ clone.buf = bufferpool.Get() -+ clone.namespaces = enc.namespaces -+ return clone -+} -+ -+func (enc *logfmtEncoder) OpenNamespace(key string) { -+ key = strings.Map(keyRuneFilter, key) -+ enc.namespaces = append(enc.namespaces, key) -+} -+ -+func (enc *logfmtEncoder) EncodeEntry(ent zapcore.Entry, fields []zapcore.Field) (*buffer.Buffer, error) { -+ final := enc.clone() -+ if final.TimeKey != "" { -+ final.AddTime(final.TimeKey, ent.Time) -+ } -+ if final.LevelKey != "" { -+ final.addKey(final.LevelKey) -+ cur := final.buf.Len() -+ if final.EncodeLevel != nil { -+ final.EncodeLevel(ent.Level, final) -+ } -+ if cur == final.buf.Len() { -+ // User-supplied EncodeLevel was a no-op. Fall back to strings to keep -+ // output valid. -+ final.AppendString(ent.Level.String()) -+ } -+ } -+ if ent.LoggerName != "" && final.NameKey != "" { -+ final.addKey(final.NameKey) -+ cur := final.buf.Len() -+ if final.EncodeName != nil { -+ final.EncodeName(ent.LoggerName, final) -+ } -+ if cur == final.buf.Len() { -+ // User-supplied EncodeName was a no-op. Fall back to strings to -+ // keep output valid. -+ final.AppendString(ent.LoggerName) -+ } -+ } -+ if ent.Caller.Defined && final.CallerKey != "" { -+ final.addKey(final.CallerKey) -+ cur := final.buf.Len() -+ if final.EncodeCaller != nil { -+ final.EncodeCaller(ent.Caller, final) -+ } -+ if cur == final.buf.Len() { -+ // User-supplied EncodeCaller was a no-op. Fall back to strings to -+ // keep output valid. -+ final.AppendString(ent.Caller.String()) -+ } -+ } -+ if final.MessageKey != "" { -+ final.addKey(enc.MessageKey) -+ final.AppendString(ent.Message) -+ } -+ if enc.buf.Len() > 0 { -+ if final.buf.Len() > 0 { -+ final.buf.AppendByte(' ') -+ } -+ final.buf.Write(enc.buf.Bytes()) -+ } -+ addFields(final, fields) -+ if ent.Stack != "" && final.StacktraceKey != "" { -+ final.AddString(final.StacktraceKey, ent.Stack) -+ } -+ if final.LineEnding != "" { -+ final.buf.AppendString(final.LineEnding) -+ } else { -+ final.buf.AppendString(zapcore.DefaultLineEnding) -+ } -+ -+ ret := final.buf -+ putEncoder(final) -+ return ret, nil -+} -+ -+func (enc *logfmtEncoder) addSeparator() { -+ if !enc.arrayLiteral { -+ return -+ } -+ -+ last := enc.buf.Len() - 1 -+ if last >= 0 && enc.buf.Bytes()[last] != '[' { -+ enc.buf.AppendByte(',') -+ } -+} -+ -+func (enc *logfmtEncoder) addKey(key string) { -+ key = strings.Map(keyRuneFilter, key) -+ if enc.buf.Len() > 0 { -+ enc.buf.AppendByte(' ') -+ } -+ for _, ns := range enc.namespaces { -+ enc.safeAddString(ns) -+ enc.buf.AppendByte('.') -+ } -+ enc.safeAddString(key) -+ enc.buf.AppendByte('=') -+} -+ -+// safeAddString JSON-escapes a string and appends it to the internal buffer. -+// Unlike the standard library's encoder, it doesn't attempt to protect the -+// user from browser vulnerabilities or JSONP-related problems. -+func (enc *logfmtEncoder) safeAddString(s string) { -+ for i := 0; i < len(s); { -+ if enc.tryAddRuneSelf(s[i]) { -+ i++ -+ continue -+ } -+ r, size := utf8.DecodeRuneInString(s[i:]) -+ if enc.tryAddRuneError(r, size) { -+ i++ -+ continue -+ } -+ enc.buf.AppendString(s[i : i+size]) -+ i += size -+ } -+} -+ -+// safeAddByteString is no-alloc equivalent of safeAddString(string(s)) for s []byte. -+func (enc *logfmtEncoder) safeAddByteString(s []byte) { -+ for i := 0; i < len(s); { -+ if enc.tryAddRuneSelf(s[i]) { -+ i++ -+ continue -+ } -+ r, size := utf8.DecodeRune(s[i:]) -+ if enc.tryAddRuneError(r, size) { -+ i++ -+ continue -+ } -+ enc.buf.Write(s[i : i+size]) -+ i += size -+ } -+} -+ -+// tryAddRuneSelf appends b if it is valid UTF-8 character represented in a single byte. -+func (enc *logfmtEncoder) tryAddRuneSelf(b byte) bool { -+ if b >= utf8.RuneSelf { -+ return false -+ } -+ if 0x20 <= b && b != '\\' && b != '"' { -+ enc.buf.AppendByte(b) -+ return true -+ } -+ switch b { -+ case '\\', '"': -+ enc.buf.AppendByte('\\') -+ enc.buf.AppendByte(b) -+ case '\n': -+ enc.buf.AppendByte('\\') -+ enc.buf.AppendByte('n') -+ case '\r': -+ enc.buf.AppendByte('\\') -+ enc.buf.AppendByte('r') -+ case '\t': -+ enc.buf.AppendByte('\\') -+ enc.buf.AppendByte('t') -+ default: -+ // Encode bytes < 0x20, except for the escape sequences above. -+ const _hex = "0123456789abcdef" -+ enc.buf.AppendString(`\u00`) -+ enc.buf.AppendByte(_hex[b>>4]) -+ enc.buf.AppendByte(_hex[b&0xF]) -+ } -+ return true -+} -+ -+func (enc *logfmtEncoder) tryAddRuneError(r rune, size int) bool { -+ if r == utf8.RuneError && size == 1 { -+ enc.buf.AppendString(`\ufffd`) -+ return true -+ } -+ return false -+} -+ -+func needsQuotedValueRune(r rune) bool { -+ return r <= ' ' || r == '=' || r == '"' || r == utf8.RuneError -+} -+ -+func keyRuneFilter(r rune) rune { -+ if needsQuotedValueRune(r) { -+ return -1 -+ } -+ return r -+} -+ -+func addFields(enc zapcore.ObjectEncoder, fields []zapcore.Field) { -+ for i := range fields { -+ fields[i].AddTo(enc) -+ } -+} -diff --git a/vendor/modules.txt b/vendor/modules.txt -index c6048c9..67935ef 100644 ---- a/vendor/modules.txt -+++ b/vendor/modules.txt -@@ -245,6 +245,9 @@ github.com/spf13/pflag - ## explicit; go 1.13 - github.com/stretchr/testify/assert - github.com/stretchr/testify/require -+# github.com/sykesm/zap-logfmt v0.0.4 -+## explicit; go 1.13 -+github.com/sykesm/zap-logfmt - # github.com/xlab/treeprint v0.0.0-20181112141820-a009c3971eca - ## explicit - github.com/xlab/treeprint --- -2.34.1 - diff --git a/0008-test-rust-os-agent-add-os-agent-unit-tests.patch b/0008-test-rust-os-agent-add-os-agent-unit-tests.patch deleted file mode 100644 index 0b29d7164307e791d10ca2738c042466df1d3785..0000000000000000000000000000000000000000 --- a/0008-test-rust-os-agent-add-os-agent-unit-tests.patch +++ /dev/null @@ -1,817 +0,0 @@ -From e30fcb3c11ba4290b892e7307976b2c2a64c8fee Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Tue, 16 Jan 2024 20:05:26 +0800 -Subject: [PATCH 08/13] test(rust os-agent): add os-agent unit tests - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/agent/src/rpc/agent_impl.rs | 28 +++++---- - KubeOS-Rust/cli/src/client.rs | 23 ++----- - KubeOS-Rust/cli/src/method/callable_method.rs | 28 +++++++++ - KubeOS-Rust/cli/src/method/configure.rs | 31 ++++++++++ - KubeOS-Rust/cli/src/method/prepare_upgrade.rs | 37 +++++++++++ - KubeOS-Rust/cli/src/method/request.rs | 37 +++++++++++ - KubeOS-Rust/cli/src/method/rollback.rs | 13 ++++ - KubeOS-Rust/cli/src/method/upgrade.rs | 13 ++++ - KubeOS-Rust/manager/src/api/types.rs | 58 +++++++++++++++++ - KubeOS-Rust/manager/src/sys_mgmt/config.rs | 62 +++++++++---------- - .../manager/src/sys_mgmt/containerd_image.rs | 22 +------ - .../manager/src/sys_mgmt/disk_image.rs | 7 ++- - .../manager/src/sys_mgmt/docker_image.rs | 4 +- - KubeOS-Rust/manager/src/utils/common.rs | 43 ++++++++++--- - .../manager/src/utils/container_image.rs | 46 ++++++++++++-- - KubeOS-Rust/manager/src/utils/partition.rs | 15 +++++ - 16 files changed, 366 insertions(+), 101 deletions(-) - -diff --git a/KubeOS-Rust/agent/src/rpc/agent_impl.rs b/KubeOS-Rust/agent/src/rpc/agent_impl.rs -index bc1eabd..8aef414 100644 ---- a/KubeOS-Rust/agent/src/rpc/agent_impl.rs -+++ b/KubeOS-Rust/agent/src/rpc/agent_impl.rs -@@ -13,7 +13,7 @@ - use std::{sync::Mutex, thread, time::Duration}; - - use anyhow::{bail, Result}; --use log::{debug, error, info}; -+use log::{debug, info}; - use manager::{ - api::{AgentStatus, ConfigureRequest, ImageType, Response, UpgradeRequest}, - sys_mgmt::{CtrImageHandler, DiskImageHandler, DockerImageHandler, CONFIG_TEMPLATE, DEFAULT_GRUBENV_PATH}, -@@ -101,7 +101,6 @@ impl AgentImpl { - debug!("Found configuration type: \"{}\"", config_type); - configuration.set_config(config)?; - } else { -- error!("Unknown configuration type: \"{}\"", config_type); - bail!("Unknown configuration type: \"{}\"", config_type); - } - } -@@ -123,7 +122,7 @@ impl AgentImpl { - Ok(Response { status: AgentStatus::Rollbacked }) - } - -- pub fn reboot(&self) -> Result<()> { -+ fn reboot(&self) -> Result<()> { - info!("Wait to reboot"); - thread::sleep(Duration::from_secs(1)); - sync(); -@@ -144,7 +143,15 @@ mod test { - use super::*; - - #[test] -- fn configure_impl_tests() { -+ fn test_reboot() { -+ let mut agent = AgentImpl::default(); -+ agent.disable_reboot = true; -+ let res = agent.reboot(); -+ assert!(res.is_ok()); -+ } -+ -+ #[test] -+ fn test_configure() { - let agent = AgentImpl::default(); - let req = ConfigureRequest { - configs: vec![Sysconfig { -@@ -153,7 +160,7 @@ mod test { - contents: HashMap::new(), - }], - }; -- let res = agent.configure_impl(req).unwrap(); -+ let res = agent.configure(req).unwrap(); - assert_eq!(res, Response { status: AgentStatus::Configured }); - - let req = ConfigureRequest { -@@ -163,17 +170,12 @@ mod test { - contents: HashMap::new(), - }], - }; -- let res = agent.configure_impl(req); -+ let res = agent.configure(req); - assert!(res.is_err()); - } - - #[test] -- fn upgrade_impl_tests() { -- let _ = env_logger::builder() -- .target(env_logger::Target::Stdout) -- .filter_level(log::LevelFilter::Trace) -- .is_test(true) -- .try_init(); -+ fn test_prepare_upgrade() { - let agent = AgentImpl::default(); - let req = UpgradeRequest { - version: "v2".into(), -@@ -185,7 +187,7 @@ mod test { - mtls: false, - certs: CertsInfo { ca_cert: "".to_string(), client_cert: "".to_string(), client_key: "".to_string() }, - }; -- let res = agent.prepare_upgrade_impl(req); -+ let res = agent.prepare_upgrade(req); - assert!(res.is_err()); - } - } -diff --git a/KubeOS-Rust/cli/src/client.rs b/KubeOS-Rust/cli/src/client.rs -index ce45cdd..9765a42 100644 ---- a/KubeOS-Rust/cli/src/client.rs -+++ b/KubeOS-Rust/cli/src/client.rs -@@ -43,27 +43,14 @@ impl Client { - - #[cfg(test)] - mod test { -- use kubeos_manager::api; -- - use super::*; -- use crate::method::{callable_method::RpcMethod, configure::ConfigureMethod}; -- - #[test] -- #[ignore] - fn test_client() { -- let socket_path = "/home/yuhang/os-agent-rust.sock"; -+ let socket_path = "/tmp/KubeOS-test.sock"; - let cli = Client::new(socket_path); -- -- let configured = api::AgentStatus::Configured; -- let resp = api::Response { status: configured }; -- let config_request = api::ConfigureRequest { -- configs: vec![api::Sysconfig { -- model: "kernel.sysctl".into(), -- config_path: "".into(), -- contents: std::collections::hash_map::HashMap::new(), -- }], -- }; -- let config_resp = ConfigureMethod::new(config_request).call(&cli).unwrap(); -- assert_eq!(resp, config_resp); -+ let command = "example_command"; -+ let params = vec![]; -+ let request = cli.send_request(cli.build_request(command, ¶ms)); -+ assert!(request.is_err()); - } - } -diff --git a/KubeOS-Rust/cli/src/method/callable_method.rs b/KubeOS-Rust/cli/src/method/callable_method.rs -index c46614b..a174b5b 100644 ---- a/KubeOS-Rust/cli/src/method/callable_method.rs -+++ b/KubeOS-Rust/cli/src/method/callable_method.rs -@@ -24,3 +24,31 @@ pub trait RpcMethod { - response.result().map_err(parse_error) - } - } -+ -+#[cfg(test)] -+mod tests { -+ use super::*; -+ use crate::client; -+ -+ #[derive(Default)] -+ struct DummyMethod; -+ -+ impl RpcMethod for DummyMethod { -+ type Response = String; -+ -+ fn command_name(&self) -> &'static str { -+ "dummy_command" -+ } -+ -+ fn command_params(&self) -> Vec> { -+ vec![] -+ } -+ } -+ -+ #[test] -+ fn test_call() { -+ let client = client::Client::new("/tmp/KubeOS-test.sock"); -+ let result = DummyMethod::default().call(&client); -+ assert!(result.is_err()); -+ } -+} -diff --git a/KubeOS-Rust/cli/src/method/configure.rs b/KubeOS-Rust/cli/src/method/configure.rs -index d137106..cca752d 100644 ---- a/KubeOS-Rust/cli/src/method/configure.rs -+++ b/KubeOS-Rust/cli/src/method/configure.rs -@@ -39,3 +39,34 @@ impl RpcMethod for ConfigureMethod { - vec![to_raw_value(&self.req).unwrap()] - } - } -+#[cfg(test)] -+mod tests { -+ use kubeos_manager::api::{ConfigureRequest, Sysconfig}; -+ -+ use super::*; -+ -+ #[test] -+ fn test_configure_method() { -+ let req = ConfigureRequest { configs: vec![] }; -+ let mut method = ConfigureMethod::new(req); -+ -+ // Test set_configure_request method -+ let new_req = ConfigureRequest { -+ configs: vec![Sysconfig { -+ model: "model".to_string(), -+ config_path: "config_path".to_string(), -+ contents: Default::default(), -+ }], -+ }; -+ method.set_configure_request(new_req); -+ -+ // Test command_name method -+ assert_eq!(method.command_name(), "configure"); -+ -+ // Test command_params method -+ let expected_params = -+ "RawValue({\"configs\":[{\"model\":\"model\",\"config_path\":\"config_path\",\"contents\":{}}]})"; -+ let actual_params = format!("{:?}", method.command_params()[0]); -+ assert_eq!(actual_params, expected_params); -+ } -+} -diff --git a/KubeOS-Rust/cli/src/method/prepare_upgrade.rs b/KubeOS-Rust/cli/src/method/prepare_upgrade.rs -index 91dae79..f2034f6 100644 ---- a/KubeOS-Rust/cli/src/method/prepare_upgrade.rs -+++ b/KubeOS-Rust/cli/src/method/prepare_upgrade.rs -@@ -39,3 +39,40 @@ impl RpcMethod for PrepareUpgradeMethod { - vec![to_raw_value(&self.req).unwrap()] - } - } -+#[cfg(test)] -+mod tests { -+ use kubeos_manager::api::{CertsInfo, UpgradeRequest}; -+ -+ use super::*; -+ -+ #[test] -+ fn test_prepare_upgrade_method() { -+ let req = UpgradeRequest { -+ version: "v1".into(), -+ check_sum: "".into(), -+ image_type: "".into(), -+ container_image: "".into(), -+ image_url: "".to_string(), -+ flag_safe: false, -+ mtls: false, -+ certs: CertsInfo { ca_cert: "".to_string(), client_cert: "".to_string(), client_key: "".to_string() }, -+ }; -+ let mut method = PrepareUpgradeMethod::new(req); -+ let new_req = UpgradeRequest { -+ version: "v2".into(), -+ check_sum: "xxx".into(), -+ image_type: "xxx".into(), -+ container_image: "xxx".into(), -+ image_url: "".to_string(), -+ flag_safe: false, -+ mtls: false, -+ certs: CertsInfo { ca_cert: "".to_string(), client_cert: "".to_string(), client_key: "".to_string() }, -+ }; -+ method.set_prepare_upgrade_request(new_req); -+ assert_eq!(method.command_name(), "prepare_upgrade"); -+ -+ let expected_params = "RawValue({\"version\":\"v2\",\"check_sum\":\"xxx\",\"image_type\":\"xxx\",\"container_image\":\"xxx\",\"image_url\":\"\",\"flag_safe\":false,\"mtls\":false,\"certs\":{\"ca_cert\":\"\",\"client_cert\":\"\",\"client_key\":\"\"}})"; -+ let actual_params = format!("{:?}", method.command_params()[0]); -+ assert_eq!(actual_params, expected_params); -+ } -+} -diff --git a/KubeOS-Rust/cli/src/method/request.rs b/KubeOS-Rust/cli/src/method/request.rs -index 2dc1ffb..ff75afd 100644 ---- a/KubeOS-Rust/cli/src/method/request.rs -+++ b/KubeOS-Rust/cli/src/method/request.rs -@@ -50,3 +50,40 @@ pub fn parse_error(error: Error) -> anyhow::Error { - }, - } - } -+ -+#[cfg(test)] -+mod tests { -+ use jsonrpc::error::RpcError; -+ use serde::de::Error as DeError; -+ -+ use super::*; -+ -+ #[test] -+ fn test_parse_error() { -+ // Test Error::Transport -+ let transport_error = -+ Error::Transport(Box::new(std::io::Error::new(std::io::ErrorKind::Other, "Connection timeout"))); -+ let result = parse_error(transport_error); -+ assert_eq!(result.to_string(), "Cannot connect to KubeOS os-agent unix socket, Connection timeout"); -+ -+ // Test Error::Json -+ let json_error = Error::Json(serde_json::Error::custom("Failed to parse response")); -+ let result = parse_error(json_error); -+ assert_eq!(result.to_string(), "Failed to parse response"); -+ -+ // Test Error::Rpc with "Method not found" message -+ let rpc_error = Error::Rpc(RpcError { code: -32601, message: "Method not found".to_string(), data: None }); -+ let result = parse_error(rpc_error); -+ assert_eq!(result.to_string(), "Method is unimplemented"); -+ -+ // Test Error::Rpc with other message -+ let rpc_error = Error::Rpc(RpcError { code: -32603, message: "Internal server error".to_string(), data: None }); -+ let result = parse_error(rpc_error); -+ assert_eq!(result.to_string(), "Internal server error"); -+ -+ // Test other Error variant -+ let other_error = Error::VersionMismatch; -+ let result = parse_error(other_error); -+ assert_eq!(result.to_string(), "Response is invalid"); -+ } -+} -diff --git a/KubeOS-Rust/cli/src/method/rollback.rs b/KubeOS-Rust/cli/src/method/rollback.rs -index 55aa751..7945f4b 100644 ---- a/KubeOS-Rust/cli/src/method/rollback.rs -+++ b/KubeOS-Rust/cli/src/method/rollback.rs -@@ -27,3 +27,16 @@ impl RpcMethod for RollbackMethod { - vec![] - } - } -+ -+#[cfg(test)] -+mod tests { -+ use super::*; -+ #[test] -+ fn test_rollback_method() { -+ let method = RollbackMethod::default(); -+ assert_eq!(method.command_name(), "rollback"); -+ let expected_params = "[]"; -+ let actual_params = format!("{:?}", method.command_params()); -+ assert_eq!(actual_params, expected_params); -+ } -+} -diff --git a/KubeOS-Rust/cli/src/method/upgrade.rs b/KubeOS-Rust/cli/src/method/upgrade.rs -index a9692ca..f2f94cd 100644 ---- a/KubeOS-Rust/cli/src/method/upgrade.rs -+++ b/KubeOS-Rust/cli/src/method/upgrade.rs -@@ -27,3 +27,16 @@ impl RpcMethod for UpgradeMethod { - vec![] - } - } -+ -+#[cfg(test)] -+mod tests { -+ use super::*; -+ #[test] -+ fn test_upgrade_method() { -+ let method = UpgradeMethod::default(); -+ assert_eq!(method.command_name(), "upgrade"); -+ let expected_params = "[]"; -+ let actual_params = format!("{:?}", method.command_params()); -+ assert_eq!(actual_params, expected_params); -+ } -+} -diff --git a/KubeOS-Rust/manager/src/api/types.rs b/KubeOS-Rust/manager/src/api/types.rs -index 28ee97d..98aeaa3 100644 ---- a/KubeOS-Rust/manager/src/api/types.rs -+++ b/KubeOS-Rust/manager/src/api/types.rs -@@ -80,3 +80,61 @@ impl ImageType { - pub trait ImageHandler { - fn download_image(&self, req: &UpgradeRequest) -> anyhow::Result>; - } -+ -+#[cfg(test)] -+mod tests { -+ use anyhow::Result; -+ use mockall::mock; -+ -+ use super::*; -+ use crate::utils::PreparePath; -+ -+ mock! { -+ pub CommandExec{} -+ impl CommandExecutor for CommandExec { -+ fn run_command<'a>(&self, name: &'a str, args: &[&'a str]) -> Result<()>; -+ fn run_command_with_output<'a>(&self, name: &'a str, args: &[&'a str]) -> Result; -+ } -+ impl Clone for CommandExec { -+ fn clone(&self) -> Self; -+ } -+ } -+ -+ #[test] -+ fn test_download_image() { -+ let req = UpgradeRequest { -+ version: "KubeOS v2".to_string(), -+ image_type: "containerd".to_string(), -+ container_image: "kubeos-temp".to_string(), -+ check_sum: "22222".to_string(), -+ image_url: "".to_string(), -+ flag_safe: false, -+ mtls: false, -+ certs: CertsInfo { ca_cert: "".to_string(), client_cert: "".to_string(), client_key: "".to_string() }, -+ }; -+ -+ let mut mock_executor1 = MockCommandExec::new(); -+ mock_executor1.expect_run_command().returning(|_, _| Ok(())); -+ mock_executor1.expect_run_command_with_output().returning(|_, _| Ok(String::new())); -+ let c_handler = CtrImageHandler::new(PreparePath::default(), mock_executor1); -+ let image_type = ImageType::Containerd(c_handler); -+ let result = image_type.download_image(&req); -+ assert!(result.is_err()); -+ -+ let mut mock_executor2 = MockCommandExec::new(); -+ mock_executor2.expect_run_command().returning(|_, _| Ok(())); -+ mock_executor2.expect_run_command_with_output().returning(|_, _| Ok(String::new())); -+ let docker_handler = DockerImageHandler::new(PreparePath::default(), "test".into(), mock_executor2); -+ let image_type = ImageType::Docker(docker_handler); -+ let result = image_type.download_image(&req); -+ assert!(result.is_err()); -+ -+ let mut mock_executor3 = MockCommandExec::new(); -+ mock_executor3.expect_run_command().returning(|_, _| Ok(())); -+ mock_executor3.expect_run_command_with_output().returning(|_, _| Ok(String::new())); -+ let disk_handler = DiskImageHandler::new(PreparePath::default(), mock_executor3, "test".into()); -+ let image_type = ImageType::Disk(disk_handler); -+ let result = image_type.download_image(&req); -+ assert!(result.is_err()); -+ } -+} -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/config.rs b/KubeOS-Rust/manager/src/sys_mgmt/config.rs -index cb5fad1..48517b4 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/config.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/config.rs -@@ -186,7 +186,7 @@ fn handle_delete_key(config_kv: &Vec<&str>, new_config_info: &KeyInfo) -> String - return config_kv.join("="); - } - info!("Delete configuration {}={}", key, old_value); -- String::from("") -+ String::new() - } - - fn handle_update_key(config_kv: &Vec<&str>, new_config_info: &KeyInfo) -> String { -@@ -413,11 +413,20 @@ mod tests { - let mut tmp_file = tempfile::NamedTempFile::new().unwrap(); - writeln!(tmp_file, "{}", comment).unwrap(); - writeln!(tmp_file, "a=0").unwrap(); -+ writeln!(tmp_file, "d=4").unwrap(); -+ writeln!(tmp_file, "e=5").unwrap(); -+ writeln!(tmp_file, "g=7").unwrap(); - let kernel_sysctl_persist = KernelSysctlPersist {}; - let config_detail = HashMap::from([ - ("a".to_string(), KeyInfo { value: "1".to_string(), operation: "".to_string() }), - ("b".to_string(), KeyInfo { value: "2".to_string(), operation: "delete".to_string() }), - ("c".to_string(), KeyInfo { value: "3".to_string(), operation: "add".to_string() }), -+ ("d".to_string(), KeyInfo { value: "".to_string(), operation: "".to_string() }), -+ ("e".to_string(), KeyInfo { value: "".to_string(), operation: "delete".to_string() }), -+ ("f".to_string(), KeyInfo { value: "".to_string(), operation: "add".to_string() }), -+ ("g".to_string(), KeyInfo { value: "7".to_string(), operation: "delete".to_string() }), -+ ("".to_string(), KeyInfo { value: "8".to_string(), operation: "".to_string() }), -+ ("s=x".to_string(), KeyInfo { value: "8".to_string(), operation: "".to_string() }), - ]); - let mut config = Sysconfig { - model: KERNEL_SYSCTL_PERSIST.to_string(), -@@ -426,33 +435,16 @@ mod tests { - }; - kernel_sysctl_persist.set_config(&mut config).unwrap(); - let result = fs::read_to_string(tmp_file.path().to_str().unwrap()).unwrap(); -- let expected_res = format!("{}\n{}\n{}\n", comment, "a=1", "c=3"); -+ let expected_res = format!("{}\n{}\n{}\n{}\n{}\n", comment, "a=1", "d=4", "e=5", "c=3"); - assert_eq!(result, expected_res); -- -- // test config_path is empty -- // remember modify DEFAULT_KERNEL_CONFIG_PATH first -- // let config_detail = HashMap::from([ -- // ( -- // "aaa".to_string(), -- // KeyInfo { -- // value: "3".to_string(), -- // operation: "add".to_string(), -- // }, -- // ), -- // ( -- // "bbb".to_string(), -- // KeyInfo { -- // value: "1".to_string(), -- // operation: "delete".to_string(), -- // }, -- // ), -- // ]); -- // config.config_path = "".to_string(); -- // config.contents = config_detail; -- // kernel_sysctl_persist.set_config(&mut config).unwrap(); -- // let result = fs::read_to_string(crate::sys_mgmt::DEFAULT_KERNEL_CONFIG_PATH).unwrap(); -- // let expected_res = format!("{}\n", "aaa=3",); -- // assert_eq!(result, expected_res); -+ let mut config = Sysconfig { -+ model: KERNEL_SYSCTL_PERSIST.to_string(), -+ config_path: String::from("/tmp/kubeos-test-kernel-sysctl-persist.txt"), -+ contents: HashMap::new(), -+ }; -+ kernel_sysctl_persist.set_config(&mut config).unwrap(); -+ assert!(is_file_exist(&config.config_path)); -+ delete_file_or_dir(&config.config_path).unwrap(); - } - - #[test] -@@ -492,7 +484,7 @@ menuentry 'B' --class KubeOS --class gnu-linux --class gnu --class os --unrestri - initrd /boot/initramfs.img - }"; - writeln!(tmp_file, "{}", grub_cfg).unwrap(); -- let config_first_part = HashMap::from([ -+ let config_second_part = HashMap::from([ - ("debug".to_string(), KeyInfo { value: "".to_string(), operation: "".to_string() }), - ("quiet".to_string(), KeyInfo { value: "".to_string(), operation: "delete".to_string() }), - ("panic".to_string(), KeyInfo { value: "5".to_string(), operation: "".to_string() }), -@@ -506,15 +498,16 @@ menuentry 'B' --class KubeOS --class gnu-linux --class gnu --class os --unrestri - let mut config = Sysconfig { - model: GRUB_CMDLINE_CURRENT.to_string(), - config_path: String::new(), -- contents: config_first_part, -+ contents: config_second_part, - }; - grub_cmdline.set_config(&mut config).unwrap(); - grub_cmdline.is_cur_partition = false; -- let config_second = HashMap::from([ -+ let config_first_part = HashMap::from([ - ("pci".to_string(), KeyInfo { value: "nomis".to_string(), operation: "".to_string() }), -- ("panic".to_string(), KeyInfo { value: "5".to_string(), operation: "".to_string() }), -+ ("quiet".to_string(), KeyInfo { value: "11".to_string(), operation: "delete".to_string() }), -+ ("panic".to_string(), KeyInfo { value: "5".to_string(), operation: "update".to_string() }), - ]); -- config.contents = config_second; -+ config.contents = config_first_part; - config.model = GRUB_CMDLINE_NEXT.to_string(); - grub_cmdline.set_config(&mut config).unwrap(); - let result = fs::read_to_string(tmp_file.path().to_str().unwrap()).unwrap(); -@@ -540,6 +533,11 @@ menuentry 'B' --class KubeOS --class gnu-linux --class gnu --class os --unrestri - } - "; - assert_eq!(result, expected_res); -+ -+ // test grub.cfg not exist -+ grub_cmdline.grub_path = "/tmp/grub-KubeOS-test.cfg".to_string(); -+ let res = grub_cmdline.set_config(&mut config); -+ assert!(res.is_err()); - } - - #[test] -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -index 0b50ad6..dd7036f 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -@@ -48,7 +48,7 @@ impl Default for CtrImageHandler { - - impl CtrImageHandler { - #[cfg(test)] -- fn new(paths: PreparePath, executor: T) -> Self { -+ pub fn new(paths: PreparePath, executor: T) -> Self { - Self { paths, executor } - } - -@@ -301,24 +301,4 @@ mod tests { - - assert!(result.is_ok()); - } -- -- #[test] -- #[ignore] -- fn test_download_image() { -- init(); -- let ctr = CtrImageHandler { paths: PreparePath::default(), executor: RealCommandExecutor {} }; -- let update_req = UpgradeRequest { -- version: "KubeOS v2".to_string(), -- image_type: "containerd".to_string(), -- container_image: "docker.io/library/busybox:latest".to_string(), -- check_sum: "".to_string(), -- image_url: "".to_string(), -- flag_safe: false, -- mtls: false, -- certs: CertsInfo { ca_cert: "".to_string(), client_cert: "".to_string(), client_key: "".to_string() }, -- }; -- ctr.download_image(&update_req).unwrap(); -- let tar_path = "/persist/KubeOS-Update/os.tar"; -- assert_eq!(true, Path::new(tar_path).exists()); -- } - } -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -index 4ccb603..a120db8 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -@@ -41,7 +41,7 @@ impl Default for DiskImageHandler { - - impl DiskImageHandler { - #[cfg(test)] -- fn new(paths: PreparePath, executor: T, certs_path: String) -> Self { -+ pub fn new(paths: PreparePath, executor: T, certs_path: String) -> Self { - Self { paths, executor, certs_path } - } - -@@ -392,11 +392,14 @@ mod tests { - .with_body("This is a test txt file for KubeOS test.\n") - .create(); - handler.download_image(&upgrade_request).unwrap(); -- - assert_eq!(true, handler.paths.image_path.exists()); - assert_eq!( - fs::read(handler.paths.image_path.to_str().unwrap()).unwrap(), - "This is a test txt file for KubeOS test.\n".as_bytes() - ); -+ -+ let _m = mockito::mock("GET", "/test.txt").with_status(404).with_body("Not found").create(); -+ let res = handler.download_image(&upgrade_request); -+ assert!(res.is_err()) - } - } -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -index 121e257..177dfeb 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -@@ -33,7 +33,7 @@ impl Default for DockerImageHandler { - - impl DockerImageHandler { - #[cfg(test)] -- fn new(paths: PreparePath, container_name: String, executor: T) -> Self { -+ pub fn new(paths: PreparePath, container_name: String, executor: T) -> Self { - Self { paths, container_name, executor } - } - -@@ -129,6 +129,8 @@ mod tests { - let result = - DockerImageHandler::new(PreparePath::default(), "test".into(), mock_executor).check_and_rm_container(); - assert!(result.is_ok()); -+ -+ assert_eq!(DockerImageHandler::default().container_name, "kubeos-temp"); - } - - #[test] -diff --git a/KubeOS-Rust/manager/src/utils/common.rs b/KubeOS-Rust/manager/src/utils/common.rs -index 301a8c8..da8c8c3 100644 ---- a/KubeOS-Rust/manager/src/utils/common.rs -+++ b/KubeOS-Rust/manager/src/utils/common.rs -@@ -23,14 +23,25 @@ use nix::{mount, mount::MntFlags}; - use super::executor::CommandExecutor; - use crate::sys_mgmt::{MOUNT_DIR, OS_IMAGE_NAME, PERSIST_DIR, ROOTFS_ARCHIVE, UPDATE_DIR}; - -+/// * persist_path: /persist -+/// -+/// * update_path: /persist/KubeOS-Update -+/// -+/// * mount_path: /persist/KubeOS-Update/kubeos-update -+/// -+/// * tar_path: /persist/KubeOS-Update/os.tar -+/// -+/// * image_path: /persist/update.img -+/// -+/// * rootfs_file: os.tar - #[derive(Clone)] - pub struct PreparePath { -- pub persist_path: PathBuf, // persist_path: /persist -- pub update_path: PathBuf, // update_path: /persist/KubeOS-Update -- pub mount_path: PathBuf, // mount_path: /persist/KubeOS-Update/kubeos-update -- pub tar_path: PathBuf, // tar_path: /persist/KubeOS-Update/os.tar -- pub image_path: PathBuf, // image_path: /persist/update.img -- pub rootfs_file: String, // rootfs_file: os.tar -+ pub persist_path: PathBuf, -+ pub update_path: PathBuf, -+ pub mount_path: PathBuf, -+ pub tar_path: PathBuf, -+ pub image_path: PathBuf, -+ pub rootfs_file: String, - } - - impl Default for PreparePath { -@@ -72,7 +83,7 @@ pub fn check_disk_size>(need_bytes: i64, path: P) -> Result<()> { - Ok(()) - } - --// clean_env will umount the mount path and delete directory /persist/KubeOS-Update and /persist/update.img -+/// clean_env will umount the mount path and delete directory /persist/KubeOS-Update and /persist/update.img - pub fn clean_env

(update_path: P, mount_path: P, image_path: P) -> Result<()> - where - P: AsRef, -@@ -160,6 +171,7 @@ mod tests { - use tempfile::{NamedTempFile, TempDir}; - - use super::*; -+ use crate::utils::RealCommandExecutor; - - // Mock the CommandExecutor trait - mock! { -@@ -278,10 +290,23 @@ mod tests { - } - - #[test] -- #[ignore] - fn test_get_boot_mode() { - init(); - let boot_mode = get_boot_mode(); -- assert!(boot_mode == "uefi"); -+ let executor = RealCommandExecutor {}; -+ let res = executor.run_command("ls", &["/sys/firmware/efi"]); -+ if res.is_ok() { -+ assert!(boot_mode == "uefi"); -+ } else { -+ assert!(boot_mode == "bios"); -+ } -+ } -+ -+ #[test] -+ fn test_is_command_available() { -+ init(); -+ let executor = RealCommandExecutor {}; -+ assert_eq!(is_command_available("ls", &executor), true); -+ assert_eq!(is_command_available("aaaabb", &executor), false); - } - } -diff --git a/KubeOS-Rust/manager/src/utils/container_image.rs b/KubeOS-Rust/manager/src/utils/container_image.rs -index a54fc19..7c3aa02 100644 ---- a/KubeOS-Rust/manager/src/utils/container_image.rs -+++ b/KubeOS-Rust/manager/src/utils/container_image.rs -@@ -197,12 +197,24 @@ mod tests { - let out1 = get_oci_image_digest(container_runtime, image_name, &mock).unwrap(); - let expect_output = "1111"; - assert_eq!(out1, expect_output); -+ mock.expect_run_command_with_output().times(1).returning(|_, _| Ok("invalid output".to_string())); -+ let out2 = get_oci_image_digest(container_runtime, image_name, &mock); -+ assert!(out2.is_err()); - - let container_runtime = "crictl"; - let command_output2 = "[docker.io/nginx@sha256:1111]"; - mock.expect_run_command_with_output().times(1).returning(|_, _| Ok(command_output2.to_string())); -- let out2 = get_oci_image_digest(container_runtime, image_name, &mock).unwrap(); -- assert_eq!(out2, expect_output); -+ let out3 = get_oci_image_digest(container_runtime, image_name, &mock).unwrap(); -+ assert_eq!(out3, expect_output); -+ -+ let out4 = get_oci_image_digest("invalid", image_name, &mock); -+ assert!(out4.is_err()); -+ -+ let container_runtime = "crictl"; -+ let command_output3 = "[docker.io/nginx:sha256:1111]"; -+ mock.expect_run_command_with_output().times(1).returning(|_, _| Ok(command_output3.to_string())); -+ let out5 = get_oci_image_digest(container_runtime, image_name, &mock); -+ assert!(out5.is_err()); - } - - #[test] -@@ -211,11 +223,13 @@ mod tests { - let mut mock = MockCommandExec::new(); - let image_name = "docker.io/nginx:latest"; - let container_runtime = "crictl"; -- let command_output = "[docker.io/nginx@sha256:1111]"; -- let check_sum = "1111"; -- mock.expect_run_command_with_output().times(1).returning(|_, _| Ok(command_output.to_string())); -+ let command_output = "[docker.io/nginx@sha256:1a2b]"; -+ let check_sum = "1A2B"; -+ mock.expect_run_command_with_output().times(2).returning(|_, _| Ok(command_output.to_string())); - let result = check_oci_image_digest(container_runtime, image_name, check_sum, &mock); - assert!(result.is_ok()); -+ let result = check_oci_image_digest(container_runtime, image_name, "1111", &mock); -+ assert!(result.is_err()); - } - - #[test] -@@ -251,4 +265,26 @@ mod tests { - let result = pull_image("aaa", image_name, &mock_executor); - assert!(result.is_err()); - } -+ -+ #[test] -+ fn test_remove_image_if_exist() { -+ init(); -+ let mut mock_executor = MockCommandExec::new(); -+ mock_executor -+ .expect_run_command_with_output() -+ .withf(|cmd, args| cmd == "ctr" && args.contains(&"check")) // simplified with a closure -+ .times(1) -+ .returning(|_, _| Ok(String::from("something"))); -+ mock_executor -+ .expect_run_command() -+ .withf(|cmd, args| cmd == "ctr" && args.contains(&"rm")) // simplified with a closure -+ .times(1) -+ .returning(|_, _| Ok(())); -+ let image_name = "docker.io/nginx:latest"; -+ let res = remove_image_if_exist("ctr", image_name, &mock_executor); -+ assert!(res.is_ok()); -+ -+ let res = remove_image_if_exist("invalid", image_name, &mock_executor); -+ assert!(res.is_err()); -+ } - } -diff --git a/KubeOS-Rust/manager/src/utils/partition.rs b/KubeOS-Rust/manager/src/utils/partition.rs -index 0419159..fcfa2d8 100644 ---- a/KubeOS-Rust/manager/src/utils/partition.rs -+++ b/KubeOS-Rust/manager/src/utils/partition.rs -@@ -22,6 +22,7 @@ pub struct PartitionInfo { - pub fs_type: String, - } - -+/// get_partition_info returns the current partition info and the next partition info. - pub fn get_partition_info(executor: &T) -> Result<(PartitionInfo, PartitionInfo), anyhow::Error> { - let lsblk = executor.run_command_with_output("lsblk", &["-lno", "NAME,MOUNTPOINTS,FSTYPE"])?; - // After split whitespace, the root directory line should have 3 elements, which are "sda2 / ext4". -@@ -93,5 +94,19 @@ mod tests { - PartitionInfo { device: "/dev/sda3".to_string(), menuentry: "B".to_string(), fs_type: "ext4".to_string() }, - ); - assert_eq!(res, expect_res); -+ -+ let command_output2 = "sda\nsda1 /boot/efi vfat\nsda2 ext4\nsda3 / ext4\nsda4 /persist ext4\nsr0 iso9660\n"; -+ mock.expect_run_command_with_output().times(1).returning(|_, _| Ok(command_output2.to_string())); -+ let res = get_partition_info(&mock).unwrap(); -+ let expect_res = ( -+ PartitionInfo { device: "/dev/sda3".to_string(), menuentry: "B".to_string(), fs_type: "ext4".to_string() }, -+ PartitionInfo { device: "/dev/sda2".to_string(), menuentry: "A".to_string(), fs_type: "ext4".to_string() }, -+ ); -+ assert_eq!(res, expect_res); -+ -+ let command_output3 = ""; -+ mock.expect_run_command_with_output().times(1).returning(|_, _| Ok(command_output3.to_string())); -+ let res = get_partition_info(&mock); -+ assert!(res.is_err()); - } - } --- -2.34.1 - diff --git a/0009-fix-checksum-comparison-log-format.patch b/0009-fix-checksum-comparison-log-format.patch deleted file mode 100644 index 9b5dffaaabdedcc8ffadb41eda4ffe09840df311..0000000000000000000000000000000000000000 --- a/0009-fix-checksum-comparison-log-format.patch +++ /dev/null @@ -1,52 +0,0 @@ -From 23b76996928a59e5472a288e40980fc8ba4b1e34 Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Wed, 24 Jan 2024 10:39:27 +0800 -Subject: [PATCH 09/13] fix: checksum comparison log format - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs | 9 +++++---- - 1 file changed, 5 insertions(+), 4 deletions(-) - -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -index 4ccb603..f60d714 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -@@ -72,13 +72,14 @@ impl DiskImageHandler { - - fn checksum_match(&self, file_path: &str, check_sum: &str) -> Result<()> { - trace!("Start to check checksum"); -+ let check_sum = check_sum.to_ascii_lowercase(); - let file = fs::read(file_path)?; - let mut hasher = Sha256::new(); - hasher.update(file); - let hash = hasher.finalize(); - // sha256sum -b /persist/update.img -- let cal_sum = format!("{:X}", hash); -- if cal_sum.to_lowercase() != check_sum.to_lowercase() { -+ let cal_sum = format!("{:X}", hash).to_ascii_lowercase(); -+ if cal_sum != check_sum { - delete_file_or_dir(file_path)?; - bail!("Checksum {} mismatch to {}", cal_sum, check_sum); - } -@@ -302,7 +303,7 @@ mod tests { - handler.paths.image_path = tmp_file.path().to_path_buf(); - let mut req = UpgradeRequest { - version: "v2".into(), -- check_sum: "98ea7aff44631d183e6df3488f1107357d7503e11e5f146effdbfd11810cd4a2".into(), -+ check_sum: "98Ea7aff44631D183e6df3488f1107357d7503e11e5f146effdbfd11810cd4a2".into(), - image_type: "disk".into(), - container_image: "".into(), - image_url: "http://localhost:8080/aaa.txt".to_string(), -@@ -313,7 +314,7 @@ mod tests { - assert_eq!(handler.paths.image_path.exists(), true); - handler.checksum_match(handler.paths.image_path.to_str().unwrap(), &req.check_sum).unwrap(); - -- req.check_sum = "1234567890".into(); -+ req.check_sum = "1234567Abc".into(); - let res = handler.checksum_match(handler.paths.image_path.to_str().unwrap(), &req.check_sum); - assert!(res.is_err()); - } --- -2.34.1 - diff --git a/0010-fix-check-image-name-is-valid-regex.patch b/0010-fix-check-image-name-is-valid-regex.patch deleted file mode 100644 index f0739e3eb4b1d0f415ee7745aab90c008cf6e1e0..0000000000000000000000000000000000000000 --- a/0010-fix-check-image-name-is-valid-regex.patch +++ /dev/null @@ -1,106 +0,0 @@ -From f2c736335868873cd0cb7562a7ba95ee7c19a315 Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Thu, 25 Jan 2024 11:57:16 +0800 -Subject: [PATCH 10/13] fix: check image name is valid regex - -the regex for checking the validity of the container image image is wrong in case of "IP:PORT@sha256:111" - -Signed-off-by: Yuhang Wei ---- - .../manager/src/utils/container_image.rs | 73 ++++++++++++++++--- - 1 file changed, 62 insertions(+), 11 deletions(-) - -diff --git a/KubeOS-Rust/manager/src/utils/container_image.rs b/KubeOS-Rust/manager/src/utils/container_image.rs -index a54fc19..dc31925 100644 ---- a/KubeOS-Rust/manager/src/utils/container_image.rs -+++ b/KubeOS-Rust/manager/src/utils/container_image.rs -@@ -17,7 +17,7 @@ use regex::Regex; - use super::executor::CommandExecutor; - - pub fn is_valid_image_name(image: &str) -> Result<()> { -- let pattern = r"^(?P[a-z0-9\-.]+\.[a-z0-9\-]+:?[0-9]*)?/?((?P[a-zA-Z0-9-_]+?)|(?P[a-zA-Z0-9-_]+?)/(?P[a-zA-Z-_]+?))(?P(?::[\w_.-]+)?|(?:@sha256:[a-fA-F0-9]+)?)$"; -+ let pattern = r"^((?:[\w.-]+)(?::\d+)?/)*(?:[\w.-]+)((?::[\w_.-]+)?|(?:@sha256:[a-fA-F0-9]+)?)$"; - let reg_ex = Regex::new(pattern)?; - if !reg_ex.is_match(image) { - bail!("Invalid image name: {}", image); -@@ -172,16 +172,67 @@ mod tests { - #[test] - fn test_is_valid_image_name() { - init(); -- let out = is_valid_image_name("nginx").unwrap(); -- assert_eq!(out, ()); -- let out = -- is_valid_image_name("docker.example.com:5000/gmr/alpine@sha256:11111111111111111111111111111111").unwrap(); -- assert_eq!(out, ()); -- let out = -- is_valid_image_name("sosedoff/pgweb:latest@sha256:5a156ff125e5a12ac7ff43ee5120fa249cf62248337b6d04574c8"); -- match out { -- Ok(_) => assert_eq!(true, false), -- Err(_) => assert_eq!(true, true), -+ let correct_images = vec![ -+ "alpine", -+ "alpine:latest", -+ "localhost/latest", -+ "library/alpine", -+ "localhost:1234/test", -+ "test:1234/blaboon", -+ "alpine:3.7", -+ "docker.example.edu/gmr/alpine:3.7", -+ "docker.example.com:5000/gmr/alpine@sha256:5a156ff125e5a12ac7ff43ee5120fa249cf62248337b6d04abc574c8", -+ "docker.example.co.uk/gmr/alpine/test2:latest", -+ "registry.dobby.org/dobby/dobby-servers/arthound:2019-08-08", -+ "owasp/zap:3.8.0", -+ "registry.dobby.co/dobby/dobby-servers/github-run:2021-10-04", -+ "docker.elastic.co/kibana/kibana:7.6.2", -+ "registry.dobby.org/dobby/dobby-servers/lerphound:latest", -+ "registry.dobby.org/dobby/dobby-servers/marbletown-poc:2021-03-29", -+ "marbles/marbles:v0.38.1", -+ "registry.dobby.org/dobby/dobby-servers/loophole@sha256:5a156ff125e5a12ac7ff43ee5120fa249cf62248337b6d04abc574c8", -+ "sonatype/nexon:3.30.0", -+ "prom/node-exporter:v1.1.1", -+ "sosedoff/pgweb@sha256:5a156ff125e5a12ac7ff43ee5120fa249cf62248337b6d04abc574c8", -+ "sosedoff/pgweb:latest", -+ "registry.dobby.org/dobby/dobby-servers/arpeggio:2021-06-01", -+ "registry.dobby.org/dobby/antique-penguin:release-production", -+ "dalprodictus/halcon:6.7.5", -+ "antigua/antigua:v31", -+ "weblate/weblate:4.7.2-1", -+ "redis:4.0.01-alpine", -+ "registry.dobby.com/dobby/dobby-servers/github-run:latest", -+ "192.168.122.123:5000/kubeos-x86_64:2023-01", -+ ]; -+ let wrong_images = vec![ -+ "alpine;v1.0", -+ "alpine:latest@sha256:11111111111111111111111111111111", -+ "alpine|v1.0", -+ "alpine&v1.0", -+ "sosedoff/pgweb:latest@sha256:5a156ff125e5a12ac7ff43ee5120fa249cf62248337b6d04574c8", -+ "192.168.122.123:5000/kubeos-x86_64:2023-01@sha256:1a1a1a1a1a1a1a1a1a1a1a1a1a1a", -+ "192.168.122.123:5000@sha256:1a1a1a1a1a1a1a1a1a1a1a1a1a1a", -+ "myimage$%^&", -+ ":myimage", -+ "/myimage", -+ "myimage/", -+ "myimage:", -+ "myimage@@latest", -+ "myimage::tag", -+ "registry.com//myimage:tag", -+ " myimage", -+ "myimage ", -+ "registry.com/:tag", -+ "myimage:", -+ "", -+ ":tag", -+ "IP:5000@sha256:1a1a1a1a1a1a1a1a1a1a1a1a1a1a", -+ ]; -+ for image in correct_images { -+ assert!(is_valid_image_name(image).is_ok()); -+ } -+ for image in wrong_images { -+ assert!(is_valid_image_name(image).is_err()); - } - } - --- -2.34.1 - diff --git a/0012-perf-crd-improve-default-display-of-crd-under-kubect.patch b/0012-perf-crd-improve-default-display-of-crd-under-kubect.patch deleted file mode 100644 index 0d61cbcd1cb2f638e8e35d7adac4221ab2a42eb6..0000000000000000000000000000000000000000 --- a/0012-perf-crd-improve-default-display-of-crd-under-kubect.patch +++ /dev/null @@ -1,73 +0,0 @@ -From 2c90e2e1fae25a8324cf527a71d7501b1d0b7921 Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Fri, 26 Jan 2024 10:53:40 +0800 -Subject: [PATCH 12/13] perf(crd): improve default display of crd under kubectl - get - -kubectl get os|osinstance doesn't display any valuable information. Adding default printer columns in crd.yaml to display more helpful information such as osversion, config version etc. - -Signed-off-by: Yuhang Wei ---- - .../config/crd/upgrade.openeuler.org_os.yaml | 13 ++++++++++++ - .../upgrade.openeuler.org_osinstances.yaml | 21 +++++++++++++++++++ - 2 files changed, 34 insertions(+) - -diff --git a/docs/example/config/crd/upgrade.openeuler.org_os.yaml b/docs/example/config/crd/upgrade.openeuler.org_os.yaml -index 3bb1333..2dd822e 100644 ---- a/docs/example/config/crd/upgrade.openeuler.org_os.yaml -+++ b/docs/example/config/crd/upgrade.openeuler.org_os.yaml -@@ -17,6 +17,19 @@ spec: - scope: Namespaced - versions: - - name: v1alpha1 -+ additionalPrinterColumns: -+ - name: OS VERSION -+ jsonPath: .spec.osversion -+ type: string -+ description: The version of OS -+ - name: SYSCONFIG VERSION -+ type: string -+ jsonPath: .spec.sysconfigs.version -+ description: The version of sysconfig -+ - name: UPGRADECONFIG VERSION -+ type: string -+ jsonPath: .spec.upgradeconfigs.version -+ description: The version of upgradeconfig - schema: - openAPIV3Schema: - description: OS is a specification for OS in the cluster -diff --git a/docs/example/config/crd/upgrade.openeuler.org_osinstances.yaml b/docs/example/config/crd/upgrade.openeuler.org_osinstances.yaml -index 3fa70c0..df9119b 100644 ---- a/docs/example/config/crd/upgrade.openeuler.org_osinstances.yaml -+++ b/docs/example/config/crd/upgrade.openeuler.org_osinstances.yaml -@@ -17,6 +17,27 @@ spec: - scope: Namespaced - versions: - - name: v1alpha1 -+ additionalPrinterColumns: -+ - name: NODESTATUS -+ type: string -+ jsonPath: .spec.nodestatus -+ description: The status of node -+ - name: SYSCONFIG-VERSION-CURRENT -+ type: string -+ jsonPath: .status.sysconfigs.version -+ description: The current status of sysconfig -+ - name: SYSCONFIG-VERSION-DESIRED -+ type: string -+ jsonPath: .spec.sysconfigs.version -+ description: The expected version of sysconfig -+ - name: UPGRADECONFIG-VERSION-CURRENT -+ type: string -+ jsonPath: .status.upgradeconfigs.version -+ description: The current version of upgradeconfig -+ - name: UPGRADECONFIG-VERSION-DESIRED -+ type: string -+ jsonPath: .spec.upgradeconfigs.version -+ description: The expected version of upgradeconfig - schema: - openAPIV3Schema: - description: OSInstance defines some infomation of a node --- -2.34.1 - diff --git a/0013-fix-logs-content-grammar-and-format.patch b/0013-fix-logs-content-grammar-and-format.patch deleted file mode 100644 index 93183262f5a83b5fc8a30087ab354767a4bc0c9f..0000000000000000000000000000000000000000 --- a/0013-fix-logs-content-grammar-and-format.patch +++ /dev/null @@ -1,196 +0,0 @@ -From fed39fc1ff83f016828d10c8fcbbf26762236dfa Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Wed, 24 Jan 2024 15:49:53 +0800 -Subject: [PATCH 13/13] fix: logs content, grammar and format - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/agent/src/function.rs | 3 ++- - KubeOS-Rust/manager/src/sys_mgmt/config.rs | 8 ++++---- - KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs | 2 +- - KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs | 2 +- - KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs | 6 +++--- - KubeOS-Rust/manager/src/utils/common.rs | 8 +++----- - KubeOS-Rust/manager/src/utils/executor.rs | 7 ++++--- - KubeOS-Rust/manager/src/utils/image_manager.rs | 2 +- - 8 files changed, 19 insertions(+), 19 deletions(-) - -diff --git a/KubeOS-Rust/agent/src/function.rs b/KubeOS-Rust/agent/src/function.rs -index 2c97347..9789d95 100644 ---- a/KubeOS-Rust/agent/src/function.rs -+++ b/KubeOS-Rust/agent/src/function.rs -@@ -25,7 +25,8 @@ impl RpcFunction { - F: FnOnce() -> anyhow::Result, - { - (f)().map_err(|e| { -- error!("{:?}", e); -+ let error_message = format!("{:#}", e); -+ error!("{}", error_message.replace('\n', " ").replace('\r', "")); - Error { code: ErrorCode::ServerError(RPC_OP_ERROR), message: format!("{:?}", e), data: None } - }) - } -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/config.rs b/KubeOS-Rust/manager/src/sys_mgmt/config.rs -index 48517b4..a629756 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/config.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/config.rs -@@ -66,7 +66,7 @@ pub struct GrubCmdline { - - impl Configuration for KernelSysctl { - fn set_config(&self, config: &mut Sysconfig) -> Result<()> { -- info!("Start set kernel.sysctl"); -+ info!("Start setting kernel.sysctl"); - for (key, key_info) in config.contents.iter() { - let proc_path = self.get_proc_path(key); - if key_info.operation == "delete" { -@@ -99,7 +99,7 @@ impl KernelSysctl { - - impl Configuration for KernelSysctlPersist { - fn set_config(&self, config: &mut Sysconfig) -> Result<()> { -- info!("Start set kernel.sysctl.persist"); -+ info!("Start setting kernel.sysctl.persist"); - let mut config_path = &values::DEFAULT_KERNEL_CONFIG_PATH.to_string(); - if !config.config_path.is_empty() { - config_path = &config.config_path; -@@ -247,9 +247,9 @@ fn handle_add_key(expect_configs: &HashMap, is_only_key_valid: - impl Configuration for GrubCmdline { - fn set_config(&self, config: &mut Sysconfig) -> Result<()> { - if self.is_cur_partition { -- info!("Start set grub.cmdline.current configuration"); -+ info!("Start setting grub.cmdline.current configuration"); - } else { -- info!("Start set grub.cmdline.next configuration"); -+ info!("Start setting grub.cmdline.next configuration"); - } - if !is_file_exist(&self.grub_path) { - bail!("Failed to find grub.cfg file"); -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -index dd7036f..5b0d0b7 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -@@ -72,7 +72,7 @@ impl CtrImageHandler { - .mount_path - .to_str() - .ok_or_else(|| anyhow!("Failed to get mount path: {}", self.paths.mount_path.display()))?; -- info!("Start get rootfs {}", image_name); -+ info!("Start getting rootfs {}", image_name); - self.check_and_unmount(mount_path)?; - self.executor - .run_command("ctr", &["-n", DEFAULT_NAMESPACE, "images", "mount", "--rw", image_name, mount_path])?; -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -index 7c64bf0..6d836dc 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/disk_image.rs -@@ -71,7 +71,7 @@ impl DiskImageHandler { - } - - fn checksum_match(&self, file_path: &str, check_sum: &str) -> Result<()> { -- trace!("Start to check checksum"); -+ info!("Start checking image checksum"); - let check_sum = check_sum.to_ascii_lowercase(); - let file = fs::read(file_path)?; - let mut hasher = Sha256::new(); -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -index 177dfeb..a8bbee2 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -@@ -42,16 +42,16 @@ impl DockerImageHandler { - is_valid_image_name(image_name)?; - let cli = "docker"; - remove_image_if_exist(cli, image_name, &self.executor)?; -- info!("Start pull image {}", image_name); -+ info!("Start pulling image {}", image_name); - pull_image(cli, image_name, &self.executor)?; -- info!("Start check image digest"); -+ info!("Start checking image digest"); - check_oci_image_digest(cli, image_name, &req.check_sum, &self.executor)?; - Ok(()) - } - - fn get_rootfs_archive(&self, req: &UpgradeRequest) -> Result<()> { - let image_name = &req.container_image; -- info!("Start get rootfs {}", image_name); -+ info!("Start getting rootfs {}", image_name); - self.check_and_rm_container()?; - debug!("Create container {}", self.container_name); - let container_id = -diff --git a/KubeOS-Rust/manager/src/utils/common.rs b/KubeOS-Rust/manager/src/utils/common.rs -index da8c8c3..a6d62a0 100644 ---- a/KubeOS-Rust/manager/src/utils/common.rs -+++ b/KubeOS-Rust/manager/src/utils/common.rs -@@ -79,7 +79,6 @@ pub fn check_disk_size>(need_bytes: i64, path: P) -> Result<()> { - if available_space < need_bytes { - bail!("Space is not enough for downloading"); - } -- info!("There is enough disk space to upgrade"); - Ok(()) - } - -@@ -88,9 +87,8 @@ pub fn clean_env

(update_path: P, mount_path: P, image_path: P) -> Result<()> - where - P: AsRef, - { -- info!("Clean up the residual upgrade environment"); - if is_mounted(&mount_path)? { -- debug!("Umount {}", mount_path.as_ref().display()); -+ debug!("Umount \"{}\"", mount_path.as_ref().display()); - if let Err(errno) = mount::umount2(mount_path.as_ref(), MntFlags::MNT_FORCE) { - bail!("Failed to umount {} in clean_env: {}", mount_path.as_ref().display(), errno); - } -@@ -104,10 +102,10 @@ where - pub fn delete_file_or_dir>(path: P) -> Result<()> { - if is_file_exist(&path) { - if fs::metadata(&path)?.is_file() { -- debug!("Delete file {}", path.as_ref().display()); -+ info!("Delete file \"{}\"", path.as_ref().display()); - fs::remove_file(&path)?; - } else { -- debug!("Delete directory {}", path.as_ref().display()); -+ info!("Delete directory \"{}\"", path.as_ref().display()); - fs::remove_dir_all(&path)?; - } - } -diff --git a/KubeOS-Rust/manager/src/utils/executor.rs b/KubeOS-Rust/manager/src/utils/executor.rs -index 8f4cb25..c87bf2a 100644 ---- a/KubeOS-Rust/manager/src/utils/executor.rs -+++ b/KubeOS-Rust/manager/src/utils/executor.rs -@@ -28,8 +28,9 @@ impl CommandExecutor for RealCommandExecutor { - trace!("run_command: {} {:?}", name, args); - let output = Command::new(name).args(args).output()?; - if !output.status.success() { -+ let stdout = String::from_utf8_lossy(&output.stdout); - let error_message = String::from_utf8_lossy(&output.stderr); -- bail!("Failed to run command: {} {:?}, stderr: {}", name, args, error_message); -+ bail!("Failed to run command: {} {:?}, stdout: \"{}\", stderr: \"{}\"", name, args, stdout, error_message); - } - debug!("run_command: {} {:?} done", name, args); - Ok(()) -@@ -38,11 +39,11 @@ impl CommandExecutor for RealCommandExecutor { - fn run_command_with_output<'a>(&self, name: &'a str, args: &[&'a str]) -> Result { - trace!("run_command_with_output: {} {:?}", name, args); - let output = Command::new(name).args(args).output()?; -+ let stdout = String::from_utf8_lossy(&output.stdout).to_string(); - if !output.status.success() { - let error_message = String::from_utf8_lossy(&output.stderr); -- bail!("Failed to run command: {} {:?}, stderr: {}", name, args, error_message); -+ bail!("Failed to run command: {} {:?}, stdout: \"{}\", stderr: \"{}\"", name, args, stdout, error_message); - } -- let stdout = String::from_utf8_lossy(&output.stdout).to_string(); - debug!("run_command_with_output: {} {:?} done", name, args); - Ok(stdout.trim_end_matches('\n').to_string()) - } -diff --git a/KubeOS-Rust/manager/src/utils/image_manager.rs b/KubeOS-Rust/manager/src/utils/image_manager.rs -index dc82323..90806cf 100644 ---- a/KubeOS-Rust/manager/src/utils/image_manager.rs -+++ b/KubeOS-Rust/manager/src/utils/image_manager.rs -@@ -89,7 +89,7 @@ impl UpgradeImageManager { - self.format_image()?; - self.mount_image()?; - self.extract_tar_to_image()?; -- // Pass empty image_path to clean_env to avoid delete image file -+ // Pass empty image_path to clean_env but avoid deleting the upgrade image - clean_env(&self.paths.update_path, &self.paths.mount_path, &PathBuf::new())?; - Ok(self) - } --- -2.34.1 - diff --git a/0014-fix-os-agent-add-context-when-returning-error.patch b/0014-fix-os-agent-add-context-when-returning-error.patch deleted file mode 100644 index 82b38865bfbb7610c47eea7b9f81fa28229d054c..0000000000000000000000000000000000000000 --- a/0014-fix-os-agent-add-context-when-returning-error.patch +++ /dev/null @@ -1,144 +0,0 @@ -From a9d6ff63344023e7ecc7d90904f694714514e19e Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Mon, 29 Jan 2024 15:28:29 +0800 -Subject: [PATCH 1/4] fix(os-agent):add context when returning error - -In some cases, the error log only contains "No such file" information. It is hard to identify the origin of the error. Provide more context when propagating error. - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/manager/src/sys_mgmt/config.rs | 18 ++++++++++++------ - .../manager/src/sys_mgmt/containerd_image.rs | 6 +++--- - .../manager/src/sys_mgmt/docker_image.rs | 6 +++--- - KubeOS-Rust/manager/src/utils/common.rs | 8 ++++---- - 4 files changed, 22 insertions(+), 16 deletions(-) - -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/config.rs b/KubeOS-Rust/manager/src/sys_mgmt/config.rs -index a629756..33efdca 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/config.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/config.rs -@@ -105,9 +105,10 @@ impl Configuration for KernelSysctlPersist { - config_path = &config.config_path; - } - debug!("kernel.sysctl.persist config_path: \"{}\"", config_path); -- create_config_file(config_path)?; -- let configs = get_and_set_configs(&mut config.contents, config_path)?; -- write_configs_to_file(config_path, &configs)?; -+ create_config_file(config_path).with_context(|| format!("Failed to find config path"))?; -+ let configs = get_and_set_configs(&mut config.contents, config_path) -+ .with_context(|| format!("Failed to set persist kernel configs"))?; -+ write_configs_to_file(config_path, &configs).with_context(|| format!("Failed to write configs to file"))?; - Ok(()) - } - } -@@ -254,10 +255,15 @@ impl Configuration for GrubCmdline { - if !is_file_exist(&self.grub_path) { - bail!("Failed to find grub.cfg file"); - } -- let config_partition = -- if cfg!(test) { self.is_cur_partition } else { self.get_config_partition(RealCommandExecutor {})? }; -+ let config_partition = if cfg!(test) { -+ self.is_cur_partition -+ } else { -+ self.get_config_partition(RealCommandExecutor {}) -+ .with_context(|| format!("Failed to get config partition"))? -+ }; - debug!("Config_partition: {} (false means partition A, true means partition B)", config_partition); -- let configs = get_and_set_grubcfg(&mut config.contents, &self.grub_path, config_partition)?; -+ let configs = get_and_set_grubcfg(&mut config.contents, &self.grub_path, config_partition) -+ .with_context(|| format!("Failed to set grub configs"))?; - write_configs_to_file(&self.grub_path, &configs)?; - Ok(()) - } -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -index 5b0d0b7..727949b 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -@@ -12,7 +12,7 @@ - - use std::{fs, os::unix::fs::PermissionsExt, path::Path}; - --use anyhow::{anyhow, Result}; -+use anyhow::{anyhow, Context, Result}; - use log::{debug, info}; - - use crate::{ -@@ -73,12 +73,12 @@ impl CtrImageHandler { - .to_str() - .ok_or_else(|| anyhow!("Failed to get mount path: {}", self.paths.mount_path.display()))?; - info!("Start getting rootfs {}", image_name); -- self.check_and_unmount(mount_path)?; -+ self.check_and_unmount(mount_path).with_context(|| format!("Failed to clean containerd environment"))?; - self.executor - .run_command("ctr", &["-n", DEFAULT_NAMESPACE, "images", "mount", "--rw", image_name, mount_path])?; - // copy os.tar from mount_path to its partent dir - self.copy_file(self.paths.mount_path.join(&self.paths.rootfs_file), &self.paths.tar_path, permission)?; -- self.check_and_unmount(mount_path)?; -+ self.check_and_unmount(mount_path).with_context(|| format!("Failed to clean containerd environment"))?; - Ok(()) - } - -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -index a8bbee2..f697142 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -@@ -1,4 +1,4 @@ --use anyhow::Result; -+use anyhow::{Context, Result}; - use log::{debug, info, trace}; - - use crate::{ -@@ -52,7 +52,7 @@ impl DockerImageHandler { - fn get_rootfs_archive(&self, req: &UpgradeRequest) -> Result<()> { - let image_name = &req.container_image; - info!("Start getting rootfs {}", image_name); -- self.check_and_rm_container()?; -+ self.check_and_rm_container().with_context(|| format!("Failed to remove kubeos-temp container"))?; - debug!("Create container {}", self.container_name); - let container_id = - self.executor.run_command_with_output("docker", &["create", "--name", &self.container_name, image_name])?; -@@ -65,7 +65,7 @@ impl DockerImageHandler { - self.paths.update_path.to_str().unwrap(), - ], - )?; -- self.check_and_rm_container()?; -+ self.check_and_rm_container().with_context(|| format!("Failed to remove kubeos-temp container"))?; - Ok(()) - } - -diff --git a/KubeOS-Rust/manager/src/utils/common.rs b/KubeOS-Rust/manager/src/utils/common.rs -index a6d62a0..9baf99e 100644 ---- a/KubeOS-Rust/manager/src/utils/common.rs -+++ b/KubeOS-Rust/manager/src/utils/common.rs -@@ -16,7 +16,7 @@ use std::{ - path::{Path, PathBuf}, - }; - --use anyhow::{anyhow, bail, Result}; -+use anyhow::{anyhow, bail, Context, Result}; - use log::{debug, info, trace}; - use nix::{mount, mount::MntFlags}; - -@@ -85,7 +85,7 @@ pub fn check_disk_size>(need_bytes: i64, path: P) -> Result<()> { - /// clean_env will umount the mount path and delete directory /persist/KubeOS-Update and /persist/update.img - pub fn clean_env

(update_path: P, mount_path: P, image_path: P) -> Result<()> - where -- P: AsRef, -+ P: AsRef + std::fmt::Debug, - { - if is_mounted(&mount_path)? { - debug!("Umount \"{}\"", mount_path.as_ref().display()); -@@ -94,8 +94,8 @@ where - } - } - // losetup -D? -- delete_file_or_dir(update_path)?; -- delete_file_or_dir(image_path)?; -+ delete_file_or_dir(&update_path).with_context(|| format!("Failed to delete {:?}", update_path))?; -+ delete_file_or_dir(&image_path).with_context(|| format!("Failed to delete {:?}", image_path))?; - Ok(()) - } - --- -2.34.1 - diff --git a/0015-proxy-Add-unit-tests-and-delete-useless-dependencies.patch b/0015-proxy-Add-unit-tests-and-delete-useless-dependencies.patch deleted file mode 100644 index c50afc1d39cfce95f3028d80e632ea55e32a7e13..0000000000000000000000000000000000000000 --- a/0015-proxy-Add-unit-tests-and-delete-useless-dependencies.patch +++ /dev/null @@ -1,1011 +0,0 @@ -From 2e05a5ce397b1ad3b889e200ee278f9efb5276f8 Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Tue, 30 Jan 2024 15:04:13 +0800 -Subject: [PATCH 2/4] proxy: Add unit tests and delete useless dependencies - from Cargo.toml - -Add the proxy unit test ,modify the AgentCallClient , -AgentClient and ProxyController struct design to make -it easier to mock the agent invoking. - -Delete useless dependencies from Cargo.toml and Cargo.lock - -Signed-off-by: liyuanr ---- - KubeOS-Rust/Cargo.lock | 14 -- - KubeOS-Rust/proxy/Cargo.toml | 3 +- - .../proxy/src/controller/agentclient.rs | 74 ++++------ - .../proxy/src/controller/apiserver_mock.rs | 137 +++++++++++++++--- - .../proxy/src/controller/controller.rs | 121 ++++++++-------- - KubeOS-Rust/proxy/src/controller/mod.rs | 2 +- - KubeOS-Rust/proxy/src/controller/utils.rs | 12 +- - KubeOS-Rust/proxy/src/drain.rs | 24 +-- - KubeOS-Rust/proxy/src/main.rs | 9 +- - 9 files changed, 232 insertions(+), 164 deletions(-) - -diff --git a/KubeOS-Rust/Cargo.lock b/KubeOS-Rust/Cargo.lock -index c44c152..2342c7b 100644 ---- a/KubeOS-Rust/Cargo.lock -+++ b/KubeOS-Rust/Cargo.lock -@@ -1180,18 +1180,6 @@ dependencies = [ - "syn 1.0.109", - ] - --[[package]] --name = "mockall_double" --version = "0.2.1" --source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "7dffc15b97456ecc84d2bde8c1df79145e154f45225828c4361f676e1b82acd6" --dependencies = [ -- "cfg-if", -- "proc-macro2", -- "quote", -- "syn 1.0.109", --] -- - [[package]] - name = "mockito" - version = "0.31.1" -@@ -1503,7 +1491,6 @@ dependencies = [ - "anyhow", - "assert-json-diff", - "async-trait", -- "chrono", - "cli", - "env_logger", - "futures", -@@ -1515,7 +1502,6 @@ dependencies = [ - "log", - "manager", - "mockall", -- "mockall_double", - "regex", - "reqwest", - "schemars", -diff --git a/KubeOS-Rust/proxy/Cargo.toml b/KubeOS-Rust/proxy/Cargo.toml -index fe657af..94e3b3c 100644 ---- a/KubeOS-Rust/proxy/Cargo.toml -+++ b/KubeOS-Rust/proxy/Cargo.toml -@@ -17,7 +17,6 @@ path = "src/main.rs" - [dependencies] - anyhow = "1.0.44" - async-trait = "0.1" --chrono = { version = "0.4", default-features = false, features = ["std"] } - cli = { version = "1.0.5", path = "../cli" } - env_logger = "0.9.0" - futures = "0.3.17" -@@ -45,4 +44,4 @@ http = "0.2.9" - hyper = "0.14.25" - tower-test = "0.4.0" - mockall = { version = "=0.11.3" } --mockall_double = "0.2.1" -+ -diff --git a/KubeOS-Rust/proxy/src/controller/agentclient.rs b/KubeOS-Rust/proxy/src/controller/agentclient.rs -index 73489a9..b833f27 100644 ---- a/KubeOS-Rust/proxy/src/controller/agentclient.rs -+++ b/KubeOS-Rust/proxy/src/controller/agentclient.rs -@@ -22,13 +22,6 @@ use cli::{ - }; - use manager::api::{CertsInfo, ConfigureRequest, KeyInfo as AgentKeyInfo, Sysconfig as AgentSysconfig, UpgradeRequest}; - --#[cfg_attr(test, double)] --use agent_call::AgentCallClient; --#[cfg(test)] --use mockall::automock; --#[cfg(test)] --use mockall_double::double; -- - pub struct UpgradeInfo { - pub version: String, - pub image_type: String, -@@ -57,45 +50,40 @@ pub struct KeyInfo { - pub operation: String, - } - --#[cfg_attr(test, automock)] - pub trait AgentMethod { -- fn prepare_upgrade_method(&self, upgrade_info: UpgradeInfo, agent_call: AgentCallClient) -> Result<(), Error>; -- fn upgrade_method(&self, agent_call: AgentCallClient) -> Result<(), Error>; -- fn rollback_method(&self, agent_call: AgentCallClient) -> Result<(), Error>; -- fn configure_method(&self, config_info: ConfigInfo, agent_call: AgentCallClient) -> Result<(), Error>; -+ fn prepare_upgrade_method(&self, upgrade_info: UpgradeInfo) -> Result<(), Error>; -+ fn upgrade_method(&self) -> Result<(), Error>; -+ fn rollback_method(&self) -> Result<(), Error>; -+ fn configure_method(&self, config_info: ConfigInfo) -> Result<(), Error>; - } -- --pub mod agent_call { -- use super::{Client, Error, RpcMethod}; -- #[cfg(test)] -- use mockall::automock; -- -- #[derive(Default)] -- pub struct AgentCallClient {} -- -- #[cfg_attr(test, automock)] -- impl AgentCallClient { -- pub fn call_agent(&self, client: &Client, method: T) -> Result<(), Error> { -- match method.call(client) { -- Ok(_resp) => Ok(()), -- Err(e) => Err(Error::AgentError { source: e }), -- } -- } -- } -+pub trait AgentCall { -+ fn call_agent(&self, client: &Client, method: T) -> Result<(), Error>; - } - --pub struct AgentClient { -+pub struct AgentClient { - pub agent_client: Client, -+ pub agent_call_client: T, -+} -+ -+impl AgentClient { -+ pub fn new>(socket_path: P, agent_call_client: T) -> Self { -+ AgentClient { agent_client: Client::new(socket_path), agent_call_client } -+ } - } - --impl AgentClient { -- pub fn new>(socket_path: P) -> Self { -- AgentClient { agent_client: Client::new(socket_path) } -+#[derive(Default)] -+pub struct AgentCallClient {} -+impl AgentCall for AgentCallClient { -+ fn call_agent(&self, client: &Client, method: T) -> Result<(), Error> { -+ match method.call(client) { -+ Ok(_resp) => Ok(()), -+ Err(e) => Err(Error::AgentError { source: e }), -+ } - } - } - --impl AgentMethod for AgentClient { -- fn prepare_upgrade_method(&self, upgrade_info: UpgradeInfo, agent_call: AgentCallClient) -> Result<(), Error> { -+impl AgentMethod for AgentClient { -+ fn prepare_upgrade_method(&self, upgrade_info: UpgradeInfo) -> Result<(), Error> { - let upgrade_request = UpgradeRequest { - version: upgrade_info.version, - image_type: upgrade_info.image_type, -@@ -110,27 +98,27 @@ impl AgentMethod for AgentClient { - client_key: upgrade_info.clientkey, - }, - }; -- match agent_call.call_agent(&self.agent_client, PrepareUpgradeMethod::new(upgrade_request)) { -+ match self.agent_call_client.call_agent(&self.agent_client, PrepareUpgradeMethod::new(upgrade_request)) { - Ok(_resp) => Ok(()), - Err(e) => Err(e), - } - } - -- fn upgrade_method(&self, agent_call: AgentCallClient) -> Result<(), Error> { -- match agent_call.call_agent(&self.agent_client, UpgradeMethod::default()) { -+ fn upgrade_method(&self) -> Result<(), Error> { -+ match self.agent_call_client.call_agent(&self.agent_client, UpgradeMethod::default()) { - Ok(_resp) => Ok(()), - Err(e) => Err(e), - } - } - -- fn rollback_method(&self, agent_call: AgentCallClient) -> Result<(), Error> { -- match agent_call.call_agent(&self.agent_client, RollbackMethod::default()) { -+ fn rollback_method(&self) -> Result<(), Error> { -+ match self.agent_call_client.call_agent(&self.agent_client, RollbackMethod::default()) { - Ok(_resp) => Ok(()), - Err(e) => Err(e), - } - } - -- fn configure_method(&self, config_info: ConfigInfo, agent_call: AgentCallClient) -> Result<(), Error> { -+ fn configure_method(&self, config_info: ConfigInfo) -> Result<(), Error> { - let mut agent_configs: Vec = Vec::new(); - for config in config_info.configs { - let mut contents_tmp: HashMap = HashMap::new(); -@@ -147,7 +135,7 @@ impl AgentMethod for AgentClient { - }) - } - let config_request = ConfigureRequest { configs: agent_configs }; -- match agent_call.call_agent(&self.agent_client, ConfigureMethod::new(config_request)) { -+ match self.agent_call_client.call_agent(&self.agent_client, ConfigureMethod::new(config_request)) { - Ok(_resp) => Ok(()), - Err(e) => Err(e), - } -diff --git a/KubeOS-Rust/proxy/src/controller/apiserver_mock.rs b/KubeOS-Rust/proxy/src/controller/apiserver_mock.rs -index c46d26a..ef5977c 100644 ---- a/KubeOS-Rust/proxy/src/controller/apiserver_mock.rs -+++ b/KubeOS-Rust/proxy/src/controller/apiserver_mock.rs -@@ -2,15 +2,20 @@ use self::mock_error::Error; - use super::{ - agentclient::*, - crd::{Configs, OSInstanceStatus}, -- values::{NODE_STATUS_CONFIG, NODE_STATUS_UPGRADE}, -+ values::{NODE_STATUS_CONFIG, NODE_STATUS_UPGRADE, OPERATION_TYPE_ROLLBACK}, - }; - use crate::controller::{ - apiclient::{ApplyApi, ControllerClient}, -- crd::{OSInstance, OSInstanceSpec, OSSpec, OS}, -+ crd::{Config, Content, OSInstance, OSInstanceSpec, OSSpec, OS}, - values::{LABEL_OSINSTANCE, LABEL_UPGRADING, NODE_STATUS_IDLE}, - ProxyController, - }; - use anyhow::Result; -+use cli::client::Client; -+use cli::method::{ -+ callable_method::RpcMethod, configure::ConfigureMethod, prepare_upgrade::PrepareUpgradeMethod, -+ rollback::RollbackMethod, upgrade::UpgradeMethod, -+}; - use http::{Request, Response}; - use hyper::{body::to_bytes, Body}; - use k8s_openapi::api::core::v1::Pod; -@@ -19,7 +24,8 @@ use kube::{ - api::ObjectMeta, - core::{ListMeta, ObjectList}, - }; --use kube::{Client, Resource, ResourceExt}; -+use kube::{Client as KubeClient, Resource, ResourceExt}; -+use mockall::mock; - use std::collections::BTreeMap; - - type ApiServerHandle = tower_test::mock::Handle, Response>; -@@ -34,6 +40,7 @@ pub enum Testcases { - ConfigNormal(OSInstance), - ConfigVersionMismatchReassign(OSInstance), - ConfigVersionMismatchUpdate(OSInstance), -+ Rollback(OSInstance), - } - - pub async fn timeout_after_5s(handle: tokio::task::JoinHandle<()>) { -@@ -59,7 +66,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_get(osi) - .await -- }, -+ } - Testcases::UpgradeNormal(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -78,7 +85,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_pod_list_get(osi) - .await -- }, -+ } - Testcases::UpgradeUpgradeconfigsVersionMismatch(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -97,7 +104,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_osinstance_patch_nodestatus_idle(osi) - .await -- }, -+ } - Testcases::UpgradeOSInstaceNodestatusConfig(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -107,7 +114,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_get_with_label(osi.clone()) - .await -- }, -+ } - Testcases::UpgradeOSInstaceNodestatusIdle(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -123,7 +130,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_uncordon(osi) - .await -- }, -+ } - Testcases::ConfigNormal(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -139,7 +146,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_osinstance_patch_nodestatus_idle(osi) - .await -- }, -+ } - Testcases::ConfigVersionMismatchReassign(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -152,7 +159,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_osinstance_patch_nodestatus_idle(osi) - .await -- }, -+ } - Testcases::ConfigVersionMismatchUpdate(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -165,7 +172,26 @@ impl ApiServerVerifier { - .unwrap() - .handler_osinstance_patch_spec_sysconfig_v2(osi) - .await -- }, -+ } -+ Testcases::Rollback(osi) => { -+ self.handler_osinstance_get_exist(osi.clone()) -+ .await -+ .unwrap() -+ .handler_osinstance_get_exist(osi.clone()) -+ .await -+ .unwrap() -+ .handler_node_get_with_label(osi.clone()) -+ .await -+ .unwrap() -+ .handler_osinstance_patch_upgradeconfig_v2(osi.clone()) -+ .await -+ .unwrap() -+ .handler_node_cordon(osi.clone()) -+ .await -+ .unwrap() -+ .handler_node_pod_list_get(osi) -+ .await -+ } - } - .expect("Case completed without errors"); - }) -@@ -437,6 +463,7 @@ impl ApiServerVerifier { - - pub mod mock_error { - use thiserror::Error; -+ - #[derive(Error, Debug)] - pub enum Error { - #[error("Kubernetes reported error: {source}")] -@@ -447,17 +474,27 @@ pub mod mock_error { - } - } - --impl ProxyController { -- pub fn test() -> (ProxyController, ApiServerVerifier) { -+mock! { -+ pub AgentCallClient{} -+ impl AgentCall for AgentCallClient{ -+ fn call_agent(&self, client:&Client, method: T) -> Result<(), agent_error::Error> { -+ Ok(()) -+ } -+ } -+ -+} -+impl ProxyController { -+ pub fn test() -> (ProxyController, ApiServerVerifier) { - let (mock_service, handle) = tower_test::mock::pair::, Response>(); -- let mock_k8s_client = Client::new(mock_service, "default"); -+ let mock_k8s_client = KubeClient::new(mock_service, "default"); - let mock_api_client = ControllerClient::new(mock_k8s_client.clone()); -- let mut mock_agent_client: MockAgentMethod = MockAgentMethod::new(); -- mock_agent_client.expect_rollback_method().returning(|_x| Ok(())); -- mock_agent_client.expect_prepare_upgrade_method().returning(|_x, _y| Ok(())); -- mock_agent_client.expect_upgrade_method().returning(|_x| Ok(())); -- mock_agent_client.expect_configure_method().returning(|_x, _y| Ok(())); -- let proxy_controller: ProxyController = -+ let mut mock_agent_call_client = MockAgentCallClient::new(); -+ mock_agent_call_client.expect_call_agent::().returning(|_x, _y| Ok(())); -+ mock_agent_call_client.expect_call_agent::().returning(|_x, _y| Ok(())); -+ mock_agent_call_client.expect_call_agent::().returning(|_x, _y| Ok(())); -+ mock_agent_call_client.expect_call_agent::().returning(|_x, _y| Ok(())); -+ let mock_agent_client = AgentClient::new("test", mock_agent_call_client); -+ let proxy_controller: ProxyController = - ProxyController::new(mock_k8s_client, mock_api_client, mock_agent_client); - (proxy_controller, ApiServerVerifier(handle)) - } -@@ -495,7 +532,7 @@ impl OSInstance { - } - - pub fn set_osi_nodestatus_config(node_name: &str, namespace: &str) -> Self { -- // return osinstance with nodestatus = upgrade, upgradeconfig.version=v1, sysconfig.version=v1 -+ // return osinstance with nodestatus = config, upgradeconfig.version=v1, sysconfig.version=v1 - let mut osinstance = OSInstance::set_osi_default(node_name, namespace); - osinstance.spec.nodestatus = NODE_STATUS_CONFIG.to_string(); - osinstance -@@ -512,7 +549,18 @@ impl OSInstance { - // return osinstance with nodestatus = upgrade, upgradeconfig.version=v2, sysconfig.version=v1 - let mut osinstance = OSInstance::set_osi_default(node_name, namespace); - osinstance.spec.nodestatus = NODE_STATUS_UPGRADE.to_string(); -- osinstance.spec.upgradeconfigs.as_mut().unwrap().version = Some(String::from("v2")); -+ osinstance.spec.upgradeconfigs = Some(Configs { -+ version: Some(String::from("v2")), -+ configs: Some(vec![Config { -+ model: Some(String::from("kernel.sysctl.persist")), -+ configpath: Some(String::from("/persist/persist.conf")), -+ contents: Some(vec![Content { -+ key: Some(String::from("kernel.test")), -+ value: Some(String::from("test")), -+ operation: Some(String::from("delete")), -+ }]), -+ }]), -+ }); - osinstance - } - -@@ -520,7 +568,18 @@ impl OSInstance { - // return osinstance with nodestatus = upgrade, upgradeconfig.version=v2, sysconfig.version=v1 - let mut osinstance = OSInstance::set_osi_default(node_name, namespace); - osinstance.spec.nodestatus = NODE_STATUS_CONFIG.to_string(); -- osinstance.spec.sysconfigs.as_mut().unwrap().version = Some(String::from("v2")); -+ osinstance.spec.sysconfigs = Some(Configs { -+ version: Some(String::from("v2")), -+ configs: Some(vec![Config { -+ model: Some(String::from("kernel.sysctl.persist")), -+ configpath: Some(String::from("/persist/persist.conf")), -+ contents: Some(vec![Content { -+ key: Some(String::from("kernel.test")), -+ value: Some(String::from("test")), -+ operation: Some(String::from("delete")), -+ }]), -+ }]), -+ }); - osinstance - } - } -@@ -549,7 +608,37 @@ impl OS { - pub fn set_os_syscon_v2_opstype_config() -> Self { - let mut os = OS::set_os_default(); - os.spec.opstype = String::from("config"); -- os.spec.sysconfigs = Some(Configs { version: Some(String::from("v2")), configs: None }); -+ os.spec.sysconfigs = Some(Configs { -+ version: Some(String::from("v2")), -+ configs: Some(vec![Config { -+ model: Some(String::from("kernel.sysctl.persist")), -+ configpath: Some(String::from("/persist/persist.conf")), -+ contents: Some(vec![Content { -+ key: Some(String::from("kernel.test")), -+ value: Some(String::from("test")), -+ operation: Some(String::from("delete")), -+ }]), -+ }]), -+ }); -+ os -+ } -+ -+ pub fn set_os_rollback_osversion_v2_upgradecon_v2() -> Self { -+ let mut os = OS::set_os_default(); -+ os.spec.osversion = String::from("KubeOS v2"); -+ os.spec.opstype = OPERATION_TYPE_ROLLBACK.to_string(); -+ os.spec.upgradeconfigs = Some(Configs { -+ version: Some(String::from("v2")), -+ configs: Some(vec![Config { -+ model: Some(String::from("kernel.sysctl.persist")), -+ configpath: Some(String::from("/persist/persist.conf")), -+ contents: Some(vec![Content { -+ key: Some(String::from("kernel.test")), -+ value: Some(String::from("test")), -+ operation: Some(String::from("delete")), -+ }]), -+ }]), -+ }); - os - } - } -diff --git a/KubeOS-Rust/proxy/src/controller/controller.rs b/KubeOS-Rust/proxy/src/controller/controller.rs -index b2bb332..c21f304 100644 ---- a/KubeOS-Rust/proxy/src/controller/controller.rs -+++ b/KubeOS-Rust/proxy/src/controller/controller.rs -@@ -24,10 +24,8 @@ use kube::{ - use log::{debug, error, info}; - use reconciler_error::Error; - --#[cfg_attr(test, double)] --use super::agentclient::agent_call::AgentCallClient; - use super::{ -- agentclient::{AgentMethod, ConfigInfo, KeyInfo, Sysconfig, UpgradeInfo}, -+ agentclient::{AgentCall, AgentClient, AgentMethod, ConfigInfo, KeyInfo, Sysconfig, UpgradeInfo}, - apiclient::ApplyApi, - crd::{Configs, Content, OSInstance, OS}, - utils::{check_version, get_config_version, ConfigOperation, ConfigType}, -@@ -36,12 +34,10 @@ use super::{ - REQUEUE_ERROR, REQUEUE_NORMAL, - }, - }; --#[cfg(test)] --use mockall_double::double; - --pub async fn reconcile( -+pub async fn reconcile( - os: OS, -- ctx: Context>, -+ ctx: Context>, - ) -> Result { - debug!("start reconcile"); - let proxy_controller = ctx.get_ref(); -@@ -76,7 +72,7 @@ pub async fn reconcile( - ) - .await?; - return Ok(REQUEUE_NORMAL); -- }, -+ } - ConfigOperation::UpdateConfig => { - debug!("start update config"); - osinstance.spec.sysconfigs = os_cr.spec.sysconfigs.clone(); -@@ -85,8 +81,8 @@ pub async fn reconcile( - .update_osinstance_spec(&osinstance.name(), &namespace, &osinstance.spec) - .await?; - return Ok(REQUEUE_ERROR); -- }, -- _ => {}, -+ } -+ _ => {} - } - proxy_controller.set_config(&mut osinstance, ConfigType::SysConfig).await?; - proxy_controller -@@ -108,8 +104,8 @@ pub async fn reconcile( - ) - .await?; - return Ok(REQUEUE_NORMAL); -- }, -- _ => {}, -+ } -+ _ => {} - } - if node.labels().contains_key(LABEL_UPGRADING) { - if osinstance.spec.nodestatus == NODE_STATUS_IDLE { -@@ -133,9 +129,9 @@ pub async fn reconcile( - Ok(REQUEUE_NORMAL) - } - --pub fn error_policy( -+pub fn error_policy( - error: &Error, -- _ctx: Context>, -+ _ctx: Context>, - ) -> ReconcilerAction { - error!("Reconciliation error:{}", error.to_string()); - REQUEUE_ERROR -@@ -145,31 +141,31 @@ struct ControllerResources { - osinstance: OSInstance, - node: Node, - } --pub struct ProxyController { -+pub struct ProxyController { - k8s_client: Client, - controller_client: T, -- agent_client: U, -+ agent_client: AgentClient, - } - --impl ProxyController { -- pub fn new(k8s_client: Client, controller_client: T, agent_client: U) -> Self { -+impl ProxyController { -+ pub fn new(k8s_client: Client, controller_client: T, agent_client: AgentClient) -> Self { - ProxyController { k8s_client, controller_client, agent_client } - } - } - --impl ProxyController { -+impl ProxyController { - async fn check_osi_exisit(&self, namespace: &str, node_name: &str) -> Result<(), Error> { - let osi_api: Api = Api::namespaced(self.k8s_client.clone(), namespace); - match osi_api.get(node_name).await { - Ok(osi) => { - debug!("osinstance is exist {:?}", osi.name()); - return Ok(()); -- }, -+ } - Err(kube::Error::Api(ErrorResponse { reason, .. })) if &reason == "NotFound" => { - info!("Create OSInstance {}", node_name); - self.controller_client.create_osinstance(node_name, namespace).await?; - Ok(()) -- }, -+ } - Err(err) => Err(Error::KubeError { source: err }), - } - } -@@ -257,17 +253,16 @@ impl ProxyController { - if config_info.need_config { - match config_info.configs.and_then(convert_to_agent_config) { - Some(agent_configs) => { -- let agent_call_client = AgentCallClient::default(); -- match self.agent_client.configure_method(ConfigInfo { configs: agent_configs }, agent_call_client) { -- Ok(_resp) => {}, -+ match self.agent_client.configure_method(ConfigInfo { configs: agent_configs }) { -+ Ok(_resp) => {} - Err(e) => { - return Err(Error::AgentError { source: e }); -- }, -+ } - } -- }, -+ } - None => { -- info!("config is none, no need to config"); -- }, -+ info!("config is none, No content can be configured."); -+ } - }; - self.update_osi_status(osinstance, config_type).await?; - } -@@ -290,35 +285,34 @@ impl ProxyController { - clientcert: os_cr.spec.clientcert.clone().unwrap_or_default(), - clientkey: os_cr.spec.clientkey.clone().unwrap_or_default(), - }; -- let agent_call_client = AgentCallClient::default(); -- match self.agent_client.prepare_upgrade_method(upgrade_info, agent_call_client) { -- Ok(_resp) => {}, -+ -+ match self.agent_client.prepare_upgrade_method(upgrade_info) { -+ Ok(_resp) => {} - Err(e) => { - return Err(Error::AgentError { source: e }); -- }, -+ } - } - self.evict_node(&node.name(), os_cr.spec.evictpodforce).await?; -- let agent_call_client = AgentCallClient::default(); -- match self.agent_client.upgrade_method(agent_call_client) { -- Ok(_resp) => {}, -+ match self.agent_client.upgrade_method() { -+ Ok(_resp) => {} - Err(e) => { - return Err(Error::AgentError { source: e }); -- }, -+ } - } -- }, -+ } - OPERATION_TYPE_ROLLBACK => { - self.evict_node(&node.name(), os_cr.spec.evictpodforce).await?; -- let agent_call_client = AgentCallClient::default(); -- match self.agent_client.rollback_method(agent_call_client) { -- Ok(_resp) => {}, -+ -+ match self.agent_client.rollback_method() { -+ Ok(_resp) => {} - Err(e) => { - return Err(Error::AgentError { source: e }); -- }, -+ } - } -- }, -+ } - _ => { - return Err(Error::OperationError { value: os_cr.spec.opstype.clone() }); -- }, -+ } - } - Ok(()) - } -@@ -329,12 +323,12 @@ impl ProxyController { - node_api.cordon(node_name).await?; - info!("Cordon node Successfully{}, start drain nodes", node_name); - match self.drain_node(node_name, evict_pod_force).await { -- Ok(()) => {}, -+ Ok(()) => {} - Err(e) => { - node_api.uncordon(node_name).await?; - info!("Drain node {} error, uncordon node successfully", node_name); - return Err(e); -- }, -+ } - } - Ok(()) - } -@@ -360,7 +354,7 @@ fn convert_to_agent_config(configs: Configs) -> Option> { - contents: contents_tmp, - }; - agent_configs.push(config_tmp) -- }, -+ } - None => { - info!( - "model {} which has configpath {} do not has any contents no need to configure", -@@ -368,7 +362,7 @@ fn convert_to_agent_config(configs: Configs) -> Option> { - config.configpath.unwrap_or_default() - ); - continue; -- }, -+ } - }; - } - if agent_configs.len() == 0 { -@@ -437,16 +431,13 @@ pub mod reconciler_error { - #[cfg(test)] - mod test { - use super::{error_policy, reconcile, Context, OSInstance, ProxyController, OS}; -+ use crate::controller::apiserver_mock::{timeout_after_5s, MockAgentCallClient, Testcases}; - use crate::controller::ControllerClient; -- use crate::controller::{ -- agentclient::MockAgentMethod, -- apiserver_mock::{timeout_after_5s, Testcases}, -- }; - use std::env; - - #[tokio::test] - async fn test_create_osinstance_with_no_upgrade_or_configuration() { -- let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); - env::set_var("NODE_NAME", "openeuler"); - let os = OS::set_os_default(); - let context = Context::new(test_proxy_controller); -@@ -457,7 +448,7 @@ mod test { - } - #[tokio::test] - async fn test_upgrade_normal() { -- let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); - env::set_var("NODE_NAME", "openeuler"); - let os = OS::set_os_osversion_v2_upgradecon_v2(); - let context = Context::new(test_proxy_controller); -@@ -471,7 +462,7 @@ mod test { - - #[tokio::test] - async fn test_diff_osversion_opstype_config() { -- let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); - env::set_var("NODE_NAME", "openeuler"); - let os = OS::set_os_osversion_v2_opstype_config(); - let context = Context::new(test_proxy_controller); -@@ -488,7 +479,7 @@ mod test { - - #[tokio::test] - async fn test_upgradeconfigs_version_mismatch() { -- let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); - env::set_var("NODE_NAME", "openeuler"); - let os = OS::set_os_osversion_v2_upgradecon_v2(); - let context = Context::new(test_proxy_controller); -@@ -501,7 +492,7 @@ mod test { - - #[tokio::test] - async fn test_upgrade_nodestatus_idle() { -- let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); - env::set_var("NODE_NAME", "openeuler"); - let os = OS::set_os_osversion_v2_upgradecon_v2(); - let context = Context::new(test_proxy_controller); -@@ -513,7 +504,7 @@ mod test { - - #[tokio::test] - async fn test_config_normal() { -- let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); - env::set_var("NODE_NAME", "openeuler"); - let os = OS::set_os_syscon_v2_opstype_config(); - let context = Context::new(test_proxy_controller); -@@ -525,7 +516,7 @@ mod test { - - #[tokio::test] - async fn test_sysconfig_version_mismatch_reassign() { -- let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); - env::set_var("NODE_NAME", "openeuler"); - let os = OS::set_os_syscon_v2_opstype_config(); - let context = Context::new(test_proxy_controller); -@@ -539,7 +530,7 @@ mod test { - - #[tokio::test] - async fn test_sysconfig_version_mismatch_update() { -- let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); - env::set_var("NODE_NAME", "openeuler"); - let os = OS::set_os_syscon_v2_opstype_config(); - let context = Context::new(test_proxy_controller); -@@ -550,4 +541,16 @@ mod test { - reconcile(os, context.clone()).await.expect("reconciler"); - timeout_after_5s(mocksrv).await; - } -+ -+ #[tokio::test] -+ async fn test_rollback() { -+ let (test_proxy_controller, fakeserver) = ProxyController::::test(); -+ env::set_var("NODE_NAME", "openeuler"); -+ let os = OS::set_os_rollback_osversion_v2_upgradecon_v2(); -+ let context = Context::new(test_proxy_controller); -+ let mocksrv = fakeserver -+ .run(Testcases::Rollback(OSInstance::set_osi_nodestatus_upgrade_upgradecon_v2("openeuler", "default"))); -+ reconcile(os, context.clone()).await.expect("reconciler"); -+ timeout_after_5s(mocksrv).await; -+ } - } -diff --git a/KubeOS-Rust/proxy/src/controller/mod.rs b/KubeOS-Rust/proxy/src/controller/mod.rs -index 73be45c..e30c8df 100644 ---- a/KubeOS-Rust/proxy/src/controller/mod.rs -+++ b/KubeOS-Rust/proxy/src/controller/mod.rs -@@ -19,7 +19,7 @@ mod crd; - mod utils; - mod values; - --pub use agentclient::AgentClient; -+pub use agentclient::{AgentCallClient, AgentClient}; - pub use apiclient::ControllerClient; - pub use controller::{error_policy, reconcile, reconciler_error::Error, ProxyController}; - pub use crd::OS; -diff --git a/KubeOS-Rust/proxy/src/controller/utils.rs b/KubeOS-Rust/proxy/src/controller/utils.rs -index 78502db..0f56878 100644 ---- a/KubeOS-Rust/proxy/src/controller/utils.rs -+++ b/KubeOS-Rust/proxy/src/controller/utils.rs -@@ -56,7 +56,7 @@ impl ConfigType { - ); - return ConfigOperation::Reassign; - } -- }, -+ } - ConfigType::SysConfig => { - let os_config_version = get_config_version(os.spec.sysconfigs.as_ref()); - let osi_config_version = get_config_version(osinstance.spec.sysconfigs.as_ref()); -@@ -78,7 +78,7 @@ impl ConfigType { - return ConfigOperation::UpdateConfig; - } - } -- }, -+ } - }; - ConfigOperation::DoNothing - } -@@ -96,7 +96,7 @@ impl ConfigType { - status_config_version = get_config_version(None); - } - configs = osinstance.spec.upgradeconfigs.clone(); -- }, -+ } - ConfigType::SysConfig => { - spec_config_version = get_config_version(osinstance.spec.sysconfigs.as_ref()); - if let Some(osinstance_status) = osinstance.status.as_ref() { -@@ -105,7 +105,7 @@ impl ConfigType { - status_config_version = get_config_version(None); - } - configs = osinstance.spec.sysconfigs.clone(); -- }, -+ } - } - debug!( - "=======osinstance soec config version is {},status config version is {}", -@@ -127,7 +127,7 @@ impl ConfigType { - sysconfigs: None, - }) - } -- }, -+ } - ConfigType::SysConfig => { - if let Some(osi_status) = &mut osinstance.status { - osi_status.sysconfigs = osinstance.spec.sysconfigs.clone(); -@@ -135,7 +135,7 @@ impl ConfigType { - osinstance.status = - Some(OSInstanceStatus { upgradeconfigs: None, sysconfigs: osinstance.spec.sysconfigs.clone() }) - } -- }, -+ } - } - } - } -diff --git a/KubeOS-Rust/proxy/src/drain.rs b/KubeOS-Rust/proxy/src/drain.rs -index 09cf662..72836f9 100644 ---- a/KubeOS-Rust/proxy/src/drain.rs -+++ b/KubeOS-Rust/proxy/src/drain.rs -@@ -66,7 +66,7 @@ async fn get_pods_deleted( - Ok(pods @ ObjectList { .. }) => pods, - Err(err) => { - return Err(GetPodListsError { source: err, node_name: node_name.to_string() }); -- }, -+ } - }; - let mut filterd_pods_list: Vec = Vec::new(); - let mut filterd_err: Vec = Vec::new(); -@@ -189,14 +189,14 @@ async fn wait_for_deletion(k8s_client: &kube::Client, pod: &Pod) -> Result<(), e - let name = (&p).name_any(); - info!("Pod {} deleted.", name); - break; -- }, -+ } - Ok(_) => { - info!("Pod '{}' is not yet deleted. Waiting {}s.", pod.name_any(), EVERY_DELETION_CHECK.as_secs_f64()); -- }, -+ } - Err(kube::Error::Api(e)) if e.code == response_error_not_found => { - info!("Pod {} is deleted.", pod.name_any()); - break; -- }, -+ } - Err(e) => { - error!( - "Get pod {} reported error: '{}', whether pod is deleted cannot be determined, waiting {}s.", -@@ -204,7 +204,7 @@ async fn wait_for_deletion(k8s_client: &kube::Client, pod: &Pod) -> Result<(), e - e, - EVERY_DELETION_CHECK.as_secs_f64() - ); -- }, -+ } - } - if start_time.elapsed() > TIMEOUT { - return Err(WaitDeletionError { pod_name: pod.name_any(), max_wait: TIMEOUT }); -@@ -241,7 +241,7 @@ impl PodFilter for FinishedOrFailedFilter { - return match pod.status.as_ref() { - Some(PodStatus { phase: Some(phase), .. }) if phase == "Failed" || phase == "Succeeded" => { - FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay) -- }, -+ } - _ => FilterResult::create_filter_result(false, "", PodDeleteStatus::Okay), - }; - } -@@ -269,7 +269,7 @@ impl PodFilter for DaemonFilter { - let description = format!("Cannot drain Pod '{}': Pod is member of a DaemonSet", pod.name_any()); - Box::new(FilterResult { result: false, desc: description, status: PodDeleteStatus::Error }) - } -- }, -+ } - _ => FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay), - }; - } -@@ -287,7 +287,7 @@ impl PodFilter for MirrorFilter { - Some(annotations) if annotations.contains_key("kubernetes.io/config.mirror") => { - let description = format!("Ignore Pod '{}': Pod is a static Mirror Pod", pod.name_any()); - FilterResult::create_filter_result(false, &description.to_string(), PodDeleteStatus::Warning) -- }, -+ } - _ => FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay), - }; - } -@@ -312,7 +312,7 @@ impl PodFilter for LocalStorageFilter { - let description = format!("Cannot drain Pod '{}': Pod has local Storage", pod.name_any()); - Box::new(FilterResult { result: false, desc: description, status: PodDeleteStatus::Error }) - } -- }, -+ } - _ => FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay), - }; - } -@@ -365,7 +365,7 @@ impl PodFilter for DeletedFilter { - && now - Duration::from_secs(time.0.timestamp() as u64) >= self.delete_wait_timeout => - { - FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay) -- }, -+ } - _ => FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay), - }; - } -@@ -471,7 +471,7 @@ impl ErrorHandleStrategy { - return match self { - Self::TolerateStrategy => { - return backoff.take(0); -- }, -+ } - - Self::RetryStrategy => backoff.take(MAX_RETRIES_TIMES), - }; -@@ -488,7 +488,7 @@ impl tokio_retry::Condition for ErrorHandleStrategy { - } else { - false - } -- }, -+ } - } - } - } -diff --git a/KubeOS-Rust/proxy/src/main.rs b/KubeOS-Rust/proxy/src/main.rs -index cd601d0..ad36b64 100644 ---- a/KubeOS-Rust/proxy/src/main.rs -+++ b/KubeOS-Rust/proxy/src/main.rs -@@ -20,7 +20,9 @@ use kube::{ - }; - use log::{error, info}; - mod controller; --use controller::{error_policy, reconcile, AgentClient, ControllerClient, ProxyController, OS, SOCK_PATH}; -+use controller::{ -+ error_policy, reconcile, AgentCallClient, AgentClient, ControllerClient, ProxyController, OS, SOCK_PATH, -+}; - - const PROXY_VERSION: Option<&'static str> = option_env!("CARGO_PKG_VERSION"); - #[tokio::main] -@@ -29,14 +31,15 @@ async fn main() -> Result<()> { - let client = Client::try_default().await?; - let os: Api = Api::all(client.clone()); - let controller_client = ControllerClient::new(client.clone()); -- let agent_client = AgentClient::new(SOCK_PATH); -+ let agent_call_client = AgentCallClient::default(); -+ let agent_client = AgentClient::new(SOCK_PATH, agent_call_client); - let proxy_controller = ProxyController::new(client, controller_client, agent_client); - info!("os-proxy version is {}, start renconcile", PROXY_VERSION.unwrap_or("Not Found")); - Controller::new(os, ListParams::default()) - .run(reconcile, error_policy, Context::new(proxy_controller)) - .for_each(|res| async move { - match res { -- Ok(_o) => {}, -+ Ok(_o) => {} - Err(e) => error!("reconcile failed: {}", e.to_string()), - } - }) --- -2.34.1 - diff --git a/0016-proxy-fix-code-review-issues.patch b/0016-proxy-fix-code-review-issues.patch deleted file mode 100644 index ee93ac8092f5773dfa50325f23111b437bda930c..0000000000000000000000000000000000000000 --- a/0016-proxy-fix-code-review-issues.patch +++ /dev/null @@ -1,256 +0,0 @@ -From 1c5fcb965561dd7fb48118ca50952a5323ae93be Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Tue, 30 Jan 2024 15:05:20 +0800 -Subject: [PATCH 3/4] proxy: fix code review issues - -1. Fixed the enumeration naming problem. -2. Resolved the problem of redundant return keywords. -3. Fix unnecessary reference issues. -4. Fix unnecessary matches and replace them with if let. -5. Fix unnecessary copying of bool values. - -Signed-off-by: liyuanr ---- - .../proxy/src/controller/controller.rs | 47 +++++++++---------- - KubeOS-Rust/proxy/src/controller/utils.rs | 12 ++--- - 2 files changed, 28 insertions(+), 31 deletions(-) - -diff --git a/KubeOS-Rust/proxy/src/controller/controller.rs b/KubeOS-Rust/proxy/src/controller/controller.rs -index c21f304..ad44380 100644 ---- a/KubeOS-Rust/proxy/src/controller/controller.rs -+++ b/KubeOS-Rust/proxy/src/controller/controller.rs -@@ -59,7 +59,7 @@ pub async fn reconcile( - .ok_or(Error::MissingSubResource { value: String::from("node.status.node_info") })? - .os_image; - debug!("os expected osversion is {},actual osversion is {}", os_cr.spec.osversion, node_os_image); -- if check_version(&os_cr.spec.osversion, &node_os_image) { -+ if check_version(&os_cr.spec.osversion, node_os_image) { - match ConfigType::SysConfig.check_config_version(&os, &osinstance) { - ConfigOperation::Reassign => { - debug!("start reassign"); -@@ -92,8 +92,7 @@ pub async fn reconcile( - if os_cr.spec.opstype == NODE_STATUS_CONFIG { - return Err(Error::UpgradeBeforeConfig); - } -- match ConfigType::UpgradeConfig.check_config_version(&os, &osinstance) { -- ConfigOperation::Reassign => { -+ if let ConfigOperation::Reassign = ConfigType::UpgradeConfig.check_config_version(&os, &osinstance) { - debug!("start reassign"); - proxy_controller - .refresh_node( -@@ -104,8 +103,6 @@ pub async fn reconcile( - ) - .await?; - return Ok(REQUEUE_NORMAL); -- } -- _ => {} - } - if node.labels().contains_key(LABEL_UPGRADING) { - if osinstance.spec.nodestatus == NODE_STATUS_IDLE { -@@ -159,14 +156,14 @@ impl ProxyController { - match osi_api.get(node_name).await { - Ok(osi) => { - debug!("osinstance is exist {:?}", osi.name()); -- return Ok(()); -+ Ok(()) - } - Err(kube::Error::Api(ErrorResponse { reason, .. })) if &reason == "NotFound" => { - info!("Create OSInstance {}", node_name); - self.controller_client.create_osinstance(node_name, namespace).await?; - Ok(()) - } -- Err(err) => Err(Error::KubeError { source: err }), -+ Err(err) => Err(Error::KubeClient { source: err }), - } - } - -@@ -243,7 +240,7 @@ impl ProxyController { - let namespace = &osinstance - .namespace() - .ok_or(Error::MissingObjectKey { resource: "osinstance".to_string(), value: "namespace".to_string() })?; -- self.controller_client.update_osinstance_status(&osinstance.name(), &namespace, &osinstance.status).await?; -+ self.controller_client.update_osinstance_status(&osinstance.name(), namespace, &osinstance.status).await?; - Ok(()) - } - -@@ -256,7 +253,7 @@ impl ProxyController { - match self.agent_client.configure_method(ConfigInfo { configs: agent_configs }) { - Ok(_resp) => {} - Err(e) => { -- return Err(Error::AgentError { source: e }); -+ return Err(Error::Agent { source: e }); - } - } - } -@@ -278,9 +275,9 @@ impl ProxyController { - image_type: os_cr.spec.imagetype.clone(), - check_sum: os_cr.spec.checksum.clone(), - container_image: os_cr.spec.containerimage.clone(), -- flagsafe: os_cr.spec.flagsafe.clone(), -+ flagsafe: os_cr.spec.flagsafe, - imageurl: os_cr.spec.imageurl.clone(), -- mtls: os_cr.spec.mtls.clone(), -+ mtls: os_cr.spec.mtls, - cacert: os_cr.spec.cacert.clone().unwrap_or_default(), - clientcert: os_cr.spec.clientcert.clone().unwrap_or_default(), - clientkey: os_cr.spec.clientkey.clone().unwrap_or_default(), -@@ -289,14 +286,14 @@ impl ProxyController { - match self.agent_client.prepare_upgrade_method(upgrade_info) { - Ok(_resp) => {} - Err(e) => { -- return Err(Error::AgentError { source: e }); -+ return Err(Error::Agent { source: e }); - } - } - self.evict_node(&node.name(), os_cr.spec.evictpodforce).await?; - match self.agent_client.upgrade_method() { - Ok(_resp) => {} - Err(e) => { -- return Err(Error::AgentError { source: e }); -+ return Err(Error::Agent { source: e }); - } - } - } -@@ -306,12 +303,12 @@ impl ProxyController { - match self.agent_client.rollback_method() { - Ok(_resp) => {} - Err(e) => { -- return Err(Error::AgentError { source: e }); -+ return Err(Error::Agent { source: e }); - } - } - } - _ => { -- return Err(Error::OperationError { value: os_cr.spec.opstype.clone() }); -+ return Err(Error::Operation { value: os_cr.spec.opstype.clone() }); - } - } - Ok(()) -@@ -336,7 +333,7 @@ impl ProxyController { - async fn drain_node(&self, node_name: &str, force: bool) -> Result<(), Error> { - use drain::error::DrainError::*; - match drain_os(&self.k8s_client.clone(), node_name, force).await { -- Err(DeletePodsError { errors, .. }) => Err(Error::DrainNodeError { value: errors.join("; ") }), -+ Err(DeletePodsError { errors, .. }) => Err(Error::DrainNode { value: errors.join("; ") }), - _ => Ok(()), - } - } -@@ -365,13 +362,13 @@ fn convert_to_agent_config(configs: Configs) -> Option> { - } - }; - } -- if agent_configs.len() == 0 { -+ if agent_configs.is_empty() { - info!("no contents in all models, no need to configure"); - return None; - } - return Some(agent_configs); - } -- return None; -+ None - } - - fn convert_to_config_hashmap(contents: Vec) -> Option> { -@@ -381,7 +378,7 @@ fn convert_to_config_hashmap(contents: Vec) -> Option -Date: Tue, 30 Jan 2024 16:05:56 +0800 -Subject: [PATCH 4/4] fix: clippy warnings and fmt code - -fix some clippy warnings and fmt code - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/agent/src/rpc/agent_impl.rs | 8 +- - KubeOS-Rust/cli/src/client.rs | 2 +- - KubeOS-Rust/manager/src/sys_mgmt/config.rs | 21 ++--- - .../manager/src/sys_mgmt/containerd_image.rs | 9 +- - .../manager/src/sys_mgmt/docker_image.rs | 4 +- - .../proxy/src/controller/apiserver_mock.rs | 67 +++++++++------ - .../proxy/src/controller/controller.rs | 75 ++++++++-------- - KubeOS-Rust/proxy/src/controller/mod.rs | 2 +- - KubeOS-Rust/proxy/src/controller/utils.rs | 12 +-- - KubeOS-Rust/proxy/src/drain.rs | 86 +++++++++---------- - KubeOS-Rust/proxy/src/main.rs | 2 +- - 11 files changed, 148 insertions(+), 140 deletions(-) - -diff --git a/KubeOS-Rust/agent/src/rpc/agent_impl.rs b/KubeOS-Rust/agent/src/rpc/agent_impl.rs -index 8aef414..5f3a325 100644 ---- a/KubeOS-Rust/agent/src/rpc/agent_impl.rs -+++ b/KubeOS-Rust/agent/src/rpc/agent_impl.rs -@@ -56,7 +56,7 @@ impl Default for AgentImpl { - } - - impl AgentImpl { -- pub fn prepare_upgrade_impl(&self, req: UpgradeRequest) -> Result { -+ fn prepare_upgrade_impl(&self, req: UpgradeRequest) -> Result { - let _lock = self.mutex.lock().unwrap(); - debug!("Received an 'prepare upgrade' request: {:?}", req); - info!("Start preparing for upgrading to version: {}", req.version); -@@ -75,7 +75,7 @@ impl AgentImpl { - Ok(Response { status: AgentStatus::UpgradeReady }) - } - -- pub fn upgrade_impl(&self) -> Result { -+ fn upgrade_impl(&self) -> Result { - let _lock = self.mutex.lock().unwrap(); - info!("Start to upgrade"); - let command_executor = RealCommandExecutor {}; -@@ -90,7 +90,7 @@ impl AgentImpl { - Ok(Response { status: AgentStatus::Upgraded }) - } - -- pub fn configure_impl(&self, mut req: ConfigureRequest) -> Result { -+ fn configure_impl(&self, mut req: ConfigureRequest) -> Result { - let _lock = self.mutex.lock().unwrap(); - debug!("Received a 'configure' request: {:?}", req); - info!("Start to configure"); -@@ -107,7 +107,7 @@ impl AgentImpl { - Ok(Response { status: AgentStatus::Configured }) - } - -- pub fn rollback_impl(&self) -> Result { -+ fn rollback_impl(&self) -> Result { - let _lock = self.mutex.lock().unwrap(); - info!("Start to rollback"); - let command_executor = RealCommandExecutor {}; -diff --git a/KubeOS-Rust/cli/src/client.rs b/KubeOS-Rust/cli/src/client.rs -index 9765a42..37518bd 100644 ---- a/KubeOS-Rust/cli/src/client.rs -+++ b/KubeOS-Rust/cli/src/client.rs -@@ -30,7 +30,7 @@ impl Client { - Client { json_rpc_client: JsonRPCClient::with_transport(UdsTransport::new(socket_path)) } - } - -- pub fn build_request<'a>(&self, command: &'a str, params: &'a Vec>) -> Request<'a> { -+ pub fn build_request<'a>(&self, command: &'a str, params: &'a [Box]) -> Request<'a> { - let json_rpc_request = self.json_rpc_client.build_request(command, params); - let request = Request(json_rpc_request); - request -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/config.rs b/KubeOS-Rust/manager/src/sys_mgmt/config.rs -index 33efdca..138df9d 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/config.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/config.rs -@@ -105,10 +105,10 @@ impl Configuration for KernelSysctlPersist { - config_path = &config.config_path; - } - debug!("kernel.sysctl.persist config_path: \"{}\"", config_path); -- create_config_file(config_path).with_context(|| format!("Failed to find config path"))?; -+ create_config_file(config_path).with_context(|| format!("Failed to find config path \"{}\"", config_path))?; - let configs = get_and_set_configs(&mut config.contents, config_path) -- .with_context(|| format!("Failed to set persist kernel configs"))?; -- write_configs_to_file(config_path, &configs).with_context(|| format!("Failed to write configs to file"))?; -+ .with_context(|| format!("Failed to set persist kernel configs \"{}\"", config_path))?; -+ write_configs_to_file(config_path, &configs).with_context(|| "Failed to write configs to file".to_string())?; - Ok(()) - } - } -@@ -125,7 +125,7 @@ fn create_config_file(config_path: &str) -> Result<()> { - } - - fn get_and_set_configs(expect_configs: &mut HashMap, config_path: &str) -> Result> { -- let f = File::open(config_path)?; -+ let f = File::open(config_path).with_context(|| format!("Failed to open config path \"{}\"", config_path))?; - let mut configs_write = Vec::new(); - for line in io::BufReader::new(f).lines() { - let line = line?; -@@ -169,7 +169,7 @@ fn write_configs_to_file(config_path: &str, configs: &Vec) -> Result<()> - Ok(()) - } - --fn handle_delete_key(config_kv: &Vec<&str>, new_config_info: &KeyInfo) -> String { -+fn handle_delete_key(config_kv: &[&str], new_config_info: &KeyInfo) -> String { - let key = config_kv[0]; - if config_kv.len() == 1 && new_config_info.value.is_empty() { - info!("Delete configuration key: \"{}\"", key); -@@ -190,7 +190,7 @@ fn handle_delete_key(config_kv: &Vec<&str>, new_config_info: &KeyInfo) -> String - String::new() - } - --fn handle_update_key(config_kv: &Vec<&str>, new_config_info: &KeyInfo) -> String { -+fn handle_update_key(config_kv: &[&str], new_config_info: &KeyInfo) -> String { - let key = config_kv[0]; - if !new_config_info.operation.is_empty() { - warn!( -@@ -259,12 +259,13 @@ impl Configuration for GrubCmdline { - self.is_cur_partition - } else { - self.get_config_partition(RealCommandExecutor {}) -- .with_context(|| format!("Failed to get config partition"))? -+ .with_context(|| "Failed to get config partition".to_string())? - }; - debug!("Config_partition: {} (false means partition A, true means partition B)", config_partition); - let configs = get_and_set_grubcfg(&mut config.contents, &self.grub_path, config_partition) -- .with_context(|| format!("Failed to set grub configs"))?; -- write_configs_to_file(&self.grub_path, &configs)?; -+ .with_context(|| "Failed to set grub configs".to_string())?; -+ write_configs_to_file(&self.grub_path, &configs) -+ .with_context(|| "Failed to write configs to file".to_string())?; - Ok(()) - } - } -@@ -286,7 +287,7 @@ fn get_and_set_grubcfg( - grub_path: &str, - config_partition: bool, - ) -> Result> { -- let f = File::open(grub_path)?; -+ let f = File::open(grub_path).with_context(|| format!("Failed to open grub.cfg \"{}\"", grub_path))?; - let re_find_cur_linux = r"^\s*linux.*root=.*"; - let re = Regex::new(re_find_cur_linux)?; - let mut configs_write = Vec::new(); -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -index 727949b..80caf29 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/containerd_image.rs -@@ -73,12 +73,12 @@ impl CtrImageHandler { - .to_str() - .ok_or_else(|| anyhow!("Failed to get mount path: {}", self.paths.mount_path.display()))?; - info!("Start getting rootfs {}", image_name); -- self.check_and_unmount(mount_path).with_context(|| format!("Failed to clean containerd environment"))?; -+ self.check_and_unmount(mount_path).with_context(|| "Failed to clean containerd environment".to_string())?; - self.executor - .run_command("ctr", &["-n", DEFAULT_NAMESPACE, "images", "mount", "--rw", image_name, mount_path])?; - // copy os.tar from mount_path to its partent dir - self.copy_file(self.paths.mount_path.join(&self.paths.rootfs_file), &self.paths.tar_path, permission)?; -- self.check_and_unmount(mount_path).with_context(|| format!("Failed to clean containerd environment"))?; -+ self.check_and_unmount(mount_path).with_context(|| "Failed to clean containerd environment".to_string())?; - Ok(()) - } - -@@ -103,10 +103,7 @@ impl CtrImageHandler { - - #[cfg(test)] - mod tests { -- use std::{ -- io::Write, -- path::{Path, PathBuf}, -- }; -+ use std::{io::Write, path::PathBuf}; - - use mockall::mock; - use tempfile::NamedTempFile; -diff --git a/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs b/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -index f697142..4d97552 100644 ---- a/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -+++ b/KubeOS-Rust/manager/src/sys_mgmt/docker_image.rs -@@ -52,7 +52,7 @@ impl DockerImageHandler { - fn get_rootfs_archive(&self, req: &UpgradeRequest) -> Result<()> { - let image_name = &req.container_image; - info!("Start getting rootfs {}", image_name); -- self.check_and_rm_container().with_context(|| format!("Failed to remove kubeos-temp container"))?; -+ self.check_and_rm_container().with_context(|| "Failed to remove kubeos-temp container".to_string())?; - debug!("Create container {}", self.container_name); - let container_id = - self.executor.run_command_with_output("docker", &["create", "--name", &self.container_name, image_name])?; -@@ -65,7 +65,7 @@ impl DockerImageHandler { - self.paths.update_path.to_str().unwrap(), - ], - )?; -- self.check_and_rm_container().with_context(|| format!("Failed to remove kubeos-temp container"))?; -+ self.check_and_rm_container().with_context(|| "Failed to remove kubeos-temp container".to_string())?; - Ok(()) - } - -diff --git a/KubeOS-Rust/proxy/src/controller/apiserver_mock.rs b/KubeOS-Rust/proxy/src/controller/apiserver_mock.rs -index ef5977c..2b182ca 100644 ---- a/KubeOS-Rust/proxy/src/controller/apiserver_mock.rs -+++ b/KubeOS-Rust/proxy/src/controller/apiserver_mock.rs -@@ -1,3 +1,35 @@ -+/* -+ * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. -+ * KubeOS is licensed under the Mulan PSL v2. -+ * You can use this software according to the terms and conditions of the Mulan PSL v2. -+ * You may obtain a copy of Mulan PSL v2 at: -+ * http://license.coscl.org.cn/MulanPSL2 -+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR -+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR -+ * PURPOSE. -+ * See the Mulan PSL v2 for more details. -+ */ -+ -+use std::collections::BTreeMap; -+ -+use anyhow::Result; -+use cli::{ -+ client::Client, -+ method::{ -+ callable_method::RpcMethod, configure::ConfigureMethod, prepare_upgrade::PrepareUpgradeMethod, -+ rollback::RollbackMethod, upgrade::UpgradeMethod, -+ }, -+}; -+use http::{Request, Response}; -+use hyper::{body::to_bytes, Body}; -+use k8s_openapi::api::core::v1::{Node, NodeSpec, NodeStatus, NodeSystemInfo, Pod}; -+use kube::{ -+ api::ObjectMeta, -+ core::{ListMeta, ObjectList}, -+ Client as KubeClient, Resource, ResourceExt, -+}; -+use mockall::mock; -+ - use self::mock_error::Error; - use super::{ - agentclient::*, -@@ -10,23 +42,6 @@ use crate::controller::{ - values::{LABEL_OSINSTANCE, LABEL_UPGRADING, NODE_STATUS_IDLE}, - ProxyController, - }; --use anyhow::Result; --use cli::client::Client; --use cli::method::{ -- callable_method::RpcMethod, configure::ConfigureMethod, prepare_upgrade::PrepareUpgradeMethod, -- rollback::RollbackMethod, upgrade::UpgradeMethod, --}; --use http::{Request, Response}; --use hyper::{body::to_bytes, Body}; --use k8s_openapi::api::core::v1::Pod; --use k8s_openapi::api::core::v1::{Node, NodeSpec, NodeStatus, NodeSystemInfo}; --use kube::{ -- api::ObjectMeta, -- core::{ListMeta, ObjectList}, --}; --use kube::{Client as KubeClient, Resource, ResourceExt}; --use mockall::mock; --use std::collections::BTreeMap; - - type ApiServerHandle = tower_test::mock::Handle, Response>; - pub struct ApiServerVerifier(ApiServerHandle); -@@ -66,7 +81,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_get(osi) - .await -- } -+ }, - Testcases::UpgradeNormal(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -85,7 +100,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_pod_list_get(osi) - .await -- } -+ }, - Testcases::UpgradeUpgradeconfigsVersionMismatch(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -104,7 +119,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_osinstance_patch_nodestatus_idle(osi) - .await -- } -+ }, - Testcases::UpgradeOSInstaceNodestatusConfig(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -114,7 +129,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_get_with_label(osi.clone()) - .await -- } -+ }, - Testcases::UpgradeOSInstaceNodestatusIdle(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -130,7 +145,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_uncordon(osi) - .await -- } -+ }, - Testcases::ConfigNormal(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -146,7 +161,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_osinstance_patch_nodestatus_idle(osi) - .await -- } -+ }, - Testcases::ConfigVersionMismatchReassign(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -159,7 +174,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_osinstance_patch_nodestatus_idle(osi) - .await -- } -+ }, - Testcases::ConfigVersionMismatchUpdate(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -172,7 +187,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_osinstance_patch_spec_sysconfig_v2(osi) - .await -- } -+ }, - Testcases::Rollback(osi) => { - self.handler_osinstance_get_exist(osi.clone()) - .await -@@ -191,7 +206,7 @@ impl ApiServerVerifier { - .unwrap() - .handler_node_pod_list_get(osi) - .await -- } -+ }, - } - .expect("Case completed without errors"); - }) -diff --git a/KubeOS-Rust/proxy/src/controller/controller.rs b/KubeOS-Rust/proxy/src/controller/controller.rs -index ad44380..80a85d1 100644 ---- a/KubeOS-Rust/proxy/src/controller/controller.rs -+++ b/KubeOS-Rust/proxy/src/controller/controller.rs -@@ -72,7 +72,7 @@ pub async fn reconcile( - ) - .await?; - return Ok(REQUEUE_NORMAL); -- } -+ }, - ConfigOperation::UpdateConfig => { - debug!("start update config"); - osinstance.spec.sysconfigs = os_cr.spec.sysconfigs.clone(); -@@ -81,8 +81,8 @@ pub async fn reconcile( - .update_osinstance_spec(&osinstance.name(), &namespace, &osinstance.spec) - .await?; - return Ok(REQUEUE_ERROR); -- } -- _ => {} -+ }, -+ _ => {}, - } - proxy_controller.set_config(&mut osinstance, ConfigType::SysConfig).await?; - proxy_controller -@@ -92,17 +92,17 @@ pub async fn reconcile( - if os_cr.spec.opstype == NODE_STATUS_CONFIG { - return Err(Error::UpgradeBeforeConfig); - } -- if let ConfigOperation::Reassign = ConfigType::UpgradeConfig.check_config_version(&os, &osinstance) { -- debug!("start reassign"); -- proxy_controller -- .refresh_node( -- node, -- osinstance, -- &get_config_version(os_cr.spec.upgradeconfigs.as_ref()), -- ConfigType::UpgradeConfig, -- ) -- .await?; -- return Ok(REQUEUE_NORMAL); -+ if let ConfigOperation::Reassign = ConfigType::UpgradeConfig.check_config_version(&os, &osinstance) { -+ debug!("start reassign"); -+ proxy_controller -+ .refresh_node( -+ node, -+ osinstance, -+ &get_config_version(os_cr.spec.upgradeconfigs.as_ref()), -+ ConfigType::UpgradeConfig, -+ ) -+ .await?; -+ return Ok(REQUEUE_NORMAL); - } - if node.labels().contains_key(LABEL_UPGRADING) { - if osinstance.spec.nodestatus == NODE_STATUS_IDLE { -@@ -157,12 +157,12 @@ impl ProxyController { - Ok(osi) => { - debug!("osinstance is exist {:?}", osi.name()); - Ok(()) -- } -+ }, - Err(kube::Error::Api(ErrorResponse { reason, .. })) if &reason == "NotFound" => { - info!("Create OSInstance {}", node_name); - self.controller_client.create_osinstance(node_name, namespace).await?; - Ok(()) -- } -+ }, - Err(err) => Err(Error::KubeClient { source: err }), - } - } -@@ -251,15 +251,15 @@ impl ProxyController { - match config_info.configs.and_then(convert_to_agent_config) { - Some(agent_configs) => { - match self.agent_client.configure_method(ConfigInfo { configs: agent_configs }) { -- Ok(_resp) => {} -+ Ok(_resp) => {}, - Err(e) => { - return Err(Error::Agent { source: e }); -- } -+ }, - } -- } -+ }, - None => { - info!("config is none, No content can be configured."); -- } -+ }, - }; - self.update_osi_status(osinstance, config_type).await?; - } -@@ -284,32 +284,32 @@ impl ProxyController { - }; - - match self.agent_client.prepare_upgrade_method(upgrade_info) { -- Ok(_resp) => {} -+ Ok(_resp) => {}, - Err(e) => { - return Err(Error::Agent { source: e }); -- } -+ }, - } - self.evict_node(&node.name(), os_cr.spec.evictpodforce).await?; - match self.agent_client.upgrade_method() { -- Ok(_resp) => {} -+ Ok(_resp) => {}, - Err(e) => { - return Err(Error::Agent { source: e }); -- } -+ }, - } -- } -+ }, - OPERATION_TYPE_ROLLBACK => { - self.evict_node(&node.name(), os_cr.spec.evictpodforce).await?; - - match self.agent_client.rollback_method() { -- Ok(_resp) => {} -+ Ok(_resp) => {}, - Err(e) => { - return Err(Error::Agent { source: e }); -- } -+ }, - } -- } -+ }, - _ => { - return Err(Error::Operation { value: os_cr.spec.opstype.clone() }); -- } -+ }, - } - Ok(()) - } -@@ -320,12 +320,12 @@ impl ProxyController { - node_api.cordon(node_name).await?; - info!("Cordon node Successfully{}, start drain nodes", node_name); - match self.drain_node(node_name, evict_pod_force).await { -- Ok(()) => {} -+ Ok(()) => {}, - Err(e) => { - node_api.uncordon(node_name).await?; - info!("Drain node {} error, uncordon node successfully", node_name); - return Err(e); -- } -+ }, - } - Ok(()) - } -@@ -351,7 +351,7 @@ fn convert_to_agent_config(configs: Configs) -> Option> { - contents: contents_tmp, - }; - agent_configs.push(config_tmp) -- } -+ }, - None => { - info!( - "model {} which has configpath {} do not has any contents no need to configure", -@@ -359,7 +359,7 @@ fn convert_to_agent_config(configs: Configs) -> Option> { - config.configpath.unwrap_or_default() - ); - continue; -- } -+ }, - }; - } - if agent_configs.is_empty() { -@@ -427,11 +427,14 @@ pub mod reconciler_error { - - #[cfg(test)] - mod test { -- use super::{error_policy, reconcile, Context, OSInstance, ProxyController, OS}; -- use crate::controller::apiserver_mock::{timeout_after_5s, MockAgentCallClient, Testcases}; -- use crate::controller::ControllerClient; - use std::env; - -+ use super::{error_policy, reconcile, Context, OSInstance, ProxyController, OS}; -+ use crate::controller::{ -+ apiserver_mock::{timeout_after_5s, MockAgentCallClient, Testcases}, -+ ControllerClient, -+ }; -+ - #[tokio::test] - async fn test_create_osinstance_with_no_upgrade_or_configuration() { - let (test_proxy_controller, fakeserver) = ProxyController::::test(); -diff --git a/KubeOS-Rust/proxy/src/controller/mod.rs b/KubeOS-Rust/proxy/src/controller/mod.rs -index e30c8df..b8a4e6e 100644 ---- a/KubeOS-Rust/proxy/src/controller/mod.rs -+++ b/KubeOS-Rust/proxy/src/controller/mod.rs -@@ -21,6 +21,6 @@ mod values; - - pub use agentclient::{AgentCallClient, AgentClient}; - pub use apiclient::ControllerClient; --pub use controller::{error_policy, reconcile, reconciler_error::Error, ProxyController}; -+pub use controller::{error_policy, reconcile, ProxyController}; - pub use crd::OS; - pub use values::SOCK_PATH; -diff --git a/KubeOS-Rust/proxy/src/controller/utils.rs b/KubeOS-Rust/proxy/src/controller/utils.rs -index 82d960b..148ca24 100644 ---- a/KubeOS-Rust/proxy/src/controller/utils.rs -+++ b/KubeOS-Rust/proxy/src/controller/utils.rs -@@ -56,7 +56,7 @@ impl ConfigType { - ); - return ConfigOperation::Reassign; - } -- } -+ }, - ConfigType::SysConfig => { - let os_config_version = get_config_version(os.spec.sysconfigs.as_ref()); - let osi_config_version = get_config_version(osinstance.spec.sysconfigs.as_ref()); -@@ -78,7 +78,7 @@ impl ConfigType { - return ConfigOperation::UpdateConfig; - } - } -- } -+ }, - }; - ConfigOperation::DoNothing - } -@@ -96,7 +96,7 @@ impl ConfigType { - status_config_version = get_config_version(None); - } - configs = osinstance.spec.upgradeconfigs.clone(); -- } -+ }, - ConfigType::SysConfig => { - spec_config_version = get_config_version(osinstance.spec.sysconfigs.as_ref()); - if let Some(osinstance_status) = osinstance.status.as_ref() { -@@ -105,7 +105,7 @@ impl ConfigType { - status_config_version = get_config_version(None); - } - configs = osinstance.spec.sysconfigs.clone(); -- } -+ }, - } - debug!( - "osinstance soec config version is {},status config version is {}", -@@ -127,7 +127,7 @@ impl ConfigType { - sysconfigs: None, - }) - } -- } -+ }, - ConfigType::SysConfig => { - if let Some(osi_status) = &mut osinstance.status { - osi_status.sysconfigs = osinstance.spec.sysconfigs.clone(); -@@ -135,7 +135,7 @@ impl ConfigType { - osinstance.status = - Some(OSInstanceStatus { upgradeconfigs: None, sysconfigs: osinstance.spec.sysconfigs.clone() }) - } -- } -+ }, - } - } - } -diff --git a/KubeOS-Rust/proxy/src/drain.rs b/KubeOS-Rust/proxy/src/drain.rs -index 72836f9..64417df 100644 ---- a/KubeOS-Rust/proxy/src/drain.rs -+++ b/KubeOS-Rust/proxy/src/drain.rs -@@ -66,7 +66,7 @@ async fn get_pods_deleted( - Ok(pods @ ObjectList { .. }) => pods, - Err(err) => { - return Err(GetPodListsError { source: err, node_name: node_name.to_string() }); -- } -+ }, - }; - let mut filterd_pods_list: Vec = Vec::new(); - let mut filterd_err: Vec = Vec::new(); -@@ -81,7 +81,7 @@ async fn get_pods_deleted( - filterd_pods_list.push(pod); - } - } -- if filterd_err.len() > 0 { -+ if !filterd_err.is_empty() { - return Err(DeletePodsError { errors: filterd_err }); - } - Ok(filterd_pods_list.into_iter()) -@@ -189,14 +189,14 @@ async fn wait_for_deletion(k8s_client: &kube::Client, pod: &Pod) -> Result<(), e - let name = (&p).name_any(); - info!("Pod {} deleted.", name); - break; -- } -+ }, - Ok(_) => { - info!("Pod '{}' is not yet deleted. Waiting {}s.", pod.name_any(), EVERY_DELETION_CHECK.as_secs_f64()); -- } -+ }, - Err(kube::Error::Api(e)) if e.code == response_error_not_found => { - info!("Pod {} is deleted.", pod.name_any()); - break; -- } -+ }, - Err(e) => { - error!( - "Get pod {} reported error: '{}', whether pod is deleted cannot be determined, waiting {}s.", -@@ -204,7 +204,7 @@ async fn wait_for_deletion(k8s_client: &kube::Client, pod: &Pod) -> Result<(), e - e, - EVERY_DELETION_CHECK.as_secs_f64() - ); -- } -+ }, - } - if start_time.elapsed() > TIMEOUT { - return Err(WaitDeletionError { pod_name: pod.name_any(), max_wait: TIMEOUT }); -@@ -223,25 +223,25 @@ fn get_pod_api_with_namespace(client: &kube::Client, pod: &Pod) -> Api { - } - - trait NameAny { -- fn name_any(self: &Self) -> String; -+ fn name_any(&self) -> String; - } - - impl NameAny for &Pod { -- fn name_any(self: &Self) -> String { -+ fn name_any(&self) -> String { - self.metadata.name.clone().or_else(|| self.metadata.generate_name.clone()).unwrap_or_default() - } - } - trait PodFilter { -- fn filter(self: &Self, pod: &Pod) -> Box; -+ fn filter(&self, pod: &Pod) -> Box; - } - - struct FinishedOrFailedFilter {} - impl PodFilter for FinishedOrFailedFilter { -- fn filter(self: &Self, pod: &Pod) -> Box { -+ fn filter(&self, pod: &Pod) -> Box { - return match pod.status.as_ref() { - Some(PodStatus { phase: Some(phase), .. }) if phase == "Failed" || phase == "Succeeded" => { - FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay) -- } -+ }, - _ => FilterResult::create_filter_result(false, "", PodDeleteStatus::Okay), - }; - } -@@ -251,7 +251,7 @@ struct DaemonFilter { - force: bool, - } - impl PodFilter for DaemonFilter { -- fn filter(self: &Self, pod: &Pod) -> Box { -+ fn filter(&self, pod: &Pod) -> Box { - if let FilterResult { result: true, .. } = self.finished_or_failed_filter.filter(pod).as_ref() { - return FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay); - } -@@ -269,25 +269,25 @@ impl PodFilter for DaemonFilter { - let description = format!("Cannot drain Pod '{}': Pod is member of a DaemonSet", pod.name_any()); - Box::new(FilterResult { result: false, desc: description, status: PodDeleteStatus::Error }) - } -- } -+ }, - _ => FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay), - }; - } - } - impl DaemonFilter { - fn new(force: bool) -> DaemonFilter { -- return DaemonFilter { finished_or_failed_filter: FinishedOrFailedFilter {}, force: force }; -+ DaemonFilter { finished_or_failed_filter: FinishedOrFailedFilter {}, force } - } - } - - struct MirrorFilter {} - impl PodFilter for MirrorFilter { -- fn filter(self: &Self, pod: &Pod) -> Box { -+ fn filter(&self, pod: &Pod) -> Box { - return match pod.metadata.annotations.as_ref() { - Some(annotations) if annotations.contains_key("kubernetes.io/config.mirror") => { - let description = format!("Ignore Pod '{}': Pod is a static Mirror Pod", pod.name_any()); - FilterResult::create_filter_result(false, &description.to_string(), PodDeleteStatus::Warning) -- } -+ }, - _ => FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay), - }; - } -@@ -298,7 +298,7 @@ struct LocalStorageFilter { - force: bool, - } - impl PodFilter for LocalStorageFilter { -- fn filter(self: &Self, pod: &Pod) -> Box { -+ fn filter(&self, pod: &Pod) -> Box { - if let FilterResult { result: true, .. } = self.finished_or_failed_filter.filter(pod).as_ref() { - return FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay); - } -@@ -312,14 +312,14 @@ impl PodFilter for LocalStorageFilter { - let description = format!("Cannot drain Pod '{}': Pod has local Storage", pod.name_any()); - Box::new(FilterResult { result: false, desc: description, status: PodDeleteStatus::Error }) - } -- } -+ }, - _ => FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay), - }; - } - } - impl LocalStorageFilter { - fn new(force: bool) -> LocalStorageFilter { -- return LocalStorageFilter { finished_or_failed_filter: FinishedOrFailedFilter {}, force: force }; -+ LocalStorageFilter { finished_or_failed_filter: FinishedOrFailedFilter {}, force } - } - } - struct UnreplicatedFilter { -@@ -327,7 +327,7 @@ struct UnreplicatedFilter { - force: bool, - } - impl PodFilter for UnreplicatedFilter { -- fn filter(self: &Self, pod: &Pod) -> Box { -+ fn filter(&self, pod: &Pod) -> Box { - if let FilterResult { result: true, .. } = self.finished_or_failed_filter.filter(pod).as_ref() { - return FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay); - } -@@ -338,18 +338,18 @@ impl PodFilter for UnreplicatedFilter { - return FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay); - } - -- return if !is_replicated && self.force { -+ if !is_replicated && self.force { - let description = format!("Force drain Pod '{}': Pod is unreplicated", pod.name_any()); - Box::new(FilterResult { result: true, desc: description, status: PodDeleteStatus::Warning }) - } else { - let description = format!("Cannot drain Pod '{}': Pod is unreplicated", pod.name_any()); - Box::new(FilterResult { result: false, desc: description, status: PodDeleteStatus::Error }) -- }; -+ } - } - } - impl UnreplicatedFilter { - fn new(force: bool) -> UnreplicatedFilter { -- return UnreplicatedFilter { finished_or_failed_filter: FinishedOrFailedFilter {}, force: force }; -+ UnreplicatedFilter { finished_or_failed_filter: FinishedOrFailedFilter {}, force } - } - } - -@@ -357,7 +357,7 @@ struct DeletedFilter { - delete_wait_timeout: Duration, - } - impl PodFilter for DeletedFilter { -- fn filter(self: &Self, pod: &Pod) -> Box { -+ fn filter(&self, pod: &Pod) -> Box { - let now = Instant::now().elapsed(); - return match pod.metadata.deletion_timestamp.as_ref() { - Some(time) -@@ -365,7 +365,7 @@ impl PodFilter for DeletedFilter { - && now - Duration::from_secs(time.0.timestamp() as u64) >= self.delete_wait_timeout => - { - FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay) -- } -+ }, - _ => FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay), - }; - } -@@ -379,14 +379,14 @@ struct CombinedFilter { - unreplicated_filter: UnreplicatedFilter, - } - impl PodFilter for CombinedFilter { -- fn filter(self: &Self, pod: &Pod) -> Box { -+ fn filter(&self, pod: &Pod) -> Box { - let mut filter_res = self.deleted_filter.filter(pod); - if !filter_res.result { - info!("{}", filter_res.desc); - return Box::new(FilterResult { - result: filter_res.result, - desc: filter_res.desc.clone(), -- status: filter_res.status.clone(), -+ status: filter_res.status, - }); - } - filter_res = self.daemon_filter.filter(pod); -@@ -395,7 +395,7 @@ impl PodFilter for CombinedFilter { - return Box::new(FilterResult { - result: filter_res.result, - desc: filter_res.desc.clone(), -- status: filter_res.status.clone(), -+ status: filter_res.status, - }); - } - filter_res = self.mirror_filter.filter(pod); -@@ -404,7 +404,7 @@ impl PodFilter for CombinedFilter { - return Box::new(FilterResult { - result: filter_res.result, - desc: filter_res.desc.clone(), -- status: filter_res.status.clone(), -+ status: filter_res.status, - }); - } - filter_res = self.local_storage_filter.filter(pod); -@@ -413,7 +413,7 @@ impl PodFilter for CombinedFilter { - return Box::new(FilterResult { - result: filter_res.result, - desc: filter_res.desc.clone(), -- status: filter_res.status.clone(), -+ status: filter_res.status, - }); - } - filter_res = self.unreplicated_filter.filter(pod); -@@ -422,22 +422,22 @@ impl PodFilter for CombinedFilter { - return Box::new(FilterResult { - result: filter_res.result, - desc: filter_res.desc.clone(), -- status: filter_res.status.clone(), -+ status: filter_res.status, - }); - } - -- return FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay); -+ FilterResult::create_filter_result(true, "", PodDeleteStatus::Okay) - } - } - impl CombinedFilter { - fn new(force: bool) -> CombinedFilter { -- return CombinedFilter { -+ CombinedFilter { - deleted_filter: DeletedFilter { delete_wait_timeout: TIMEOUT }, - daemon_filter: DaemonFilter::new(force), - mirror_filter: MirrorFilter {}, - local_storage_filter: LocalStorageFilter::new(force), - unreplicated_filter: UnreplicatedFilter::new(force), -- }; -+ } - } - } - -@@ -454,7 +454,7 @@ struct FilterResult { - } - impl FilterResult { - fn create_filter_result(result: bool, desc: &str, status: PodDeleteStatus) -> Box { -- Box::new(FilterResult { result: result, desc: desc.to_string(), status: status }) -+ Box::new(FilterResult { result, desc: desc.to_string(), status }) - } - } - -@@ -468,13 +468,11 @@ impl ErrorHandleStrategy { - let backoff = - ExponentialBackoff::from_millis(RETRY_BASE_DELAY.as_millis() as u64).max_delay(RETRY_MAX_DELAY).map(jitter); - -- return match self { -- Self::TolerateStrategy => { -- return backoff.take(0); -- } -+ match self { -+ Self::TolerateStrategy => backoff.take(0), - - Self::RetryStrategy => backoff.take(MAX_RETRIES_TIMES), -- }; -+ } - } - } - -@@ -482,13 +480,7 @@ impl tokio_retry::Condition for ErrorHandleStrategy { - fn should_retry(&mut self, error: &error::EvictionError) -> bool { - match self { - Self::TolerateStrategy => false, -- Self::RetryStrategy => { -- if let error::EvictionError::EvictionErrorRetry { .. } = error { -- true -- } else { -- false -- } -- } -+ Self::RetryStrategy => matches!(error, error::EvictionError::EvictionErrorRetry { .. }), - } - } - } -diff --git a/KubeOS-Rust/proxy/src/main.rs b/KubeOS-Rust/proxy/src/main.rs -index ad36b64..5c122ba 100644 ---- a/KubeOS-Rust/proxy/src/main.rs -+++ b/KubeOS-Rust/proxy/src/main.rs -@@ -39,7 +39,7 @@ async fn main() -> Result<()> { - .run(reconcile, error_policy, Context::new(proxy_controller)) - .for_each(|res| async move { - match res { -- Ok(_o) => {} -+ Ok(_o) => {}, - Err(e) => error!("reconcile failed: {}", e.to_string()), - } - }) --- -2.34.1 - diff --git a/0018-Bump-tokio-to-1.28.0.patch b/0018-Bump-tokio-to-1.28.0.patch deleted file mode 100644 index c5bac38f8760e6a274963eeaf0ee8255fc545848..0000000000000000000000000000000000000000 --- a/0018-Bump-tokio-to-1.28.0.patch +++ /dev/null @@ -1,127 +0,0 @@ -From d6a1854785e9e4ec854654baf024a32ce72d4962 Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Mon, 5 Feb 2024 10:04:46 +0800 -Subject: [PATCH 1/3] Bump tokio to 1.28.0 - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/Cargo.lock | 42 ++++++++++-------------------------- - KubeOS-Rust/proxy/Cargo.toml | 6 ++++-- - 2 files changed, 15 insertions(+), 33 deletions(-) - -diff --git a/KubeOS-Rust/Cargo.lock b/KubeOS-Rust/Cargo.lock -index 2342c7b2..004ef234 100644 ---- a/KubeOS-Rust/Cargo.lock -+++ b/KubeOS-Rust/Cargo.lock -@@ -1133,24 +1133,14 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" - - [[package]] - name = "mio" --version = "0.7.14" -+version = "0.8.10" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc" -+checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09" - dependencies = [ - "libc", - "log", -- "miow", -- "ntapi", -- "winapi", --] -- --[[package]] --name = "miow" --version = "0.3.7" --source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21" --dependencies = [ -- "winapi", -+ "wasi 0.11.0+wasi-snapshot-preview1", -+ "windows-sys", - ] - - [[package]] -@@ -1234,15 +1224,6 @@ version = "0.3.0" - source = "registry+https://github.com/rust-lang/crates.io-index" - checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be" - --[[package]] --name = "ntapi" --version = "0.3.7" --source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f" --dependencies = [ -- "winapi", --] -- - [[package]] - name = "num-traits" - version = "0.2.17" -@@ -2077,21 +2058,20 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - - [[package]] - name = "tokio" --version = "1.14.0" -+version = "1.28.0" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "70e992e41e0d2fb9f755b37446f20900f64446ef54874f40a60c78f021ac6144" -+checksum = "c3c786bf8134e5a3a166db9b29ab8f48134739014a3eca7bc6bfa95d673b136f" - dependencies = [ - "autocfg", - "bytes", - "libc", -- "memchr", - "mio", - "num_cpus", -- "once_cell", - "pin-project-lite", - "signal-hook-registry", -+ "socket2", - "tokio-macros", -- "winapi", -+ "windows-sys", - ] - - [[package]] -@@ -2106,13 +2086,13 @@ dependencies = [ - - [[package]] - name = "tokio-macros" --version = "1.8.2" -+version = "2.1.0" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "d266c00fde287f55d3f1c3e96c500c362a2b8c695076ec180f27918820bc6df8" -+checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e" - dependencies = [ - "proc-macro2", - "quote", -- "syn 1.0.109", -+ "syn 2.0.37", - ] - - [[package]] -diff --git a/KubeOS-Rust/proxy/Cargo.toml b/KubeOS-Rust/proxy/Cargo.toml -index 94e3b3c8..429c5fdb 100644 ---- a/KubeOS-Rust/proxy/Cargo.toml -+++ b/KubeOS-Rust/proxy/Cargo.toml -@@ -35,7 +35,10 @@ serde_json = "1.0.68" - socket2 = "=0.4.9" - thiserror = "1.0.29" - thread_local = "=1.1.4" --tokio = { version = "=1.14.0", features = ["macros", "rt-multi-thread"] } -+tokio = { version = "=1.28.0", default-features = false, features = [ -+ "macros", -+ "rt-multi-thread", -+] } - tokio-retry = "0.3" - - [dev-dependencies] -@@ -44,4 +47,3 @@ http = "0.2.9" - hyper = "0.14.25" - tower-test = "0.4.0" - mockall = { version = "=0.11.3" } -- --- -2.34.1 - diff --git a/0019-build-update-vendor.patch b/0019-build-update-vendor.patch deleted file mode 100644 index 88fe986c06155db1b3b42d983ba5fea9cee74781..0000000000000000000000000000000000000000 --- a/0019-build-update-vendor.patch +++ /dev/null @@ -1,89134 +0,0 @@ -From 44fc56c4b70eea7eb7b193b91e6ff4f29d862cfa Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Mon, 5 Feb 2024 10:29:04 +0800 -Subject: [PATCH 2/3] build:update vendor - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/vendor/mio/.cargo-checksum.json | 2 +- - KubeOS-Rust/vendor/mio/CHANGELOG.md | 186 +- - KubeOS-Rust/vendor/mio/Cargo.lock | 145 +- - KubeOS-Rust/vendor/mio/Cargo.toml | 117 +- - KubeOS-Rust/vendor/mio/README.md | 55 +- - .../mio/examples/tcp_listenfd_server.rs | 209 + - KubeOS-Rust/vendor/mio/examples/tcp_server.rs | 21 +- - KubeOS-Rust/vendor/mio/examples/udp_server.rs | 19 +- - KubeOS-Rust/vendor/mio/src/event/event.rs | 19 +- - KubeOS-Rust/vendor/mio/src/event/source.rs | 10 +- - KubeOS-Rust/vendor/mio/src/interest.rs | 59 +- - KubeOS-Rust/vendor/mio/src/io_source.rs | 56 +- - KubeOS-Rust/vendor/mio/src/lib.rs | 13 +- - KubeOS-Rust/vendor/mio/src/macros.rs | 28 + - KubeOS-Rust/vendor/mio/src/net/mod.rs | 22 +- - .../vendor/mio/src/net/tcp/listener.rs | 49 +- - KubeOS-Rust/vendor/mio/src/net/tcp/mod.rs | 3 - - KubeOS-Rust/vendor/mio/src/net/tcp/socket.rs | 490 -- - KubeOS-Rust/vendor/mio/src/net/tcp/stream.rs | 156 +- - KubeOS-Rust/vendor/mio/src/net/udp.rs | 87 +- - .../vendor/mio/src/net/uds/datagram.rs | 75 +- - .../vendor/mio/src/net/uds/listener.rs | 7 +- - KubeOS-Rust/vendor/mio/src/net/uds/stream.rs | 100 +- - KubeOS-Rust/vendor/mio/src/poll.rs | 253 +- - KubeOS-Rust/vendor/mio/src/sys/mod.rs | 8 + - KubeOS-Rust/vendor/mio/src/sys/shell/mod.rs | 33 +- - .../vendor/mio/src/sys/shell/selector.rs | 24 +- - KubeOS-Rust/vendor/mio/src/sys/shell/tcp.rs | 118 +- - KubeOS-Rust/vendor/mio/src/sys/shell/udp.rs | 1 + - KubeOS-Rust/vendor/mio/src/sys/shell/uds.rs | 8 + - KubeOS-Rust/vendor/mio/src/sys/unix/mod.rs | 88 +- - KubeOS-Rust/vendor/mio/src/sys/unix/net.rs | 94 +- - KubeOS-Rust/vendor/mio/src/sys/unix/pipe.rs | 296 +- - .../vendor/mio/src/sys/unix/selector/epoll.rs | 72 +- - .../mio/src/sys/unix/selector/kqueue.rs | 335 +- - .../vendor/mio/src/sys/unix/selector/mod.rs | 81 +- - .../vendor/mio/src/sys/unix/selector/poll.rs | 726 +++ - .../vendor/mio/src/sys/unix/sourcefd.rs | 22 +- - KubeOS-Rust/vendor/mio/src/sys/unix/tcp.rs | 452 +- - KubeOS-Rust/vendor/mio/src/sys/unix/udp.rs | 20 +- - .../vendor/mio/src/sys/unix/uds/datagram.rs | 15 +- - .../vendor/mio/src/sys/unix/uds/listener.rs | 62 +- - .../vendor/mio/src/sys/unix/uds/mod.rs | 43 +- - .../vendor/mio/src/sys/unix/uds/socketaddr.rs | 16 +- - .../vendor/mio/src/sys/unix/uds/stream.rs | 30 +- - KubeOS-Rust/vendor/mio/src/sys/unix/waker.rs | 251 +- - KubeOS-Rust/vendor/mio/src/sys/wasi/mod.rs | 370 ++ - KubeOS-Rust/vendor/mio/src/sys/windows/afd.rs | 110 +- - .../vendor/mio/src/sys/windows/event.rs | 3 +- - .../vendor/mio/src/sys/windows/handle.rs | 30 + - .../mio/src/sys/windows/io_status_block.rs | 6 +- - .../{miow/src => mio/src/sys/windows}/iocp.rs | 179 +- - KubeOS-Rust/vendor/mio/src/sys/windows/mod.rs | 19 +- - .../vendor/mio/src/sys/windows/named_pipe.rs | 312 +- - KubeOS-Rust/vendor/mio/src/sys/windows/net.rs | 73 +- - .../vendor/mio/src/sys/windows/overlapped.rs | 10 +- - .../vendor/mio/src/sys/windows/selector.rs | 81 +- - KubeOS-Rust/vendor/mio/src/sys/windows/tcp.rs | 319 +- - KubeOS-Rust/vendor/mio/src/sys/windows/udp.rs | 49 +- - .../vendor/mio/src/sys/windows/waker.rs | 2 +- - KubeOS-Rust/vendor/mio/src/token.rs | 4 +- - KubeOS-Rust/vendor/mio/src/waker.rs | 8 +- - KubeOS-Rust/vendor/miow/.cargo-checksum.json | 1 - - KubeOS-Rust/vendor/miow/CHANGELOG.md | 5 - - KubeOS-Rust/vendor/miow/Cargo.toml | 35 - - KubeOS-Rust/vendor/miow/LICENSE-APACHE | 201 - - KubeOS-Rust/vendor/miow/LICENSE-MIT | 25 - - KubeOS-Rust/vendor/miow/README.md | 31 - - KubeOS-Rust/vendor/miow/appveyor.yml | 20 - - KubeOS-Rust/vendor/miow/src/handle.rs | 177 - - KubeOS-Rust/vendor/miow/src/lib.rs | 52 - - KubeOS-Rust/vendor/miow/src/net.rs | 1332 ----- - KubeOS-Rust/vendor/miow/src/overlapped.rs | 92 - - KubeOS-Rust/vendor/miow/src/pipe.rs | 788 --- - .../mockall_double/.cargo-checksum.json | 1 - - KubeOS-Rust/vendor/mockall_double/Cargo.toml | 40 - - .../vendor/mockall_double/LICENSE-APACHE | 201 - - KubeOS-Rust/vendor/mockall_double/LICENSE-MIT | 25 - - KubeOS-Rust/vendor/mockall_double/README.md | 88 - - KubeOS-Rust/vendor/mockall_double/src/lib.rs | 301 -- - KubeOS-Rust/vendor/ntapi/.cargo-checksum.json | 1 - - KubeOS-Rust/vendor/ntapi/Cargo.toml | 40 - - KubeOS-Rust/vendor/ntapi/LICENSE-APACHE | 202 - - KubeOS-Rust/vendor/ntapi/LICENSE-MIT | 17 - - KubeOS-Rust/vendor/ntapi/README.md | 17 - - KubeOS-Rust/vendor/ntapi/build.rs | 15 - - KubeOS-Rust/vendor/ntapi/src/lib.rs | 70 - - KubeOS-Rust/vendor/ntapi/src/macros.rs | 112 - - KubeOS-Rust/vendor/ntapi/src/ntapi_base.rs | 40 - - KubeOS-Rust/vendor/ntapi/src/ntdbg.rs | 239 - - KubeOS-Rust/vendor/ntapi/src/ntexapi.rs | 2998 ----------- - KubeOS-Rust/vendor/ntapi/src/ntgdi.rs | 123 - - KubeOS-Rust/vendor/ntapi/src/ntioapi.rs | 1464 ------ - KubeOS-Rust/vendor/ntapi/src/ntkeapi.rs | 121 - - KubeOS-Rust/vendor/ntapi/src/ntldr.rs | 661 --- - KubeOS-Rust/vendor/ntapi/src/ntlpcapi.rs | 692 --- - KubeOS-Rust/vendor/ntapi/src/ntmisc.rs | 42 - - KubeOS-Rust/vendor/ntapi/src/ntmmapi.rs | 630 --- - KubeOS-Rust/vendor/ntapi/src/ntnls.rs | 29 - - KubeOS-Rust/vendor/ntapi/src/ntobapi.rs | 226 - - KubeOS-Rust/vendor/ntapi/src/ntpebteb.rs | 431 -- - KubeOS-Rust/vendor/ntapi/src/ntpfapi.rs | 219 - - KubeOS-Rust/vendor/ntapi/src/ntpnpapi.rs | 118 - - KubeOS-Rust/vendor/ntapi/src/ntpoapi.rs | 134 - - KubeOS-Rust/vendor/ntapi/src/ntpsapi.rs | 1471 ------ - KubeOS-Rust/vendor/ntapi/src/ntregapi.rs | 450 -- - KubeOS-Rust/vendor/ntapi/src/ntrtl.rs | 4378 ----------------- - KubeOS-Rust/vendor/ntapi/src/ntsam.rs | 1077 ---- - KubeOS-Rust/vendor/ntapi/src/ntseapi.rs | 439 -- - KubeOS-Rust/vendor/ntapi/src/ntsmss.rs | 15 - - KubeOS-Rust/vendor/ntapi/src/nttmapi.rs | 239 - - KubeOS-Rust/vendor/ntapi/src/nttp.rs | 207 - - KubeOS-Rust/vendor/ntapi/src/ntwow64.rs | 476 -- - KubeOS-Rust/vendor/ntapi/src/ntxcapi.rs | 29 - - KubeOS-Rust/vendor/ntapi/src/ntzwapi.rs | 2699 ---------- - KubeOS-Rust/vendor/ntapi/src/string.rs | 58 - - KubeOS-Rust/vendor/ntapi/src/subprocesstag.rs | 77 - - KubeOS-Rust/vendor/ntapi/src/winapi_local.rs | 1 - - .../vendor/ntapi/src/winapi_local/um.rs | 2 - - .../ntapi/src/winapi_local/um/winioctl.rs | 4 - - .../vendor/ntapi/src/winapi_local/um/winnt.rs | 86 - - KubeOS-Rust/vendor/ntapi/src/winsta.rs | 848 ---- - .../vendor/tokio-macros/.cargo-checksum.json | 2 +- - KubeOS-Rust/vendor/tokio-macros/CHANGELOG.md | 23 + - KubeOS-Rust/vendor/tokio-macros/Cargo.toml | 6 +- - KubeOS-Rust/vendor/tokio-macros/LICENSE | 2 +- - KubeOS-Rust/vendor/tokio-macros/src/entry.rs | 241 +- - KubeOS-Rust/vendor/tokio-macros/src/lib.rs | 18 +- - KubeOS-Rust/vendor/tokio-macros/src/select.rs | 11 +- - KubeOS-Rust/vendor/tokio/.cargo-checksum.json | 2 +- - KubeOS-Rust/vendor/tokio/CHANGELOG.md | 943 +++- - KubeOS-Rust/vendor/tokio/Cargo.toml | 190 +- - KubeOS-Rust/vendor/tokio/LICENSE | 2 +- - KubeOS-Rust/vendor/tokio/README.md | 57 +- - KubeOS-Rust/vendor/tokio/build.rs | 175 +- - .../vendor/tokio/docs/reactor-refactor.md | 8 +- - KubeOS-Rust/vendor/tokio/external-types.toml | 11 + - KubeOS-Rust/vendor/tokio/src/blocking.rs | 15 + - KubeOS-Rust/vendor/tokio/src/doc/mod.rs | 1 - - KubeOS-Rust/vendor/tokio/src/doc/os.rs | 41 +- - KubeOS-Rust/vendor/tokio/src/doc/winapi.rs | 66 - - KubeOS-Rust/vendor/tokio/src/fs/file.rs | 96 +- - KubeOS-Rust/vendor/tokio/src/fs/file/tests.rs | 31 +- - KubeOS-Rust/vendor/tokio/src/fs/mocks.rs | 17 +- - KubeOS-Rust/vendor/tokio/src/fs/mod.rs | 25 +- - .../vendor/tokio/src/fs/open_options.rs | 19 +- - .../src/fs/open_options/mock_open_options.rs | 1 + - KubeOS-Rust/vendor/tokio/src/fs/read_dir.rs | 95 +- - .../vendor/tokio/src/fs/symlink_dir.rs | 2 +- - .../vendor/tokio/src/fs/symlink_file.rs | 2 +- - KubeOS-Rust/vendor/tokio/src/fs/try_exists.rs | 34 + - .../vendor/tokio/src/future/block_on.rs | 11 +- - KubeOS-Rust/vendor/tokio/src/future/mod.rs | 5 - - .../vendor/tokio/src/future/poll_fn.rs | 28 +- - KubeOS-Rust/vendor/tokio/src/future/ready.rs | 27 - - KubeOS-Rust/vendor/tokio/src/fuzz.rs | 1 + - KubeOS-Rust/vendor/tokio/src/io/async_fd.rs | 222 +- - KubeOS-Rust/vendor/tokio/src/io/blocking.rs | 5 +- - .../vendor/tokio/src/io/bsd/poll_aio.rs | 6 +- - .../tokio/src/io/{driver => }/interest.rs | 4 +- - KubeOS-Rust/vendor/tokio/src/io/mod.rs | 50 +- - .../vendor/tokio/src/io/poll_evented.rs | 88 +- - KubeOS-Rust/vendor/tokio/src/io/read_buf.rs | 69 +- - .../vendor/tokio/src/io/{driver => }/ready.rs | 2 +- - KubeOS-Rust/vendor/tokio/src/io/split.rs | 6 +- - KubeOS-Rust/vendor/tokio/src/io/stderr.rs | 41 +- - KubeOS-Rust/vendor/tokio/src/io/stdin.rs | 41 +- - .../vendor/tokio/src/io/stdio_common.rs | 11 +- - KubeOS-Rust/vendor/tokio/src/io/stdout.rs | 41 +- - .../tokio/src/io/util/async_seek_ext.rs | 2 +- - .../tokio/src/io/util/async_write_ext.rs | 10 +- - .../vendor/tokio/src/io/util/buf_reader.rs | 3 +- - KubeOS-Rust/vendor/tokio/src/io/util/copy.rs | 72 +- - .../tokio/src/io/util/copy_bidirectional.rs | 57 +- - .../vendor/tokio/src/io/util/copy_buf.rs | 8 +- - KubeOS-Rust/vendor/tokio/src/io/util/empty.rs | 20 +- - .../vendor/tokio/src/io/util/fill_buf.rs | 6 + - KubeOS-Rust/vendor/tokio/src/io/util/mem.rs | 64 +- - KubeOS-Rust/vendor/tokio/src/io/util/read.rs | 2 +- - .../vendor/tokio/src/io/util/read_exact.rs | 4 +- - .../vendor/tokio/src/io/util/read_to_end.rs | 53 +- - .../vendor/tokio/src/io/util/read_until.rs | 1 + - KubeOS-Rust/vendor/tokio/src/io/util/take.rs | 4 + - .../tokio/src/io/util/vec_with_initialized.rs | 36 +- - .../vendor/tokio/src/io/util/write_all.rs | 2 +- - KubeOS-Rust/vendor/tokio/src/lib.rs | 203 +- - KubeOS-Rust/vendor/tokio/src/loom/mocked.rs | 12 + - .../vendor/tokio/src/loom/std/atomic_ptr.rs | 34 - - .../vendor/tokio/src/loom/std/atomic_u16.rs | 4 +- - .../vendor/tokio/src/loom/std/atomic_u32.rs | 12 +- - .../vendor/tokio/src/loom/std/atomic_u64.rs | 64 +- - .../tokio/src/loom/std/atomic_u64_as_mutex.rs | 76 + - .../tokio/src/loom/std/atomic_u64_native.rs | 4 + - .../loom/std/atomic_u64_static_const_new.rs | 12 + - .../loom/std/atomic_u64_static_once_cell.rs | 57 + - .../vendor/tokio/src/loom/std/atomic_u8.rs | 34 - - .../vendor/tokio/src/loom/std/atomic_usize.rs | 4 +- - KubeOS-Rust/vendor/tokio/src/loom/std/mod.rs | 45 +- - .../vendor/tokio/src/loom/std/mutex.rs | 6 + - .../vendor/tokio/src/loom/std/parking_lot.rs | 118 +- - .../vendor/tokio/src/macros/addr_of.rs | 22 + - KubeOS-Rust/vendor/tokio/src/macros/cfg.rs | 157 +- - KubeOS-Rust/vendor/tokio/src/macros/join.rs | 73 +- - KubeOS-Rust/vendor/tokio/src/macros/mod.rs | 3 + - .../vendor/tokio/src/macros/scoped_tls.rs | 2 +- - KubeOS-Rust/vendor/tokio/src/macros/select.rs | 38 +- - .../vendor/tokio/src/macros/support.rs | 6 +- - .../vendor/tokio/src/macros/thread_local.rs | 30 +- - KubeOS-Rust/vendor/tokio/src/macros/trace.rs | 9 +- - .../vendor/tokio/src/macros/try_join.rs | 79 +- - KubeOS-Rust/vendor/tokio/src/net/addr.rs | 28 +- - KubeOS-Rust/vendor/tokio/src/net/mod.rs | 14 +- - .../vendor/tokio/src/net/tcp/listener.rs | 199 +- - KubeOS-Rust/vendor/tokio/src/net/tcp/mod.rs | 4 +- - .../vendor/tokio/src/net/tcp/socket.rs | 299 +- - KubeOS-Rust/vendor/tokio/src/net/tcp/split.rs | 38 +- - .../vendor/tokio/src/net/tcp/split_owned.rs | 42 +- - .../vendor/tokio/src/net/tcp/stream.rs | 393 +- - KubeOS-Rust/vendor/tokio/src/net/udp.rs | 508 +- - .../tokio/src/net/unix/datagram/socket.rs | 203 +- - .../vendor/tokio/src/net/unix/listener.rs | 64 +- - KubeOS-Rust/vendor/tokio/src/net/unix/mod.rs | 17 +- - KubeOS-Rust/vendor/tokio/src/net/unix/pipe.rs | 1222 +++++ - .../vendor/tokio/src/net/unix/split.rs | 42 +- - .../vendor/tokio/src/net/unix/split_owned.rs | 46 +- - .../vendor/tokio/src/net/unix/stream.rs | 108 +- - .../vendor/tokio/src/net/unix/ucred.rs | 83 +- - .../tokio/src/net/windows/named_pipe.rs | 686 ++- - KubeOS-Rust/vendor/tokio/src/park/either.rs | 74 - - KubeOS-Rust/vendor/tokio/src/park/mod.rs | 117 - - KubeOS-Rust/vendor/tokio/src/park/thread.rs | 346 -- - KubeOS-Rust/vendor/tokio/src/process/mod.rs | 346 +- - .../vendor/tokio/src/process/unix/mod.rs | 120 +- - .../vendor/tokio/src/process/unix/orphan.rs | 29 +- - .../vendor/tokio/src/process/windows.rs | 126 +- - .../tokio/src/runtime/basic_scheduler.rs | 519 -- - .../vendor/tokio/src/runtime/blocking/mod.rs | 34 +- - .../vendor/tokio/src/runtime/blocking/pool.rs | 379 +- - .../tokio/src/runtime/blocking/schedule.rs | 49 +- - .../tokio/src/runtime/blocking/shutdown.rs | 4 +- - .../vendor/tokio/src/runtime/blocking/task.rs | 2 +- - .../vendor/tokio/src/runtime/builder.rs | 501 +- - .../vendor/tokio/src/runtime/config.rs | 34 + - .../vendor/tokio/src/runtime/context.rs | 465 +- - .../vendor/tokio/src/{ => runtime}/coop.rs | 116 +- - KubeOS-Rust/vendor/tokio/src/runtime/defer.rs | 27 + - .../vendor/tokio/src/runtime/driver.rs | 337 +- - KubeOS-Rust/vendor/tokio/src/runtime/enter.rs | 205 - - .../vendor/tokio/src/runtime/handle.rs | 216 +- - .../vendor/tokio/src/runtime/io/metrics.rs | 24 + - .../src/{io/driver => runtime/io}/mod.rs | 342 +- - .../src/{io/driver => runtime/io}/platform.rs | 0 - .../{io/driver => runtime/io}/registration.rs | 65 +- - .../{io/driver => runtime/io}/scheduled_io.rs | 75 +- - .../vendor/tokio/src/runtime/metrics/batch.rs | 115 + - .../vendor/tokio/src/runtime/metrics/io.rs | 24 + - .../vendor/tokio/src/runtime/metrics/mock.rs | 44 + - .../vendor/tokio/src/runtime/metrics/mod.rs | 35 + - .../tokio/src/runtime/metrics/runtime.rs | 673 +++ - .../tokio/src/runtime/metrics/scheduler.rs | 34 + - .../tokio/src/runtime/metrics/worker.rs | 65 + - KubeOS-Rust/vendor/tokio/src/runtime/mod.rs | 451 +- - KubeOS-Rust/vendor/tokio/src/runtime/park.rs | 342 +- - .../unix/driver.rs => runtime/process.rs} | 30 +- - .../vendor/tokio/src/runtime/runtime.rs | 436 ++ - .../src/runtime/scheduler/current_thread.rs | 634 +++ - .../vendor/tokio/src/runtime/scheduler/mod.rs | 194 + - .../runtime/scheduler/multi_thread/handle.rs | 98 + - .../multi_thread}/idle.rs | 16 +- - .../src/runtime/scheduler/multi_thread/mod.rs | 84 + - .../runtime/scheduler/multi_thread/park.rs | 237 + - .../{ => scheduler/multi_thread}/queue.rs | 138 +- - .../multi_thread}/worker.rs | 384 +- - .../vendor/tokio/src/runtime/signal/mod.rs | 142 + - .../vendor/tokio/src/runtime/spawner.rs | 47 - - .../vendor/tokio/src/runtime/stats/mock.rs | 27 - - .../vendor/tokio/src/runtime/stats/mod.rs | 17 - - .../vendor/tokio/src/runtime/stats/stats.rs | 122 - - .../vendor/tokio/src/runtime/task/abort.rs | 87 + - .../vendor/tokio/src/runtime/task/core.rs | 147 +- - .../vendor/tokio/src/runtime/task/error.rs | 33 +- - .../vendor/tokio/src/runtime/task/harness.rs | 328 +- - .../vendor/tokio/src/runtime/task/id.rs | 87 + - .../vendor/tokio/src/runtime/task/join.rs | 194 +- - .../vendor/tokio/src/runtime/task/list.rs | 10 +- - .../vendor/tokio/src/runtime/task/mod.rs | 87 +- - .../vendor/tokio/src/runtime/task/raw.rs | 179 +- - .../vendor/tokio/src/runtime/task/state.rs | 8 +- - .../vendor/tokio/src/runtime/task/waker.rs | 88 +- - .../tokio/src/runtime/tests/loom_blocking.rs | 71 + - ...er.rs => loom_current_thread_scheduler.rs} | 20 +- - .../tokio/src/runtime/tests/loom_join_set.rs | 82 + - .../tokio/src/runtime/tests/loom_queue.rs | 43 +- - .../tokio/src/runtime/tests/loom_yield.rs | 37 + - .../vendor/tokio/src/runtime/tests/mod.rs | 36 +- - .../vendor/tokio/src/runtime/tests/queue.rs | 84 +- - .../vendor/tokio/src/runtime/tests/task.rs | 52 +- - .../src/runtime/tests/task_combinations.rs | 153 +- - .../vendor/tokio/src/runtime/thread_id.rs | 31 + - .../tokio/src/runtime/thread_pool/mod.rs | 118 - - .../{time/driver => runtime/time}/entry.rs | 195 +- - .../vendor/tokio/src/runtime/time/handle.rs | 62 + - .../src/{time/driver => runtime/time}/mod.rs | 310 +- - .../vendor/tokio/src/runtime/time/source.rs | 38 + - .../driver => runtime/time}/tests/mod.rs | 200 +- - .../driver => runtime/time}/wheel/level.rs | 11 +- - .../driver => runtime/time}/wheel/mod.rs | 18 +- - KubeOS-Rust/vendor/tokio/src/signal/mod.rs | 2 +- - .../vendor/tokio/src/signal/registry.rs | 37 +- - KubeOS-Rust/vendor/tokio/src/signal/unix.rs | 115 +- - .../vendor/tokio/src/signal/unix/driver.rs | 207 - - .../vendor/tokio/src/signal/windows.rs | 361 +- - .../vendor/tokio/src/signal/windows/stub.rs | 14 +- - .../vendor/tokio/src/signal/windows/sys.rs | 118 +- - KubeOS-Rust/vendor/tokio/src/sync/barrier.rs | 65 +- - .../vendor/tokio/src/sync/batch_semaphore.rs | 177 +- - .../vendor/tokio/src/sync/broadcast.rs | 448 +- - KubeOS-Rust/vendor/tokio/src/sync/mod.rs | 10 +- - .../vendor/tokio/src/sync/mpsc/block.rs | 143 +- - .../vendor/tokio/src/sync/mpsc/bounded.rs | 139 +- - .../vendor/tokio/src/sync/mpsc/chan.rs | 64 +- - .../vendor/tokio/src/sync/mpsc/error.rs | 6 +- - .../vendor/tokio/src/sync/mpsc/list.rs | 2 +- - KubeOS-Rust/vendor/tokio/src/sync/mpsc/mod.rs | 30 +- - .../vendor/tokio/src/sync/mpsc/unbounded.rs | 94 +- - KubeOS-Rust/vendor/tokio/src/sync/mutex.rs | 625 ++- - KubeOS-Rust/vendor/tokio/src/sync/notify.rs | 658 ++- - .../vendor/tokio/src/sync/once_cell.rs | 4 +- - KubeOS-Rust/vendor/tokio/src/sync/oneshot.rs | 226 +- - KubeOS-Rust/vendor/tokio/src/sync/rwlock.rs | 489 +- - .../tokio/src/sync/rwlock/owned_read_guard.rs | 67 +- - .../src/sync/rwlock/owned_write_guard.rs | 266 +- - .../sync/rwlock/owned_write_guard_mapped.rs | 70 +- - .../tokio/src/sync/rwlock/read_guard.rs | 65 +- - .../tokio/src/sync/rwlock/write_guard.rs | 275 +- - .../src/sync/rwlock/write_guard_mapped.rs | 75 +- - .../vendor/tokio/src/sync/semaphore.rs | 148 +- - .../tokio/src/sync/task/atomic_waker.rs | 7 +- - .../tokio/src/sync/tests/atomic_waker.rs | 6 +- - .../tokio/src/sync/tests/loom_notify.rs | 191 + - .../vendor/tokio/src/sync/tests/loom_watch.rs | 54 + - .../vendor/tokio/src/sync/tests/notify.rs | 76 + - .../tokio/src/sync/tests/semaphore_batch.rs | 43 +- - KubeOS-Rust/vendor/tokio/src/sync/watch.rs | 606 ++- - KubeOS-Rust/vendor/tokio/src/task/blocking.rs | 24 +- - KubeOS-Rust/vendor/tokio/src/task/builder.rs | 131 +- - .../vendor/tokio/src/task/consume_budget.rs | 45 + - KubeOS-Rust/vendor/tokio/src/task/join_set.rs | 583 +++ - KubeOS-Rust/vendor/tokio/src/task/local.rs | 655 ++- - KubeOS-Rust/vendor/tokio/src/task/mod.rs | 29 +- - KubeOS-Rust/vendor/tokio/src/task/spawn.rs | 50 +- - .../vendor/tokio/src/task/task_local.rs | 318 +- - .../vendor/tokio/src/task/unconstrained.rs | 2 +- - .../vendor/tokio/src/task/yield_now.rs | 15 +- - KubeOS-Rust/vendor/tokio/src/time/clock.rs | 140 +- - .../vendor/tokio/src/time/driver/handle.rs | 88 - - .../tokio/src/time/driver/wheel/stack.rs | 112 - - KubeOS-Rust/vendor/tokio/src/time/error.rs | 5 +- - KubeOS-Rust/vendor/tokio/src/time/instant.rs | 24 +- - KubeOS-Rust/vendor/tokio/src/time/interval.rs | 102 +- - KubeOS-Rust/vendor/tokio/src/time/mod.rs | 13 +- - .../tokio/src/time/{driver => }/sleep.rs | 201 +- - .../vendor/tokio/src/time/tests/mod.rs | 22 - - .../vendor/tokio/src/time/tests/test_sleep.rs | 443 -- - KubeOS-Rust/vendor/tokio/src/time/timeout.rs | 85 +- - .../thread_pool => util}/atomic_cell.rs | 10 +- - KubeOS-Rust/vendor/tokio/src/util/error.rs | 7 +- - .../tokio/src/util/idle_notified_set.rs | 462 ++ - .../vendor/tokio/src/util/linked_list.rs | 142 +- - KubeOS-Rust/vendor/tokio/src/util/memchr.rs | 74 + - KubeOS-Rust/vendor/tokio/src/util/mod.rs | 40 +- - .../vendor/tokio/src/util/once_cell.rs | 70 + - KubeOS-Rust/vendor/tokio/src/util/pad.rs | 52 - - KubeOS-Rust/vendor/tokio/src/util/rand.rs | 144 +- - KubeOS-Rust/vendor/tokio/src/util/rc_cell.rs | 57 + - KubeOS-Rust/vendor/tokio/src/util/slab.rs | 67 +- - KubeOS-Rust/vendor/tokio/src/util/trace.rs | 80 +- - .../vendor/tokio/src/util/vec_deque_cell.rs | 53 - - KubeOS-Rust/vendor/tokio/src/util/wake.rs | 9 +- - .../vendor/tokio/tests/_require_full.rs | 8 +- - .../vendor/tokio/tests/async_send_sync.rs | 223 +- - KubeOS-Rust/vendor/tokio/tests/buffered.rs | 6 +- - KubeOS-Rust/vendor/tokio/tests/fs.rs | 2 +- - .../vendor/tokio/tests/fs_canonicalize_dir.rs | 22 + - KubeOS-Rust/vendor/tokio/tests/fs_copy.rs | 2 +- - KubeOS-Rust/vendor/tokio/tests/fs_dir.rs | 41 +- - KubeOS-Rust/vendor/tokio/tests/fs_file.rs | 106 +- - KubeOS-Rust/vendor/tokio/tests/fs_link.rs | 59 +- - .../vendor/tokio/tests/fs_open_options.rs | 80 + - .../tokio/tests/fs_open_options_windows.rs | 51 + - .../vendor/tokio/tests/fs_remove_dir_all.rs | 31 + - .../vendor/tokio/tests/fs_remove_file.rs | 24 + - KubeOS-Rust/vendor/tokio/tests/fs_rename.rs | 28 + - .../tokio/tests/fs_symlink_dir_windows.rs | 31 + - .../tokio/tests/fs_symlink_file_windows.rs | 24 + - .../vendor/tokio/tests/fs_try_exists.rs | 44 + - .../vendor/tokio/tests/io_buf_writer.rs | 36 +- - .../tokio/tests/io_copy_bidirectional.rs | 38 +- - KubeOS-Rust/vendor/tokio/tests/io_driver.rs | 5 +- - .../vendor/tokio/tests/io_driver_drop.rs | 2 +- - KubeOS-Rust/vendor/tokio/tests/io_fill_buf.rs | 2 +- - .../vendor/tokio/tests/io_mem_stream.rs | 19 + - KubeOS-Rust/vendor/tokio/tests/io_panic.rs | 176 + - KubeOS-Rust/vendor/tokio/tests/io_read.rs | 26 +- - KubeOS-Rust/vendor/tokio/tests/io_read_buf.rs | 58 + - .../vendor/tokio/tests/io_read_to_end.rs | 46 + - KubeOS-Rust/vendor/tokio/tests/io_split.rs | 2 +- - KubeOS-Rust/vendor/tokio/tests/io_take.rs | 62 +- - .../vendor/tokio/tests/io_util_empty.rs | 32 + - .../vendor/tokio/tests/join_handle_panic.rs | 20 + - KubeOS-Rust/vendor/tokio/tests/macros_join.rs | 107 +- - KubeOS-Rust/vendor/tokio/tests/macros_pin.rs | 10 +- - .../vendor/tokio/tests/macros_rename_test.rs | 35 + - .../vendor/tokio/tests/macros_select.rs | 204 +- - KubeOS-Rust/vendor/tokio/tests/macros_test.rs | 40 + - .../vendor/tokio/tests/macros_try_join.rs | 109 +- - .../vendor/tokio/tests/net_bind_resource.rs | 3 +- - .../vendor/tokio/tests/net_lookup_host.rs | 2 + - .../{named_pipe.rs => net_named_pipe.rs} | 132 +- - KubeOS-Rust/vendor/tokio/tests/net_panic.rs | 188 + - .../vendor/tokio/tests/net_unix_pipe.rs | 429 ++ - KubeOS-Rust/vendor/tokio/tests/no_rt.rs | 2 + - .../tokio/tests/process_kill_on_drop.rs | 2 +- - .../vendor/tokio/tests/process_raw_handle.rs | 2 +- - .../vendor/tokio/tests/process_smoke.rs | 2 +- - KubeOS-Rust/vendor/tokio/tests/rt_basic.rs | 257 + - KubeOS-Rust/vendor/tokio/tests/rt_common.rs | 299 +- - .../vendor/tokio/tests/rt_handle_block_on.rs | 26 +- - KubeOS-Rust/vendor/tokio/tests/rt_metrics.rs | 557 +++ - KubeOS-Rust/vendor/tokio/tests/rt_panic.rs | 77 + - KubeOS-Rust/vendor/tokio/tests/rt_threaded.rs | 103 +- - .../tokio/tests/rt_time_start_paused.rs | 14 + - .../vendor/tokio/tests/signal_no_rt.rs | 1 + - .../vendor/tokio/tests/signal_panic.rs | 29 + - .../tokio/tests/support/leaked_buffers.rs | 26 + - .../vendor/tokio/tests/support/panic.rs | 34 + - .../vendor/tokio/tests/sync_barrier.rs | 5 +- - .../vendor/tokio/tests/sync_broadcast.rs | 189 +- - KubeOS-Rust/vendor/tokio/tests/sync_errors.rs | 5 +- - KubeOS-Rust/vendor/tokio/tests/sync_mpsc.rs | 164 +- - .../vendor/tokio/tests/sync_mpsc_weak.rs | 513 ++ - KubeOS-Rust/vendor/tokio/tests/sync_mutex.rs | 40 +- - .../vendor/tokio/tests/sync_mutex_owned.rs | 28 +- - KubeOS-Rust/vendor/tokio/tests/sync_notify.rs | 76 +- - .../vendor/tokio/tests/sync_once_cell.rs | 355 +- - .../vendor/tokio/tests/sync_oneshot.rs | 26 +- - KubeOS-Rust/vendor/tokio/tests/sync_panic.rs | 197 + - KubeOS-Rust/vendor/tokio/tests/sync_rwlock.rs | 87 +- - .../vendor/tokio/tests/sync_semaphore.rs | 67 +- - .../tokio/tests/sync_semaphore_owned.rs | 36 +- - KubeOS-Rust/vendor/tokio/tests/sync_watch.rs | 42 +- - KubeOS-Rust/vendor/tokio/tests/task_abort.rs | 12 +- - .../vendor/tokio/tests/task_blocking.rs | 91 +- - .../vendor/tokio/tests/task_builder.rs | 20 +- - KubeOS-Rust/vendor/tokio/tests/task_id.rs | 303 ++ - .../vendor/tokio/tests/task_join_set.rs | 235 + - KubeOS-Rust/vendor/tokio/tests/task_local.rs | 96 +- - .../vendor/tokio/tests/task_local_set.rs | 206 +- - KubeOS-Rust/vendor/tokio/tests/task_panic.rs | 123 + - KubeOS-Rust/vendor/tokio/tests/tcp_accept.rs | 2 +- - KubeOS-Rust/vendor/tokio/tests/tcp_connect.rs | 3 +- - KubeOS-Rust/vendor/tokio/tests/tcp_echo.rs | 2 +- - .../vendor/tokio/tests/tcp_into_split.rs | 2 +- - .../vendor/tokio/tests/tcp_into_std.rs | 2 +- - KubeOS-Rust/vendor/tokio/tests/tcp_peek.rs | 6 +- - .../vendor/tokio/tests/tcp_shutdown.rs | 2 +- - KubeOS-Rust/vendor/tokio/tests/tcp_socket.rs | 17 +- - KubeOS-Rust/vendor/tokio/tests/tcp_split.rs | 4 +- - KubeOS-Rust/vendor/tokio/tests/tcp_stream.rs | 51 +- - .../vendor/tokio/tests/time_interval.rs | 154 +- - KubeOS-Rust/vendor/tokio/tests/time_panic.rs | 93 + - KubeOS-Rust/vendor/tokio/tests/time_pause.rs | 7 +- - KubeOS-Rust/vendor/tokio/tests/time_rt.rs | 3 +- - KubeOS-Rust/vendor/tokio/tests/time_sleep.rs | 36 +- - .../vendor/tokio/tests/time_timeout.rs | 14 + - KubeOS-Rust/vendor/tokio/tests/udp.rs | 163 +- - .../vendor/tokio/tests/uds_datagram.rs | 50 +- - KubeOS-Rust/vendor/tokio/tests/uds_stream.rs | 12 +- - KubeOS-Rust/vendor/tokio/tests/unwindsafe.rs | 42 + - 479 files changed, 33848 insertions(+), 35217 deletions(-) - create mode 100644 KubeOS-Rust/vendor/mio/examples/tcp_listenfd_server.rs - delete mode 100644 KubeOS-Rust/vendor/mio/src/net/tcp/socket.rs - create mode 100644 KubeOS-Rust/vendor/mio/src/sys/unix/selector/poll.rs - create mode 100644 KubeOS-Rust/vendor/mio/src/sys/wasi/mod.rs - create mode 100644 KubeOS-Rust/vendor/mio/src/sys/windows/handle.rs - rename KubeOS-Rust/vendor/{miow/src => mio/src/sys/windows}/iocp.rs (60%) - delete mode 100644 KubeOS-Rust/vendor/miow/.cargo-checksum.json - delete mode 100644 KubeOS-Rust/vendor/miow/CHANGELOG.md - delete mode 100644 KubeOS-Rust/vendor/miow/Cargo.toml - delete mode 100644 KubeOS-Rust/vendor/miow/LICENSE-APACHE - delete mode 100644 KubeOS-Rust/vendor/miow/LICENSE-MIT - delete mode 100644 KubeOS-Rust/vendor/miow/README.md - delete mode 100644 KubeOS-Rust/vendor/miow/appveyor.yml - delete mode 100644 KubeOS-Rust/vendor/miow/src/handle.rs - delete mode 100644 KubeOS-Rust/vendor/miow/src/lib.rs - delete mode 100644 KubeOS-Rust/vendor/miow/src/net.rs - delete mode 100644 KubeOS-Rust/vendor/miow/src/overlapped.rs - delete mode 100644 KubeOS-Rust/vendor/miow/src/pipe.rs - delete mode 100644 KubeOS-Rust/vendor/mockall_double/.cargo-checksum.json - delete mode 100644 KubeOS-Rust/vendor/mockall_double/Cargo.toml - delete mode 100644 KubeOS-Rust/vendor/mockall_double/LICENSE-APACHE - delete mode 100644 KubeOS-Rust/vendor/mockall_double/LICENSE-MIT - delete mode 100644 KubeOS-Rust/vendor/mockall_double/README.md - delete mode 100644 KubeOS-Rust/vendor/mockall_double/src/lib.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/.cargo-checksum.json - delete mode 100644 KubeOS-Rust/vendor/ntapi/Cargo.toml - delete mode 100644 KubeOS-Rust/vendor/ntapi/LICENSE-APACHE - delete mode 100644 KubeOS-Rust/vendor/ntapi/LICENSE-MIT - delete mode 100644 KubeOS-Rust/vendor/ntapi/README.md - delete mode 100644 KubeOS-Rust/vendor/ntapi/build.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/lib.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/macros.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntapi_base.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntdbg.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntexapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntgdi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntioapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntkeapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntldr.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntlpcapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntmisc.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntmmapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntnls.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntobapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntpebteb.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntpfapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntpnpapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntpoapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntpsapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntregapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntrtl.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntsam.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntseapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntsmss.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/nttmapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/nttp.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntwow64.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntxcapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/ntzwapi.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/string.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/subprocesstag.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/winapi_local.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/winapi_local/um.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/winapi_local/um/winioctl.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/winapi_local/um/winnt.rs - delete mode 100644 KubeOS-Rust/vendor/ntapi/src/winsta.rs - create mode 100644 KubeOS-Rust/vendor/tokio/external-types.toml - delete mode 100644 KubeOS-Rust/vendor/tokio/src/doc/winapi.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/fs/try_exists.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/future/ready.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/fuzz.rs - rename KubeOS-Rust/vendor/tokio/src/io/{driver => }/interest.rs (98%) - rename KubeOS-Rust/vendor/tokio/src/io/{driver => }/ready.rs (99%) - delete mode 100644 KubeOS-Rust/vendor/tokio/src/loom/std/atomic_ptr.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_as_mutex.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_native.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_static_const_new.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_static_once_cell.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u8.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/macros/addr_of.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/net/unix/pipe.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/park/either.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/park/mod.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/park/thread.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/basic_scheduler.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/config.rs - rename KubeOS-Rust/vendor/tokio/src/{ => runtime}/coop.rs (76%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/defer.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/enter.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/io/metrics.rs - rename KubeOS-Rust/vendor/tokio/src/{io/driver => runtime/io}/mod.rs (53%) - rename KubeOS-Rust/vendor/tokio/src/{io/driver => runtime/io}/platform.rs (100%) - rename KubeOS-Rust/vendor/tokio/src/{io/driver => runtime/io}/registration.rs (82%) - rename KubeOS-Rust/vendor/tokio/src/{io/driver => runtime/io}/scheduled_io.rs (88%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/metrics/batch.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/metrics/io.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/metrics/mock.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/metrics/mod.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/metrics/runtime.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/metrics/scheduler.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/metrics/worker.rs - rename KubeOS-Rust/vendor/tokio/src/{process/unix/driver.rs => runtime/process.rs} (55%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/runtime.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/scheduler/current_thread.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/scheduler/mod.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/handle.rs - rename KubeOS-Rust/vendor/tokio/src/runtime/{thread_pool => scheduler/multi_thread}/idle.rs (93%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/mod.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/park.rs - rename KubeOS-Rust/vendor/tokio/src/runtime/{ => scheduler/multi_thread}/queue.rs (80%) - rename KubeOS-Rust/vendor/tokio/src/runtime/{thread_pool => scheduler/multi_thread}/worker.rs (66%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/signal/mod.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/spawner.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/stats/mock.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/stats/mod.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/stats/stats.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/task/abort.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/task/id.rs - rename KubeOS-Rust/vendor/tokio/src/runtime/tests/{loom_basic_scheduler.rs => loom_current_thread_scheduler.rs} (86%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_join_set.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_yield.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/thread_id.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/mod.rs - rename KubeOS-Rust/vendor/tokio/src/{time/driver => runtime/time}/entry.rs (86%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/time/handle.rs - rename KubeOS-Rust/vendor/tokio/src/{time/driver => runtime/time}/mod.rs (66%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/runtime/time/source.rs - rename KubeOS-Rust/vendor/tokio/src/{time/driver => runtime/time}/tests/mod.rs (50%) - rename KubeOS-Rust/vendor/tokio/src/{time/driver => runtime/time}/wheel/level.rs (96%) - rename KubeOS-Rust/vendor/tokio/src/{time/driver => runtime/time}/wheel/mod.rs (95%) - delete mode 100644 KubeOS-Rust/vendor/tokio/src/signal/unix/driver.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/task/consume_budget.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/task/join_set.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/time/driver/handle.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/time/driver/wheel/stack.rs - rename KubeOS-Rust/vendor/tokio/src/time/{driver => }/sleep.rs (65%) - delete mode 100644 KubeOS-Rust/vendor/tokio/src/time/tests/mod.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/time/tests/test_sleep.rs - rename KubeOS-Rust/vendor/tokio/src/{runtime/thread_pool => util}/atomic_cell.rs (77%) - create mode 100644 KubeOS-Rust/vendor/tokio/src/util/idle_notified_set.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/util/memchr.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/util/once_cell.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/util/pad.rs - create mode 100644 KubeOS-Rust/vendor/tokio/src/util/rc_cell.rs - delete mode 100644 KubeOS-Rust/vendor/tokio/src/util/vec_deque_cell.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_canonicalize_dir.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_open_options.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_open_options_windows.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_remove_dir_all.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_remove_file.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_rename.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_symlink_dir_windows.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_symlink_file_windows.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/fs_try_exists.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/io_panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/io_util_empty.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/join_handle_panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/macros_rename_test.rs - rename KubeOS-Rust/vendor/tokio/tests/{named_pipe.rs => net_named_pipe.rs} (78%) - create mode 100644 KubeOS-Rust/vendor/tokio/tests/net_panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/net_unix_pipe.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/rt_metrics.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/rt_panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/rt_time_start_paused.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/signal_panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/support/leaked_buffers.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/support/panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/sync_mpsc_weak.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/sync_panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/task_id.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/task_join_set.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/task_panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/time_panic.rs - create mode 100644 KubeOS-Rust/vendor/tokio/tests/unwindsafe.rs - -diff --git a/KubeOS-Rust/vendor/mio/.cargo-checksum.json b/KubeOS-Rust/vendor/mio/.cargo-checksum.json -index 38ac274b..a084d256 100644 ---- a/KubeOS-Rust/vendor/mio/.cargo-checksum.json -+++ b/KubeOS-Rust/vendor/mio/.cargo-checksum.json -@@ -1 +1 @@ --{"files":{"CHANGELOG.md":"1d4a69dd365fd87d9f89f13950890c0f47c79e3e7c06fc0dd56afdbde147cacf","Cargo.lock":"785e3ad156e71ae393db5522f9f62707cf30ed9838f7e2459d9d8820ec8889f8","Cargo.toml":"084ef10f7468e8b54dfbc6bacfe8ef7adc464de0d7553950f8659946d001704b","LICENSE":"07919255c7e04793d8ea760d6c2ce32d19f9ff02bdbdde3ce90b1e1880929a9b","README.md":"82e4ccb5a33551e3372cf4bed2e38696b722dbd3cba133666bb73bebf15a3a43","examples/tcp_server.rs":"53de2e3077327485505e84fe3b0bdf93a3258e4d4deb13988dd9f8577cc071ae","examples/udp_server.rs":"852629aa194926bcb36d86793a36256ac1e4958e3bb5ae255550f1b197409971","src/event/event.rs":"286447271c1a7c41dd2083fe38798956e40f395cceb940afc17489824b5fbdce","src/event/events.rs":"5cad85e0d0c9e619b6017f868c681ed0dc023e7aae8c0c5c0c7337b2fa96a8a6","src/event/mod.rs":"c129c42114867e3e7337a6605952db8cef8a7ef0938f67a28fa68e73fc420c6a","src/event/source.rs":"1f991439b52380a6b45c09cb7e5319df1216e544add97877405d629118def823","src/interest.rs":"f4a3adc629956199a4580e3bcfcdad5dc13518c4141ce7d4f08d2569aa7ddec5","src/io_source.rs":"6946ab1bc749324739f2b51962efdaa0051f6da3df2381d0c8f79109daa99434","src/lib.rs":"cdbba64f9ad6f38a20cf8da7c5a6fb373c304c29f9fc43ea1f37321503bdc54a","src/macros.rs":"c484744396b163555c8593cf15929201dd23b3ff75a4be03b8dc34e46f6d9caa","src/net/mod.rs":"d7154b9b579c0d8f40e1b2e9e68dea157f69e301ba00ad703f3451b507466f30","src/net/tcp/listener.rs":"841c9c778a98c501d20bf557de40192762aaa3ecf5c20710bc9c71d40fbb89aa","src/net/tcp/mod.rs":"300214b6ff47e818c72907742fa993abd9664a6e7bc9ae34ad42ae793abfbfd9","src/net/tcp/socket.rs":"9cd43120610937c8929fd41b4c3eec60fb31a63fdb93034a5eb5b807861ffd4f","src/net/tcp/stream.rs":"793ceb378819cc3b4cbeceddbee5043a224d8d2905986fc3c9b4b83de97d1fd9","src/net/udp.rs":"2d0009f7cda073ff490b113b4a2a32c15328ae3c12352c765801549ab3a4acc6","src/net/uds/datagram.rs":"980944654a03f61311a7208043011db4831d40b92bd440ed57515cac6104ff2f","src/net/uds/listener.rs":"714b1638a522cc95bb70b137441bc1282684fbcde4432b6872ad052f66670164","src/net/uds/mod.rs":"70d4368adae74652d46771b29e633396e5f1b70e9b7d1370cf5fec9a78605c04","src/net/uds/stream.rs":"fa6dd11e5736c8372037945f96c5b0c7adee1a29c2b194bc9bf9f7cc2db7f1f4","src/poll.rs":"f5c839be5daff54c8d8e0e7e1967936693c899b18bfc0ecdada1da18b6bea551","src/sys/mod.rs":"58d6750b37d4bd94ac90e9aaeb88aa79a65f379931857691ae5e7df16a55c15d","src/sys/shell/mod.rs":"6c8b107397e110e916c02e0f1f1f03344974456a7e929a731eeb462d5ba13968","src/sys/shell/selector.rs":"9f6eee2b858c68012962cfcd7ed747acd198c518ddb807ada2a30eb1faf4c052","src/sys/shell/tcp.rs":"bb0696538c7dfd22e96d5285e33d606ce5519952e4a3c1fe2b9f7b9eca3c965b","src/sys/shell/udp.rs":"fc830fea77935d141f87179c5ceec95318c67d24060051c155deb5ace14d7134","src/sys/shell/uds.rs":"10c2933423e251fca678322ff9fc7501fcaacdfa769307399cb5dfc7bef63ec3","src/sys/shell/waker.rs":"81bc18cf52345a8d17e8142291e43dd70a36dfd9f5eb486f3e787998ee4451dc","src/sys/unix/mod.rs":"d2b03e3d166d174f1ad283e6a2aa1c3287b4d6e0affb3ed7ea7e033fbbfc5f1d","src/sys/unix/net.rs":"f09760a7d039c7ae7a04184051973b63a8ca2d9fbfa78268743173ed4569fefa","src/sys/unix/pipe.rs":"30b85b750b96c5dfa3e45334d5ee8ab9ccd58a27b5b06279dc2d57354b6d018f","src/sys/unix/selector/epoll.rs":"b179284751fe409e4ebe23bb44c8cebeb317afa569504d3d8d5e8cbda5a66728","src/sys/unix/selector/kqueue.rs":"7baad92dce647024e993e5a6c6a5da9d81632f85b333eb1ca4d32eeba920cbde","src/sys/unix/selector/mod.rs":"ee617b86483def04fb9e75e5ed8f5c71a7148511f1c289749b7a77100bae6829","src/sys/unix/sourcefd.rs":"3ef7c2817bc1d2424ec55e41209b6cd0a2634c4ac17bacdc47dbac8e91255944","src/sys/unix/tcp.rs":"fe0ae1da5c9b08dd6bf06fbdb592bfc6d613e57910bb7ffe4733acd44cfd13cf","src/sys/unix/udp.rs":"babf7d444eba0db29b130f0e254b0715e2566e7ea5b0f0e35cddf72d83f40b3b","src/sys/unix/uds/datagram.rs":"a7da7e4292ac42ccc2be5ad5909ced1d20377ace0198868fed89e086edc016f7","src/sys/unix/uds/listener.rs":"ee26d73cc02e455aed0635f4874fe3df94f9e9ef9425ce7918422e86503c6bfb","src/sys/unix/uds/mod.rs":"fcdab5bd2a889e5157e2b93f065d0a4c1df7b5dd681e9b83a664e4269facb4a8","src/sys/unix/uds/socketaddr.rs":"378ac08a6434ade8e3703e2b4f2f17e6c0a9e6eb290b1464d2cac7105377bf5f","src/sys/unix/uds/stream.rs":"f785ff59f9e8ddec8519f5bfbd93150f26674efa91742909eb839d44250fe334","src/sys/unix/waker.rs":"5233c7d353c34f06da24f9f7db9eb9408d2dca221b255f0080ebcf258ac659e2","src/sys/windows/afd.rs":"954287fa361f4c4bb6af9b61d8d21325fc80301afd7e4c2c36415355dde0dbeb","src/sys/windows/event.rs":"75539e2db54858605e565742a68242b2a69fe9b8cd8d60ff7a109cf43e5b5930","src/sys/windows/io_status_block.rs":"9920f2b12ebd90f1c42cd73fff775d015321dd2186d58fd10bca8f349489e5e0","src/sys/windows/mod.rs":"96217f0a3a90788b081684c0f3e704ee117c500f20564606cd630cdfaa57decd","src/sys/windows/named_pipe.rs":"dfef8d9389b547b48749795711eb8046a8990bebed8815d71b6d59207c289612","src/sys/windows/net.rs":"facfd513f2d59daee38d644c7494874daf5b0a78e6d2742665d497e25d6495f1","src/sys/windows/overlapped.rs":"a041d2a6f03eb5e005ed14f23bc5cdf12dfc33036a7644dc925518ad944987f0","src/sys/windows/selector.rs":"2e9c300f2e3b156294aa08e961ceb49674ebaa2177174a67be33cc3b057e119a","src/sys/windows/tcp.rs":"acd1797c94ebb0acab6a989bd80004b6f092d051b050a7f8d21d9676f0a2bad2","src/sys/windows/udp.rs":"07b104a6be6cba40acf9933cd6283260a2e272b7d50743d836aa13f4bc4b07f3","src/sys/windows/waker.rs":"acae348778e4f60762b9e4cf083ff02305d9a7a14216456154a9be7f7af4c6c9","src/token.rs":"e883c0f8e3c8ce7de01e577e91271af7242d1e0254437345d85458d8d9b77973","src/waker.rs":"04f34d2148516945052dfe4c0930100b45f5ebabc838e90b162cb2904d361f74"},"package":"8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc"} -\ No newline at end of file -+{"files":{"CHANGELOG.md":"3d83e49761225c32fdd474e555685a50cbd6ecaed8e6132cc717142a3e5a93c2","Cargo.lock":"a3c8049acd7c8864c0be45765983a20d284995244c11ab83e0adb3e656aa5a74","Cargo.toml":"18ac4411a6e8557bb049b603ef6cb26bdf7ef2f2b2c1ebb00369a92590ef648d","LICENSE":"07919255c7e04793d8ea760d6c2ce32d19f9ff02bdbdde3ce90b1e1880929a9b","README.md":"e33863e6f79ed1f7e85b10b7108030b698460f280c8598b1fcb981e515e46edc","examples/tcp_listenfd_server.rs":"f05bbee8eb91a2e42fec29cbacbdd6dc5f9c95097b3ee12dfe944143e45f5996","examples/tcp_server.rs":"7309036fe2cd17530bcbc53b2b0ec12478caad39bcae5bda72cdd0263c647f4f","examples/udp_server.rs":"8e0795247be36b78a8cec02bd16af78083ac963d7d7fda3f422c673b17b62493","src/event/event.rs":"00ff34dd2e391784d5f7c4613029fb9aa8cc31a019306936960c27092486e5a9","src/event/events.rs":"5cad85e0d0c9e619b6017f868c681ed0dc023e7aae8c0c5c0c7337b2fa96a8a6","src/event/mod.rs":"c129c42114867e3e7337a6605952db8cef8a7ef0938f67a28fa68e73fc420c6a","src/event/source.rs":"d2d1aaff10fb31e7d2dfe8a4500d100a9b2d0a2ab1663503c0f275b35b0072b6","src/interest.rs":"983bb64b4e4443fbbf20461e7b198b128ca13cd1e853c1e9258ce401a8d046ea","src/io_source.rs":"166d4555f96cca194542361f7114a7e6456ce45b23097cb6afd26b7165e6ca1f","src/lib.rs":"230807008c9956195cd74d63a00879aa2ac67cede03723d336bb177c130f237f","src/macros.rs":"954a9c57fcdabc8625664880a41fedf2457ff87d5d5d6fee5e3c8c6112ac765b","src/net/mod.rs":"22b7f18555a06c1d5b074b67ed28ace5c59b1a3842232a9cd50f612cf0214cdc","src/net/tcp/listener.rs":"94e0277c84fc09041ef3f4c757ed0a935afa03edbdeadcb19a6a89938392a691","src/net/tcp/mod.rs":"f2c50c1d338a69d704e18727142d8495be2927b390d7bbb77cc0cf4e945ed83a","src/net/tcp/stream.rs":"aae550afe7dc458ad2b8860b7fc29c1feda345fe63a1e66e4de17610bead970e","src/net/udp.rs":"0d6245c99b1d4bedf6967ec138d0f4f9073a29e0d4404e3f96ff6830edb8250e","src/net/uds/datagram.rs":"a8d781620846997e5a89800d80e09a7b962c3f9ab14622a054b0b0d1b1b5c84e","src/net/uds/listener.rs":"0971d863f286333a6e7bcf5b031205a2f3a3160222160757a79a1e3d642e62c7","src/net/uds/mod.rs":"70d4368adae74652d46771b29e633396e5f1b70e9b7d1370cf5fec9a78605c04","src/net/uds/stream.rs":"93805ef2abc2ced64a3a0a095f60cd41db0349c49265a00b24b68444f32bba63","src/poll.rs":"b596d13c2df7132b723cf639261b910462bfb2b07f53a448fe682cb48467813a","src/sys/mod.rs":"b5d208443393e6c05084159d32dee9dae4c1e91409cc09a2d86e11e67d2f042f","src/sys/shell/mod.rs":"140595b0c19c0c63640eb5e2913fd16e3f1f88c06f15867b526e7cb75a5c35f3","src/sys/shell/selector.rs":"32aaf1145def1659983e2f6041c41aab33fd25c88b8d55f707502ab164019dd1","src/sys/shell/tcp.rs":"81a5219507eea81895f4f984ceb157a9c0d3c046d50190b1c562f52d77f2b607","src/sys/shell/udp.rs":"0db637a4ce1ec3a5ccb410d1e94bcc525df8ad005c1d4235d7d50111d335dbde","src/sys/shell/uds.rs":"af4ff92fe38e1b58d5aa4ea49bfcc6b0a1f842f08f2335d54ef0c279b76de99e","src/sys/shell/waker.rs":"81bc18cf52345a8d17e8142291e43dd70a36dfd9f5eb486f3e787998ee4451dc","src/sys/unix/mod.rs":"0b4528cdf3833f1a26c680b0f6b55f3c8b6bf628286b5d40ba07b6d41ed6b072","src/sys/unix/net.rs":"9f8ee521427404fb456d8d872bcdfd75f2e6f6872b1e7d1a4cbd6c87f0747eb9","src/sys/unix/pipe.rs":"f370aa8d75be97f1d584bc2adab7eb2812ee69cc421796375ea9ea36b694694d","src/sys/unix/selector/epoll.rs":"1c79b7a4dbc2e0bdd89562289cb6e5f84f5a5850e5438362290f9aee71cb6fff","src/sys/unix/selector/kqueue.rs":"e5cd64e9838b6af1a59a13d61bac384f4b823d1955817fc76dd75525c4abe34a","src/sys/unix/selector/mod.rs":"488f8e9a37ec608d477f22991f9ffa36d85c16a4f2e74f5fc97e1be9ff24aa45","src/sys/unix/selector/poll.rs":"9184841c3372e01cff30d25a7f90d0474a67b2f8b0b7456b7ac41dfae279d8e0","src/sys/unix/sourcefd.rs":"18292d551d78a4ae6900ee31c969909a784d42b49184b7e0581c08f170dabf04","src/sys/unix/tcp.rs":"8bdfd74dac5897e5c364a9b370828e2a22f2193539b499ff9ce688ae185894ec","src/sys/unix/udp.rs":"ff8f15655e2cbb2ebec5153bda9bad021a418c2a42976af899392f63f5af9633","src/sys/unix/uds/datagram.rs":"01634c6b9e57ebaa96463850408410970259dc0a6d948494d16372a5f9f3ef6f","src/sys/unix/uds/listener.rs":"4d6f2d0d8a3e22415990056b0f229c19c9f07486a8fad243f5c73446739f037b","src/sys/unix/uds/mod.rs":"7d743fb1952cbb5cefd5b30b5c3918f8f5c27bed9203f05fa5ffa514f3d994eb","src/sys/unix/uds/socketaddr.rs":"394f81f4ac7c30716ad84d1f17e06a44a8d090e8e6535e4354c7d474e23e32fe","src/sys/unix/uds/stream.rs":"a762f933789c8f6e8d690adc1a71f1996aebb0ce17ee8781de27cf681edccec1","src/sys/unix/waker.rs":"7f29fcaa11040203865ccc8e143b6b60824e8fbaf440c325c3f8312ec8625216","src/sys/wasi/mod.rs":"dd4945e34b2169c4d3737fe7566269e2f7d1867664657b9b49bd097c88759699","src/sys/windows/afd.rs":"97caca7e7a15de2b16ad23d714f5b508b354bcaca01f26a769bb98fab4968b18","src/sys/windows/event.rs":"0b3f9c4ba4f10e8ede7c7c7163b8b4207c0d8155285dca7b4737cd055ec2c459","src/sys/windows/handle.rs":"f75276733a6f930f755a1bc5651cba8be52320a45709eec0b4ce5efe8779c5b6","src/sys/windows/io_status_block.rs":"74f51e68fc3b5bcf03a5d6d1c23ab3a0ac31a05c7314f329fdfa10d3d552828a","src/sys/windows/iocp.rs":"f82ee941190849e345174d6a20771984685411cc48716e3c79dede5ba925f33d","src/sys/windows/mod.rs":"2359bea017df508a5c47d5d8896d7b70b077e08647ce4f526e1d666072210621","src/sys/windows/named_pipe.rs":"10b3c46a9939093df780b01a683573155ec50920a802e69ae6ef2f4c9730d33e","src/sys/windows/net.rs":"67093e8c2c672bc7e7c809c83f400061abac0b9e01a748811e3b91e410df008b","src/sys/windows/overlapped.rs":"94fa619a7655228485c714ef5b5ed4b703a360e51130cdfc07d20c1aa38cb3c5","src/sys/windows/selector.rs":"f405fa81757e9505982d9b96fea3b2390d1bcbae4fb6833939abc04efc2d9d5a","src/sys/windows/tcp.rs":"1911960fd32657d31a53ed3ba4a374d1592bae2b2c7fca80213cdfbfa773a831","src/sys/windows/udp.rs":"45cbba2941287d89e089f168e29f65cea03b8b11aa8f5b7fee173d53a5c0e6b0","src/sys/windows/waker.rs":"cf27f75061b86dabe362d936c5945fd0e644aea833993de45d40b4be5fbbe56c","src/token.rs":"4e64c8e337fbee4e3a2f5e8661241b5261c9c5487e20fa73425d89e2e152e8de","src/waker.rs":"cd521418aede70369775607232d1162ff70f3993f4951ed113cc18fcd7af6539"},"package":"8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"} -\ No newline at end of file -diff --git a/KubeOS-Rust/vendor/mio/CHANGELOG.md b/KubeOS-Rust/vendor/mio/CHANGELOG.md -index d2cd8e4d..de6b39c7 100644 ---- a/KubeOS-Rust/vendor/mio/CHANGELOG.md -+++ b/KubeOS-Rust/vendor/mio/CHANGELOG.md -@@ -1,3 +1,186 @@ -+# 0.8.10 -+ -+## Added -+ -+* Solaris support -+ (https://github.com/tokio-rs/mio/pull/1724). -+ -+# 0.8.9 -+ -+## Added -+ -+* ESP-IDF framework support -+ (https://github.com/tokio-rs/mio/pull/1692). -+* AIX operating system support -+ (https://github.com/tokio-rs/mio/pull/1704). -+* Vita support -+ (https://github.com/tokio-rs/mio/pull/1721). -+* `{UnixListener,UnixStream}:bind_addr` -+ (https://github.com/tokio-rs/mio/pull/1630). -+* `mio_unsupported_force_poll_poll` and `mio_unsupported_force_waker_pipe` -+ **unsupported** configuration flags to force a specific poll or waker -+ implementation -+ (https://github.com/tokio-rs/mio/pull/1684, -+ https://github.com/tokio-rs/mio/pull/1685, -+ https://github.com/tokio-rs/mio/pull/1692). -+ -+## Fixed -+ -+* The `pipe(2)` based waker (swapped file descriptors) -+ (https://github.com/tokio-rs/mio/pull/1722). -+* The duplicate waker check to work correctly with cloned `Registry`s. -+ (https://github.com/tokio-rs/mio/pull/1706). -+ -+# 0.8.8 -+ -+## Fixed -+ -+* Fix compilation on WASI (https://github.com/tokio-rs/mio/pull/1676). -+ -+# 0.8.7 -+ -+## Added -+ -+* Add/fix support for tvOS and watchOS, Mio should now build for tvOS and -+ watchOS, but we don't have a CI setup yet -+ (https://github.com/tokio-rs/mio/pull/1658). -+ -+## Changed -+ -+* Made the `log` dependency optional behind the `log` feature flag (enabled by -+ default). Users that disabled Mio's default features will now not see any -+ logging from Mio, enabling the `log` feature will fix that. This was done in -+ response to the `log` crate increasing it's MSRV to v1.60, see -+ https://github.com/rust-lang/log/pull/552 -+ (https://github.com/tokio-rs/mio/pull/1673). -+* Update windows-sys dependency to v0.48 -+ (https://github.com/tokio-rs/mio/pull/1663). -+ -+## Fixed -+ -+* Fix overflow in `Poll::poll` when using `Duration::MAX` as timeout -+ (https://github.com/tokio-rs/mio/pull/1657). -+ -+# 0.8.6 -+ -+## Added -+ -+* `Interest::PRIORITY` on Linux and Android, to trigger `Event::is_priority` -+ (https://github.com/tokio-rs/mio/pull/1647). -+ -+## Changed -+ -+* Updated windows-sys to 0.45 -+ (https://github.com/tokio-rs/mio/pull/1644). -+* We started testing with sanitizers on the CI -+ (https://github.com/tokio-rs/mio/pull/1648). -+ -+## Fixed -+ -+* A number of potential fd leaks when setup resulted in an error right after -+ creation (https://github.com/tokio-rs/mio/pull/1636). -+* Less truncating for timeout values in `Poll::poll` -+ (https://github.com/tokio-rs/mio/pull/1642). -+ -+# 0.8.5 -+ -+## Changed -+ -+* Updated `windows-sys` to 0.42.0 -+ (https://github.com/tokio-rs/mio/pull/1624). -+* Officially document Wine as not supported, some people claimed it worked, -+ other claims it doesn't, but nobody stepped up to fix the problem -+ (https://github.com/tokio-rs/mio/pull/1596). -+* Switch to GitHub Actions -+ (https://github.com/tokio-rs/mio/pull/1598, https://github.com/tokio-rs/mio/pull/1601). -+* Documented the current Poll::poll time behaviour -+ (https://github.com/tokio-rs/mio/pull/1603). -+ -+## Fixed -+ -+* Timeout less than one millisecond becoming zero millsiconds -+ (https://github.com/tokio-rs/mio/pull/1615, https://github.com/tokio-rs/mio/pull/1616) -+* Undefined reference to `epoll\_create1` on Android API level < 21. -+ (https://github.com/tokio-rs/mio/pull/1590). -+ -+# 0.8.4 -+ -+## Added -+ -+* Support `Registery::try_clone` on `wasm32-wasi` -+ (https://github.com/tokio-rs/mio/pull/1576). -+* Add docs about polling without registering event sources -+ (https://github.com/tokio-rs/mio/pull/1585). -+ -+# 0.8.3 -+ -+## Changed -+ -+* Replace `winapi` dependency with `windows-sys`. -+ (https://github.com/tokio-rs/mio/pull/1556). -+* Future proofed the kevent ABI for FreeBSD -+ (https://github.com/tokio-rs/mio/pull/1572). -+ -+## Fixed -+ -+* Improved support for Redox, making it possible to run on stable Rust -+ (https://github.com/tokio-rs/mio/pull/1555). -+* Don't ignore EAGAIN in UDS connect call -+ (https://github.com/tokio-rs/mio/pull/1564). -+* Documentation of `TcpStream::connect` -+ (https://github.com/tokio-rs/mio/pull/1565). -+ -+# 0.8.2 -+ -+## Added -+ -+* Experimental support for Redox. -+ -+# 0.8.1 -+ -+## Added -+ -+* Add `try_io` method to all I/O types (#1551). This execute a user defined I/O -+ closure while updating Mio's internal state ensuring that the I/O type -+ receives more events if it hits a WouldBlock error. This is added to the -+ following types: -+ * `TcpStream` -+ * `UdpSocket` -+ * `UnixDatagram` -+ * `UnixStream` -+ * `unix::pipe::Sender` -+ * `unix::pipe::Receiver` -+* Basic, experimental support for `wasm32-wasi` target (#1549). Note that a lot -+ of time type are still missing, e.g. the `Waker`, and may never be possible to -+ implement. -+ -+# 0.8.0 -+ -+## Removed -+ -+* Deprecated features (https://github.com/tokio-rs/mio/commit/105f8f2afb57b01ddea716a0aa9720f226c520e3): -+ * extra-docs (always enabled) -+ * tcp (replaced with "net" feature). -+ * udp (replaced with "net" feature). -+ * uds (replaced with "net" feature). -+ * pipe (replaced with "os-ext" feature). -+ * os-util (replaced with "os-ext" feature). -+* `TcpSocket` type -+ (https://github.com/tokio-rs/mio/commit/02e9be41f27daf822575444fdd2b3067433a5996). -+ The socket2 crate provides all the functionality and more. -+* Support for Solaris, it never really worked anyway -+ (https://github.com/tokio-rs/mio/pull/1528). -+ -+## Changes -+ -+* Update minimum Rustc version (MSVR) to 1.46.0 -+ (https://github.com/tokio-rs/mio/commit/5c577efecd23750a9a3e0f6ad080ab98f14a255d). -+ -+## Added -+ -+* `UdpSocket::peer_addr` -+ (https://github.com/tokio-rs/mio/commit/5fc104d08e0e74c8a19247f7cba0f058699fc438). -+ - # 0.7.14 - - ## Fixes -@@ -37,6 +220,8 @@ - * Fix an instance of not doc(cfg(.*)) - (https://github.com/tokio-rs/mio/commit/25e8f911357c740034f10a170dfa4ea1b28234ce). - -+# 0.7.9 -+ - ## Fixes - - * Fix error handling in `NamedPipe::write` -@@ -71,7 +256,6 @@ - themselves already - (https://github.com/tokio-rs/mio/commit/1be481dcbbcb6906364008b5d61e7f53cddc3eb3). - -- - ## Fixes - - * Underflow in `SocketAddr::address` -diff --git a/KubeOS-Rust/vendor/mio/Cargo.lock b/KubeOS-Rust/vendor/mio/Cargo.lock -index 0e3c8c5d..b2ac22f8 100644 ---- a/KubeOS-Rust/vendor/mio/Cargo.lock -+++ b/KubeOS-Rust/vendor/mio/Cargo.lock -@@ -10,132 +10,155 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - - [[package]] - name = "env_logger" --version = "0.6.2" -+version = "0.9.3" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "aafcde04e90a5226a6443b7aabdb016ba2f8307c847d524724bd9b346dd1a2d3" -+checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7" - dependencies = [ - "log", - ] - - [[package]] --name = "fuchsia-cprng" --version = "0.1.1" -+name = "getrandom" -+version = "0.2.8" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba" -+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31" -+dependencies = [ -+ "cfg-if", -+ "libc", -+ "wasi", -+] - - [[package]] - name = "libc" --version = "0.2.86" -+version = "0.2.149" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "b7282d924be3275cec7f6756ff4121987bc6481325397dde6ba3e7802b1a8b1c" -+checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b" - - [[package]] - name = "log" --version = "0.4.14" -+version = "0.4.17" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710" -+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" - dependencies = [ - "cfg-if", - ] - - [[package]] - name = "mio" --version = "0.7.14" -+version = "0.8.10" - dependencies = [ - "env_logger", - "libc", - "log", -- "miow", -- "ntapi", - "rand", -- "winapi", -+ "wasi", -+ "windows-sys", - ] - - [[package]] --name = "miow" --version = "0.3.6" -+name = "ppv-lite86" -+version = "0.2.17" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "5a33c1b55807fbed163481b5ba66db4b2fa6cde694a5027be10fb724206c5897" --dependencies = [ -- "socket2", -- "winapi", --] -+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" - - [[package]] --name = "ntapi" --version = "0.3.6" -+name = "rand" -+version = "0.8.5" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44" -+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" - dependencies = [ -- "winapi", -+ "libc", -+ "rand_chacha", -+ "rand_core", - ] - - [[package]] --name = "rand" --version = "0.4.6" -+name = "rand_chacha" -+version = "0.3.1" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" -+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" - dependencies = [ -- "fuchsia-cprng", -- "libc", -- "rand_core 0.3.1", -- "rdrand", -- "winapi", -+ "ppv-lite86", -+ "rand_core", - ] - - [[package]] - name = "rand_core" --version = "0.3.1" -+version = "0.6.4" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b" -+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" - dependencies = [ -- "rand_core 0.4.2", -+ "getrandom", - ] - - [[package]] --name = "rand_core" --version = "0.4.2" -+name = "wasi" -+version = "0.11.0+wasi-snapshot-preview1" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc" -+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" - - [[package]] --name = "rdrand" --version = "0.4.0" -+name = "windows-sys" -+version = "0.48.0" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2" -+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" - dependencies = [ -- "rand_core 0.3.1", -+ "windows-targets", - ] - - [[package]] --name = "socket2" --version = "0.3.19" -+name = "windows-targets" -+version = "0.48.0" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "122e570113d28d773067fab24266b66753f6ea915758651696b6e35e49f88d6e" -+checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5" - dependencies = [ -- "cfg-if", -- "libc", -- "winapi", -+ "windows_aarch64_gnullvm", -+ "windows_aarch64_msvc", -+ "windows_i686_gnu", -+ "windows_i686_msvc", -+ "windows_x86_64_gnu", -+ "windows_x86_64_gnullvm", -+ "windows_x86_64_msvc", - ] - - [[package]] --name = "winapi" --version = "0.3.9" -+name = "windows_aarch64_gnullvm" -+version = "0.48.0" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" --dependencies = [ -- "winapi-i686-pc-windows-gnu", -- "winapi-x86_64-pc-windows-gnu", --] -+checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc" -+ -+[[package]] -+name = "windows_aarch64_msvc" -+version = "0.48.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3" -+ -+[[package]] -+name = "windows_i686_gnu" -+version = "0.48.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241" -+ -+[[package]] -+name = "windows_i686_msvc" -+version = "0.48.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00" -+ -+[[package]] -+name = "windows_x86_64_gnu" -+version = "0.48.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1" - - [[package]] --name = "winapi-i686-pc-windows-gnu" --version = "0.4.0" -+name = "windows_x86_64_gnullvm" -+version = "0.48.0" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" -+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953" - - [[package]] --name = "winapi-x86_64-pc-windows-gnu" --version = "0.4.0" -+name = "windows_x86_64_msvc" -+version = "0.48.0" - source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" -+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a" -diff --git a/KubeOS-Rust/vendor/mio/Cargo.toml b/KubeOS-Rust/vendor/mio/Cargo.toml -index 01df8f40..67c05c22 100644 ---- a/KubeOS-Rust/vendor/mio/Cargo.toml -+++ b/KubeOS-Rust/vendor/mio/Cargo.toml -@@ -12,60 +12,117 @@ - [package] - edition = "2018" - name = "mio" --version = "0.7.14" --authors = ["Carl Lerche ", "Thomas de Zeeuw ", "Tokio Contributors "] --include = ["Cargo.toml", "LICENSE", "README.md", "CHANGELOG.md", "src/**/*.rs", "examples/**/*.rs"] --description = "Lightweight non-blocking IO" -+version = "0.8.10" -+authors = [ -+ "Carl Lerche ", -+ "Thomas de Zeeuw ", -+ "Tokio Contributors ", -+] -+include = [ -+ "Cargo.toml", -+ "LICENSE", -+ "README.md", -+ "CHANGELOG.md", -+ "src/**/*.rs", -+ "examples/**/*.rs", -+] -+description = "Lightweight non-blocking I/O." - homepage = "https://github.com/tokio-rs/mio" --documentation = "https://docs.rs/mio/0.7.14" - readme = "README.md" --keywords = ["io", "async", "non-blocking"] -+keywords = [ -+ "io", -+ "async", -+ "non-blocking", -+] - categories = ["asynchronous"] - license = "MIT" - repository = "https://github.com/tokio-rs/mio" -+ - [package.metadata.docs.rs] - all-features = true --rustdoc-args = ["--cfg", "docsrs"] --targets = ["aarch64-apple-ios", "aarch64-linux-android", "x86_64-apple-darwin", "x86_64-pc-windows-msvc", "x86_64-sun-solaris", "x86_64-unknown-dragonfly", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu", "x86_64-unknown-netbsd", "x86_64-unknown-openbsd"] -+rustdoc-args = [ -+ "--cfg", -+ "docsrs", -+ "--generate-link-to-definition", -+] -+targets = [ -+ "aarch64-apple-ios", -+ "aarch64-linux-android", -+ "wasm32-wasi", -+ "x86_64-apple-darwin", -+ "x86_64-pc-windows-msvc", -+ "x86_64-unknown-dragonfly", -+ "x86_64-unknown-freebsd", -+ "x86_64-unknown-illumos", -+ "x86_64-unknown-linux-gnu", -+ "x86_64-unknown-netbsd", -+ "x86_64-unknown-openbsd", -+] - - [package.metadata.playground] --features = ["os-poll", "os-ext", "net"] -+features = [ -+ "os-poll", -+ "os-ext", -+ "net", -+] - - [[example]] - name = "tcp_server" --required-features = ["os-poll", "net"] -+required-features = [ -+ "os-poll", -+ "net", -+] -+ -+[[example]] -+name = "tcp_listenfd_server" -+required-features = [ -+ "os-poll", -+ "net", -+] - - [[example]] - name = "udp_server" --required-features = ["os-poll", "net"] -+required-features = [ -+ "os-poll", -+ "net", -+] -+ - [dependencies.log] - version = "0.4.8" -+optional = true -+ - [dev-dependencies.env_logger] --version = "0.6.2" -+version = "0.9.3" - default-features = false - - [dev-dependencies.rand] --version = "0.4" -+version = "0.8" - - [features] --default = [] --extra-docs = [] -+default = ["log"] - net = [] --os-ext = ["os-poll"] -+os-ext = [ -+ "os-poll", -+ "windows-sys/Win32_System_Pipes", -+ "windows-sys/Win32_Security", -+] - os-poll = [] --os-util = ["os-ext"] --pipe = ["os-ext"] --tcp = ["net"] --udp = ["net"] --uds = ["net"] --[target."cfg(unix)".dependencies.libc] --version = "0.2.86" --[target."cfg(windows)".dependencies.miow] --version = "0.3.6" - --[target."cfg(windows)".dependencies.ntapi] --version = "0.3" -+[target."cfg(target_os = \"wasi\")".dependencies.libc] -+version = "0.2.149" -+ -+[target."cfg(target_os = \"wasi\")".dependencies.wasi] -+version = "0.11.0" -+ -+[target."cfg(unix)".dependencies.libc] -+version = "0.2.149" - --[target."cfg(windows)".dependencies.winapi] --version = "0.3" --features = ["winsock2", "mswsock", "mstcpip"] -+[target."cfg(windows)".dependencies.windows-sys] -+version = "0.48" -+features = [ -+ "Win32_Foundation", -+ "Win32_Networking_WinSock", -+ "Win32_Storage_FileSystem", -+ "Win32_System_IO", -+ "Win32_System_WindowsProgramming", -+] -diff --git a/KubeOS-Rust/vendor/mio/README.md b/KubeOS-Rust/vendor/mio/README.md -index c8653f8a..39dae387 100644 ---- a/KubeOS-Rust/vendor/mio/README.md -+++ b/KubeOS-Rust/vendor/mio/README.md -@@ -1,4 +1,4 @@ --# Mio – Metal IO -+# Mio – Metal I/O - - Mio is a fast, low-level I/O library for Rust focusing on non-blocking APIs and - event notification for building high performance I/O apps with as little -@@ -6,23 +6,22 @@ overhead as possible over the OS abstractions. - - [![Crates.io][crates-badge]][crates-url] - [![MIT licensed][mit-badge]][mit-url] --[![Build Status][azure-badge]][azure-url] -+[![Build Status][actions-badge]][actions-url] - [![Build Status][cirrus-badge]][cirrus-url] - - [crates-badge]: https://img.shields.io/crates/v/mio.svg - [crates-url]: https://crates.io/crates/mio - [mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg - [mit-url]: LICENSE --[azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.mio?branchName=master --[azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=2&branchName=master -+[actions-badge]: https://github.com/tokio-rs/mio/workflows/CI/badge.svg -+[actions-url]: https://github.com/tokio-rs/mio/actions?query=workflow%3ACI+branch%3Amaster - [cirrus-badge]: https://api.cirrus-ci.com/github/tokio-rs/mio.svg - [cirrus-url]: https://cirrus-ci.com/github/tokio-rs/mio - - **API documentation** - --* [master](https://tokio-rs.github.io/mio/doc/mio/) -+* [v0.8](https://docs.rs/mio/^0.8) - * [v0.7](https://docs.rs/mio/^0.7) --* [v0.6](https://docs.rs/mio/^0.6) - - This is a low level library, if you are looking for something easier to get - started with, see [Tokio](https://tokio.rs). -@@ -33,7 +32,7 @@ To use `mio`, first add this to your `Cargo.toml`: - - ```toml - [dependencies] --mio = "0.7" -+mio = "0.8" - ``` - - Next we can start using Mio. The following is quick introduction using -@@ -129,19 +128,18 @@ or higher-level libraries. - - Currently supported platforms: - --* Android -+* Android (API level 21) - * DragonFly BSD - * FreeBSD - * Linux - * NetBSD - * OpenBSD --* Solaris - * Windows - * iOS - * macOS - --There are potentially others. If you find that Mio works on another --platform, submit a PR to update the list! -+There are potentially others. If you find that Mio works on another platform, -+submit a PR to update the list! - - Mio can handle interfacing with each of the event systems of the aforementioned - platforms. The details of their implementation are further discussed in the -@@ -152,12 +150,45 @@ This uses the Windows AFD system to access socket readiness events. - - [wepoll]: https://github.com/piscisaureus/wepoll - -+### Unsupported -+ -+* Haiku, see [issue #1472] -+* Solaris, see [issue #1152] -+* Wine, see [issue #1444] -+ -+[issue #1472]: https://github.com/tokio-rs/mio/issues/1472 -+[issue #1152]: https://github.com/tokio-rs/mio/issues/1152 -+[issue #1444]: https://github.com/tokio-rs/mio/issues/1444 -+ -+## Unsupported flags -+ -+Mio uses different implementations to support the same functionality depending -+on the platform. Mio generally uses the "best" implementation possible, where -+"best" usually means most efficient for Mio's use case. However this means that -+the implementation is often specific to a limited number of platforms, meaning -+we often have multiple implementations for the same functionality. In some cases -+it might be required to not use the "best" implementation, but another -+implementation Mio supports (on other platforms). **Mio does not officially -+support secondary implementations on platforms**, however we do have various cfg -+flags to force another implementation for these situations. -+ -+Current flags: -+ * `mio_unsupported_force_poll_poll`, uses an implementation based on `poll(2)` -+ for `mio::Poll`. -+ * `mio_unsupported_force_waker_pipe`, uses an implementation based on `pipe(2)` -+ for `mio::Waker`. -+ -+**Again, Mio does not officially supports this**. Furthermore these flags may -+disappear in the future. -+ - ## Community - - A group of Mio users hang out on [Discord], this can be a good place to go for --questions. -+questions. It's also possible to open a [new issue on GitHub] to ask questions, -+report bugs or suggest new features. - - [Discord]: https://discord.gg/tokio -+[new issue on GitHub]: https://github.com/tokio-rs/mio/issues/new - - ## Contributing - -diff --git a/KubeOS-Rust/vendor/mio/examples/tcp_listenfd_server.rs b/KubeOS-Rust/vendor/mio/examples/tcp_listenfd_server.rs -new file mode 100644 -index 00000000..941d7f04 ---- /dev/null -+++ b/KubeOS-Rust/vendor/mio/examples/tcp_listenfd_server.rs -@@ -0,0 +1,209 @@ -+// You can run this example from the root of the mio repo: -+// cargo run --example tcp_listenfd_server --features="os-poll net" -+// or with wasi: -+// cargo +nightly build --target wasm32-wasi --example tcp_listenfd_server --features="os-poll net" -+// wasmtime run --tcplisten 127.0.0.1:9000 --env 'LISTEN_FDS=1' target/wasm32-wasi/debug/examples/tcp_listenfd_server.wasm -+ -+use mio::event::Event; -+use mio::net::{TcpListener, TcpStream}; -+use mio::{Events, Interest, Poll, Registry, Token}; -+use std::collections::HashMap; -+use std::io::{self, Read, Write}; -+use std::str::from_utf8; -+ -+// Setup some tokens to allow us to identify which event is for which socket. -+const SERVER: Token = Token(0); -+ -+// Some data we'll send over the connection. -+const DATA: &[u8] = b"Hello world!\n"; -+ -+#[cfg(not(windows))] -+fn get_first_listen_fd_listener() -> Option { -+ #[cfg(unix)] -+ use std::os::unix::io::FromRawFd; -+ #[cfg(target_os = "wasi")] -+ use std::os::wasi::io::FromRawFd; -+ -+ let stdlistener = unsafe { std::net::TcpListener::from_raw_fd(3) }; -+ stdlistener.set_nonblocking(true).unwrap(); -+ Some(stdlistener) -+} -+ -+#[cfg(windows)] -+fn get_first_listen_fd_listener() -> Option { -+ // Windows does not support `LISTEN_FDS` -+ None -+} -+ -+fn main() -> io::Result<()> { -+ env_logger::init(); -+ -+ std::env::var("LISTEN_FDS").expect("LISTEN_FDS environment variable unset"); -+ -+ // Create a poll instance. -+ let mut poll = Poll::new()?; -+ // Create storage for events. -+ let mut events = Events::with_capacity(128); -+ -+ // Setup the TCP server socket. -+ let mut server = { -+ let stdlistener = get_first_listen_fd_listener().unwrap(); -+ println!("Using preopened socket FD 3"); -+ println!("You can connect to the server using `nc`:"); -+ match stdlistener.local_addr() { -+ Ok(a) => println!(" $ nc {} {}", a.ip(), a.port()), -+ Err(_) => println!(" $ nc "), -+ } -+ println!("You'll see our welcome message and anything you type will be printed here."); -+ TcpListener::from_std(stdlistener) -+ }; -+ -+ // Register the server with poll we can receive events for it. -+ poll.registry() -+ .register(&mut server, SERVER, Interest::READABLE)?; -+ -+ // Map of `Token` -> `TcpStream`. -+ let mut connections = HashMap::new(); -+ // Unique token for each incoming connection. -+ let mut unique_token = Token(SERVER.0 + 1); -+ -+ loop { -+ poll.poll(&mut events, None)?; -+ -+ for event in events.iter() { -+ match event.token() { -+ SERVER => loop { -+ // Received an event for the TCP server socket, which -+ // indicates we can accept an connection. -+ let (mut connection, address) = match server.accept() { -+ Ok((connection, address)) => (connection, address), -+ Err(ref e) if would_block(e) => { -+ // If we get a `WouldBlock` error we know our -+ // listener has no more incoming connections queued, -+ // so we can return to polling and wait for some -+ // more. -+ break; -+ } -+ Err(e) => { -+ // If it was any other kind of error, something went -+ // wrong and we terminate with an error. -+ return Err(e); -+ } -+ }; -+ -+ println!("Accepted connection from: {}", address); -+ -+ let token = next(&mut unique_token); -+ poll.registry() -+ .register(&mut connection, token, Interest::WRITABLE)?; -+ -+ connections.insert(token, connection); -+ }, -+ token => { -+ // Maybe received an event for a TCP connection. -+ let done = if let Some(connection) = connections.get_mut(&token) { -+ handle_connection_event(poll.registry(), connection, event)? -+ } else { -+ // Sporadic events happen, we can safely ignore them. -+ false -+ }; -+ if done { -+ if let Some(mut connection) = connections.remove(&token) { -+ poll.registry().deregister(&mut connection)?; -+ } -+ } -+ } -+ } -+ } -+ } -+} -+ -+fn next(current: &mut Token) -> Token { -+ let next = current.0; -+ current.0 += 1; -+ Token(next) -+} -+ -+/// Returns `true` if the connection is done. -+fn handle_connection_event( -+ registry: &Registry, -+ connection: &mut TcpStream, -+ event: &Event, -+) -> io::Result { -+ if event.is_writable() { -+ // We can (maybe) write to the connection. -+ match connection.write(DATA) { -+ // We want to write the entire `DATA` buffer in a single go. If we -+ // write less we'll return a short write error (same as -+ // `io::Write::write_all` does). -+ Ok(n) if n < DATA.len() => return Err(io::ErrorKind::WriteZero.into()), -+ Ok(_) => { -+ // After we've written something we'll reregister the connection -+ // to only respond to readable events. -+ registry.reregister(connection, event.token(), Interest::READABLE)? -+ } -+ // Would block "errors" are the OS's way of saying that the -+ // connection is not actually ready to perform this I/O operation. -+ Err(ref err) if would_block(err) => {} -+ // Got interrupted (how rude!), we'll try again. -+ Err(ref err) if interrupted(err) => { -+ return handle_connection_event(registry, connection, event) -+ } -+ // Other errors we'll consider fatal. -+ Err(err) => return Err(err), -+ } -+ } -+ -+ if event.is_readable() { -+ let mut connection_closed = false; -+ let mut received_data = vec![0; 4096]; -+ let mut bytes_read = 0; -+ // We can (maybe) read from the connection. -+ loop { -+ match connection.read(&mut received_data[bytes_read..]) { -+ Ok(0) => { -+ // Reading 0 bytes means the other side has closed the -+ // connection or is done writing, then so are we. -+ connection_closed = true; -+ break; -+ } -+ Ok(n) => { -+ bytes_read += n; -+ if bytes_read == received_data.len() { -+ received_data.resize(received_data.len() + 1024, 0); -+ } -+ } -+ // Would block "errors" are the OS's way of saying that the -+ // connection is not actually ready to perform this I/O operation. -+ Err(ref err) if would_block(err) => break, -+ Err(ref err) if interrupted(err) => continue, -+ // Other errors we'll consider fatal. -+ Err(err) => return Err(err), -+ } -+ } -+ -+ if bytes_read != 0 { -+ let received_data = &received_data[..bytes_read]; -+ if let Ok(str_buf) = from_utf8(received_data) { -+ println!("Received data: {}", str_buf.trim_end()); -+ } else { -+ println!("Received (none UTF-8) data: {:?}", received_data); -+ } -+ } -+ -+ if connection_closed { -+ println!("Connection closed"); -+ return Ok(true); -+ } -+ } -+ -+ Ok(false) -+} -+ -+fn would_block(err: &io::Error) -> bool { -+ err.kind() == io::ErrorKind::WouldBlock -+} -+ -+fn interrupted(err: &io::Error) -> bool { -+ err.kind() == io::ErrorKind::Interrupted -+} -diff --git a/KubeOS-Rust/vendor/mio/examples/tcp_server.rs b/KubeOS-Rust/vendor/mio/examples/tcp_server.rs -index 42426ee9..21e2f2a8 100644 ---- a/KubeOS-Rust/vendor/mio/examples/tcp_server.rs -+++ b/KubeOS-Rust/vendor/mio/examples/tcp_server.rs -@@ -1,5 +1,5 @@ - // You can run this example from the root of the mio repo: --// cargo run --example tcp_server --features="os-poll tcp" -+// cargo run --example tcp_server --features="os-poll net" - use mio::event::Event; - use mio::net::{TcpListener, TcpStream}; - use mio::{Events, Interest, Poll, Registry, Token}; -@@ -13,6 +13,7 @@ const SERVER: Token = Token(0); - // Some data we'll send over the connection. - const DATA: &[u8] = b"Hello world!\n"; - -+#[cfg(not(target_os = "wasi"))] - fn main() -> io::Result<()> { - env_logger::init(); - -@@ -36,10 +37,15 @@ fn main() -> io::Result<()> { - - println!("You can connect to the server using `nc`:"); - println!(" $ nc 127.0.0.1 9000"); -- println!("You'll see our welcome message and anything you type we'll be printed here."); -+ println!("You'll see our welcome message and anything you type will be printed here."); - - loop { -- poll.poll(&mut events, None)?; -+ if let Err(err) = poll.poll(&mut events, None) { -+ if interrupted(&err) { -+ continue; -+ } -+ return Err(err); -+ } - - for event in events.iter() { - match event.token() { -@@ -82,7 +88,9 @@ fn main() -> io::Result<()> { - false - }; - if done { -- connections.remove(&token); -+ if let Some(mut connection) = connections.remove(&token) { -+ poll.registry().deregister(&mut connection)?; -+ } - } - } - } -@@ -179,3 +187,8 @@ fn would_block(err: &io::Error) -> bool { - fn interrupted(err: &io::Error) -> bool { - err.kind() == io::ErrorKind::Interrupted - } -+ -+#[cfg(target_os = "wasi")] -+fn main() { -+ panic!("can't bind to an address with wasi") -+} -diff --git a/KubeOS-Rust/vendor/mio/examples/udp_server.rs b/KubeOS-Rust/vendor/mio/examples/udp_server.rs -index febb6621..698d710c 100644 ---- a/KubeOS-Rust/vendor/mio/examples/udp_server.rs -+++ b/KubeOS-Rust/vendor/mio/examples/udp_server.rs -@@ -1,14 +1,16 @@ - // You can run this example from the root of the mio repo: --// cargo run --example udp_server --features="os-poll udp" -+// cargo run --example udp_server --features="os-poll net" - use log::warn; --use mio::net::UdpSocket; - use mio::{Events, Interest, Poll, Token}; - use std::io; - - // A token to allow us to identify which event is for the `UdpSocket`. - const UDP_SOCKET: Token = Token(0); - -+#[cfg(not(target_os = "wasi"))] - fn main() -> io::Result<()> { -+ use mio::net::UdpSocket; -+ - env_logger::init(); - - // Create a poll instance. -@@ -19,6 +21,7 @@ fn main() -> io::Result<()> { - - // Setup the UDP socket. - let addr = "127.0.0.1:9000".parse().unwrap(); -+ - let mut socket = UdpSocket::bind(addr)?; - - // Register our socket with the token defined above and an interest in being -@@ -37,7 +40,12 @@ fn main() -> io::Result<()> { - // Our event loop. - loop { - // Poll to check if we have events waiting for us. -- poll.poll(&mut events, None)?; -+ if let Err(err) = poll.poll(&mut events, None) { -+ if err.kind() == io::ErrorKind::Interrupted { -+ continue; -+ } -+ return Err(err); -+ } - - // Process each event. - for event in events.iter() { -@@ -75,3 +83,8 @@ fn main() -> io::Result<()> { - } - } - } -+ -+#[cfg(target_os = "wasi")] -+fn main() { -+ panic!("can't bind to an address with wasi") -+} -diff --git a/KubeOS-Rust/vendor/mio/src/event/event.rs b/KubeOS-Rust/vendor/mio/src/event/event.rs -index 9e4a95e7..2d85742b 100644 ---- a/KubeOS-Rust/vendor/mio/src/event/event.rs -+++ b/KubeOS-Rust/vendor/mio/src/event/event.rs -@@ -25,6 +25,15 @@ impl Event { - } - - /// Returns true if the event contains readable readiness. -+ /// -+ /// # Notes -+ /// -+ /// Out-of-band (OOB) data also triggers readable events. But must -+ /// application don't actually read OOB data, this could leave an -+ /// application open to a Denial-of-Service (Dos) attack, see -+ /// . -+ /// However because Mio uses edge-triggers it will not result in an infinite -+ /// loop as described in the article above. - pub fn is_readable(&self) -> bool { - sys::event::is_readable(&self.inner) - } -@@ -53,7 +62,7 @@ impl Event { - /// | [kqueue] | `EV_ERROR` and `EV_EOF` with `fflags` set to `0`. | - /// - /// [OS selector]: ../struct.Poll.html#implementation-notes -- /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html -+ /// [epoll]: https://man7.org/linux/man-pages/man7/epoll.7.html - /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 - pub fn is_error(&self) -> bool { - sys::event::is_error(&self.inner) -@@ -84,7 +93,7 @@ impl Event { - /// | [kqueue] | `EV_EOF` | - /// - /// [OS selector]: ../struct.Poll.html#implementation-notes -- /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html -+ /// [epoll]: https://man7.org/linux/man-pages/man7/epoll.7.html - /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 - pub fn is_read_closed(&self) -> bool { - sys::event::is_read_closed(&self.inner) -@@ -114,7 +123,7 @@ impl Event { - /// | [kqueue] | `EV_EOF` | - /// - /// [OS selector]: ../struct.Poll.html#implementation-notes -- /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html -+ /// [epoll]: https://man7.org/linux/man-pages/man7/epoll.7.html - /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 - pub fn is_write_closed(&self) -> bool { - sys::event::is_write_closed(&self.inner) -@@ -135,7 +144,7 @@ impl Event { - /// | [kqueue] | *Not supported* | - /// - /// [OS selector]: ../struct.Poll.html#implementation-notes -- /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html -+ /// [epoll]: https://man7.org/linux/man-pages/man7/epoll.7.html - /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 - #[inline] - pub fn is_priority(&self) -> bool { -@@ -158,7 +167,7 @@ impl Event { - /// 1: Only supported on DragonFly BSD, FreeBSD, iOS and macOS. - /// - /// [OS selector]: ../struct.Poll.html#implementation-notes -- /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html -+ /// [epoll]: https://man7.org/linux/man-pages/man7/epoll.7.html - /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 - pub fn is_aio(&self) -> bool { - sys::event::is_aio(&self.inner) -diff --git a/KubeOS-Rust/vendor/mio/src/event/source.rs b/KubeOS-Rust/vendor/mio/src/event/source.rs -index f38268ab..619f72d4 100644 ---- a/KubeOS-Rust/vendor/mio/src/event/source.rs -+++ b/KubeOS-Rust/vendor/mio/src/event/source.rs -@@ -38,8 +38,8 @@ use std::io; - /// - /// Implementing `Source` on a struct containing a socket: - /// --#[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] --#[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - /// use mio::{Interest, Registry, Token}; - /// use mio::event::Source; - /// use mio::net::TcpStream; -@@ -121,7 +121,7 @@ where - token: Token, - interests: Interest, - ) -> io::Result<()> { -- (&mut **self).register(registry, token, interests) -+ (**self).register(registry, token, interests) - } - - fn reregister( -@@ -130,10 +130,10 @@ where - token: Token, - interests: Interest, - ) -> io::Result<()> { -- (&mut **self).reregister(registry, token, interests) -+ (**self).reregister(registry, token, interests) - } - - fn deregister(&mut self, registry: &Registry) -> io::Result<()> { -- (&mut **self).deregister(registry) -+ (**self).deregister(registry) - } - } -diff --git a/KubeOS-Rust/vendor/mio/src/interest.rs b/KubeOS-Rust/vendor/mio/src/interest.rs -index ee5158ab..2bab7869 100644 ---- a/KubeOS-Rust/vendor/mio/src/interest.rs -+++ b/KubeOS-Rust/vendor/mio/src/interest.rs -@@ -17,21 +17,12 @@ use std::{fmt, ops}; - pub struct Interest(NonZeroU8); - - // These must be unique. --const READABLE: u8 = 0b0_001; --const WRITABLE: u8 = 0b0_010; -+const READABLE: u8 = 0b0001; -+const WRITABLE: u8 = 0b0010; - // The following are not available on all platforms. --#[cfg_attr( -- not(any( -- target_os = "dragonfly", -- target_os = "freebsd", -- target_os = "ios", -- target_os = "macos" -- )), -- allow(dead_code) --)] --const AIO: u8 = 0b0_100; --#[cfg_attr(not(target_os = "freebsd"), allow(dead_code))] --const LIO: u8 = 0b1_000; -+const AIO: u8 = 0b0100; -+const LIO: u8 = 0b1000; -+const PRIORITY: u8 = 0b10000; - - impl Interest { - /// Returns a `Interest` set representing readable interests. -@@ -45,7 +36,9 @@ impl Interest { - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - pub const AIO: Interest = Interest(unsafe { NonZeroU8::new_unchecked(AIO) }); - -@@ -53,6 +46,10 @@ impl Interest { - #[cfg(target_os = "freebsd")] - pub const LIO: Interest = Interest(unsafe { NonZeroU8::new_unchecked(LIO) }); - -+ /// Returns a `Interest` set representing priority completion interests. -+ #[cfg(any(target_os = "linux", target_os = "android"))] -+ pub const PRIORITY: Interest = Interest(unsafe { NonZeroU8::new_unchecked(PRIORITY) }); -+ - /// Add together two `Interest`. - /// - /// This does the same thing as the `BitOr` implementation, but is a -@@ -66,6 +63,7 @@ impl Interest { - /// # silent_dead_code_warning(INTERESTS) - /// ``` - #[allow(clippy::should_implement_trait)] -+ #[must_use = "this returns the result of the operation, without modifying the original"] - pub const fn add(self, other: Interest) -> Interest { - Interest(unsafe { NonZeroU8::new_unchecked(self.0.get() | other.0.get()) }) - } -@@ -90,29 +88,40 @@ impl Interest { - /// // Its also possible to remove multiple interests at once. - /// assert_eq!(RW_INTERESTS.remove(RW_INTERESTS), None); - /// ``` -+ #[must_use = "this returns the result of the operation, without modifying the original"] - pub fn remove(self, other: Interest) -> Option { - NonZeroU8::new(self.0.get() & !other.0.get()).map(Interest) - } - - /// Returns true if the value includes readable readiness. -+ #[must_use] - pub const fn is_readable(self) -> bool { - (self.0.get() & READABLE) != 0 - } - - /// Returns true if the value includes writable readiness. -+ #[must_use] - pub const fn is_writable(self) -> bool { - (self.0.get() & WRITABLE) != 0 - } - -- /// Returns true if `Interest` contains AIO readiness -+ /// Returns true if `Interest` contains AIO readiness. -+ #[must_use] - pub const fn is_aio(self) -> bool { - (self.0.get() & AIO) != 0 - } - -- /// Returns true if `Interest` contains LIO readiness -+ /// Returns true if `Interest` contains LIO readiness. -+ #[must_use] - pub const fn is_lio(self) -> bool { - (self.0.get() & LIO) != 0 - } -+ -+ /// Returns true if `Interest` contains priority readiness. -+ #[must_use] -+ pub const fn is_priority(self) -> bool { -+ (self.0.get() & PRIORITY) != 0 -+ } - } - - impl ops::BitOr for Interest { -@@ -152,7 +161,9 @@ impl fmt::Debug for Interest { - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - { - if self.is_aio() { -@@ -163,7 +174,7 @@ impl fmt::Debug for Interest { - one = true - } - } -- #[cfg(any(target_os = "freebsd"))] -+ #[cfg(target_os = "freebsd")] - { - if self.is_lio() { - if one { -@@ -173,6 +184,16 @@ impl fmt::Debug for Interest { - one = true - } - } -+ #[cfg(any(target_os = "linux", target_os = "android"))] -+ { -+ if self.is_priority() { -+ if one { -+ write!(fmt, " | ")? -+ } -+ write!(fmt, "PRIORITY")?; -+ one = true -+ } -+ } - debug_assert!(one, "printing empty interests"); - Ok(()) - } -diff --git a/KubeOS-Rust/vendor/mio/src/io_source.rs b/KubeOS-Rust/vendor/mio/src/io_source.rs -index 6939c0d0..06dc5e17 100644 ---- a/KubeOS-Rust/vendor/mio/src/io_source.rs -+++ b/KubeOS-Rust/vendor/mio/src/io_source.rs -@@ -1,14 +1,14 @@ - use std::ops::{Deref, DerefMut}; - #[cfg(unix)] - use std::os::unix::io::AsRawFd; -+#[cfg(target_os = "wasi")] -+use std::os::wasi::io::AsRawFd; - #[cfg(windows)] - use std::os::windows::io::AsRawSocket; - #[cfg(debug_assertions)] - use std::sync::atomic::{AtomicUsize, Ordering}; - use std::{fmt, io}; - --#[cfg(any(unix, debug_assertions))] --use crate::poll; - use crate::sys::IoSourceState; - use crate::{event, Interest, Registry, Token}; - -@@ -142,7 +142,8 @@ where - ) -> io::Result<()> { - #[cfg(debug_assertions)] - self.selector_id.associate(registry)?; -- poll::selector(registry).register(self.inner.as_raw_fd(), token, interests) -+ self.state -+ .register(registry, token, interests, self.inner.as_raw_fd()) - } - - fn reregister( -@@ -153,13 +154,14 @@ where - ) -> io::Result<()> { - #[cfg(debug_assertions)] - self.selector_id.check_association(registry)?; -- poll::selector(registry).reregister(self.inner.as_raw_fd(), token, interests) -+ self.state -+ .reregister(registry, token, interests, self.inner.as_raw_fd()) - } - - fn deregister(&mut self, registry: &Registry) -> io::Result<()> { - #[cfg(debug_assertions)] - self.selector_id.remove_association(registry)?; -- poll::selector(registry).deregister(self.inner.as_raw_fd()) -+ self.state.deregister(registry, self.inner.as_raw_fd()) - } - } - -@@ -198,6 +200,44 @@ where - } - } - -+#[cfg(target_os = "wasi")] -+impl event::Source for IoSource -+where -+ T: AsRawFd, -+{ -+ fn register( -+ &mut self, -+ registry: &Registry, -+ token: Token, -+ interests: Interest, -+ ) -> io::Result<()> { -+ #[cfg(debug_assertions)] -+ self.selector_id.associate(registry)?; -+ registry -+ .selector() -+ .register(self.inner.as_raw_fd() as _, token, interests) -+ } -+ -+ fn reregister( -+ &mut self, -+ registry: &Registry, -+ token: Token, -+ interests: Interest, -+ ) -> io::Result<()> { -+ #[cfg(debug_assertions)] -+ self.selector_id.check_association(registry)?; -+ registry -+ .selector() -+ .reregister(self.inner.as_raw_fd() as _, token, interests) -+ } -+ -+ fn deregister(&mut self, registry: &Registry) -> io::Result<()> { -+ #[cfg(debug_assertions)] -+ self.selector_id.remove_association(registry)?; -+ registry.selector().deregister(self.inner.as_raw_fd() as _) -+ } -+} -+ - impl fmt::Debug for IoSource - where - T: fmt::Debug, -@@ -230,7 +270,7 @@ impl SelectorId { - /// Associate an I/O source with `registry`, returning an error if its - /// already registered. - fn associate(&self, registry: &Registry) -> io::Result<()> { -- let registry_id = poll::selector(®istry).id(); -+ let registry_id = registry.selector().id(); - let previous_id = self.id.swap(registry_id, Ordering::AcqRel); - - if previous_id == Self::UNASSOCIATED { -@@ -247,7 +287,7 @@ impl SelectorId { - /// error if its registered with a different `Registry` or not registered at - /// all. - fn check_association(&self, registry: &Registry) -> io::Result<()> { -- let registry_id = poll::selector(®istry).id(); -+ let registry_id = registry.selector().id(); - let id = self.id.load(Ordering::Acquire); - - if id == registry_id { -@@ -268,7 +308,7 @@ impl SelectorId { - /// Remove a previously made association from `registry`, returns an error - /// if it was not previously associated with `registry`. - fn remove_association(&self, registry: &Registry) -> io::Result<()> { -- let registry_id = poll::selector(®istry).id(); -+ let registry_id = registry.selector().id(); - let previous_id = self.id.swap(Self::UNASSOCIATED, Ordering::AcqRel); - - if previous_id == registry_id { -diff --git a/KubeOS-Rust/vendor/mio/src/lib.rs b/KubeOS-Rust/vendor/mio/src/lib.rs -index 1ad8495d..56a7160b 100644 ---- a/KubeOS-Rust/vendor/mio/src/lib.rs -+++ b/KubeOS-Rust/vendor/mio/src/lib.rs -@@ -1,4 +1,3 @@ --#![doc(html_root_url = "https://docs.rs/mio/0.7.14")] - #![deny( - missing_docs, - missing_debug_implementations, -@@ -49,6 +48,7 @@ mod interest; - mod poll; - mod sys; - mod token; -+#[cfg(not(target_os = "wasi"))] - mod waker; - - pub mod event; -@@ -66,6 +66,7 @@ pub use event::Events; - pub use interest::Interest; - pub use poll::{Poll, Registry}; - pub use token::Token; -+#[cfg(not(target_os = "wasi"))] - pub use waker::Waker; - - #[cfg(all(unix, feature = "os-ext"))] -@@ -100,7 +101,7 @@ pub mod features { - #![cfg_attr(feature = "os-poll", doc = "## `os-poll` (enabled)")] - #![cfg_attr(not(feature = "os-poll"), doc = "## `os-poll` (disabled)")] - //! -- //! Mio by default provides only a shell implementation, that `panic!`s the -+ //! Mio by default provides only a shell implementation that `panic!`s the - //! moment it is actually run. To run it requires OS support, this is - //! enabled by activating the `os-poll` feature. - //! -@@ -174,8 +175,8 @@ pub mod guide { - //! - //! [event source]: ../event/trait.Source.html - //! -- #![cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] -- #![cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+ #![cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+ #![cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - //! # use mio::net::TcpListener; - //! # use mio::{Poll, Token, Interest}; - //! # fn main() -> std::io::Result<()> { -@@ -213,8 +214,8 @@ pub mod guide { - //! [poll]: ../struct.Poll.html#method.poll - //! [event sources]: ../event/trait.Source.html - //! -- #![cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] -- #![cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+ #![cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+ #![cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - //! # use std::io; - //! # use std::time::Duration; - //! # use mio::net::TcpListener; -diff --git a/KubeOS-Rust/vendor/mio/src/macros.rs b/KubeOS-Rust/vendor/mio/src/macros.rs -index f97f9091..e380c6b1 100644 ---- a/KubeOS-Rust/vendor/mio/src/macros.rs -+++ b/KubeOS-Rust/vendor/mio/src/macros.rs -@@ -68,3 +68,31 @@ macro_rules! cfg_any_os_ext { - )* - } - } -+ -+macro_rules! trace { -+ ($($t:tt)*) => { -+ log!(trace, $($t)*) -+ } -+} -+ -+macro_rules! warn { -+ ($($t:tt)*) => { -+ log!(warn, $($t)*) -+ } -+} -+ -+macro_rules! error { -+ ($($t:tt)*) => { -+ log!(error, $($t)*) -+ } -+} -+ -+macro_rules! log { -+ ($level: ident, $($t:tt)*) => { -+ #[cfg(feature = "log")] -+ { log::$level!($($t)*) } -+ // Silence unused variables warnings. -+ #[cfg(not(feature = "log"))] -+ { if false { let _ = ( $($t)* ); } } -+ } -+} -diff --git a/KubeOS-Rust/vendor/mio/src/net/mod.rs b/KubeOS-Rust/vendor/mio/src/net/mod.rs -index 4df701d4..7d714ca0 100644 ---- a/KubeOS-Rust/vendor/mio/src/net/mod.rs -+++ b/KubeOS-Rust/vendor/mio/src/net/mod.rs -@@ -6,11 +6,31 @@ - //! matter the target platform. - //! - //! [portability guidelines]: ../struct.Poll.html#portability -+//! -+//! # Notes -+//! -+//! When using a datagram based socket, i.e. [`UdpSocket`] or [`UnixDatagram`], -+//! its only possible to receive a packet once. This means that if you provide a -+//! buffer that is too small you won't be able to receive the data anymore. How -+//! OSs deal with this situation is different for each OS: -+//! * Unixes, such as Linux, FreeBSD and macOS, will simply fill the buffer and -+//! return the amount of bytes written. This means that if the returned value -+//! is equal to the size of the buffer it may have only written a part of the -+//! packet (or the packet has the same size as the buffer). -+//! * Windows returns an `WSAEMSGSIZE` error. -+//! -+//! Mio does not change the value (either ok or error) returned by the OS, it's -+//! up to the user handle this. How to deal with these difference is still up -+//! for debate, specifically in -+//! . The best advice we can -+//! give is to always call receive with a large enough buffer. - - mod tcp; --pub use self::tcp::{TcpListener, TcpSocket, TcpStream, TcpKeepalive}; -+pub use self::tcp::{TcpListener, TcpStream}; - -+#[cfg(not(target_os = "wasi"))] - mod udp; -+#[cfg(not(target_os = "wasi"))] - pub use self::udp::UdpSocket; - - #[cfg(unix)] -diff --git a/KubeOS-Rust/vendor/mio/src/net/tcp/listener.rs b/KubeOS-Rust/vendor/mio/src/net/tcp/listener.rs -index da276f3b..df51d57a 100644 ---- a/KubeOS-Rust/vendor/mio/src/net/tcp/listener.rs -+++ b/KubeOS-Rust/vendor/mio/src/net/tcp/listener.rs -@@ -1,12 +1,18 @@ - use std::net::{self, SocketAddr}; - #[cfg(unix)] - use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; -+#[cfg(target_os = "wasi")] -+use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; - #[cfg(windows)] - use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket}; - use std::{fmt, io}; - --use super::{TcpSocket, TcpStream}; - use crate::io_source::IoSource; -+use crate::net::TcpStream; -+#[cfg(unix)] -+use crate::sys::tcp::set_reuseaddr; -+#[cfg(not(target_os = "wasi"))] -+use crate::sys::tcp::{bind, listen, new_for_addr}; - use crate::{event, sys, Interest, Registry, Token}; - - /// A structure representing a socket server -@@ -49,8 +55,13 @@ impl TcpListener { - /// 2. Set the `SO_REUSEADDR` option on the socket on Unix. - /// 3. Bind the socket to the specified address. - /// 4. Calls `listen` on the socket to prepare it to receive new connections. -+ #[cfg(not(target_os = "wasi"))] - pub fn bind(addr: SocketAddr) -> io::Result { -- let socket = TcpSocket::new_for_addr(addr)?; -+ let socket = new_for_addr(addr)?; -+ #[cfg(unix)] -+ let listener = unsafe { TcpListener::from_raw_fd(socket) }; -+ #[cfg(windows)] -+ let listener = unsafe { TcpListener::from_raw_socket(socket as _) }; - - // On platforms with Berkeley-derived sockets, this allows to quickly - // rebind a socket, without needing to wait for the OS to clean up the -@@ -60,10 +71,11 @@ impl TcpListener { - // which allows “socket hijacking”, so we explicitly don't set it here. - // https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse - #[cfg(not(windows))] -- socket.set_reuseaddr(true)?; -+ set_reuseaddr(&listener.inner, true)?; - -- socket.bind(addr)?; -- socket.listen(1024) -+ bind(&listener.inner, addr)?; -+ listen(&listener.inner, 1024)?; -+ Ok(listener) - } - - /// Creates a new `TcpListener` from a standard `net::TcpListener`. -@@ -207,3 +219,30 @@ impl FromRawSocket for TcpListener { - TcpListener::from_std(FromRawSocket::from_raw_socket(socket)) - } - } -+ -+#[cfg(target_os = "wasi")] -+impl IntoRawFd for TcpListener { -+ fn into_raw_fd(self) -> RawFd { -+ self.inner.into_inner().into_raw_fd() -+ } -+} -+ -+#[cfg(target_os = "wasi")] -+impl AsRawFd for TcpListener { -+ fn as_raw_fd(&self) -> RawFd { -+ self.inner.as_raw_fd() -+ } -+} -+ -+#[cfg(target_os = "wasi")] -+impl FromRawFd for TcpListener { -+ /// Converts a `RawFd` to a `TcpListener`. -+ /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the socket is in -+ /// non-blocking mode. -+ unsafe fn from_raw_fd(fd: RawFd) -> TcpListener { -+ TcpListener::from_std(FromRawFd::from_raw_fd(fd)) -+ } -+} -diff --git a/KubeOS-Rust/vendor/mio/src/net/tcp/mod.rs b/KubeOS-Rust/vendor/mio/src/net/tcp/mod.rs -index 4e47aeed..94af5c10 100644 ---- a/KubeOS-Rust/vendor/mio/src/net/tcp/mod.rs -+++ b/KubeOS-Rust/vendor/mio/src/net/tcp/mod.rs -@@ -1,8 +1,5 @@ - mod listener; - pub use self::listener::TcpListener; - --mod socket; --pub use self::socket::{TcpSocket, TcpKeepalive}; -- - mod stream; - pub use self::stream::TcpStream; -diff --git a/KubeOS-Rust/vendor/mio/src/net/tcp/socket.rs b/KubeOS-Rust/vendor/mio/src/net/tcp/socket.rs -deleted file mode 100644 -index 69fbacf6..00000000 ---- a/KubeOS-Rust/vendor/mio/src/net/tcp/socket.rs -+++ /dev/null -@@ -1,490 +0,0 @@ --use std::io; --use std::mem; --use std::net::SocketAddr; --#[cfg(unix)] --use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; --#[cfg(windows)] --use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket}; --use std::time::Duration; -- --use crate::net::{TcpListener, TcpStream}; --use crate::sys; -- --/// A non-blocking TCP socket used to configure a stream or listener. --/// --/// The `TcpSocket` type wraps the operating-system's socket handle. This type --/// is used to configure the socket before establishing a connection or start --/// listening for inbound connections. --/// --/// The socket will be closed when the value is dropped. --#[derive(Debug)] --pub struct TcpSocket { -- sys: sys::tcp::TcpSocket, --} -- --/// Configures a socket's TCP keepalive parameters. --#[derive(Debug, Default, Clone)] --pub struct TcpKeepalive { -- pub(crate) time: Option, -- #[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- target_os = "windows", -- ))] -- pub(crate) interval: Option, -- #[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- ))] -- pub(crate) retries: Option, --} -- --impl TcpSocket { -- /// Create a new IPv4 TCP socket. -- /// -- /// This calls `socket(2)`. -- pub fn new_v4() -> io::Result { -- sys::tcp::new_v4_socket().map(|sys| TcpSocket { sys }) -- } -- -- /// Create a new IPv6 TCP socket. -- /// -- /// This calls `socket(2)`. -- pub fn new_v6() -> io::Result { -- sys::tcp::new_v6_socket().map(|sys| TcpSocket { sys }) -- } -- -- pub(crate) fn new_for_addr(addr: SocketAddr) -> io::Result { -- if addr.is_ipv4() { -- TcpSocket::new_v4() -- } else { -- TcpSocket::new_v6() -- } -- } -- -- /// Bind `addr` to the TCP socket. -- pub fn bind(&self, addr: SocketAddr) -> io::Result<()> { -- sys::tcp::bind(self.sys, addr) -- } -- -- /// Connect the socket to `addr`. -- /// -- /// This consumes the socket and performs the connect operation. Once the -- /// connection completes, the socket is now a non-blocking `TcpStream` and -- /// can be used as such. -- pub fn connect(self, addr: SocketAddr) -> io::Result { -- let stream = sys::tcp::connect(self.sys, addr)?; -- -- // Don't close the socket -- mem::forget(self); -- Ok(TcpStream::from_std(stream)) -- } -- -- /// Listen for inbound connections, converting the socket to a -- /// `TcpListener`. -- pub fn listen(self, backlog: u32) -> io::Result { -- let listener = sys::tcp::listen(self.sys, backlog)?; -- -- // Don't close the socket -- mem::forget(self); -- Ok(TcpListener::from_std(listener)) -- } -- -- /// Sets the value of `SO_REUSEADDR` on this socket. -- pub fn set_reuseaddr(&self, reuseaddr: bool) -> io::Result<()> { -- sys::tcp::set_reuseaddr(self.sys, reuseaddr) -- } -- -- /// Get the value of `SO_REUSEADDR` set on this socket. -- pub fn get_reuseaddr(&self) -> io::Result { -- sys::tcp::get_reuseaddr(self.sys) -- } -- -- /// Sets the value of `SO_REUSEPORT` on this socket. -- /// Only supported available in unix -- #[cfg(all(unix, not(any(target_os = "solaris", target_os = "illumos"))))] -- pub fn set_reuseport(&self, reuseport: bool) -> io::Result<()> { -- sys::tcp::set_reuseport(self.sys, reuseport) -- } -- -- /// Get the value of `SO_REUSEPORT` set on this socket. -- /// Only supported available in unix -- #[cfg(all(unix, not(any(target_os = "solaris", target_os = "illumos"))))] -- pub fn get_reuseport(&self) -> io::Result { -- sys::tcp::get_reuseport(self.sys) -- } -- -- /// Sets the value of `SO_LINGER` on this socket. -- pub fn set_linger(&self, dur: Option) -> io::Result<()> { -- sys::tcp::set_linger(self.sys, dur) -- } -- -- /// Gets the value of `SO_LINGER` on this socket -- pub fn get_linger(&self) -> io::Result> { -- sys::tcp::get_linger(self.sys) -- } -- -- /// Sets the value of `SO_RCVBUF` on this socket. -- pub fn set_recv_buffer_size(&self, size: u32) -> io::Result<()> { -- sys::tcp::set_recv_buffer_size(self.sys, size) -- } -- -- /// Get the value of `SO_RCVBUF` set on this socket. -- /// -- /// Note that if [`set_recv_buffer_size`] has been called on this socket -- /// previously, the value returned by this function may not be the same as -- /// the argument provided to `set_recv_buffer_size`. This is for the -- /// following reasons: -- /// -- /// * Most operating systems have minimum and maximum allowed sizes for the -- /// receive buffer, and will clamp the provided value if it is below the -- /// minimum or above the maximum. The minimum and maximum buffer sizes are -- /// OS-dependent. -- /// * Linux will double the buffer size to account for internal bookkeeping -- /// data, and returns the doubled value from `getsockopt(2)`. As per `man -- /// 7 socket`: -- /// > Sets or gets the maximum socket receive buffer in bytes. The -- /// > kernel doubles this value (to allow space for bookkeeping -- /// > overhead) when it is set using `setsockopt(2)`, and this doubled -- /// > value is returned by `getsockopt(2)`. -- /// -- /// [`set_recv_buffer_size`]: #method.set_recv_buffer_size -- pub fn get_recv_buffer_size(&self) -> io::Result { -- sys::tcp::get_recv_buffer_size(self.sys) -- } -- -- /// Sets the value of `SO_SNDBUF` on this socket. -- pub fn set_send_buffer_size(&self, size: u32) -> io::Result<()> { -- sys::tcp::set_send_buffer_size(self.sys, size) -- } -- -- /// Get the value of `SO_SNDBUF` set on this socket. -- /// -- /// Note that if [`set_send_buffer_size`] has been called on this socket -- /// previously, the value returned by this function may not be the same as -- /// the argument provided to `set_send_buffer_size`. This is for the -- /// following reasons: -- /// -- /// * Most operating systems have minimum and maximum allowed sizes for the -- /// receive buffer, and will clamp the provided value if it is below the -- /// minimum or above the maximum. The minimum and maximum buffer sizes are -- /// OS-dependent. -- /// * Linux will double the buffer size to account for internal bookkeeping -- /// data, and returns the doubled value from `getsockopt(2)`. As per `man -- /// 7 socket`: -- /// > Sets or gets the maximum socket send buffer in bytes. The -- /// > kernel doubles this value (to allow space for bookkeeping -- /// > overhead) when it is set using `setsockopt(2)`, and this doubled -- /// > value is returned by `getsockopt(2)`. -- /// -- /// [`set_send_buffer_size`]: #method.set_send_buffer_size -- pub fn get_send_buffer_size(&self) -> io::Result { -- sys::tcp::get_send_buffer_size(self.sys) -- } -- -- /// Sets whether keepalive messages are enabled to be sent on this socket. -- /// -- /// This will set the `SO_KEEPALIVE` option on this socket. -- pub fn set_keepalive(&self, keepalive: bool) -> io::Result<()> { -- sys::tcp::set_keepalive(self.sys, keepalive) -- } -- -- /// Returns whether or not TCP keepalive probes will be sent by this socket. -- pub fn get_keepalive(&self) -> io::Result { -- sys::tcp::get_keepalive(self.sys) -- } -- -- /// Sets parameters configuring TCP keepalive probes for this socket. -- /// -- /// The supported parameters depend on the operating system, and are -- /// configured using the [`TcpKeepalive`] struct. At a minimum, all systems -- /// support configuring the [keepalive time]: the time after which the OS -- /// will start sending keepalive messages on an idle connection. -- /// -- /// # Notes -- /// -- /// * This will enable TCP keepalive on this socket, if it is not already -- /// enabled. -- /// * On some platforms, such as Windows, any keepalive parameters *not* -- /// configured by the `TcpKeepalive` struct passed to this function may be -- /// overwritten with their default values. Therefore, this function should -- /// either only be called once per socket, or the same parameters should -- /// be passed every time it is called. -- /// -- /// # Examples -- #[cfg_attr(feature = "os-poll", doc = "```")] -- #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] -- /// use mio::net::{TcpSocket, TcpKeepalive}; -- /// use std::time::Duration; -- /// -- /// # fn main() -> Result<(), std::io::Error> { -- /// let socket = TcpSocket::new_v6()?; -- /// let keepalive = TcpKeepalive::default() -- /// .with_time(Duration::from_secs(4)); -- /// // Depending on the target operating system, we may also be able to -- /// // configure the keepalive probe interval and/or the number of retries -- /// // here as well. -- /// -- /// socket.set_keepalive_params(keepalive)?; -- /// # Ok(()) } -- /// ``` -- /// -- /// [`TcpKeepalive`]: ../struct.TcpKeepalive.html -- /// [keepalive time]: ../struct.TcpKeepalive.html#method.with_time -- pub fn set_keepalive_params(&self, keepalive: TcpKeepalive) -> io::Result<()> { -- self.set_keepalive(true)?; -- sys::tcp::set_keepalive_params(self.sys, keepalive) -- } -- -- /// Returns the amount of time after which TCP keepalive probes will be sent -- /// on idle connections. -- /// -- /// If `None`, then keepalive messages are disabled. -- /// -- /// This returns the value of `SO_KEEPALIVE` + `IPPROTO_TCP` on OpenBSD, -- /// NetBSD, and Haiku, `TCP_KEEPALIVE` on macOS and iOS, and `TCP_KEEPIDLE` -- /// on all other Unix operating systems. On Windows, it is not possible to -- /// access the value of TCP keepalive parameters after they have been set. -- /// -- /// Some platforms specify this value in seconds, so sub-second -- /// specifications may be omitted. -- #[cfg_attr(docsrs, doc(cfg(not(target_os = "windows"))))] -- #[cfg(not(target_os = "windows"))] -- pub fn get_keepalive_time(&self) -> io::Result> { -- sys::tcp::get_keepalive_time(self.sys) -- } -- -- /// Returns the time interval between TCP keepalive probes, if TCP keepalive is -- /// enabled on this socket. -- /// -- /// If `None`, then keepalive messages are disabled. -- /// -- /// This returns the value of `TCP_KEEPINTVL` on supported Unix operating -- /// systems. On Windows, it is not possible to access the value of TCP -- /// keepalive parameters after they have been set.. -- /// -- /// Some platforms specify this value in seconds, so sub-second -- /// specifications may be omitted. -- #[cfg_attr( -- docsrs, -- doc(cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- ))) -- )] -- #[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- ))] -- pub fn get_keepalive_interval(&self) -> io::Result> { -- sys::tcp::get_keepalive_interval(self.sys) -- } -- -- /// Returns the maximum number of TCP keepalive probes that will be sent before -- /// dropping a connection, if TCP keepalive is enabled on this socket. -- /// -- /// If `None`, then keepalive messages are disabled. -- /// -- /// This returns the value of `TCP_KEEPCNT` on Unix operating systems that -- /// support this option. On Windows, it is not possible to access the value -- /// of TCP keepalive parameters after they have been set. -- #[cfg_attr( -- docsrs, -- doc(cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- ))) -- )] -- #[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- ))] -- pub fn get_keepalive_retries(&self) -> io::Result> { -- sys::tcp::get_keepalive_retries(self.sys) -- } -- -- /// Returns the local address of this socket -- /// -- /// Will return `Err` result in windows if called before calling `bind` -- pub fn get_localaddr(&self) -> io::Result { -- sys::tcp::get_localaddr(self.sys) -- } --} -- --impl Drop for TcpSocket { -- fn drop(&mut self) { -- sys::tcp::close(self.sys); -- } --} -- --#[cfg(unix)] --impl IntoRawFd for TcpSocket { -- fn into_raw_fd(self) -> RawFd { -- let ret = self.sys; -- // Avoid closing the socket -- mem::forget(self); -- ret -- } --} -- --#[cfg(unix)] --impl AsRawFd for TcpSocket { -- fn as_raw_fd(&self) -> RawFd { -- self.sys -- } --} -- --#[cfg(unix)] --impl FromRawFd for TcpSocket { -- /// Converts a `RawFd` to a `TcpSocket`. -- /// -- /// # Notes -- /// -- /// The caller is responsible for ensuring that the socket is in -- /// non-blocking mode. -- unsafe fn from_raw_fd(fd: RawFd) -> TcpSocket { -- TcpSocket { sys: fd } -- } --} -- --#[cfg(windows)] --impl IntoRawSocket for TcpSocket { -- fn into_raw_socket(self) -> RawSocket { -- // The winapi crate defines `SOCKET` as `usize`. The Rust std -- // conditionally defines `RawSocket` as a fixed size unsigned integer -- // matching the pointer width. These end up being the same type but we -- // must cast between them. -- let ret = self.sys as RawSocket; -- -- // Avoid closing the socket -- mem::forget(self); -- -- ret -- } --} -- --#[cfg(windows)] --impl AsRawSocket for TcpSocket { -- fn as_raw_socket(&self) -> RawSocket { -- self.sys as RawSocket -- } --} -- --#[cfg(windows)] --impl FromRawSocket for TcpSocket { -- /// Converts a `RawSocket` to a `TcpSocket`. -- /// -- /// # Notes -- /// -- /// The caller is responsible for ensuring that the socket is in -- /// non-blocking mode. -- unsafe fn from_raw_socket(socket: RawSocket) -> TcpSocket { -- TcpSocket { -- sys: socket as sys::tcp::TcpSocket, -- } -- } --} -- --impl TcpKeepalive { -- // Sets the amount of time after which TCP keepalive probes will be sent -- /// on idle connections. -- /// -- /// This will set the value of `SO_KEEPALIVE` + `IPPROTO_TCP` on OpenBSD, -- /// NetBSD, and Haiku, `TCP_KEEPALIVE` on macOS and iOS, and `TCP_KEEPIDLE` -- /// on all other Unix operating systems. On Windows, this sets the value of -- /// the `tcp_keepalive` struct's `keepalivetime` field. -- /// -- /// Some platforms specify this value in seconds, so sub-second -- /// specifications may be omitted. -- pub fn with_time(self, time: Duration) -> Self { -- Self { -- time: Some(time), -- ..self -- } -- } -- -- /// Sets the time interval between TCP keepalive probes. -- /// This sets the value of `TCP_KEEPINTVL` on supported Unix operating -- /// systems. On Windows, this sets the value of the `tcp_keepalive` struct's -- /// `keepaliveinterval` field. -- /// -- /// Some platforms specify this value in seconds, so sub-second -- /// specifications may be omitted. -- #[cfg_attr( -- docsrs, -- doc(cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- target_os = "windows" -- ))) -- )] -- #[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- target_os = "windows" -- ))] -- pub fn with_interval(self, interval: Duration) -> Self { -- Self { -- interval: Some(interval), -- ..self -- } -- } -- -- /// Sets the maximum number of TCP keepalive probes that will be sent before -- /// dropping a connection, if TCP keepalive is enabled on this socket. -- /// -- /// This will set the value of `TCP_KEEPCNT` on Unix operating systems that -- /// support this option. -- #[cfg_attr( -- docsrs, -- doc(cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- ))) -- )] -- #[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- ))] -- pub fn with_retries(self, retries: u32) -> Self { -- Self { -- retries: Some(retries), -- ..self -- } -- } -- -- /// Returns a new, empty set of TCP keepalive parameters. -- pub fn new() -> Self { -- Self::default() -- } --} -diff --git a/KubeOS-Rust/vendor/mio/src/net/tcp/stream.rs b/KubeOS-Rust/vendor/mio/src/net/tcp/stream.rs -index cdbd46a4..8a3f6a2f 100644 ---- a/KubeOS-Rust/vendor/mio/src/net/tcp/stream.rs -+++ b/KubeOS-Rust/vendor/mio/src/net/tcp/stream.rs -@@ -3,11 +3,14 @@ use std::io::{self, IoSlice, IoSliceMut, Read, Write}; - use std::net::{self, Shutdown, SocketAddr}; - #[cfg(unix)] - use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; -+#[cfg(target_os = "wasi")] -+use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; - #[cfg(windows)] - use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket}; - - use crate::io_source::IoSource; --use crate::net::TcpSocket; -+#[cfg(not(target_os = "wasi"))] -+use crate::sys::tcp::{connect, new_for_addr}; - use crate::{event, Interest, Registry, Token}; - - /// A non-blocking TCP stream between a local socket and a remote socket. -@@ -49,9 +52,43 @@ pub struct TcpStream { - impl TcpStream { - /// Create a new TCP stream and issue a non-blocking connect to the - /// specified address. -+ /// -+ /// # Notes -+ /// -+ /// The returned `TcpStream` may not be connected (and thus usable), unlike -+ /// the API found in `std::net::TcpStream`. Because Mio issues a -+ /// *non-blocking* connect it will not block the thread and instead return -+ /// an unconnected `TcpStream`. -+ /// -+ /// Ensuring the returned stream is connected is surprisingly complex when -+ /// considering cross-platform support. Doing this properly should follow -+ /// the steps below, an example implementation can be found -+ /// [here](https://github.com/Thomasdezeeuw/heph/blob/0c4f1ab3eaf08bea1d65776528bfd6114c9f8374/src/net/tcp/stream.rs#L560-L622). -+ /// -+ /// 1. Call `TcpStream::connect` -+ /// 2. Register the returned stream with at least [write interest]. -+ /// 3. Wait for a (writable) event. -+ /// 4. Check `TcpStream::peer_addr`. If it returns `libc::EINPROGRESS` or -+ /// `ErrorKind::NotConnected` it means the stream is not yet connected, -+ /// go back to step 3. If it returns an address it means the stream is -+ /// connected, go to step 5. If another error is returned something -+ /// went wrong. -+ /// 5. Now the stream can be used. -+ /// -+ /// This may return a `WouldBlock` in which case the socket connection -+ /// cannot be completed immediately, it usually means there are insufficient -+ /// entries in the routing cache. -+ /// -+ /// [write interest]: Interest::WRITABLE -+ #[cfg(not(target_os = "wasi"))] - pub fn connect(addr: SocketAddr) -> io::Result { -- let socket = TcpSocket::new_for_addr(addr)?; -- socket.connect(addr) -+ let socket = new_for_addr(addr)?; -+ #[cfg(unix)] -+ let stream = unsafe { TcpStream::from_raw_fd(socket) }; -+ #[cfg(windows)] -+ let stream = unsafe { TcpStream::from_raw_socket(socket as _) }; -+ connect(&stream.inner, addr)?; -+ Ok(stream) - } - - /// Creates a new `TcpStream` from a standard `net::TcpStream`. -@@ -103,7 +140,7 @@ impl TcpStream { - /// - /// On Windows make sure the stream is connected before calling this method, - /// by receiving an (writable) event. Trying to set `nodelay` on an -- /// unconnected `TcpStream` is undefined behavior. -+ /// unconnected `TcpStream` is unspecified behavior. - pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> { - self.inner.set_nodelay(nodelay) - } -@@ -118,7 +155,7 @@ impl TcpStream { - /// - /// On Windows make sure the stream is connected before calling this method, - /// by receiving an (writable) event. Trying to get `nodelay` on an -- /// unconnected `TcpStream` is undefined behavior. -+ /// unconnected `TcpStream` is unspecified behavior. - pub fn nodelay(&self) -> io::Result { - self.inner.nodelay() - } -@@ -132,7 +169,7 @@ impl TcpStream { - /// - /// On Windows make sure the stream is connected before calling this method, - /// by receiving an (writable) event. Trying to set `ttl` on an -- /// unconnected `TcpStream` is undefined behavior. -+ /// unconnected `TcpStream` is unspecified behavior. - pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { - self.inner.set_ttl(ttl) - } -@@ -145,7 +182,7 @@ impl TcpStream { - /// - /// On Windows make sure the stream is connected before calling this method, - /// by receiving an (writable) event. Trying to get `ttl` on an -- /// unconnected `TcpStream` is undefined behavior. -+ /// unconnected `TcpStream` is unspecified behavior. - /// - /// [link]: #method.set_ttl - pub fn ttl(&self) -> io::Result { -@@ -170,53 +207,111 @@ impl TcpStream { - pub fn peek(&self, buf: &mut [u8]) -> io::Result { - self.inner.peek(buf) - } -+ -+ /// Execute an I/O operation ensuring that the socket receives more events -+ /// if it hits a [`WouldBlock`] error. -+ /// -+ /// # Notes -+ /// -+ /// This method is required to be called for **all** I/O operations to -+ /// ensure the user will receive events once the socket is ready again after -+ /// returning a [`WouldBlock`] error. -+ /// -+ /// [`WouldBlock`]: io::ErrorKind::WouldBlock -+ /// -+ /// # Examples -+ /// -+ #[cfg_attr(unix, doc = "```no_run")] -+ #[cfg_attr(windows, doc = "```ignore")] -+ /// # use std::error::Error; -+ /// # -+ /// # fn main() -> Result<(), Box> { -+ /// use std::io; -+ /// #[cfg(unix)] -+ /// use std::os::unix::io::AsRawFd; -+ /// #[cfg(windows)] -+ /// use std::os::windows::io::AsRawSocket; -+ /// use mio::net::TcpStream; -+ /// -+ /// let address = "127.0.0.1:8080".parse().unwrap(); -+ /// let stream = TcpStream::connect(address)?; -+ /// -+ /// // Wait until the stream is readable... -+ /// -+ /// // Read from the stream using a direct libc call, of course the -+ /// // `io::Read` implementation would be easier to use. -+ /// let mut buf = [0; 512]; -+ /// let n = stream.try_io(|| { -+ /// let buf_ptr = &mut buf as *mut _ as *mut _; -+ /// #[cfg(unix)] -+ /// let res = unsafe { libc::recv(stream.as_raw_fd(), buf_ptr, buf.len(), 0) }; -+ /// #[cfg(windows)] -+ /// let res = unsafe { libc::recvfrom(stream.as_raw_socket() as usize, buf_ptr, buf.len() as i32, 0, std::ptr::null_mut(), std::ptr::null_mut()) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::recv, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("read {} bytes", n); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn try_io(&self, f: F) -> io::Result -+ where -+ F: FnOnce() -> io::Result, -+ { -+ self.inner.do_io(|_| f()) -+ } - } - - impl Read for TcpStream { - fn read(&mut self, buf: &mut [u8]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).read(buf)) -+ self.inner.do_io(|mut inner| inner.read(buf)) - } - - fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).read_vectored(bufs)) -+ self.inner.do_io(|mut inner| inner.read_vectored(bufs)) - } - } - - impl<'a> Read for &'a TcpStream { - fn read(&mut self, buf: &mut [u8]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).read(buf)) -+ self.inner.do_io(|mut inner| inner.read(buf)) - } - - fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).read_vectored(bufs)) -+ self.inner.do_io(|mut inner| inner.read_vectored(bufs)) - } - } - - impl Write for TcpStream { - fn write(&mut self, buf: &[u8]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).write(buf)) -+ self.inner.do_io(|mut inner| inner.write(buf)) - } - - fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).write_vectored(bufs)) -+ self.inner.do_io(|mut inner| inner.write_vectored(bufs)) - } - - fn flush(&mut self) -> io::Result<()> { -- self.inner.do_io(|inner| (&*inner).flush()) -+ self.inner.do_io(|mut inner| inner.flush()) - } - } - - impl<'a> Write for &'a TcpStream { - fn write(&mut self, buf: &[u8]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).write(buf)) -+ self.inner.do_io(|mut inner| inner.write(buf)) - } - - fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).write_vectored(bufs)) -+ self.inner.do_io(|mut inner| inner.write_vectored(bufs)) - } - - fn flush(&mut self) -> io::Result<()> { -- self.inner.do_io(|inner| (&*inner).flush()) -+ self.inner.do_io(|mut inner| inner.flush()) - } - } - -@@ -303,3 +398,30 @@ impl FromRawSocket for TcpStream { - TcpStream::from_std(FromRawSocket::from_raw_socket(socket)) - } - } -+ -+#[cfg(target_os = "wasi")] -+impl IntoRawFd for TcpStream { -+ fn into_raw_fd(self) -> RawFd { -+ self.inner.into_inner().into_raw_fd() -+ } -+} -+ -+#[cfg(target_os = "wasi")] -+impl AsRawFd for TcpStream { -+ fn as_raw_fd(&self) -> RawFd { -+ self.inner.as_raw_fd() -+ } -+} -+ -+#[cfg(target_os = "wasi")] -+impl FromRawFd for TcpStream { -+ /// Converts a `RawFd` to a `TcpStream`. -+ /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the socket is in -+ /// non-blocking mode. -+ unsafe fn from_raw_fd(fd: RawFd) -> TcpStream { -+ TcpStream::from_std(FromRawFd::from_raw_fd(fd)) -+ } -+} -diff --git a/KubeOS-Rust/vendor/mio/src/net/udp.rs b/KubeOS-Rust/vendor/mio/src/net/udp.rs -index c5c3ba92..6129527a 100644 ---- a/KubeOS-Rust/vendor/mio/src/net/udp.rs -+++ b/KubeOS-Rust/vendor/mio/src/net/udp.rs -@@ -79,7 +79,7 @@ use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket} - /// let num_recv = echoer_socket.recv(&mut buffer)?; - /// println!("echo {:?} -> {:?}", buffer, num_recv); - /// buffer = [0; 9]; --/// # drop(buffer); // Silence unused assignment warning. -+/// # _ = buffer; // Silence unused assignment warning. - /// # return Ok(()); - /// } - /// _ => unreachable!() -@@ -161,6 +161,29 @@ impl UdpSocket { - self.inner.local_addr() - } - -+ /// Returns the socket address of the remote peer this socket was connected to. -+ /// -+ /// # Examples -+ /// -+ #[cfg_attr(feature = "os-poll", doc = "```")] -+ #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] -+ /// # use std::error::Error; -+ /// # -+ /// # fn main() -> Result<(), Box> { -+ /// use mio::net::UdpSocket; -+ /// -+ /// let addr = "127.0.0.1:0".parse()?; -+ /// let peer_addr = "127.0.0.1:11100".parse()?; -+ /// let socket = UdpSocket::bind(addr)?; -+ /// socket.connect(peer_addr)?; -+ /// assert_eq!(socket.peer_addr()?.ip(), peer_addr.ip()); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn peer_addr(&self) -> io::Result { -+ self.inner.peer_addr() -+ } -+ - /// Sends data on the socket to the given address. On success, returns the - /// number of bytes written. - /// -@@ -297,6 +320,10 @@ impl UdpSocket { - /// Connects the UDP socket setting the default destination for `send()` - /// and limiting packets that are read via `recv` from the address specified - /// in `addr`. -+ /// -+ /// This may return a `WouldBlock` in which case the socket connection -+ /// cannot be completed immediately, it usually means there are insufficient -+ /// entries in the routing cache. - pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { - self.inner.connect(addr) - } -@@ -525,6 +552,64 @@ impl UdpSocket { - pub fn take_error(&self) -> io::Result> { - self.inner.take_error() - } -+ -+ /// Execute an I/O operation ensuring that the socket receives more events -+ /// if it hits a [`WouldBlock`] error. -+ /// -+ /// # Notes -+ /// -+ /// This method is required to be called for **all** I/O operations to -+ /// ensure the user will receive events once the socket is ready again after -+ /// returning a [`WouldBlock`] error. -+ /// -+ /// [`WouldBlock`]: io::ErrorKind::WouldBlock -+ /// -+ /// # Examples -+ /// -+ #[cfg_attr(unix, doc = "```no_run")] -+ #[cfg_attr(windows, doc = "```ignore")] -+ /// # use std::error::Error; -+ /// # -+ /// # fn main() -> Result<(), Box> { -+ /// use std::io; -+ /// #[cfg(unix)] -+ /// use std::os::unix::io::AsRawFd; -+ /// #[cfg(windows)] -+ /// use std::os::windows::io::AsRawSocket; -+ /// use mio::net::UdpSocket; -+ /// -+ /// let address = "127.0.0.1:8080".parse().unwrap(); -+ /// let dgram = UdpSocket::bind(address)?; -+ /// -+ /// // Wait until the dgram is readable... -+ /// -+ /// // Read from the dgram using a direct libc call, of course the -+ /// // `io::Read` implementation would be easier to use. -+ /// let mut buf = [0; 512]; -+ /// let n = dgram.try_io(|| { -+ /// let buf_ptr = &mut buf as *mut _ as *mut _; -+ /// #[cfg(unix)] -+ /// let res = unsafe { libc::recv(dgram.as_raw_fd(), buf_ptr, buf.len(), 0) }; -+ /// #[cfg(windows)] -+ /// let res = unsafe { libc::recvfrom(dgram.as_raw_socket() as usize, buf_ptr, buf.len() as i32, 0, std::ptr::null_mut(), std::ptr::null_mut()) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::recv, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("read {} bytes", n); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn try_io(&self, f: F) -> io::Result -+ where -+ F: FnOnce() -> io::Result, -+ { -+ self.inner.do_io(|_| f()) -+ } - } - - impl event::Source for UdpSocket { -diff --git a/KubeOS-Rust/vendor/mio/src/net/uds/datagram.rs b/KubeOS-Rust/vendor/mio/src/net/uds/datagram.rs -index 0c8f5ffa..e963d6e2 100644 ---- a/KubeOS-Rust/vendor/mio/src/net/uds/datagram.rs -+++ b/KubeOS-Rust/vendor/mio/src/net/uds/datagram.rs -@@ -22,8 +22,8 @@ impl UnixDatagram { - /// - /// This function is intended to be used to wrap a Unix datagram from the - /// standard library in the Mio equivalent. The conversion assumes nothing -- /// about the underlying datagram; ; it is left up to the user to set it -- /// in non-blocking mode. -+ /// about the underlying datagram; it is left up to the user to set it in -+ /// non-blocking mode. - pub fn from_std(socket: net::UnixDatagram) -> UnixDatagram { - UnixDatagram { - inner: IoSource::new(socket), -@@ -31,6 +31,9 @@ impl UnixDatagram { - } - - /// Connects the socket to the specified address. -+ /// -+ /// This may return a `WouldBlock` in which case the socket connection -+ /// cannot be completed immediately. - pub fn connect>(&self, path: P) -> io::Result<()> { - self.inner.connect(path) - } -@@ -108,6 +111,74 @@ impl UnixDatagram { - pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { - self.inner.shutdown(how) - } -+ -+ /// Execute an I/O operation ensuring that the socket receives more events -+ /// if it hits a [`WouldBlock`] error. -+ /// -+ /// # Notes -+ /// -+ /// This method is required to be called for **all** I/O operations to -+ /// ensure the user will receive events once the socket is ready again after -+ /// returning a [`WouldBlock`] error. -+ /// -+ /// [`WouldBlock`]: io::ErrorKind::WouldBlock -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// # use std::error::Error; -+ /// # -+ /// # fn main() -> Result<(), Box> { -+ /// use std::io; -+ /// use std::os::unix::io::AsRawFd; -+ /// use mio::net::UnixDatagram; -+ /// -+ /// let (dgram1, dgram2) = UnixDatagram::pair()?; -+ /// -+ /// // Wait until the dgram is writable... -+ /// -+ /// // Write to the dgram using a direct libc call, of course the -+ /// // `io::Write` implementation would be easier to use. -+ /// let buf = b"hello"; -+ /// let n = dgram1.try_io(|| { -+ /// let buf_ptr = &buf as *const _ as *const _; -+ /// let res = unsafe { libc::send(dgram1.as_raw_fd(), buf_ptr, buf.len(), 0) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::send, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("write {} bytes", n); -+ /// -+ /// // Wait until the dgram is readable... -+ /// -+ /// // Read from the dgram using a direct libc call, of course the -+ /// // `io::Read` implementation would be easier to use. -+ /// let mut buf = [0; 512]; -+ /// let n = dgram2.try_io(|| { -+ /// let buf_ptr = &mut buf as *mut _ as *mut _; -+ /// let res = unsafe { libc::recv(dgram2.as_raw_fd(), buf_ptr, buf.len(), 0) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::recv, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("read {} bytes", n); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn try_io(&self, f: F) -> io::Result -+ where -+ F: FnOnce() -> io::Result, -+ { -+ self.inner.do_io(|_| f()) -+ } - } - - impl event::Source for UnixDatagram { -diff --git a/KubeOS-Rust/vendor/mio/src/net/uds/listener.rs b/KubeOS-Rust/vendor/mio/src/net/uds/listener.rs -index 37e8106d..eeffe042 100644 ---- a/KubeOS-Rust/vendor/mio/src/net/uds/listener.rs -+++ b/KubeOS-Rust/vendor/mio/src/net/uds/listener.rs -@@ -13,11 +13,16 @@ pub struct UnixListener { - } - - impl UnixListener { -- /// Creates a new `UnixListener` bound to the specified socket. -+ /// Creates a new `UnixListener` bound to the specified socket `path`. - pub fn bind>(path: P) -> io::Result { - sys::uds::listener::bind(path.as_ref()).map(UnixListener::from_std) - } - -+ /// Creates a new `UnixListener` bound to the specified socket `address`. -+ pub fn bind_addr(address: &SocketAddr) -> io::Result { -+ sys::uds::listener::bind_addr(address).map(UnixListener::from_std) -+ } -+ - /// Creates a new `UnixListener` from a standard `net::UnixListener`. - /// - /// This function is intended to be used to wrap a Unix listener from the -diff --git a/KubeOS-Rust/vendor/mio/src/net/uds/stream.rs b/KubeOS-Rust/vendor/mio/src/net/uds/stream.rs -index f21d9e7b..1c17d84a 100644 ---- a/KubeOS-Rust/vendor/mio/src/net/uds/stream.rs -+++ b/KubeOS-Rust/vendor/mio/src/net/uds/stream.rs -@@ -1,4 +1,5 @@ - use crate::io_source::IoSource; -+use crate::net::SocketAddr; - use crate::{event, sys, Interest, Registry, Token}; - - use std::fmt; -@@ -15,10 +16,21 @@ pub struct UnixStream { - - impl UnixStream { - /// Connects to the socket named by `path`. -+ /// -+ /// This may return a `WouldBlock` in which case the socket connection -+ /// cannot be completed immediately. Usually it means the backlog is full. - pub fn connect>(path: P) -> io::Result { - sys::uds::stream::connect(path.as_ref()).map(UnixStream::from_std) - } - -+ /// Connects to the socket named by `address`. -+ /// -+ /// This may return a `WouldBlock` in which case the socket connection -+ /// cannot be completed immediately. Usually it means the backlog is full. -+ pub fn connect_addr(address: &SocketAddr) -> io::Result { -+ sys::uds::stream::connect_addr(address).map(UnixStream::from_std) -+ } -+ - /// Creates a new `UnixStream` from a standard `net::UnixStream`. - /// - /// This function is intended to be used to wrap a Unix stream from the -@@ -69,53 +81,121 @@ impl UnixStream { - pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { - self.inner.shutdown(how) - } -+ -+ /// Execute an I/O operation ensuring that the socket receives more events -+ /// if it hits a [`WouldBlock`] error. -+ /// -+ /// # Notes -+ /// -+ /// This method is required to be called for **all** I/O operations to -+ /// ensure the user will receive events once the socket is ready again after -+ /// returning a [`WouldBlock`] error. -+ /// -+ /// [`WouldBlock`]: io::ErrorKind::WouldBlock -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// # use std::error::Error; -+ /// # -+ /// # fn main() -> Result<(), Box> { -+ /// use std::io; -+ /// use std::os::unix::io::AsRawFd; -+ /// use mio::net::UnixStream; -+ /// -+ /// let (stream1, stream2) = UnixStream::pair()?; -+ /// -+ /// // Wait until the stream is writable... -+ /// -+ /// // Write to the stream using a direct libc call, of course the -+ /// // `io::Write` implementation would be easier to use. -+ /// let buf = b"hello"; -+ /// let n = stream1.try_io(|| { -+ /// let buf_ptr = &buf as *const _ as *const _; -+ /// let res = unsafe { libc::send(stream1.as_raw_fd(), buf_ptr, buf.len(), 0) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::send, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("write {} bytes", n); -+ /// -+ /// // Wait until the stream is readable... -+ /// -+ /// // Read from the stream using a direct libc call, of course the -+ /// // `io::Read` implementation would be easier to use. -+ /// let mut buf = [0; 512]; -+ /// let n = stream2.try_io(|| { -+ /// let buf_ptr = &mut buf as *mut _ as *mut _; -+ /// let res = unsafe { libc::recv(stream2.as_raw_fd(), buf_ptr, buf.len(), 0) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::recv, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("read {} bytes", n); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn try_io(&self, f: F) -> io::Result -+ where -+ F: FnOnce() -> io::Result, -+ { -+ self.inner.do_io(|_| f()) -+ } - } - - impl Read for UnixStream { - fn read(&mut self, buf: &mut [u8]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).read(buf)) -+ self.inner.do_io(|mut inner| inner.read(buf)) - } - - fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).read_vectored(bufs)) -+ self.inner.do_io(|mut inner| inner.read_vectored(bufs)) - } - } - - impl<'a> Read for &'a UnixStream { - fn read(&mut self, buf: &mut [u8]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).read(buf)) -+ self.inner.do_io(|mut inner| inner.read(buf)) - } - - fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).read_vectored(bufs)) -+ self.inner.do_io(|mut inner| inner.read_vectored(bufs)) - } - } - - impl Write for UnixStream { - fn write(&mut self, buf: &[u8]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).write(buf)) -+ self.inner.do_io(|mut inner| inner.write(buf)) - } - - fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).write_vectored(bufs)) -+ self.inner.do_io(|mut inner| inner.write_vectored(bufs)) - } - - fn flush(&mut self) -> io::Result<()> { -- self.inner.do_io(|inner| (&*inner).flush()) -+ self.inner.do_io(|mut inner| inner.flush()) - } - } - - impl<'a> Write for &'a UnixStream { - fn write(&mut self, buf: &[u8]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).write(buf)) -+ self.inner.do_io(|mut inner| inner.write(buf)) - } - - fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result { -- self.inner.do_io(|inner| (&*inner).write_vectored(bufs)) -+ self.inner.do_io(|mut inner| inner.write_vectored(bufs)) - } - - fn flush(&mut self) -> io::Result<()> { -- self.inner.do_io(|inner| (&*inner).flush()) -+ self.inner.do_io(|mut inner| inner.flush()) - } - } - -diff --git a/KubeOS-Rust/vendor/mio/src/poll.rs b/KubeOS-Rust/vendor/mio/src/poll.rs -index a6f4ab0b..092482f2 100644 ---- a/KubeOS-Rust/vendor/mio/src/poll.rs -+++ b/KubeOS-Rust/vendor/mio/src/poll.rs -@@ -1,10 +1,18 @@ --use crate::{event, sys, Events, Interest, Token}; --use log::trace; --#[cfg(unix)] -+#[cfg(all( -+ unix, -+ not(mio_unsupported_force_poll_poll), -+ not(any(target_os = "solaris", target_os = "vita")) -+))] - use std::os::unix::io::{AsRawFd, RawFd}; -+#[cfg(all(debug_assertions, not(target_os = "wasi")))] -+use std::sync::atomic::{AtomicBool, Ordering}; -+#[cfg(all(debug_assertions, not(target_os = "wasi")))] -+use std::sync::Arc; - use std::time::Duration; - use std::{fmt, io}; - -+use crate::{event, sys, Events, Interest, Token}; -+ - /// Polls for readiness events on all registered values. - /// - /// `Poll` allows a program to monitor a large number of [`event::Source`]s, -@@ -30,8 +38,8 @@ use std::{fmt, io}; - /// - /// A basic example -- establishing a `TcpStream` connection. - /// --#[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] --#[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - /// # use std::error::Error; - /// # fn main() -> Result<(), Box> { - /// use mio::{Events, Poll, Interest, Token}; -@@ -127,8 +135,8 @@ use std::{fmt, io}; - /// - /// For example: - /// --#[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] --#[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - /// # use std::error::Error; - /// # use std::net; - /// # fn main() -> Result<(), Box> { -@@ -163,6 +171,52 @@ use std::{fmt, io}; - /// - /// [event sources]: ./event/trait.Source.html - /// -+/// ### Accessing raw fd/socket/handle -+/// -+/// Mio makes it possible for many types to be converted into a raw file -+/// descriptor (fd, Unix), socket (Windows) or handle (Windows). This makes it -+/// possible to support more operations on the type than Mio supports, for -+/// example it makes [mio-aio] possible. However accessing the raw fd is not -+/// without it's pitfalls. -+/// -+/// Specifically performing I/O operations outside of Mio on these types (via -+/// the raw fd) has unspecified behaviour. It could cause no more events to be -+/// generated for the type even though it returned `WouldBlock` (in an operation -+/// directly accessing the fd). The behaviour is OS specific and Mio can only -+/// guarantee cross-platform behaviour if it can control the I/O. -+/// -+/// [mio-aio]: https://github.com/asomers/mio-aio -+/// -+/// *The following is **not** guaranteed, just a description of the current -+/// situation!* Mio is allowed to change the following without it being considered -+/// a breaking change, don't depend on this, it's just here to inform the user. -+/// Currently the kqueue and epoll implementation support direct I/O operations -+/// on the fd without Mio's knowledge. Windows however needs **all** I/O -+/// operations to go through Mio otherwise it is not able to update it's -+/// internal state properly and won't generate events. -+/// -+/// ### Polling without registering event sources -+/// -+/// -+/// *The following is **not** guaranteed, just a description of the current -+/// situation!* Mio is allowed to change the following without it being -+/// considered a breaking change, don't depend on this, it's just here to inform -+/// the user. On platforms that use epoll, kqueue or IOCP (see implementation -+/// notes below) polling without previously registering [event sources] will -+/// result in sleeping forever, only a process signal will be able to wake up -+/// the thread. -+/// -+/// On WASM/WASI this is different as it doesn't support process signals, -+/// furthermore the WASI specification doesn't specify a behaviour in this -+/// situation, thus it's up to the implementation what to do here. As an -+/// example, the wasmtime runtime will return `EINVAL` in this situation, but -+/// different runtimes may return different results. If you have further -+/// insights or thoughts about this situation (and/or how Mio should handle it) -+/// please add you comment to [pull request#1580]. -+/// -+/// [event sources]: crate::event::Source -+/// [pull request#1580]: https://github.com/tokio-rs/mio/pull/1580 -+/// - /// # Implementation notes - /// - /// `Poll` is backed by the selector provided by the operating system. -@@ -172,13 +226,12 @@ use std::{fmt, io}; - /// | Android | [epoll] | - /// | DragonFly BSD | [kqueue] | - /// | FreeBSD | [kqueue] | -+/// | iOS | [kqueue] | -+/// | illumos | [epoll] | - /// | Linux | [epoll] | - /// | NetBSD | [kqueue] | - /// | OpenBSD | [kqueue] | --/// | Solaris | [epoll] | --/// | illumos | [epoll] | - /// | Windows | [IOCP] | --/// | iOS | [kqueue] | - /// | macOS | [kqueue] | - /// - /// On all supported platforms, socket operations are handled by using the -@@ -195,10 +248,10 @@ use std::{fmt, io}; - /// data to be copied into an intermediate buffer before it is passed to the - /// kernel. - /// --/// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html -+/// [epoll]: https://man7.org/linux/man-pages/man7/epoll.7.html - /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 --/// [IOCP]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365198(v=vs.85).aspx --/// [`signalfd`]: http://man7.org/linux/man-pages/man2/signalfd.2.html -+/// [IOCP]: https://docs.microsoft.com/en-us/windows/win32/fileio/i-o-completion-ports -+/// [`signalfd`]: https://man7.org/linux/man-pages/man2/signalfd.2.html - /// [`SourceFd`]: unix/struct.SourceFd.html - /// [`Poll::poll`]: struct.Poll.html#method.poll - pub struct Poll { -@@ -208,9 +261,64 @@ pub struct Poll { - /// Registers I/O resources. - pub struct Registry { - selector: sys::Selector, -+ /// Whether this selector currently has an associated waker. -+ #[cfg(all(debug_assertions, not(target_os = "wasi")))] -+ has_waker: Arc, - } - - impl Poll { -+ cfg_os_poll! { -+ /// Return a new `Poll` handle. -+ /// -+ /// This function will make a syscall to the operating system to create -+ /// the system selector. If this syscall fails, `Poll::new` will return -+ /// with the error. -+ /// -+ /// close-on-exec flag is set on the file descriptors used by the selector to prevent -+ /// leaking it to executed processes. However, on some systems such as -+ /// old Linux systems that don't support `epoll_create1` syscall it is done -+ /// non-atomically, so a separate thread executing in parallel to this -+ /// function may accidentally leak the file descriptor if it executes a -+ /// new process before this function returns. -+ /// -+ /// See [struct] level docs for more details. -+ /// -+ /// [struct]: struct.Poll.html -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// # use std::error::Error; -+ /// # fn main() -> Result<(), Box> { -+ /// use mio::{Poll, Events}; -+ /// use std::time::Duration; -+ /// -+ /// let mut poll = match Poll::new() { -+ /// Ok(poll) => poll, -+ /// Err(e) => panic!("failed to create Poll instance; err={:?}", e), -+ /// }; -+ /// -+ /// // Create a structure to receive polled events -+ /// let mut events = Events::with_capacity(1024); -+ /// -+ /// // Wait for events, but none will be received because no -+ /// // `event::Source`s have been registered with this `Poll` instance. -+ /// poll.poll(&mut events, Some(Duration::from_millis(500)))?; -+ /// assert!(events.is_empty()); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn new() -> io::Result { -+ sys::Selector::new().map(|selector| Poll { -+ registry: Registry { -+ selector, -+ #[cfg(all(debug_assertions, not(target_os = "wasi")))] -+ has_waker: Arc::new(AtomicBool::new(false)), -+ }, -+ }) -+ } -+ } -+ - /// Create a separate `Registry` which can be used to register - /// `event::Source`s. - pub fn registry(&self) -> &Registry { -@@ -256,12 +364,16 @@ impl Poll { - /// of Mio would automatically retry the poll call if it was interrupted - /// (if `EINTR` was returned). - /// -+ /// Currently if the `timeout` elapses without any readiness events -+ /// triggering this will return `Ok(())`. However we're not guaranteeing -+ /// this behaviour as this depends on the OS. -+ /// - /// # Examples - /// - /// A basic example -- establishing a `TcpStream` connection. - /// -- #[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] -- #[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+ #[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+ #[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - /// # use std::error::Error; - /// # fn main() -> Result<(), Box> { - /// use mio::{Events, Poll, Interest, Token}; -@@ -315,50 +427,11 @@ impl Poll { - } - } - --cfg_os_poll! { -- impl Poll { -- /// Return a new `Poll` handle. -- /// -- /// This function will make a syscall to the operating system to create -- /// the system selector. If this syscall fails, `Poll::new` will return -- /// with the error. -- /// -- /// See [struct] level docs for more details. -- /// -- /// [struct]: struct.Poll.html -- /// -- /// # Examples -- /// -- /// ``` -- /// # use std::error::Error; -- /// # fn main() -> Result<(), Box> { -- /// use mio::{Poll, Events}; -- /// use std::time::Duration; -- /// -- /// let mut poll = match Poll::new() { -- /// Ok(poll) => poll, -- /// Err(e) => panic!("failed to create Poll instance; err={:?}", e), -- /// }; -- /// -- /// // Create a structure to receive polled events -- /// let mut events = Events::with_capacity(1024); -- /// -- /// // Wait for events, but none will be received because no -- /// // `event::Source`s have been registered with this `Poll` instance. -- /// poll.poll(&mut events, Some(Duration::from_millis(500)))?; -- /// assert!(events.is_empty()); -- /// # Ok(()) -- /// # } -- /// ``` -- pub fn new() -> io::Result { -- sys::Selector::new().map(|selector| Poll { -- registry: Registry { selector }, -- }) -- } -- } --} -- --#[cfg(unix)] -+#[cfg(all( -+ unix, -+ not(mio_unsupported_force_poll_poll), -+ not(any(target_os = "solaris", target_os = "vita")) -+))] - impl AsRawFd for Poll { - fn as_raw_fd(&self) -> RawFd { - self.registry.as_raw_fd() -@@ -382,7 +455,7 @@ impl Registry { - /// - /// # Arguments - /// -- /// `source: &S: event::Source`: This is the source of events that the -+ /// `source: &mut S: event::Source`: This is the source of events that the - /// `Poll` instance should monitor for readiness state changes. - /// - /// `token: Token`: The caller picks a token to associate with the socket. -@@ -409,7 +482,7 @@ impl Registry { - /// Callers must ensure that if a source being registered with a `Poll` - /// instance was previously registered with that `Poll` instance, then a - /// call to [`deregister`] has already occurred. Consecutive calls to -- /// `register` is undefined behavior. -+ /// `register` is unspecified behavior. - /// - /// Unless otherwise specified, the caller should assume that once an event - /// source is registered with a `Poll` instance, it is bound to that `Poll` -@@ -425,8 +498,8 @@ impl Registry { - /// - /// # Examples - /// -- #[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] -- #[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+ #[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+ #[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - /// # use std::error::Error; - /// # use std::net; - /// # fn main() -> Result<(), Box> { -@@ -495,7 +568,7 @@ impl Registry { - /// requested for the handle. - /// - /// The event source must have previously been registered with this instance -- /// of `Poll`, otherwise the behavior is undefined. -+ /// of `Poll`, otherwise the behavior is unspecified. - /// - /// See the [`register`] documentation for details about the function - /// arguments and see the [`struct`] docs for a high level overview of -@@ -503,8 +576,8 @@ impl Registry { - /// - /// # Examples - /// -- #[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] -- #[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+ #[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+ #[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - /// # use std::error::Error; - /// # use std::net; - /// # fn main() -> Result<(), Box> { -@@ -562,16 +635,16 @@ impl Registry { - /// the poll. - /// - /// The event source must have previously been registered with this instance -- /// of `Poll`, otherwise the behavior is undefined. -+ /// of `Poll`, otherwise the behavior is unspecified. - /// - /// A handle can be passed back to `register` after it has been - /// deregistered; however, it must be passed back to the **same** `Poll` -- /// instance, otherwise the behavior is undefined. -+ /// instance, otherwise the behavior is unspecified. - /// - /// # Examples - /// -- #[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] -- #[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+ #[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+ #[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - /// # use std::error::Error; - /// # use std::net; - /// # fn main() -> Result<(), Box> { -@@ -615,18 +688,27 @@ impl Registry { - /// Event sources registered with this `Registry` will be registered with - /// the original `Registry` and `Poll` instance. - pub fn try_clone(&self) -> io::Result { -- self.selector -- .try_clone() -- .map(|selector| Registry { selector }) -+ self.selector.try_clone().map(|selector| Registry { -+ selector, -+ #[cfg(all(debug_assertions, not(target_os = "wasi")))] -+ has_waker: Arc::clone(&self.has_waker), -+ }) - } - - /// Internal check to ensure only a single `Waker` is active per [`Poll`] - /// instance. -- #[cfg(debug_assertions)] -+ #[cfg(all(debug_assertions, not(target_os = "wasi")))] - pub(crate) fn register_waker(&self) { -- if self.selector.register_waker() { -- panic!("Only a single `Waker` can be active per `Poll` instance"); -- } -+ assert!( -+ !self.has_waker.swap(true, Ordering::AcqRel), -+ "Only a single `Waker` can be active per `Poll` instance" -+ ); -+ } -+ -+ /// Get access to the `sys::Selector`. -+ #[cfg(any(not(target_os = "wasi"), feature = "net"))] -+ pub(crate) fn selector(&self) -> &sys::Selector { -+ &self.selector - } - } - -@@ -636,20 +718,23 @@ impl fmt::Debug for Registry { - } - } - --#[cfg(unix)] -+#[cfg(all( -+ unix, -+ not(mio_unsupported_force_poll_poll), -+ not(any(target_os = "solaris", target_os = "vita")) -+))] - impl AsRawFd for Registry { - fn as_raw_fd(&self) -> RawFd { - self.selector.as_raw_fd() - } - } - --/// Get access to the `sys::Selector` from `Registry`. --pub(crate) fn selector(registry: &Registry) -> &sys::Selector { -- ®istry.selector --} -- - cfg_os_poll! { -- #[cfg(unix)] -+ #[cfg(all( -+ unix, -+ not(mio_unsupported_force_poll_poll), -+ not(any(target_os = "solaris", target_os = "vita")), -+ ))] - #[test] - pub fn as_raw_fd() { - let poll = Poll::new().unwrap(); -diff --git a/KubeOS-Rust/vendor/mio/src/sys/mod.rs b/KubeOS-Rust/vendor/mio/src/sys/mod.rs -index 81ae6d2e..04e0b200 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/mod.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/mod.rs -@@ -54,6 +54,7 @@ cfg_os_poll! { - #[cfg(unix)] - cfg_os_poll! { - mod unix; -+ #[allow(unused_imports)] - pub use self::unix::*; - } - -@@ -63,6 +64,12 @@ cfg_os_poll! { - pub use self::windows::*; - } - -+#[cfg(target_os = "wasi")] -+cfg_os_poll! { -+ mod wasi; -+ pub(crate) use self::wasi::*; -+} -+ - cfg_not_os_poll! { - mod shell; - pub(crate) use self::shell::*; -@@ -70,6 +77,7 @@ cfg_not_os_poll! { - #[cfg(unix)] - cfg_any_os_ext! { - mod unix; -+ #[cfg(feature = "os-ext")] - pub use self::unix::SourceFd; - } - -diff --git a/KubeOS-Rust/vendor/mio/src/sys/shell/mod.rs b/KubeOS-Rust/vendor/mio/src/sys/shell/mod.rs -index 7e1533f4..76085b8a 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/shell/mod.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/shell/mod.rs -@@ -7,7 +7,9 @@ macro_rules! os_required { - mod selector; - pub(crate) use self::selector::{event, Event, Events, Selector}; - -+#[cfg(not(target_os = "wasi"))] - mod waker; -+#[cfg(not(target_os = "wasi"))] - pub(crate) use self::waker::Waker; - - cfg_net! { -@@ -21,8 +23,10 @@ cfg_io_source! { - use std::io; - #[cfg(windows)] - use std::os::windows::io::RawSocket; -+ #[cfg(unix)] -+ use std::os::unix::io::RawFd; - -- #[cfg(windows)] -+ #[cfg(any(windows, unix))] - use crate::{Registry, Token, Interest}; - - pub(crate) struct IoSourceState; -@@ -42,6 +46,33 @@ cfg_io_source! { - } - } - -+ #[cfg(unix)] -+ impl IoSourceState { -+ pub fn register( -+ &mut self, -+ _: &Registry, -+ _: Token, -+ _: Interest, -+ _: RawFd, -+ ) -> io::Result<()> { -+ os_required!() -+ } -+ -+ pub fn reregister( -+ &mut self, -+ _: &Registry, -+ _: Token, -+ _: Interest, -+ _: RawFd, -+ ) -> io::Result<()> { -+ os_required!() -+ } -+ -+ pub fn deregister(&mut self, _: &Registry, _: RawFd) -> io::Result<()> { -+ os_required!() -+ } -+ } -+ - #[cfg(windows)] - impl IoSourceState { - pub fn register( -diff --git a/KubeOS-Rust/vendor/mio/src/sys/shell/selector.rs b/KubeOS-Rust/vendor/mio/src/sys/shell/selector.rs -index 91fc0bf4..0a168980 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/shell/selector.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/shell/selector.rs -@@ -18,11 +18,6 @@ impl Selector { - pub fn select(&self, _: &mut Events, _: Option) -> io::Result<()> { - os_required!(); - } -- -- #[cfg(debug_assertions)] -- pub fn register_waker(&self) -> bool { -- os_required!(); -- } - } - - #[cfg(unix)] -@@ -44,6 +39,25 @@ cfg_any_os_ext! { - } - } - -+#[cfg(target_os = "wasi")] -+cfg_any_os_ext! { -+ use crate::{Interest, Token}; -+ -+ impl Selector { -+ pub fn register(&self, _: wasi::Fd, _: Token, _: Interest) -> io::Result<()> { -+ os_required!(); -+ } -+ -+ pub fn reregister(&self, _: wasi::Fd, _: Token, _: Interest) -> io::Result<()> { -+ os_required!(); -+ } -+ -+ pub fn deregister(&self, _: wasi::Fd) -> io::Result<()> { -+ os_required!(); -+ } -+ } -+} -+ - cfg_io_source! { - #[cfg(debug_assertions)] - impl Selector { -diff --git a/KubeOS-Rust/vendor/mio/src/sys/shell/tcp.rs b/KubeOS-Rust/vendor/mio/src/sys/shell/tcp.rs -index 0ed225f7..260763ae 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/shell/tcp.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/shell/tcp.rs -@@ -1,127 +1,31 @@ --use crate::net::TcpKeepalive; - use std::io; - use std::net::{self, SocketAddr}; --use std::time::Duration; - --pub(crate) type TcpSocket = i32; -- --pub(crate) fn new_v4_socket() -> io::Result { -- os_required!(); --} -- --pub(crate) fn new_v6_socket() -> io::Result { -- os_required!(); --} -- --pub(crate) fn bind(_socket: TcpSocket, _addr: SocketAddr) -> io::Result<()> { -- os_required!(); --} -- --pub(crate) fn connect(_: TcpSocket, _addr: SocketAddr) -> io::Result { -- os_required!(); --} -- --pub(crate) fn listen(_: TcpSocket, _: u32) -> io::Result { -+#[cfg(not(target_os = "wasi"))] -+pub(crate) fn new_for_addr(_: SocketAddr) -> io::Result { - os_required!(); - } - --pub(crate) fn close(_: TcpSocket) { -+#[cfg(not(target_os = "wasi"))] -+pub(crate) fn bind(_: &net::TcpListener, _: SocketAddr) -> io::Result<()> { - os_required!(); - } - --pub(crate) fn set_reuseaddr(_: TcpSocket, _: bool) -> io::Result<()> { -+#[cfg(not(target_os = "wasi"))] -+pub(crate) fn connect(_: &net::TcpStream, _: SocketAddr) -> io::Result<()> { - os_required!(); - } - --pub(crate) fn get_reuseaddr(_: TcpSocket) -> io::Result { -+#[cfg(not(target_os = "wasi"))] -+pub(crate) fn listen(_: &net::TcpListener, _: u32) -> io::Result<()> { - os_required!(); - } - --#[cfg(all(unix, not(any(target_os = "solaris", target_os = "illumos"))))] --pub(crate) fn set_reuseport(_: TcpSocket, _: bool) -> io::Result<()> { -- os_required!(); --} -- --#[cfg(all(unix, not(any(target_os = "solaris", target_os = "illumos"))))] --pub(crate) fn get_reuseport(_: TcpSocket) -> io::Result { -- os_required!(); --} -- --pub(crate) fn set_linger(_: TcpSocket, _: Option) -> io::Result<()> { -- os_required!(); --} -- --pub(crate) fn get_linger(_: TcpSocket) -> io::Result> { -- os_required!(); --} -- --pub(crate) fn set_recv_buffer_size(_: TcpSocket, _: u32) -> io::Result<()> { -- os_required!(); --} -- --pub(crate) fn get_recv_buffer_size(_: TcpSocket) -> io::Result { -- os_required!(); --} -- --pub(crate) fn set_send_buffer_size(_: TcpSocket, _: u32) -> io::Result<()> { -- os_required!(); --} -- --pub(crate) fn get_send_buffer_size(_: TcpSocket) -> io::Result { -- os_required!(); --} -- --pub(crate) fn set_keepalive(_: TcpSocket, _: bool) -> io::Result<()> { -- os_required!(); --} -- --pub(crate) fn get_keepalive(_: TcpSocket) -> io::Result { -- os_required!(); --} -- --pub(crate) fn set_keepalive_params(_: TcpSocket, _: TcpKeepalive) -> io::Result<()> { -- os_required!() --} -- --#[cfg(any( -- target_os = "android", -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- target_os = "solaris", --))] --pub(crate) fn get_keepalive_time(_: TcpSocket) -> io::Result> { -- os_required!() --} -- --#[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", --))] --pub(crate) fn get_keepalive_interval(_: TcpSocket) -> io::Result> { -- os_required!() --} -- --#[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", --))] --pub(crate) fn get_keepalive_retries(_: TcpSocket) -> io::Result> { -- os_required!() --} -- --pub fn accept(_: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { -+#[cfg(unix)] -+pub(crate) fn set_reuseaddr(_: &net::TcpListener, _: bool) -> io::Result<()> { - os_required!(); - } - --pub(crate) fn get_localaddr(_: TcpSocket) -> io::Result { -+pub(crate) fn accept(_: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { - os_required!(); - } -diff --git a/KubeOS-Rust/vendor/mio/src/sys/shell/udp.rs b/KubeOS-Rust/vendor/mio/src/sys/shell/udp.rs -index 48ccac74..6a48b694 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/shell/udp.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/shell/udp.rs -@@ -1,3 +1,4 @@ -+#![cfg(not(target_os = "wasi"))] - use std::io; - use std::net::{self, SocketAddr}; - -diff --git a/KubeOS-Rust/vendor/mio/src/sys/shell/uds.rs b/KubeOS-Rust/vendor/mio/src/sys/shell/uds.rs -index c18aca04..bac547b0 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/shell/uds.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/shell/uds.rs -@@ -42,6 +42,10 @@ pub(crate) mod listener { - os_required!() - } - -+ pub(crate) fn bind_addr(_: &SocketAddr) -> io::Result { -+ os_required!() -+ } -+ - pub(crate) fn accept(_: &net::UnixListener) -> io::Result<(UnixStream, SocketAddr)> { - os_required!() - } -@@ -61,6 +65,10 @@ pub(crate) mod stream { - os_required!() - } - -+ pub(crate) fn connect_addr(_: &SocketAddr) -> io::Result { -+ os_required!() -+ } -+ - pub(crate) fn pair() -> io::Result<(net::UnixStream, net::UnixStream)> { - os_required!() - } -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/mod.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/mod.rs -index 231480a5..bd2fe7d7 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/mod.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/mod.rs -@@ -18,6 +18,7 @@ cfg_os_poll! { - pub(crate) use self::selector::{event, Event, Events, Selector}; - - mod sourcefd; -+ #[cfg(feature = "os-ext")] - pub use self::sourcefd::SourceFd; - - mod waker; -@@ -33,30 +34,82 @@ cfg_os_poll! { - } - - cfg_io_source! { -- use std::io; -- - // Both `kqueue` and `epoll` don't need to hold any user space state. -- pub(crate) struct IoSourceState; -+ #[cfg(not(any(mio_unsupported_force_poll_poll, target_os = "solaris", target_os = "vita")))] -+ mod stateless_io_source { -+ use std::io; -+ use std::os::unix::io::RawFd; -+ use crate::Registry; -+ use crate::Token; -+ use crate::Interest; - -- impl IoSourceState { -- pub fn new() -> IoSourceState { -- IoSourceState -- } -+ pub(crate) struct IoSourceState; -+ -+ impl IoSourceState { -+ pub fn new() -> IoSourceState { -+ IoSourceState -+ } -+ -+ pub fn do_io(&self, f: F, io: &T) -> io::Result -+ where -+ F: FnOnce(&T) -> io::Result, -+ { -+ // We don't hold state, so we can just call the function and -+ // return. -+ f(io) -+ } -+ -+ pub fn register( -+ &mut self, -+ registry: &Registry, -+ token: Token, -+ interests: Interest, -+ fd: RawFd, -+ ) -> io::Result<()> { -+ // Pass through, we don't have any state -+ registry.selector().register(fd, token, interests) -+ } - -- pub fn do_io(&self, f: F, io: &T) -> io::Result -- where -- F: FnOnce(&T) -> io::Result, -- { -- // We don't hold state, so we can just call the function and -- // return. -- f(io) -+ pub fn reregister( -+ &mut self, -+ registry: &Registry, -+ token: Token, -+ interests: Interest, -+ fd: RawFd, -+ ) -> io::Result<()> { -+ // Pass through, we don't have any state -+ registry.selector().reregister(fd, token, interests) -+ } -+ -+ pub fn deregister(&mut self, registry: &Registry, fd: RawFd) -> io::Result<()> { -+ // Pass through, we don't have any state -+ registry.selector().deregister(fd) -+ } - } - } -- } - -- cfg_os_ext! { -- pub(crate) mod pipe; -+ #[cfg(not(any(mio_unsupported_force_poll_poll, target_os = "solaris",target_os = "vita")))] -+ pub(crate) use self::stateless_io_source::IoSourceState; -+ -+ #[cfg(any(mio_unsupported_force_poll_poll, target_os = "solaris", target_os = "vita"))] -+ pub(crate) use self::selector::IoSourceState; - } -+ -+ #[cfg(any( -+ // For the public `pipe` module, must match `cfg_os_ext` macro. -+ feature = "os-ext", -+ // For the `Waker` type based on a pipe. -+ mio_unsupported_force_waker_pipe, -+ target_os = "aix", -+ target_os = "dragonfly", -+ target_os = "illumos", -+ target_os = "netbsd", -+ target_os = "openbsd", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "vita", -+ ))] -+ pub(crate) mod pipe; - } - - cfg_not_os_poll! { -@@ -67,6 +120,7 @@ cfg_not_os_poll! { - - cfg_any_os_ext! { - mod sourcefd; -+ #[cfg(feature = "os-ext")] - pub use self::sourcefd::SourceFd; - } - } -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/net.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/net.rs -index 2f8d618c..32f68a66 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/net.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/net.rs -@@ -20,44 +20,53 @@ pub(crate) fn new_socket(domain: libc::c_int, socket_type: libc::c_int) -> io::R - target_os = "illumos", - target_os = "linux", - target_os = "netbsd", -- target_os = "openbsd" -+ target_os = "openbsd", -+ target_os = "solaris", - ))] - let socket_type = socket_type | libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC; - -- // Gives a warning for platforms without SOCK_NONBLOCK. -- #[allow(clippy::let_and_return)] -- let socket = syscall!(socket(domain, socket_type, 0)); -+ let socket = syscall!(socket(domain, socket_type, 0))?; - - // Mimick `libstd` and set `SO_NOSIGPIPE` on apple systems. -- #[cfg(target_vendor = "apple")] -- let socket = socket.and_then(|socket| { -- syscall!(setsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_NOSIGPIPE, -- &1 as *const libc::c_int as *const libc::c_void, -- size_of::() as libc::socklen_t -- )) -- .map(|_| socket) -- }); -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ ))] -+ if let Err(err) = syscall!(setsockopt( -+ socket, -+ libc::SOL_SOCKET, -+ libc::SO_NOSIGPIPE, -+ &1 as *const libc::c_int as *const libc::c_void, -+ size_of::() as libc::socklen_t -+ )) { -+ let _ = syscall!(close(socket)); -+ return Err(err); -+ } - -- // Darwin doesn't have SOCK_NONBLOCK or SOCK_CLOEXEC. Not sure about -- // Solaris, couldn't find anything online. -- #[cfg(any(target_os = "ios", target_os = "macos", target_os = "solaris"))] -- let socket = socket.and_then(|socket| { -- // For platforms that don't support flags in socket, we need to -- // set the flags ourselves. -- syscall!(fcntl(socket, libc::F_SETFL, libc::O_NONBLOCK)) -- .and_then(|_| syscall!(fcntl(socket, libc::F_SETFD, libc::FD_CLOEXEC)).map(|_| socket)) -- .map_err(|e| { -- // If either of the `fcntl` calls failed, ensure the socket is -- // closed and return the error. -- let _ = syscall!(close(socket)); -- e -- }) -- }); -+ // Darwin (and others) doesn't have SOCK_NONBLOCK or SOCK_CLOEXEC. -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "vita", -+ ))] -+ { -+ if let Err(err) = syscall!(fcntl(socket, libc::F_SETFL, libc::O_NONBLOCK)) { -+ let _ = syscall!(close(socket)); -+ return Err(err); -+ } -+ #[cfg(not(any(target_os = "espidf", target_os = "vita")))] -+ if let Err(err) = syscall!(fcntl(socket, libc::F_SETFD, libc::FD_CLOEXEC)) { -+ let _ = syscall!(close(socket)); -+ return Err(err); -+ } -+ } - -- socket -+ Ok(socket) - } - - /// A type with the same memory layout as `libc::sockaddr`. Used in converting Rust level -@@ -90,16 +99,26 @@ pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, libc::socklen_ - sin_family: libc::AF_INET as libc::sa_family_t, - sin_port: addr.port().to_be(), - sin_addr, -+ #[cfg(not(target_os = "vita"))] - sin_zero: [0; 8], -+ #[cfg(target_os = "vita")] -+ sin_zero: [0; 6], - #[cfg(any( -+ target_os = "aix", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", -- target_os = "openbsd" -+ target_os = "openbsd", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "vita", - ))] - sin_len: 0, -+ #[cfg(target_os = "vita")] -+ sin_vport: addr.port().to_be(), - }; - - let sockaddr = SocketAddrCRepr { v4: sockaddr_in }; -@@ -116,15 +135,22 @@ pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, libc::socklen_ - sin6_flowinfo: addr.flowinfo(), - sin6_scope_id: addr.scope_id(), - #[cfg(any( -+ target_os = "aix", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", -- target_os = "openbsd" -+ target_os = "openbsd", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "vita", - ))] - sin6_len: 0, -- #[cfg(any(target_os = "solaris", target_os = "illumos"))] -+ #[cfg(target_os = "vita")] -+ sin6_vport: addr.port().to_be(), -+ #[cfg(any(target_os = "illumos", target_os = "solaris"))] - __sin6_src_id: 0, - }; - -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/pipe.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/pipe.rs -index ccf5252d..7f23787f 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/pipe.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/pipe.rs -@@ -2,9 +2,85 @@ - //! - //! See the [`new`] function for documentation. - -+use std::io; -+use std::os::unix::io::RawFd; -+ -+pub(crate) fn new_raw() -> io::Result<[RawFd; 2]> { -+ let mut fds: [RawFd; 2] = [-1, -1]; -+ -+ #[cfg(any( -+ target_os = "android", -+ target_os = "dragonfly", -+ target_os = "freebsd", -+ target_os = "linux", -+ target_os = "netbsd", -+ target_os = "openbsd", -+ target_os = "illumos", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "vita", -+ ))] -+ unsafe { -+ if libc::pipe2(fds.as_mut_ptr(), libc::O_CLOEXEC | libc::O_NONBLOCK) != 0 { -+ return Err(io::Error::last_os_error()); -+ } -+ } -+ -+ #[cfg(any( -+ target_os = "aix", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ ))] -+ unsafe { -+ // For platforms that don't have `pipe2(2)` we need to manually set the -+ // correct flags on the file descriptor. -+ if libc::pipe(fds.as_mut_ptr()) != 0 { -+ return Err(io::Error::last_os_error()); -+ } -+ -+ for fd in &fds { -+ if libc::fcntl(*fd, libc::F_SETFL, libc::O_NONBLOCK) != 0 -+ || libc::fcntl(*fd, libc::F_SETFD, libc::FD_CLOEXEC) != 0 -+ { -+ let err = io::Error::last_os_error(); -+ // Don't leak file descriptors. Can't handle closing error though. -+ let _ = libc::close(fds[0]); -+ let _ = libc::close(fds[1]); -+ return Err(err); -+ } -+ } -+ } -+ -+ #[cfg(not(any( -+ target_os = "aix", -+ target_os = "android", -+ target_os = "dragonfly", -+ target_os = "freebsd", -+ target_os = "illumos", -+ target_os = "ios", -+ target_os = "linux", -+ target_os = "macos", -+ target_os = "netbsd", -+ target_os = "openbsd", -+ target_os = "redox", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "solaris", -+ target_os = "vita", -+ )))] -+ compile_error!("unsupported target for `mio::unix::pipe`"); -+ -+ Ok(fds) -+} -+ -+cfg_os_ext! { - use std::fs::File; --use std::io::{self, IoSlice, IoSliceMut, Read, Write}; --use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; -+use std::io::{IoSlice, IoSliceMut, Read, Write}; -+use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd}; - use std::process::{ChildStderr, ChildStdin, ChildStdout}; - - use crate::io_source::IoSource; -@@ -145,59 +221,8 @@ use crate::{event, Interest, Registry, Token}; - /// # } - /// ``` - pub fn new() -> io::Result<(Sender, Receiver)> { -- let mut fds: [RawFd; 2] = [-1, -1]; -- -- #[cfg(any( -- target_os = "android", -- target_os = "dragonfly", -- target_os = "freebsd", -- target_os = "linux", -- target_os = "netbsd", -- target_os = "openbsd", -- target_os = "illumos", -- ))] -- unsafe { -- if libc::pipe2(fds.as_mut_ptr(), libc::O_CLOEXEC | libc::O_NONBLOCK) != 0 { -- return Err(io::Error::last_os_error()); -- } -- } -- -- #[cfg(any(target_os = "ios", target_os = "macos", target_os = "solaris"))] -- unsafe { -- // For platforms that don't have `pipe2(2)` we need to manually set the -- // correct flags on the file descriptor. -- if libc::pipe(fds.as_mut_ptr()) != 0 { -- return Err(io::Error::last_os_error()); -- } -- -- for fd in &fds { -- if libc::fcntl(*fd, libc::F_SETFL, libc::O_NONBLOCK) != 0 -- || libc::fcntl(*fd, libc::F_SETFD, libc::FD_CLOEXEC) != 0 -- { -- let err = io::Error::last_os_error(); -- // Don't leak file descriptors. Can't handle error though. -- let _ = libc::close(fds[0]); -- let _ = libc::close(fds[1]); -- return Err(err); -- } -- } -- } -- -- #[cfg(not(any( -- target_os = "android", -- target_os = "dragonfly", -- target_os = "freebsd", -- target_os = "linux", -- target_os = "netbsd", -- target_os = "openbsd", -- target_os = "ios", -- target_os = "macos", -- target_os = "solaris", -- target_os = "illumos", -- )))] -- compile_error!("unsupported target for `mio::unix::pipe`"); -- -- // Safety: we just initialised the `fds` above. -+ let fds = new_raw()?; -+ // SAFETY: `new_raw` initialised the `fds` above. - let r = unsafe { Receiver::from_raw_fd(fds[0]) }; - let w = unsafe { Sender::from_raw_fd(fds[1]) }; - Ok((w, r)) -@@ -216,6 +241,74 @@ impl Sender { - pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> { - set_nonblocking(self.inner.as_raw_fd(), nonblocking) - } -+ -+ /// Execute an I/O operation ensuring that the socket receives more events -+ /// if it hits a [`WouldBlock`] error. -+ /// -+ /// # Notes -+ /// -+ /// This method is required to be called for **all** I/O operations to -+ /// ensure the user will receive events once the socket is ready again after -+ /// returning a [`WouldBlock`] error. -+ /// -+ /// [`WouldBlock`]: io::ErrorKind::WouldBlock -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// # use std::error::Error; -+ /// # -+ /// # fn main() -> Result<(), Box> { -+ /// use std::io; -+ /// use std::os::unix::io::AsRawFd; -+ /// use mio::unix::pipe; -+ /// -+ /// let (sender, receiver) = pipe::new()?; -+ /// -+ /// // Wait until the sender is writable... -+ /// -+ /// // Write to the sender using a direct libc call, of course the -+ /// // `io::Write` implementation would be easier to use. -+ /// let buf = b"hello"; -+ /// let n = sender.try_io(|| { -+ /// let buf_ptr = &buf as *const _ as *const _; -+ /// let res = unsafe { libc::write(sender.as_raw_fd(), buf_ptr, buf.len()) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::write, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("write {} bytes", n); -+ /// -+ /// // Wait until the receiver is readable... -+ /// -+ /// // Read from the receiver using a direct libc call, of course the -+ /// // `io::Read` implementation would be easier to use. -+ /// let mut buf = [0; 512]; -+ /// let n = receiver.try_io(|| { -+ /// let buf_ptr = &mut buf as *mut _ as *mut _; -+ /// let res = unsafe { libc::read(receiver.as_raw_fd(), buf_ptr, buf.len()) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::read, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("read {} bytes", n); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn try_io(&self, f: F) -> io::Result -+ where -+ F: FnOnce() -> io::Result, -+ { -+ self.inner.do_io(|_| f()) -+ } - } - - impl event::Source for Sender { -@@ -244,29 +337,29 @@ impl event::Source for Sender { - - impl Write for Sender { - fn write(&mut self, buf: &[u8]) -> io::Result { -- self.inner.do_io(|sender| (&*sender).write(buf)) -+ self.inner.do_io(|mut sender| sender.write(buf)) - } - - fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result { -- self.inner.do_io(|sender| (&*sender).write_vectored(bufs)) -+ self.inner.do_io(|mut sender| sender.write_vectored(bufs)) - } - - fn flush(&mut self) -> io::Result<()> { -- self.inner.do_io(|sender| (&*sender).flush()) -+ self.inner.do_io(|mut sender| sender.flush()) - } - } - - impl Write for &Sender { - fn write(&mut self, buf: &[u8]) -> io::Result { -- self.inner.do_io(|sender| (&*sender).write(buf)) -+ self.inner.do_io(|mut sender| sender.write(buf)) - } - - fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result { -- self.inner.do_io(|sender| (&*sender).write_vectored(bufs)) -+ self.inner.do_io(|mut sender| sender.write_vectored(bufs)) - } - - fn flush(&mut self) -> io::Result<()> { -- self.inner.do_io(|sender| (&*sender).flush()) -+ self.inner.do_io(|mut sender| sender.flush()) - } - } - -@@ -313,6 +406,74 @@ impl Receiver { - pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> { - set_nonblocking(self.inner.as_raw_fd(), nonblocking) - } -+ -+ /// Execute an I/O operation ensuring that the socket receives more events -+ /// if it hits a [`WouldBlock`] error. -+ /// -+ /// # Notes -+ /// -+ /// This method is required to be called for **all** I/O operations to -+ /// ensure the user will receive events once the socket is ready again after -+ /// returning a [`WouldBlock`] error. -+ /// -+ /// [`WouldBlock`]: io::ErrorKind::WouldBlock -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// # use std::error::Error; -+ /// # -+ /// # fn main() -> Result<(), Box> { -+ /// use std::io; -+ /// use std::os::unix::io::AsRawFd; -+ /// use mio::unix::pipe; -+ /// -+ /// let (sender, receiver) = pipe::new()?; -+ /// -+ /// // Wait until the sender is writable... -+ /// -+ /// // Write to the sender using a direct libc call, of course the -+ /// // `io::Write` implementation would be easier to use. -+ /// let buf = b"hello"; -+ /// let n = sender.try_io(|| { -+ /// let buf_ptr = &buf as *const _ as *const _; -+ /// let res = unsafe { libc::write(sender.as_raw_fd(), buf_ptr, buf.len()) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::write, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("write {} bytes", n); -+ /// -+ /// // Wait until the receiver is readable... -+ /// -+ /// // Read from the receiver using a direct libc call, of course the -+ /// // `io::Read` implementation would be easier to use. -+ /// let mut buf = [0; 512]; -+ /// let n = receiver.try_io(|| { -+ /// let buf_ptr = &mut buf as *mut _ as *mut _; -+ /// let res = unsafe { libc::read(receiver.as_raw_fd(), buf_ptr, buf.len()) }; -+ /// if res != -1 { -+ /// Ok(res as usize) -+ /// } else { -+ /// // If EAGAIN or EWOULDBLOCK is set by libc::read, the closure -+ /// // should return `WouldBlock` error. -+ /// Err(io::Error::last_os_error()) -+ /// } -+ /// })?; -+ /// eprintln!("read {} bytes", n); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn try_io(&self, f: F) -> io::Result -+ where -+ F: FnOnce() -> io::Result, -+ { -+ self.inner.do_io(|_| f()) -+ } - } - - impl event::Source for Receiver { -@@ -341,21 +502,21 @@ impl event::Source for Receiver { - - impl Read for Receiver { - fn read(&mut self, buf: &mut [u8]) -> io::Result { -- self.inner.do_io(|sender| (&*sender).read(buf)) -+ self.inner.do_io(|mut sender| sender.read(buf)) - } - - fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result { -- self.inner.do_io(|sender| (&*sender).read_vectored(bufs)) -+ self.inner.do_io(|mut sender| sender.read_vectored(bufs)) - } - } - - impl Read for &Receiver { - fn read(&mut self, buf: &mut [u8]) -> io::Result { -- self.inner.do_io(|sender| (&*sender).read(buf)) -+ self.inner.do_io(|mut sender| sender.read(buf)) - } - - fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result { -- self.inner.do_io(|sender| (&*sender).read_vectored(bufs)) -+ self.inner.do_io(|mut sender| sender.read_vectored(bufs)) - } - } - -@@ -399,7 +560,7 @@ impl IntoRawFd for Receiver { - } - } - --#[cfg(not(target_os = "illumos"))] -+#[cfg(not(any(target_os = "illumos", target_os = "solaris", target_os = "vita")))] - fn set_nonblocking(fd: RawFd, nonblocking: bool) -> io::Result<()> { - let value = nonblocking as libc::c_int; - if unsafe { libc::ioctl(fd, libc::FIONBIO, &value) } == -1 { -@@ -409,7 +570,7 @@ fn set_nonblocking(fd: RawFd, nonblocking: bool) -> io::Result<()> { - } - } - --#[cfg(target_os = "illumos")] -+#[cfg(any(target_os = "illumos", target_os = "solaris", target_os = "vita"))] - fn set_nonblocking(fd: RawFd, nonblocking: bool) -> io::Result<()> { - let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) }; - if flags < 0 { -@@ -430,3 +591,4 @@ fn set_nonblocking(fd: RawFd, nonblocking: bool) -> io::Result<()> { - - Ok(()) - } -+} // `cfg_os_ext!`. -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/selector/epoll.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/selector/epoll.rs -index 38667d66..c0a8a4c1 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/selector/epoll.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/selector/epoll.rs -@@ -1,10 +1,9 @@ - use crate::{Interest, Token}; - --use libc::{EPOLLET, EPOLLIN, EPOLLOUT, EPOLLRDHUP}; --use log::error; -+use libc::{EPOLLET, EPOLLIN, EPOLLOUT, EPOLLPRI, EPOLLRDHUP}; - use std::os::unix::io::{AsRawFd, RawFd}; - #[cfg(debug_assertions)] --use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; -+use std::sync::atomic::{AtomicUsize, Ordering}; - use std::time::Duration; - use std::{cmp, i32, io, ptr}; - -@@ -17,26 +16,48 @@ pub struct Selector { - #[cfg(debug_assertions)] - id: usize, - ep: RawFd, -- #[cfg(debug_assertions)] -- has_waker: AtomicBool, - } - - impl Selector { - pub fn new() -> io::Result { -+ #[cfg(not(target_os = "android"))] -+ let res = syscall!(epoll_create1(libc::EPOLL_CLOEXEC)); -+ -+ // On Android < API level 16 `epoll_create1` is not defined, so use a -+ // raw system call. - // According to libuv, `EPOLL_CLOEXEC` is not defined on Android API < - // 21. But `EPOLL_CLOEXEC` is an alias for `O_CLOEXEC` on that platform, - // so we use it instead. - #[cfg(target_os = "android")] -- let flag = libc::O_CLOEXEC; -- #[cfg(not(target_os = "android"))] -- let flag = libc::EPOLL_CLOEXEC; -+ let res = syscall!(syscall(libc::SYS_epoll_create1, libc::O_CLOEXEC)); -+ -+ let ep = match res { -+ Ok(ep) => ep as RawFd, -+ Err(err) => { -+ // When `epoll_create1` is not available fall back to use -+ // `epoll_create` followed by `fcntl`. -+ if let Some(libc::ENOSYS) = err.raw_os_error() { -+ match syscall!(epoll_create(1024)) { -+ Ok(ep) => match syscall!(fcntl(ep, libc::F_SETFD, libc::FD_CLOEXEC)) { -+ Ok(ep) => ep as RawFd, -+ Err(err) => { -+ // `fcntl` failed, cleanup `ep`. -+ let _ = unsafe { libc::close(ep) }; -+ return Err(err); -+ } -+ }, -+ Err(err) => return Err(err), -+ } -+ } else { -+ return Err(err); -+ } -+ } -+ }; - -- syscall!(epoll_create1(flag)).map(|ep| Selector { -+ Ok(Selector { - #[cfg(debug_assertions)] - id: NEXT_ID.fetch_add(1, Ordering::Relaxed), - ep, -- #[cfg(debug_assertions)] -- has_waker: AtomicBool::new(false), - }) - } - -@@ -46,8 +67,6 @@ impl Selector { - #[cfg(debug_assertions)] - id: self.id, - ep, -- #[cfg(debug_assertions)] -- has_waker: AtomicBool::new(self.has_waker.load(Ordering::Acquire)), - }) - } - -@@ -61,7 +80,17 @@ impl Selector { - const MAX_SAFE_TIMEOUT: u128 = libc::c_int::max_value() as u128; - - let timeout = timeout -- .map(|to| cmp::min(to.as_millis(), MAX_SAFE_TIMEOUT) as libc::c_int) -+ .map(|to| { -+ // `Duration::as_millis` truncates, so round up. This avoids -+ // turning sub-millisecond timeouts into a zero timeout, unless -+ // the caller explicitly requests that by specifying a zero -+ // timeout. -+ let to_ms = to -+ .checked_add(Duration::from_nanos(999_999)) -+ .unwrap_or(to) -+ .as_millis(); -+ cmp::min(MAX_SAFE_TIMEOUT, to_ms) as libc::c_int -+ }) - .unwrap_or(-1); - - events.clear(); -@@ -82,6 +111,8 @@ impl Selector { - let mut event = libc::epoll_event { - events: interests_to_epoll(interests), - u64: usize::from(token) as u64, -+ #[cfg(target_os = "redox")] -+ _pad: 0, - }; - - syscall!(epoll_ctl(self.ep, libc::EPOLL_CTL_ADD, fd, &mut event)).map(|_| ()) -@@ -91,6 +122,8 @@ impl Selector { - let mut event = libc::epoll_event { - events: interests_to_epoll(interests), - u64: usize::from(token) as u64, -+ #[cfg(target_os = "redox")] -+ _pad: 0, - }; - - syscall!(epoll_ctl(self.ep, libc::EPOLL_CTL_MOD, fd, &mut event)).map(|_| ()) -@@ -99,11 +132,6 @@ impl Selector { - pub fn deregister(&self, fd: RawFd) -> io::Result<()> { - syscall!(epoll_ctl(self.ep, libc::EPOLL_CTL_DEL, fd, ptr::null_mut())).map(|_| ()) - } -- -- #[cfg(debug_assertions)] -- pub fn register_waker(&self) -> bool { -- self.has_waker.swap(true, Ordering::AcqRel) -- } - } - - cfg_io_source! { -@@ -140,6 +168,10 @@ fn interests_to_epoll(interests: Interest) -> u32 { - kind |= EPOLLOUT; - } - -+ if interests.is_priority() { -+ kind |= EPOLLPRI; -+ } -+ - kind as u32 - } - -@@ -222,7 +254,7 @@ pub mod event { - libc::EPOLLET, - libc::EPOLLRDHUP, - libc::EPOLLONESHOT, -- #[cfg(any(target_os = "linux", target_os = "solaris"))] -+ #[cfg(target_os = "linux")] - libc::EPOLLEXCLUSIVE, - #[cfg(any(target_os = "android", target_os = "linux"))] - libc::EPOLLWAKEUP, -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/selector/kqueue.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/selector/kqueue.rs -index b36a5375..0a2a24a5 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/selector/kqueue.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/selector/kqueue.rs -@@ -1,10 +1,9 @@ - use crate::{Interest, Token}; --use log::error; --use std::mem::MaybeUninit; -+use std::mem::{self, MaybeUninit}; - use std::ops::{Deref, DerefMut}; - use std::os::unix::io::{AsRawFd, RawFd}; - #[cfg(debug_assertions)] --use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; -+use std::sync::atomic::{AtomicUsize, Ordering}; - use std::time::Duration; - use std::{cmp, io, ptr, slice}; - -@@ -21,7 +20,12 @@ type Count = libc::size_t; - // Type of the `filter` field in the `kevent` structure. - #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))] - type Filter = libc::c_short; --#[cfg(any(target_os = "macos", target_os = "ios"))] -+#[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+))] - type Filter = i16; - #[cfg(target_os = "netbsd")] - type Filter = u32; -@@ -29,21 +33,15 @@ type Filter = u32; - // Type of the `flags` field in the `kevent` structure. - #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))] - type Flags = libc::c_ushort; --#[cfg(any(target_os = "macos", target_os = "ios"))] --type Flags = u16; --#[cfg(target_os = "netbsd")] --type Flags = u32; -- --// Type of the `data` field in the `kevent` structure. - #[cfg(any( -- target_os = "dragonfly", -- target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" - ))] --type Data = libc::intptr_t; --#[cfg(any(target_os = "netbsd", target_os = "openbsd"))] --type Data = i64; -+type Flags = u16; -+#[cfg(target_os = "netbsd")] -+type Flags = u32; - - // Type of the `udata` field in the `kevent` structure. - #[cfg(not(target_os = "netbsd"))] -@@ -57,9 +55,8 @@ macro_rules! kevent { - ident: $id as libc::uintptr_t, - filter: $filter as Filter, - flags: $flags, -- fflags: 0, -- data: 0, - udata: $data as UData, -+ ..unsafe { mem::zeroed() } - } - }; - } -@@ -69,21 +66,19 @@ pub struct Selector { - #[cfg(debug_assertions)] - id: usize, - kq: RawFd, -- #[cfg(debug_assertions)] -- has_waker: AtomicBool, - } - - impl Selector { - pub fn new() -> io::Result { -- syscall!(kqueue()) -- .and_then(|kq| syscall!(fcntl(kq, libc::F_SETFD, libc::FD_CLOEXEC)).map(|_| kq)) -- .map(|kq| Selector { -- #[cfg(debug_assertions)] -- id: NEXT_ID.fetch_add(1, Ordering::Relaxed), -- kq, -- #[cfg(debug_assertions)] -- has_waker: AtomicBool::new(false), -- }) -+ let kq = syscall!(kqueue())?; -+ let selector = Selector { -+ #[cfg(debug_assertions)] -+ id: NEXT_ID.fetch_add(1, Ordering::Relaxed), -+ kq, -+ }; -+ -+ syscall!(fcntl(kq, libc::F_SETFD, libc::FD_CLOEXEC))?; -+ Ok(selector) - } - - pub fn try_clone(&self) -> io::Result { -@@ -92,8 +87,6 @@ impl Selector { - #[cfg(debug_assertions)] - id: self.id, - kq, -- #[cfg(debug_assertions)] -- has_waker: AtomicBool::new(self.has_waker.load(Ordering::Acquire)), - }) - } - -@@ -163,7 +156,7 @@ impl Selector { - // the array. - slice::from_raw_parts_mut(changes[0].as_mut_ptr(), n_changes) - }; -- kevent_register(self.kq, changes, &[libc::EPIPE as Data]) -+ kevent_register(self.kq, changes, &[libc::EPIPE as i64]) - } - - pub fn reregister(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { -@@ -195,7 +188,7 @@ impl Selector { - kevent_register( - self.kq, - &mut changes, -- &[libc::ENOENT as Data, libc::EPIPE as Data], -+ &[libc::ENOENT as i64, libc::EPIPE as i64], - ) - } - -@@ -211,16 +204,17 @@ impl Selector { - // the ENOENT error when it comes up. The ENOENT error informs us that - // the filter wasn't there in first place, but we don't really care - // about that since our goal is to remove it. -- kevent_register(self.kq, &mut changes, &[libc::ENOENT as Data]) -- } -- -- #[cfg(debug_assertions)] -- pub fn register_waker(&self) -> bool { -- self.has_waker.swap(true, Ordering::AcqRel) -+ kevent_register(self.kq, &mut changes, &[libc::ENOENT as i64]) - } - - // Used by `Waker`. -- #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - pub fn setup_waker(&self, token: Token) -> io::Result<()> { - // First attempt to accept user space notifications. - let mut kevent = kevent!( -@@ -240,7 +234,13 @@ impl Selector { - } - - // Used by `Waker`. -- #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - pub fn wake(&self, token: Token) -> io::Result<()> { - let mut kevent = kevent!( - 0, -@@ -264,7 +264,7 @@ impl Selector { - fn kevent_register( - kq: RawFd, - changes: &mut [libc::kevent], -- ignored_errors: &[Data], -+ ignored_errors: &[i64], - ) -> io::Result<()> { - syscall!(kevent( - kq, -@@ -285,15 +285,15 @@ fn kevent_register( - Err(err) - } - }) -- .and_then(|()| check_errors(&changes, ignored_errors)) -+ .and_then(|()| check_errors(changes, ignored_errors)) - } - - /// Check all events for possible errors, it returns the first error found. --fn check_errors(events: &[libc::kevent], ignored_errors: &[Data]) -> io::Result<()> { -+fn check_errors(events: &[libc::kevent], ignored_errors: &[i64]) -> io::Result<()> { - for event in events { - // We can't use references to packed structures (in checking the ignored - // errors), so we need copy the data out before use. -- let data = event.data; -+ let data = event.data as _; - // Check for the error flag, the actual error will be in the `data` - // field. - if (event.flags & libc::EV_ERROR != 0) && data != 0 && !ignored_errors.contains(&data) { -@@ -371,14 +371,26 @@ pub mod event { - - pub fn is_readable(event: &Event) -> bool { - event.filter == libc::EVFILT_READ || { -- #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - // Used by the `Awakener`. On platforms that use `eventfd` or a unix - // pipe it will emit a readable event so we'll fake that here as - // well. - { - event.filter == libc::EVFILT_USER - } -- #[cfg(not(any(target_os = "freebsd", target_os = "ios", target_os = "macos")))] -+ #[cfg(not(any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ )))] - { - false - } -@@ -415,7 +427,9 @@ pub mod event { - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - { - event.filter == libc::EVFILT_AIO -@@ -424,7 +438,9 @@ pub mod event { - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - )))] - { - false -@@ -460,7 +476,9 @@ pub mod event { - target_os = "freebsd", - target_os = "dragonfly", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::EVFILT_FS, - #[cfg(target_os = "freebsd")] -@@ -469,7 +487,9 @@ pub mod event { - target_os = "freebsd", - target_os = "dragonfly", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::EVFILT_USER, - #[cfg(target_os = "freebsd")] -@@ -478,9 +498,19 @@ pub mod event { - libc::EVFILT_EMPTY, - #[cfg(target_os = "dragonfly")] - libc::EVFILT_EXCEPT, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::EVFILT_MACHPORT, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::EVFILT_VM, - ); - -@@ -505,11 +535,26 @@ pub mod event { - libc::EV_ERROR, - libc::EV_EOF, - libc::EV_SYSFLAGS, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::EV_FLAG0, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::EV_POLL, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::EV_OOBAND, - #[cfg(target_os = "dragonfly")] - libc::EV_NODATA, -@@ -526,49 +571,63 @@ pub mod event { - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::NOTE_TRIGGER, - #[cfg(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::NOTE_FFNOP, - #[cfg(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::NOTE_FFAND, - #[cfg(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::NOTE_FFOR, - #[cfg(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::NOTE_FFCOPY, - #[cfg(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::NOTE_FFCTRLMASK, - #[cfg(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", -- target_os = "macos" -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", - ))] - libc::NOTE_FFLAGSMASK, - libc::NOTE_LOWAT, -@@ -578,24 +637,49 @@ pub mod event { - libc::NOTE_OOB, - #[cfg(target_os = "openbsd")] - libc::NOTE_EOF, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_EXTEND, - libc::NOTE_ATTRIB, - libc::NOTE_LINK, - libc::NOTE_RENAME, - libc::NOTE_REVOKE, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_NONE, - #[cfg(any(target_os = "openbsd"))] - libc::NOTE_TRUNCATE, - libc::NOTE_EXIT, - libc::NOTE_FORK, - libc::NOTE_EXEC, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_SIGNAL, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_EXITSTATUS, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_EXIT_DETAIL, - libc::NOTE_PDATAMASK, - libc::NOTE_PCTRLMASK, -@@ -603,55 +687,132 @@ pub mod event { - target_os = "dragonfly", - target_os = "freebsd", - target_os = "netbsd", -- target_os = "openbsd" -+ target_os = "openbsd", - ))] - libc::NOTE_TRACK, - #[cfg(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "netbsd", -- target_os = "openbsd" -+ target_os = "openbsd", - ))] - libc::NOTE_TRACKERR, - #[cfg(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "netbsd", -- target_os = "openbsd" -+ target_os = "openbsd", - ))] - libc::NOTE_CHILD, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_EXIT_DETAIL_MASK, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_EXIT_DECRYPTFAIL, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_EXIT_MEMORY, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_EXIT_CSERROR, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_VM_PRESSURE, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_VM_PRESSURE_TERMINATE, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_VM_PRESSURE_SUDDEN_TERMINATE, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_VM_ERROR, -- #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_SECONDS, - #[cfg(any(target_os = "freebsd"))] - libc::NOTE_MSECONDS, -- #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_USECONDS, -- #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_NSECONDS, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -- #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_ABSOLUTE, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_LEEWAY, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_CRITICAL, -- #[cfg(any(target_os = "ios", target_os = "macos"))] -+ #[cfg(any( -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos" -+ ))] - libc::NOTE_BACKGROUND, - ); - -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/selector/mod.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/selector/mod.rs -index b73d645b..322673d1 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/selector/mod.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/selector/mod.rs -@@ -1,36 +1,71 @@ --#[cfg(any( -- target_os = "android", -- target_os = "illumos", -- target_os = "linux", -- target_os = "solaris" -+#[cfg(all( -+ not(mio_unsupported_force_poll_poll), -+ any( -+ target_os = "android", -+ target_os = "illumos", -+ target_os = "linux", -+ target_os = "redox", -+ ) - ))] - mod epoll; - --#[cfg(any( -- target_os = "android", -- target_os = "illumos", -- target_os = "linux", -- target_os = "solaris" -+#[cfg(all( -+ not(mio_unsupported_force_poll_poll), -+ any( -+ target_os = "android", -+ target_os = "illumos", -+ target_os = "linux", -+ target_os = "redox", -+ ) - ))] - pub(crate) use self::epoll::{event, Event, Events, Selector}; - - #[cfg(any( -- target_os = "dragonfly", -- target_os = "freebsd", -- target_os = "ios", -- target_os = "macos", -- target_os = "netbsd", -- target_os = "openbsd" -+ mio_unsupported_force_poll_poll, -+ target_os = "solaris", -+ target_os = "vita" - ))] --mod kqueue; -+mod poll; - - #[cfg(any( -- target_os = "dragonfly", -- target_os = "freebsd", -- target_os = "ios", -- target_os = "macos", -- target_os = "netbsd", -- target_os = "openbsd" -+ mio_unsupported_force_poll_poll, -+ target_os = "solaris", -+ target_os = "vita" -+))] -+pub(crate) use self::poll::{event, Event, Events, Selector}; -+ -+cfg_io_source! { -+ #[cfg(any(mio_unsupported_force_poll_poll, target_os = "solaris", target_os = "vita"))] -+ pub(crate) use self::poll::IoSourceState; -+} -+ -+#[cfg(all( -+ not(mio_unsupported_force_poll_poll), -+ any( -+ target_os = "dragonfly", -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "netbsd", -+ target_os = "openbsd", -+ target_os = "tvos", -+ target_os = "watchos", -+ ) -+))] -+mod kqueue; -+ -+#[cfg(all( -+ not(mio_unsupported_force_poll_poll), -+ any( -+ target_os = "dragonfly", -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "netbsd", -+ target_os = "openbsd", -+ target_os = "tvos", -+ target_os = "watchos", -+ ), - ))] - pub(crate) use self::kqueue::{event, Event, Events, Selector}; - -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/selector/poll.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/selector/poll.rs -new file mode 100644 -index 00000000..8346e07b ---- /dev/null -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/selector/poll.rs -@@ -0,0 +1,726 @@ -+// This implementation is based on the one in the `polling` crate. -+// Thanks to https://github.com/Kestrer for the original implementation! -+// Permission to use this code has been granted by original author: -+// https://github.com/tokio-rs/mio/pull/1602#issuecomment-1218441031 -+ -+use crate::sys::unix::selector::LOWEST_FD; -+use crate::sys::unix::waker::WakerInternal; -+use crate::{Interest, Token}; -+use std::collections::HashMap; -+use std::fmt::{Debug, Formatter}; -+use std::os::unix::io::{AsRawFd, RawFd}; -+use std::sync::atomic::AtomicBool; -+use std::sync::atomic::{AtomicUsize, Ordering}; -+use std::sync::{Arc, Condvar, Mutex}; -+use std::time::Duration; -+use std::{cmp, fmt, io}; -+ -+/// Unique id for use as `SelectorId`. -+#[cfg(debug_assertions)] -+static NEXT_ID: AtomicUsize = AtomicUsize::new(1); -+ -+#[derive(Debug)] -+pub struct Selector { -+ state: Arc, -+} -+ -+impl Selector { -+ pub fn new() -> io::Result { -+ let state = SelectorState::new()?; -+ -+ Ok(Selector { -+ state: Arc::new(state), -+ }) -+ } -+ -+ pub fn try_clone(&self) -> io::Result { -+ // Just to keep the compiler happy :) -+ let _ = LOWEST_FD; -+ -+ let state = self.state.clone(); -+ -+ Ok(Selector { state }) -+ } -+ -+ pub fn select(&self, events: &mut Events, timeout: Option) -> io::Result<()> { -+ self.state.select(events, timeout) -+ } -+ -+ pub fn register(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { -+ self.state.register(fd, token, interests) -+ } -+ -+ #[allow(dead_code)] -+ pub(crate) fn register_internal( -+ &self, -+ fd: RawFd, -+ token: Token, -+ interests: Interest, -+ ) -> io::Result> { -+ self.state.register_internal(fd, token, interests) -+ } -+ -+ pub fn reregister(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { -+ self.state.reregister(fd, token, interests) -+ } -+ -+ pub fn deregister(&self, fd: RawFd) -> io::Result<()> { -+ self.state.deregister(fd) -+ } -+ -+ pub fn wake(&self, token: Token) -> io::Result<()> { -+ self.state.wake(token) -+ } -+ cfg_io_source! { -+ #[cfg(debug_assertions)] -+ pub fn id(&self) -> usize { -+ self.state.id -+ } -+ } -+} -+ -+/// Interface to poll. -+#[derive(Debug)] -+struct SelectorState { -+ /// File descriptors to poll. -+ fds: Mutex, -+ -+ /// File descriptors which will be removed before the next poll call. -+ /// -+ /// When a file descriptor is deregistered while a poll is running, we need to filter -+ /// out all removed descriptors after that poll is finished running. -+ pending_removal: Mutex>, -+ -+ /// Token associated with Waker that have recently asked to wake. This will -+ /// cause a synthetic behaviour where on any wakeup we add all pending tokens -+ /// to the list of emitted events. -+ pending_wake_token: Mutex>, -+ -+ /// Data is written to this to wake up the current instance of `wait`, which can occur when the -+ /// user notifies it (in which case `notified` would have been set) or when an operation needs -+ /// to occur (in which case `waiting_operations` would have been incremented). -+ notify_waker: WakerInternal, -+ -+ /// The number of operations (`add`, `modify` or `delete`) that are currently waiting on the -+ /// mutex to become free. When this is nonzero, `wait` must be suspended until it reaches zero -+ /// again. -+ waiting_operations: AtomicUsize, -+ /// The condition variable that gets notified when `waiting_operations` reaches zero or -+ /// `notified` becomes true. -+ /// -+ /// This is used with the `fds` mutex. -+ operations_complete: Condvar, -+ -+ /// This selectors id. -+ #[cfg(debug_assertions)] -+ #[allow(dead_code)] -+ id: usize, -+} -+ -+/// The file descriptors to poll in a `Poller`. -+#[derive(Debug, Clone)] -+struct Fds { -+ /// The list of `pollfds` taken by poll. -+ /// -+ /// The first file descriptor is always present and is used to notify the poller. -+ poll_fds: Vec, -+ /// The map of each file descriptor to data associated with it. This does not include the file -+ /// descriptors created by the internal notify waker. -+ fd_data: HashMap, -+} -+ -+/// Transparent wrapper around `libc::pollfd`, used to support `Debug` derives without adding the -+/// `extra_traits` feature of `libc`. -+#[repr(transparent)] -+#[derive(Clone)] -+struct PollFd(libc::pollfd); -+ -+impl Debug for PollFd { -+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { -+ f.debug_struct("pollfd") -+ .field("fd", &self.0.fd) -+ .field("events", &self.0.events) -+ .field("revents", &self.0.revents) -+ .finish() -+ } -+} -+ -+/// Data associated with a file descriptor in a poller. -+#[derive(Debug, Clone)] -+struct FdData { -+ /// The index into `poll_fds` this file descriptor is. -+ poll_fds_index: usize, -+ /// The key of the `Event` associated with this file descriptor. -+ token: Token, -+ /// Used to communicate with IoSourceState when we need to internally deregister -+ /// based on a closed fd. -+ shared_record: Arc, -+} -+ -+impl SelectorState { -+ pub fn new() -> io::Result { -+ let notify_waker = WakerInternal::new()?; -+ -+ Ok(Self { -+ fds: Mutex::new(Fds { -+ poll_fds: vec![PollFd(libc::pollfd { -+ fd: notify_waker.as_raw_fd(), -+ events: libc::POLLIN, -+ revents: 0, -+ })], -+ fd_data: HashMap::new(), -+ }), -+ pending_removal: Mutex::new(Vec::new()), -+ pending_wake_token: Mutex::new(None), -+ notify_waker, -+ waiting_operations: AtomicUsize::new(0), -+ operations_complete: Condvar::new(), -+ #[cfg(debug_assertions)] -+ id: NEXT_ID.fetch_add(1, Ordering::Relaxed), -+ }) -+ } -+ -+ pub fn select(&self, events: &mut Events, timeout: Option) -> io::Result<()> { -+ events.clear(); -+ -+ let mut fds = self.fds.lock().unwrap(); -+ -+ // Keep track of fds that receive POLLHUP or POLLERR (i.e. won't receive further -+ // events) and internally deregister them before they are externally deregister'd. See -+ // IoSourceState below to track how the external deregister call will be handled -+ // when this state occurs. -+ let mut closed_raw_fds = Vec::new(); -+ -+ loop { -+ // Complete all current operations. -+ loop { -+ if self.waiting_operations.load(Ordering::SeqCst) == 0 { -+ break; -+ } -+ -+ fds = self.operations_complete.wait(fds).unwrap(); -+ } -+ -+ // Perform the poll. -+ trace!("Polling on {:?}", &fds); -+ let num_events = poll(&mut fds.poll_fds, timeout)?; -+ trace!("Poll finished: {:?}", &fds); -+ -+ if num_events == 0 { -+ return Ok(()); -+ } -+ -+ let waker_events = fds.poll_fds[0].0.revents; -+ let notified = waker_events != 0; -+ let mut num_fd_events = if notified { num_events - 1 } else { num_events }; -+ -+ let pending_wake_token = self.pending_wake_token.lock().unwrap().take(); -+ -+ if notified { -+ self.notify_waker.ack_and_reset(); -+ if pending_wake_token.is_some() { -+ num_fd_events += 1; -+ } -+ } -+ -+ // We now check whether this poll was performed with descriptors which were pending -+ // for removal and filter out any matching. -+ let mut pending_removal_guard = self.pending_removal.lock().unwrap(); -+ let mut pending_removal = std::mem::replace(pending_removal_guard.as_mut(), Vec::new()); -+ drop(pending_removal_guard); -+ -+ // Store the events if there were any. -+ if num_fd_events > 0 { -+ let fds = &mut *fds; -+ -+ events.reserve(num_fd_events); -+ -+ // Add synthetic events we picked up from calls to wake() -+ if let Some(pending_wake_token) = pending_wake_token { -+ events.push(Event { -+ token: pending_wake_token, -+ events: waker_events, -+ }); -+ } -+ -+ for fd_data in fds.fd_data.values_mut() { -+ let PollFd(poll_fd) = &mut fds.poll_fds[fd_data.poll_fds_index]; -+ -+ if pending_removal.contains(&poll_fd.fd) { -+ // Fd was removed while poll was running -+ continue; -+ } -+ -+ if poll_fd.revents != 0 { -+ // Store event -+ events.push(Event { -+ token: fd_data.token, -+ events: poll_fd.revents, -+ }); -+ -+ if poll_fd.revents & (libc::POLLHUP | libc::POLLERR) != 0 { -+ pending_removal.push(poll_fd.fd); -+ closed_raw_fds.push(poll_fd.fd); -+ } -+ -+ // Remove the interest which just got triggered the IoSourceState's do_io -+ // wrapper used with this selector will add back the interest using -+ // reregister. -+ poll_fd.events &= !poll_fd.revents; -+ -+ // Minor optimization to potentially avoid looping n times where n is the -+ // number of input fds (i.e. we might loop between m and n times where m is -+ // the number of fds with revents != 0). -+ if events.len() == num_fd_events { -+ break; -+ } -+ } -+ } -+ -+ break; // No more polling. -+ } -+ -+ // If we didn't break above it means we got woken up internally (for example for adding an fd), so we poll again. -+ } -+ -+ drop(fds); -+ let _ = self.deregister_all(&closed_raw_fds); -+ -+ Ok(()) -+ } -+ -+ pub fn register(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { -+ self.register_internal(fd, token, interests).map(|_| ()) -+ } -+ -+ pub fn register_internal( -+ &self, -+ fd: RawFd, -+ token: Token, -+ interests: Interest, -+ ) -> io::Result> { -+ #[cfg(debug_assertions)] -+ if fd == self.notify_waker.as_raw_fd() { -+ return Err(io::Error::from(io::ErrorKind::InvalidInput)); -+ } -+ -+ // We must handle the unlikely case that the following order of operations happens: -+ // -+ // register(1 as RawFd) -+ // deregister(1 as RawFd) -+ // register(1 as RawFd) -+ // -+ // -+ // Fd's pending removal only get cleared when poll has been run. It is possible that -+ // between registering and deregistering and then _again_ registering the file descriptor -+ // poll never gets called, thus the fd stays stuck in the pending removal list. -+ // -+ // To avoid this scenario we remove an fd from pending removals when registering it. -+ let mut pending_removal = self.pending_removal.lock().unwrap(); -+ if let Some(idx) = pending_removal.iter().position(|&pending| pending == fd) { -+ pending_removal.swap_remove(idx); -+ } -+ drop(pending_removal); -+ -+ self.modify_fds(|fds| { -+ if fds.fd_data.contains_key(&fd) { -+ return Err(io::Error::new( -+ io::ErrorKind::AlreadyExists, -+ "I/O source already registered this `Registry` \ -+ (an old file descriptor might have been closed without deregistration)", -+ )); -+ } -+ -+ let poll_fds_index = fds.poll_fds.len(); -+ let record = Arc::new(RegistrationRecord::new()); -+ fds.fd_data.insert( -+ fd, -+ FdData { -+ poll_fds_index, -+ token, -+ shared_record: record.clone(), -+ }, -+ ); -+ -+ fds.poll_fds.push(PollFd(libc::pollfd { -+ fd, -+ events: interests_to_poll(interests), -+ revents: 0, -+ })); -+ -+ Ok(record) -+ }) -+ } -+ -+ pub fn reregister(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { -+ self.modify_fds(|fds| { -+ let data = fds.fd_data.get_mut(&fd).ok_or(io::ErrorKind::NotFound)?; -+ data.token = token; -+ let poll_fds_index = data.poll_fds_index; -+ fds.poll_fds[poll_fds_index].0.events = interests_to_poll(interests); -+ -+ Ok(()) -+ }) -+ } -+ -+ pub fn deregister(&self, fd: RawFd) -> io::Result<()> { -+ self.deregister_all(&[fd]) -+ .map_err(|_| io::ErrorKind::NotFound)?; -+ Ok(()) -+ } -+ -+ /// Perform a modification on `fds`, interrupting the current caller of `wait` if it's running. -+ fn modify_fds(&self, f: impl FnOnce(&mut Fds) -> T) -> T { -+ self.waiting_operations.fetch_add(1, Ordering::SeqCst); -+ -+ // Wake up the current caller of `wait` if there is one. -+ let sent_notification = self.notify_waker.wake().is_ok(); -+ -+ let mut fds = self.fds.lock().unwrap(); -+ -+ // If there was no caller of `wait` our notification was not removed from the pipe. -+ if sent_notification { -+ self.notify_waker.ack_and_reset(); -+ } -+ -+ let res = f(&mut *fds); -+ -+ if self.waiting_operations.fetch_sub(1, Ordering::SeqCst) == 1 { -+ self.operations_complete.notify_one(); -+ } -+ -+ res -+ } -+ -+ /// Special optimized version of [Self::deregister] which handles multiple removals -+ /// at once. Ok result if all removals were performed, Err if any entries -+ /// were not found. -+ fn deregister_all(&self, targets: &[RawFd]) -> Result<(), ()> { -+ if targets.is_empty() { -+ return Ok(()); -+ } -+ -+ let mut pending_removal = self.pending_removal.lock().unwrap(); -+ pending_removal.extend(targets); -+ drop(pending_removal); -+ -+ self.modify_fds(|fds| { -+ let mut all_successful = true; -+ -+ for target in targets { -+ match fds.fd_data.remove(target).ok_or(()) { -+ Ok(data) => { -+ data.shared_record.mark_unregistered(); -+ fds.poll_fds.swap_remove(data.poll_fds_index); -+ if let Some(swapped_pollfd) = fds.poll_fds.get(data.poll_fds_index) { -+ fds.fd_data -+ .get_mut(&swapped_pollfd.0.fd) -+ .unwrap() -+ .poll_fds_index = data.poll_fds_index; -+ } -+ } -+ Err(_) => all_successful = false, -+ } -+ } -+ -+ if all_successful { -+ Ok(()) -+ } else { -+ Err(()) -+ } -+ }) -+ } -+ -+ pub fn wake(&self, token: Token) -> io::Result<()> { -+ self.pending_wake_token.lock().unwrap().replace(token); -+ self.notify_waker.wake() -+ } -+} -+ -+/// Shared record between IoSourceState and SelectorState that allows us to internally -+/// deregister partially or fully closed fds (i.e. when we get POLLHUP or PULLERR) without -+/// confusing IoSourceState and trying to deregister twice. This isn't strictly -+/// required as technically deregister is idempotent but it is confusing -+/// when trying to debug behaviour as we get imbalanced calls to register/deregister and -+/// superfluous NotFound errors. -+#[derive(Debug)] -+pub(crate) struct RegistrationRecord { -+ is_unregistered: AtomicBool, -+} -+ -+impl RegistrationRecord { -+ pub fn new() -> Self { -+ Self { -+ is_unregistered: AtomicBool::new(false), -+ } -+ } -+ -+ pub fn mark_unregistered(&self) { -+ self.is_unregistered.store(true, Ordering::Relaxed); -+ } -+ -+ #[allow(dead_code)] -+ pub fn is_registered(&self) -> bool { -+ !self.is_unregistered.load(Ordering::Relaxed) -+ } -+} -+ -+#[cfg(target_os = "linux")] -+const POLLRDHUP: libc::c_short = libc::POLLRDHUP; -+#[cfg(not(target_os = "linux"))] -+const POLLRDHUP: libc::c_short = 0; -+ -+const READ_EVENTS: libc::c_short = libc::POLLIN | POLLRDHUP; -+ -+const WRITE_EVENTS: libc::c_short = libc::POLLOUT; -+ -+const PRIORITY_EVENTS: libc::c_short = libc::POLLPRI; -+ -+/// Get the input poll events for the given event. -+fn interests_to_poll(interest: Interest) -> libc::c_short { -+ let mut kind = 0; -+ -+ if interest.is_readable() { -+ kind |= READ_EVENTS; -+ } -+ -+ if interest.is_writable() { -+ kind |= WRITE_EVENTS; -+ } -+ -+ if interest.is_priority() { -+ kind |= PRIORITY_EVENTS; -+ } -+ -+ kind -+} -+ -+/// Helper function to call poll. -+fn poll(fds: &mut [PollFd], timeout: Option) -> io::Result { -+ loop { -+ // A bug in kernels < 2.6.37 makes timeouts larger than LONG_MAX / CONFIG_HZ -+ // (approx. 30 minutes with CONFIG_HZ=1200) effectively infinite on 32 bits -+ // architectures. The magic number is the same constant used by libuv. -+ #[cfg(target_pointer_width = "32")] -+ const MAX_SAFE_TIMEOUT: u128 = 1789569; -+ #[cfg(not(target_pointer_width = "32"))] -+ const MAX_SAFE_TIMEOUT: u128 = libc::c_int::max_value() as u128; -+ -+ let timeout = timeout -+ .map(|to| { -+ // `Duration::as_millis` truncates, so round up. This avoids -+ // turning sub-millisecond timeouts into a zero timeout, unless -+ // the caller explicitly requests that by specifying a zero -+ // timeout. -+ let to_ms = to -+ .checked_add(Duration::from_nanos(999_999)) -+ .unwrap_or(to) -+ .as_millis(); -+ cmp::min(MAX_SAFE_TIMEOUT, to_ms) as libc::c_int -+ }) -+ .unwrap_or(-1); -+ -+ let res = syscall!(poll( -+ fds.as_mut_ptr() as *mut libc::pollfd, -+ fds.len() as libc::nfds_t, -+ timeout, -+ )); -+ -+ match res { -+ Ok(num_events) => break Ok(num_events as usize), -+ // poll returns EAGAIN if we can retry it. -+ Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => continue, -+ Err(e) => return Err(e), -+ } -+ } -+} -+ -+#[derive(Debug, Clone)] -+pub struct Event { -+ token: Token, -+ events: libc::c_short, -+} -+ -+pub type Events = Vec; -+ -+pub mod event { -+ use crate::sys::unix::selector::poll::POLLRDHUP; -+ use crate::sys::Event; -+ use crate::Token; -+ use std::fmt; -+ -+ pub fn token(event: &Event) -> Token { -+ event.token -+ } -+ -+ pub fn is_readable(event: &Event) -> bool { -+ (event.events & libc::POLLIN) != 0 || (event.events & libc::POLLPRI) != 0 -+ } -+ -+ pub fn is_writable(event: &Event) -> bool { -+ (event.events & libc::POLLOUT) != 0 -+ } -+ -+ pub fn is_error(event: &Event) -> bool { -+ (event.events & libc::POLLERR) != 0 -+ } -+ -+ pub fn is_read_closed(event: &Event) -> bool { -+ // Both halves of the socket have closed -+ (event.events & libc::POLLHUP) != 0 -+ // Socket has received FIN or called shutdown(SHUT_RD) -+ || (event.events & POLLRDHUP) != 0 -+ } -+ -+ pub fn is_write_closed(event: &Event) -> bool { -+ // Both halves of the socket have closed -+ (event.events & libc::POLLHUP) != 0 -+ // Unix pipe write end has closed -+ || ((event.events & libc::POLLOUT) != 0 && (event.events & libc::POLLERR) != 0) -+ // The other side (read end) of a Unix pipe has closed. -+ || (event.events == libc::POLLERR) -+ } -+ -+ pub fn is_priority(event: &Event) -> bool { -+ (event.events & libc::POLLPRI) != 0 -+ } -+ -+ pub fn is_aio(_: &Event) -> bool { -+ // Not supported in the kernel, only in libc. -+ false -+ } -+ -+ pub fn is_lio(_: &Event) -> bool { -+ // Not supported. -+ false -+ } -+ -+ pub fn debug_details(f: &mut fmt::Formatter<'_>, event: &Event) -> fmt::Result { -+ #[allow(clippy::trivially_copy_pass_by_ref)] -+ fn check_events(got: &libc::c_short, want: &libc::c_short) -> bool { -+ (*got & want) != 0 -+ } -+ debug_detail!( -+ EventsDetails(libc::c_short), -+ check_events, -+ libc::POLLIN, -+ libc::POLLPRI, -+ libc::POLLOUT, -+ libc::POLLRDNORM, -+ libc::POLLRDBAND, -+ libc::POLLWRNORM, -+ libc::POLLWRBAND, -+ libc::POLLERR, -+ libc::POLLHUP, -+ ); -+ -+ f.debug_struct("poll_event") -+ .field("token", &event.token) -+ .field("events", &EventsDetails(event.events)) -+ .finish() -+ } -+} -+ -+cfg_io_source! { -+ use crate::Registry; -+ -+ struct InternalState { -+ selector: Selector, -+ token: Token, -+ interests: Interest, -+ fd: RawFd, -+ shared_record: Arc, -+ } -+ -+ impl Drop for InternalState { -+ fn drop(&mut self) { -+ if self.shared_record.is_registered() { -+ let _ = self.selector.deregister(self.fd); -+ } -+ } -+ } -+ -+ pub(crate) struct IoSourceState { -+ inner: Option>, -+ } -+ -+ impl IoSourceState { -+ pub fn new() -> IoSourceState { -+ IoSourceState { inner: None } -+ } -+ -+ pub fn do_io(&self, f: F, io: &T) -> io::Result -+ where -+ F: FnOnce(&T) -> io::Result, -+ { -+ let result = f(io); -+ -+ if let Err(err) = &result { -+ if err.kind() == io::ErrorKind::WouldBlock { -+ self.inner.as_ref().map_or(Ok(()), |state| { -+ state -+ .selector -+ .reregister(state.fd, state.token, state.interests) -+ })?; -+ } -+ } -+ -+ result -+ } -+ -+ pub fn register( -+ &mut self, -+ registry: &Registry, -+ token: Token, -+ interests: Interest, -+ fd: RawFd, -+ ) -> io::Result<()> { -+ if self.inner.is_some() { -+ Err(io::ErrorKind::AlreadyExists.into()) -+ } else { -+ let selector = registry.selector().try_clone()?; -+ -+ selector.register_internal(fd, token, interests).map(move |shared_record| { -+ let state = InternalState { -+ selector, -+ token, -+ interests, -+ fd, -+ shared_record, -+ }; -+ -+ self.inner = Some(Box::new(state)); -+ }) -+ } -+ } -+ -+ pub fn reregister( -+ &mut self, -+ registry: &Registry, -+ token: Token, -+ interests: Interest, -+ fd: RawFd, -+ ) -> io::Result<()> { -+ match self.inner.as_mut() { -+ Some(state) => registry -+ .selector() -+ .reregister(fd, token, interests) -+ .map(|()| { -+ state.token = token; -+ state.interests = interests; -+ }), -+ None => Err(io::ErrorKind::NotFound.into()), -+ } -+ } -+ -+ pub fn deregister(&mut self, registry: &Registry, fd: RawFd) -> io::Result<()> { -+ if let Some(state) = self.inner.take() { -+ // Marking unregistered will short circuit the drop behaviour of calling -+ // deregister so the call to deregister below is strictly required. -+ state.shared_record.mark_unregistered(); -+ } -+ -+ registry.selector().deregister(fd) -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/sourcefd.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/sourcefd.rs -index ba52b385..84e776d2 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/sourcefd.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/sourcefd.rs -@@ -1,4 +1,4 @@ --use crate::{event, poll, Interest, Registry, Token}; -+use crate::{event, Interest, Registry, Token}; - - use std::io; - use std::os::unix::io::RawFd; -@@ -25,8 +25,14 @@ use std::os::unix::io::RawFd; - /// - /// Basic usage. - /// --#[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] --#[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+#[cfg_attr( -+ all(feature = "os-poll", feature = "net", feature = "os-ext"), -+ doc = "```" -+)] -+#[cfg_attr( -+ not(all(feature = "os-poll", feature = "net", feature = "os-ext")), -+ doc = "```ignore" -+)] - /// # use std::error::Error; - /// # fn main() -> Result<(), Box> { - /// use mio::{Interest, Poll, Token}; -@@ -51,8 +57,8 @@ use std::os::unix::io::RawFd; - /// - /// Implementing [`event::Source`] for a custom type backed by a [`RawFd`]. - /// --#[cfg_attr(all(feature = "os-poll", features = "os-ext"), doc = "```")] --#[cfg_attr(not(all(feature = "os-poll", features = "os-ext")), doc = "```ignore")] -+#[cfg_attr(all(feature = "os-poll", feature = "os-ext"), doc = "```")] -+#[cfg_attr(not(all(feature = "os-poll", feature = "os-ext")), doc = "```ignore")] - /// use mio::{event, Interest, Registry, Token}; - /// use mio::unix::SourceFd; - /// -@@ -92,7 +98,7 @@ impl<'a> event::Source for SourceFd<'a> { - token: Token, - interests: Interest, - ) -> io::Result<()> { -- poll::selector(registry).register(*self.0, token, interests) -+ registry.selector().register(*self.0, token, interests) - } - - fn reregister( -@@ -101,10 +107,10 @@ impl<'a> event::Source for SourceFd<'a> { - token: Token, - interests: Interest, - ) -> io::Result<()> { -- poll::selector(registry).reregister(*self.0, token, interests) -+ registry.selector().reregister(*self.0, token, interests) - } - - fn deregister(&mut self, registry: &Registry) -> io::Result<()> { -- poll::selector(registry).deregister(*self.0) -+ registry.selector().deregister(*self.0) - } - } -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/tcp.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/tcp.rs -index 59642c61..6f755e87 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/tcp.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/tcp.rs -@@ -1,428 +1,57 @@ - use std::convert::TryInto; - use std::io; --use std::mem; - use std::mem::{size_of, MaybeUninit}; - use std::net::{self, SocketAddr}; - use std::os::unix::io::{AsRawFd, FromRawFd}; --use std::time::Duration; - - use crate::sys::unix::net::{new_socket, socket_addr, to_socket_addr}; --use crate::net::TcpKeepalive; - --#[cfg(any(target_os = "openbsd", target_os = "netbsd", target_os = "haiku"))] --use libc::SO_KEEPALIVE as KEEPALIVE_TIME; --#[cfg(any(target_os = "macos", target_os = "ios"))] --use libc::TCP_KEEPALIVE as KEEPALIVE_TIME; --#[cfg(not(any( -- target_os = "macos", -- target_os = "ios", -- target_os = "openbsd", -- target_os = "netbsd", -- target_os = "haiku" --)))] --use libc::TCP_KEEPIDLE as KEEPALIVE_TIME; --pub type TcpSocket = libc::c_int; -- --pub(crate) fn new_v4_socket() -> io::Result { -- new_socket(libc::AF_INET, libc::SOCK_STREAM) --} -- --pub(crate) fn new_v6_socket() -> io::Result { -- new_socket(libc::AF_INET6, libc::SOCK_STREAM) -+pub(crate) fn new_for_addr(address: SocketAddr) -> io::Result { -+ let domain = match address { -+ SocketAddr::V4(_) => libc::AF_INET, -+ SocketAddr::V6(_) => libc::AF_INET6, -+ }; -+ new_socket(domain, libc::SOCK_STREAM) - } - --pub(crate) fn bind(socket: TcpSocket, addr: SocketAddr) -> io::Result<()> { -+pub(crate) fn bind(socket: &net::TcpListener, addr: SocketAddr) -> io::Result<()> { - let (raw_addr, raw_addr_length) = socket_addr(&addr); -- syscall!(bind(socket, raw_addr.as_ptr(), raw_addr_length))?; -+ syscall!(bind(socket.as_raw_fd(), raw_addr.as_ptr(), raw_addr_length))?; - Ok(()) - } - --pub(crate) fn connect(socket: TcpSocket, addr: SocketAddr) -> io::Result { -+pub(crate) fn connect(socket: &net::TcpStream, addr: SocketAddr) -> io::Result<()> { - let (raw_addr, raw_addr_length) = socket_addr(&addr); - -- match syscall!(connect(socket, raw_addr.as_ptr(), raw_addr_length)) { -- Err(err) if err.raw_os_error() != Some(libc::EINPROGRESS) => { -- Err(err) -- } -- _ => { -- Ok(unsafe { net::TcpStream::from_raw_fd(socket) }) -- } -+ match syscall!(connect( -+ socket.as_raw_fd(), -+ raw_addr.as_ptr(), -+ raw_addr_length -+ )) { -+ Err(err) if err.raw_os_error() != Some(libc::EINPROGRESS) => Err(err), -+ _ => Ok(()), - } - } - --pub(crate) fn listen(socket: TcpSocket, backlog: u32) -> io::Result { -+pub(crate) fn listen(socket: &net::TcpListener, backlog: u32) -> io::Result<()> { - let backlog = backlog.try_into().unwrap_or(i32::max_value()); -- syscall!(listen(socket, backlog))?; -- Ok(unsafe { net::TcpListener::from_raw_fd(socket) }) --} -- --pub(crate) fn close(socket: TcpSocket) { -- let _ = unsafe { net::TcpStream::from_raw_fd(socket) }; -+ syscall!(listen(socket.as_raw_fd(), backlog))?; -+ Ok(()) - } - --pub(crate) fn set_reuseaddr(socket: TcpSocket, reuseaddr: bool) -> io::Result<()> { -- let val: libc::c_int = if reuseaddr { 1 } else { 0 }; -+pub(crate) fn set_reuseaddr(socket: &net::TcpListener, reuseaddr: bool) -> io::Result<()> { -+ let val: libc::c_int = i32::from(reuseaddr); - syscall!(setsockopt( -- socket, -+ socket.as_raw_fd(), - libc::SOL_SOCKET, - libc::SO_REUSEADDR, - &val as *const libc::c_int as *const libc::c_void, - size_of::() as libc::socklen_t, -- )) -- .map(|_| ()) --} -- --pub(crate) fn get_reuseaddr(socket: TcpSocket) -> io::Result { -- let mut optval: libc::c_int = 0; -- let mut optlen = mem::size_of::() as libc::socklen_t; -- -- syscall!(getsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_REUSEADDR, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ))?; -- -- Ok(optval != 0) --} -- --#[cfg(all(unix, not(any(target_os = "solaris", target_os = "illumos"))))] --pub(crate) fn set_reuseport(socket: TcpSocket, reuseport: bool) -> io::Result<()> { -- let val: libc::c_int = if reuseport { 1 } else { 0 }; -- -- syscall!(setsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_REUSEPORT, -- &val as *const libc::c_int as *const libc::c_void, -- size_of::() as libc::socklen_t, -- )) -- .map(|_| ()) --} -- --#[cfg(all(unix, not(any(target_os = "solaris", target_os = "illumos"))))] --pub(crate) fn get_reuseport(socket: TcpSocket) -> io::Result { -- let mut optval: libc::c_int = 0; -- let mut optlen = mem::size_of::() as libc::socklen_t; -- -- syscall!(getsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_REUSEPORT, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ))?; -- -- Ok(optval != 0) --} -- --pub(crate) fn get_localaddr(socket: TcpSocket) -> io::Result { -- let mut addr: libc::sockaddr_storage = unsafe { std::mem::zeroed() }; -- let mut length = size_of::() as libc::socklen_t; -- -- syscall!(getsockname( -- socket, -- &mut addr as *mut _ as *mut _, -- &mut length -- ))?; -- -- unsafe { to_socket_addr(&addr) } --} -- --pub(crate) fn set_linger(socket: TcpSocket, dur: Option) -> io::Result<()> { -- let val: libc::linger = libc::linger { -- l_onoff: if dur.is_some() { 1 } else { 0 }, -- l_linger: dur -- .map(|dur| dur.as_secs() as libc::c_int) -- .unwrap_or_default(), -- }; -- syscall!(setsockopt( -- socket, -- libc::SOL_SOCKET, -- #[cfg(target_vendor = "apple")] -- libc::SO_LINGER_SEC, -- #[cfg(not(target_vendor = "apple"))] -- libc::SO_LINGER, -- &val as *const libc::linger as *const libc::c_void, -- size_of::() as libc::socklen_t, -- )) -- .map(|_| ()) --} -- --pub(crate) fn get_linger(socket: TcpSocket) -> io::Result> { -- let mut val: libc::linger = unsafe { std::mem::zeroed() }; -- let mut len = mem::size_of::() as libc::socklen_t; -- -- syscall!(getsockopt( -- socket, -- libc::SOL_SOCKET, -- #[cfg(target_vendor = "apple")] -- libc::SO_LINGER_SEC, -- #[cfg(not(target_vendor = "apple"))] -- libc::SO_LINGER, -- &mut val as *mut _ as *mut _, -- &mut len, -- ))?; -- -- if val.l_onoff == 0 { -- Ok(None) -- } else { -- Ok(Some(Duration::from_secs(val.l_linger as u64))) -- } --} -- --pub(crate) fn set_recv_buffer_size(socket: TcpSocket, size: u32) -> io::Result<()> { -- let size = size.try_into().ok().unwrap_or_else(i32::max_value); -- syscall!(setsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_RCVBUF, -- &size as *const _ as *const libc::c_void, -- size_of::() as libc::socklen_t -- )) -- .map(|_| ()) --} -- --pub(crate) fn get_recv_buffer_size(socket: TcpSocket) -> io::Result { -- let mut optval: libc::c_int = 0; -- let mut optlen = size_of::() as libc::socklen_t; -- syscall!(getsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_RCVBUF, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ))?; -- -- Ok(optval as u32) --} -- --pub(crate) fn set_send_buffer_size(socket: TcpSocket, size: u32) -> io::Result<()> { -- let size = size.try_into().ok().unwrap_or_else(i32::max_value); -- syscall!(setsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_SNDBUF, -- &size as *const _ as *const libc::c_void, -- size_of::() as libc::socklen_t -- )) -- .map(|_| ()) --} -- --pub(crate) fn get_send_buffer_size(socket: TcpSocket) -> io::Result { -- let mut optval: libc::c_int = 0; -- let mut optlen = size_of::() as libc::socklen_t; -- -- syscall!(getsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_SNDBUF, -- &mut optval as *mut _ as *mut _, -- &mut optlen, - ))?; -- -- Ok(optval as u32) --} -- --pub(crate) fn set_keepalive(socket: TcpSocket, keepalive: bool) -> io::Result<()> { -- let val: libc::c_int = if keepalive { 1 } else { 0 }; -- syscall!(setsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_KEEPALIVE, -- &val as *const _ as *const libc::c_void, -- size_of::() as libc::socklen_t -- )) -- .map(|_| ()) --} -- --pub(crate) fn get_keepalive(socket: TcpSocket) -> io::Result { -- let mut optval: libc::c_int = 0; -- let mut optlen = mem::size_of::() as libc::socklen_t; -- -- syscall!(getsockopt( -- socket, -- libc::SOL_SOCKET, -- libc::SO_KEEPALIVE, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ))?; -- -- Ok(optval != 0) --} -- --pub(crate) fn set_keepalive_params(socket: TcpSocket, keepalive: TcpKeepalive) -> io::Result<()> { -- if let Some(dur) = keepalive.time { -- set_keepalive_time(socket, dur)?; -- } -- -- #[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", -- ))] -- { -- if let Some(dur) = keepalive.interval { -- set_keepalive_interval(socket, dur)?; -- } -- -- if let Some(retries) = keepalive.retries { -- set_keepalive_retries(socket, retries)?; -- } -- } -- -- - Ok(()) - } - --fn set_keepalive_time(socket: TcpSocket, time: Duration) -> io::Result<()> { -- let time_secs = time -- .as_secs() -- .try_into() -- .ok() -- .unwrap_or_else(i32::max_value); -- syscall!(setsockopt( -- socket, -- libc::IPPROTO_TCP, -- KEEPALIVE_TIME, -- &(time_secs as libc::c_int) as *const _ as *const libc::c_void, -- size_of::() as libc::socklen_t -- )) -- .map(|_| ()) --} -- --pub(crate) fn get_keepalive_time(socket: TcpSocket) -> io::Result> { -- if !get_keepalive(socket)? { -- return Ok(None); -- } -- -- let mut optval: libc::c_int = 0; -- let mut optlen = mem::size_of::() as libc::socklen_t; -- syscall!(getsockopt( -- socket, -- libc::IPPROTO_TCP, -- KEEPALIVE_TIME, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ))?; -- -- Ok(Some(Duration::from_secs(optval as u64))) --} -- --/// Linux, FreeBSD, and NetBSD support setting the keepalive interval via --/// `TCP_KEEPINTVL`. --/// See: --/// - https://man7.org/linux/man-pages/man7/tcp.7.html --/// - https://www.freebsd.org/cgi/man.cgi?query=tcp#end --/// - http://man.netbsd.org/tcp.4#DESCRIPTION --/// --/// OpenBSD does not: --/// https://man.openbsd.org/tcp --#[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", --))] --fn set_keepalive_interval(socket: TcpSocket, interval: Duration) -> io::Result<()> { -- let interval_secs = interval -- .as_secs() -- .try_into() -- .ok() -- .unwrap_or_else(i32::max_value); -- syscall!(setsockopt( -- socket, -- libc::IPPROTO_TCP, -- libc::TCP_KEEPINTVL, -- &(interval_secs as libc::c_int) as *const _ as *const libc::c_void, -- size_of::() as libc::socklen_t -- )) -- .map(|_| ()) --} -- --#[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", --))] --pub(crate) fn get_keepalive_interval(socket: TcpSocket) -> io::Result> { -- if !get_keepalive(socket)? { -- return Ok(None); -- } -- -- let mut optval: libc::c_int = 0; -- let mut optlen = mem::size_of::() as libc::socklen_t; -- syscall!(getsockopt( -- socket, -- libc::IPPROTO_TCP, -- libc::TCP_KEEPINTVL, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ))?; -- -- Ok(Some(Duration::from_secs(optval as u64))) --} -- --/// Linux, macOS/iOS, FreeBSD, and NetBSD support setting the number of TCP --/// keepalive retries via `TCP_KEEPCNT`. --/// See: --/// - https://man7.org/linux/man-pages/man7/tcp.7.html --/// - https://www.freebsd.org/cgi/man.cgi?query=tcp#end --/// - http://man.netbsd.org/tcp.4#DESCRIPTION --/// --/// OpenBSD does not: --/// https://man.openbsd.org/tcp --#[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", --))] --fn set_keepalive_retries(socket: TcpSocket, retries: u32) -> io::Result<()> { -- let retries = retries.try_into().ok().unwrap_or_else(i32::max_value); -- syscall!(setsockopt( -- socket, -- libc::IPPROTO_TCP, -- libc::TCP_KEEPCNT, -- &(retries as libc::c_int) as *const _ as *const libc::c_void, -- size_of::() as libc::socklen_t -- )) -- .map(|_| ()) --} -- --#[cfg(any( -- target_os = "linux", -- target_os = "macos", -- target_os = "ios", -- target_os = "freebsd", -- target_os = "netbsd", --))] --pub(crate) fn get_keepalive_retries(socket: TcpSocket) -> io::Result> { -- if !get_keepalive(socket)? { -- return Ok(None); -- } -- -- let mut optval: libc::c_int = 0; -- let mut optlen = mem::size_of::() as libc::socklen_t; -- syscall!(getsockopt( -- socket, -- libc::IPPROTO_TCP, -- libc::TCP_KEEPCNT, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ))?; -- -- Ok(Some(optval as u32)) --} -- --pub fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { -+pub(crate) fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { - let mut addr: MaybeUninit = MaybeUninit::uninit(); - let mut length = size_of::() as libc::socklen_t; - -@@ -431,16 +60,14 @@ pub fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, Socket - #[cfg(any( - // Android x86's seccomp profile forbids calls to `accept4(2)` - // See https://github.com/tokio-rs/mio/issues/1445 for details -- all( -- not(target_arch="x86"), -- target_os = "android" -- ), -+ all(not(target_arch="x86"), target_os = "android"), - target_os = "dragonfly", - target_os = "freebsd", - target_os = "illumos", - target_os = "linux", - target_os = "netbsd", -- target_os = "openbsd" -+ target_os = "openbsd", -+ target_os = "solaris", - ))] - let stream = { - syscall!(accept4( -@@ -456,13 +83,15 @@ pub fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, Socket - // OSes inherit the non-blocking flag from the listener, so we just have to - // set `CLOEXEC`. - #[cfg(any( -- all( -- target_arch = "x86", -- target_os = "android" -- ), -- target_os = "ios", -- target_os = "macos", -- target_os = "solaris" -+ target_os = "aix", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "redox", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "vita", -+ all(target_arch = "x86", target_os = "android"), - ))] - let stream = { - syscall!(accept( -@@ -472,12 +101,17 @@ pub fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, Socket - )) - .map(|socket| unsafe { net::TcpStream::from_raw_fd(socket) }) - .and_then(|s| { -+ #[cfg(not(any(target_os = "espidf", target_os = "vita")))] - syscall!(fcntl(s.as_raw_fd(), libc::F_SETFD, libc::FD_CLOEXEC))?; -- -+ - // See https://github.com/tokio-rs/mio/issues/1450 -- #[cfg(all(target_arch = "x86",target_os = "android"))] -+ #[cfg(any( -+ all(target_arch = "x86", target_os = "android"), -+ target_os = "espidf", -+ target_os = "vita", -+ ))] - syscall!(fcntl(s.as_raw_fd(), libc::F_SETFL, libc::O_NONBLOCK))?; -- -+ - Ok(s) - }) - }?; -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/udp.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/udp.rs -index 5a97cbd8..843ae885 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/udp.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/udp.rs -@@ -6,21 +6,13 @@ use std::net::{self, SocketAddr}; - use std::os::unix::io::{AsRawFd, FromRawFd}; - - pub fn bind(addr: SocketAddr) -> io::Result { -- // Gives a warning for non Apple platforms. -- #[allow(clippy::let_and_return)] -- let socket = new_ip_socket(addr, libc::SOCK_DGRAM); -+ let fd = new_ip_socket(addr, libc::SOCK_DGRAM)?; -+ let socket = unsafe { net::UdpSocket::from_raw_fd(fd) }; - -- socket.and_then(|socket| { -- let (raw_addr, raw_addr_length) = socket_addr(&addr); -- syscall!(bind(socket, raw_addr.as_ptr(), raw_addr_length)) -- .map_err(|err| { -- // Close the socket if we hit an error, ignoring the error -- // from closing since we can't pass back two errors. -- let _ = unsafe { libc::close(socket) }; -- err -- }) -- .map(|_| unsafe { net::UdpSocket::from_raw_fd(socket) }) -- }) -+ let (raw_addr, raw_addr_length) = socket_addr(&addr); -+ syscall!(bind(fd, raw_addr.as_ptr(), raw_addr_length))?; -+ -+ Ok(socket) - } - - pub(crate) fn only_v6(socket: &net::UdpSocket) -> io::Result { -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/datagram.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/datagram.rs -index d3e5314f..5853a4d5 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/datagram.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/datagram.rs -@@ -2,23 +2,24 @@ use super::{socket_addr, SocketAddr}; - use crate::sys::unix::net::new_socket; - - use std::io; -+use std::os::unix::ffi::OsStrExt; - use std::os::unix::io::{AsRawFd, FromRawFd}; - use std::os::unix::net; - use std::path::Path; - - pub(crate) fn bind(path: &Path) -> io::Result { -- let fd = new_socket(libc::AF_UNIX, libc::SOCK_DGRAM)?; -- // Ensure the fd is closed. -- let socket = unsafe { net::UnixDatagram::from_raw_fd(fd) }; -- let (sockaddr, socklen) = socket_addr(path)?; -+ let (sockaddr, socklen) = socket_addr(path.as_os_str().as_bytes())?; - let sockaddr = &sockaddr as *const libc::sockaddr_un as *const _; -- syscall!(bind(fd, sockaddr, socklen))?; -+ -+ let socket = unbound()?; -+ syscall!(bind(socket.as_raw_fd(), sockaddr, socklen))?; -+ - Ok(socket) - } - - pub(crate) fn unbound() -> io::Result { -- new_socket(libc::AF_UNIX, libc::SOCK_DGRAM) -- .map(|socket| unsafe { net::UnixDatagram::from_raw_fd(socket) }) -+ let fd = new_socket(libc::AF_UNIX, libc::SOCK_DGRAM)?; -+ Ok(unsafe { net::UnixDatagram::from_raw_fd(fd) }) - } - - pub(crate) fn pair() -> io::Result<(net::UnixDatagram, net::UnixDatagram)> { -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/listener.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/listener.rs -index 547ff570..65d332c8 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/listener.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/listener.rs -@@ -1,25 +1,30 @@ - use super::socket_addr; - use crate::net::{SocketAddr, UnixStream}; - use crate::sys::unix::net::new_socket; -+use std::os::unix::ffi::OsStrExt; - use std::os::unix::io::{AsRawFd, FromRawFd}; - use std::os::unix::net; - use std::path::Path; - use std::{io, mem}; - - pub(crate) fn bind(path: &Path) -> io::Result { -- let socket = new_socket(libc::AF_UNIX, libc::SOCK_STREAM)?; -- let (sockaddr, socklen) = socket_addr(path)?; -- let sockaddr = &sockaddr as *const libc::sockaddr_un as *const libc::sockaddr; -+ let socket_address = { -+ let (sockaddr, socklen) = socket_addr(path.as_os_str().as_bytes())?; -+ SocketAddr::from_parts(sockaddr, socklen) -+ }; -+ -+ bind_addr(&socket_address) -+} - -- syscall!(bind(socket, sockaddr, socklen)) -- .and_then(|_| syscall!(listen(socket, 1024))) -- .map_err(|err| { -- // Close the socket if we hit an error, ignoring the error from -- // closing since we can't pass back two errors. -- let _ = unsafe { libc::close(socket) }; -- err -- }) -- .map(|_| unsafe { net::UnixListener::from_raw_fd(socket) }) -+pub(crate) fn bind_addr(address: &SocketAddr) -> io::Result { -+ let fd = new_socket(libc::AF_UNIX, libc::SOCK_STREAM)?; -+ let socket = unsafe { net::UnixListener::from_raw_fd(fd) }; -+ let sockaddr = address.raw_sockaddr() as *const libc::sockaddr_un as *const libc::sockaddr; -+ -+ syscall!(bind(fd, sockaddr, *address.raw_socklen()))?; -+ syscall!(listen(fd, 1024))?; -+ -+ Ok(socket) - } - - pub(crate) fn accept(listener: &net::UnixListener) -> io::Result<(UnixStream, SocketAddr)> { -@@ -39,16 +44,18 @@ pub(crate) fn accept(listener: &net::UnixListener) -> io::Result<(UnixStream, So - let mut socklen = mem::size_of_val(&sockaddr) as libc::socklen_t; - - #[cfg(not(any( -+ target_os = "aix", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", -- target_os = "solaris", -+ target_os = "redox", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "vita", - // Android x86's seccomp profile forbids calls to `accept4(2)` - // See https://github.com/tokio-rs/mio/issues/1445 for details -- all( -- target_arch = "x86", -- target_os = "android" -- ) -+ all(target_arch = "x86", target_os = "android"), - )))] - let socket = { - let flags = libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC; -@@ -62,14 +69,16 @@ pub(crate) fn accept(listener: &net::UnixListener) -> io::Result<(UnixStream, So - }; - - #[cfg(any( -+ target_os = "aix", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", -- target_os = "solaris", -- all( -- target_arch = "x86", -- target_os = "android" -- ) -+ target_os = "redox", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "vita", -+ all(target_arch = "x86", target_os = "android") - ))] - let socket = syscall!(accept( - listener.as_raw_fd(), -@@ -80,12 +89,17 @@ pub(crate) fn accept(listener: &net::UnixListener) -> io::Result<(UnixStream, So - // Ensure the socket is closed if either of the `fcntl` calls - // error below. - let s = unsafe { net::UnixStream::from_raw_fd(socket) }; -+ #[cfg(not(any(target_os = "espidf", target_os = "vita")))] - syscall!(fcntl(socket, libc::F_SETFD, libc::FD_CLOEXEC))?; - - // See https://github.com/tokio-rs/mio/issues/1450 -- #[cfg(all(target_arch = "x86",target_os = "android"))] -+ #[cfg(any( -+ all(target_arch = "x86", target_os = "android"), -+ target_os = "espidf", -+ target_os = "vita", -+ ))] - syscall!(fcntl(socket, libc::F_SETFL, libc::O_NONBLOCK))?; -- -+ - Ok(s) - }); - -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/mod.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/mod.rs -index 3ec829f0..376ee05e 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/mod.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/mod.rs -@@ -3,7 +3,7 @@ pub use self::socketaddr::SocketAddr; - - /// Get the `sun_path` field offset of `sockaddr_un` for the target OS. - /// --/// On Linux, this funtion equates to the same value as -+/// On Linux, this function equates to the same value as - /// `size_of::()`, but some other implementations include - /// other fields before `sun_path`, so the expression more portably - /// describes the size of the address structure. -@@ -15,16 +15,14 @@ pub(in crate::sys) fn path_offset(sockaddr: &libc::sockaddr_un) -> usize { - - cfg_os_poll! { - use std::cmp::Ordering; -- use std::os::unix::ffi::OsStrExt; - use std::os::unix::io::{RawFd, FromRawFd}; -- use std::path::Path; - use std::{io, mem}; - - pub(crate) mod datagram; - pub(crate) mod listener; - pub(crate) mod stream; - -- pub(in crate::sys) fn socket_addr(path: &Path) -> io::Result<(libc::sockaddr_un, libc::socklen_t)> { -+ pub(in crate::sys) fn socket_addr(bytes: &[u8]) -> io::Result<(libc::sockaddr_un, libc::socklen_t)> { - let sockaddr = mem::MaybeUninit::::zeroed(); - - // This is safe to assume because a `libc::sockaddr_un` filled with `0` -@@ -39,8 +37,7 @@ cfg_os_poll! { - - sockaddr.sun_family = libc::AF_UNIX as libc::sa_family_t; - -- let bytes = path.as_os_str().as_bytes(); -- match (bytes.get(0), bytes.len().cmp(&sockaddr.sun_path.len())) { -+ match (bytes.first(), bytes.len().cmp(&sockaddr.sun_path.len())) { - // Abstract paths don't need a null terminator - (Some(&0), Ordering::Greater) => { - return Err(io::Error::new( -@@ -64,7 +61,7 @@ cfg_os_poll! { - let offset = path_offset(&sockaddr); - let mut socklen = offset + bytes.len(); - -- match bytes.get(0) { -+ match bytes.first() { - // The struct has already been zeroes so the null byte for pathname - // addresses is already there. - Some(&0) | None => {} -@@ -77,26 +74,45 @@ cfg_os_poll! { - fn pair(flags: libc::c_int) -> io::Result<(T, T)> - where T: FromRawFd, - { -- #[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "solaris")))] -+ #[cfg(not(any( -+ target_os = "aix", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "vita", -+ )))] - let flags = flags | libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC; - - let mut fds = [-1; 2]; - syscall!(socketpair(libc::AF_UNIX, flags, 0, fds.as_mut_ptr()))?; - let pair = unsafe { (T::from_raw_fd(fds[0]), T::from_raw_fd(fds[1])) }; - -- // Darwin and Solaris do not have SOCK_NONBLOCK or SOCK_CLOEXEC. -+ // Darwin (and others) doesn't have SOCK_NONBLOCK or SOCK_CLOEXEC. - // - // In order to set those flags, additional `fcntl` sys calls must be - // performed. If a `fnctl` fails after the sockets have been created, - // the file descriptors will leak. Creating `pair` above ensures that if - // there is an error, the file descriptors are closed. -- #[cfg(any(target_os = "ios", target_os = "macos", target_os = "solaris"))] -+ #[cfg(any( -+ target_os = "aix", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ target_os = "espidf", -+ target_os = "vita", -+ ))] - { - syscall!(fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK))?; -+ #[cfg(not(any(target_os = "espidf", target_os = "vita")))] - syscall!(fcntl(fds[0], libc::F_SETFD, libc::FD_CLOEXEC))?; - syscall!(fcntl(fds[1], libc::F_SETFL, libc::O_NONBLOCK))?; -+ #[cfg(not(any(target_os = "espidf", target_os = "vita")))] - syscall!(fcntl(fds[1], libc::F_SETFD, libc::FD_CLOEXEC))?; - } -+ - Ok(pair) - } - -@@ -114,6 +130,7 @@ cfg_os_poll! { - #[cfg(test)] - mod tests { - use super::{path_offset, socket_addr}; -+ use std::os::unix::ffi::OsStrExt; - use std::path::Path; - use std::str; - -@@ -125,7 +142,7 @@ cfg_os_poll! { - // Pathname addresses do have a null terminator, so `socklen` is - // expected to be `PATH_LEN` + `offset` + 1. - let path = Path::new(PATH); -- let (sockaddr, actual) = socket_addr(path).unwrap(); -+ let (sockaddr, actual) = socket_addr(path.as_os_str().as_bytes()).unwrap(); - let offset = path_offset(&sockaddr); - let expected = PATH_LEN + offset + 1; - assert_eq!(expected as libc::socklen_t, actual) -@@ -138,9 +155,7 @@ cfg_os_poll! { - - // Abstract addresses do not have a null terminator, so `socklen` is - // expected to be `PATH_LEN` + `offset`. -- let abstract_path = str::from_utf8(PATH).unwrap(); -- let path = Path::new(abstract_path); -- let (sockaddr, actual) = socket_addr(path).unwrap(); -+ let (sockaddr, actual) = socket_addr(PATH).unwrap(); - let offset = path_offset(&sockaddr); - let expected = PATH_LEN + offset; - assert_eq!(expected as libc::socklen_t, actual) -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/socketaddr.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/socketaddr.rs -index c07a073c..8e0ef53a 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/socketaddr.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/socketaddr.rs -@@ -73,19 +73,21 @@ cfg_os_poll! { - SocketAddr { sockaddr, socklen } - } - -+ pub(crate) fn raw_sockaddr(&self) -> &libc::sockaddr_un { -+ &self.sockaddr -+ } -+ -+ pub(crate) fn raw_socklen(&self) -> &libc::socklen_t { -+ &self.socklen -+ } -+ - /// Returns `true` if the address is unnamed. - /// - /// Documentation reflected in [`SocketAddr`] - /// - /// [`SocketAddr`]: std::os::unix::net::SocketAddr -- // FIXME: The matches macro requires rust 1.42.0 and we still support 1.39.0 -- #[allow(clippy::match_like_matches_macro)] - pub fn is_unnamed(&self) -> bool { -- if let AddressKind::Unnamed = self.address() { -- true -- } else { -- false -- } -+ matches!(self.address(), AddressKind::Unnamed) - } - - /// Returns the contents of this address if it is a `pathname` address. -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/stream.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/stream.rs -index 149dd14e..261d27b0 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/uds/stream.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/uds/stream.rs -@@ -2,28 +2,32 @@ use super::{socket_addr, SocketAddr}; - use crate::sys::unix::net::new_socket; - - use std::io; -+use std::os::unix::ffi::OsStrExt; - use std::os::unix::io::{AsRawFd, FromRawFd}; - use std::os::unix::net; - use std::path::Path; - - pub(crate) fn connect(path: &Path) -> io::Result { -- let socket = new_socket(libc::AF_UNIX, libc::SOCK_STREAM)?; -- let (sockaddr, socklen) = socket_addr(path)?; -- let sockaddr = &sockaddr as *const libc::sockaddr_un as *const libc::sockaddr; -+ let socket_address = { -+ let (sockaddr, socklen) = socket_addr(path.as_os_str().as_bytes())?; -+ SocketAddr::from_parts(sockaddr, socklen) -+ }; - -- match syscall!(connect(socket, sockaddr, socklen)) { -+ connect_addr(&socket_address) -+} -+ -+pub(crate) fn connect_addr(address: &SocketAddr) -> io::Result { -+ let fd = new_socket(libc::AF_UNIX, libc::SOCK_STREAM)?; -+ let socket = unsafe { net::UnixStream::from_raw_fd(fd) }; -+ let sockaddr = address.raw_sockaddr() as *const libc::sockaddr_un as *const libc::sockaddr; -+ -+ match syscall!(connect(fd, sockaddr, *address.raw_socklen())) { - Ok(_) => {} -- Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {} -- Err(e) => { -- // Close the socket if we hit an error, ignoring the error -- // from closing since we can't pass back two errors. -- let _ = unsafe { libc::close(socket) }; -- -- return Err(e); -- } -+ Err(ref err) if err.raw_os_error() == Some(libc::EINPROGRESS) => {} -+ Err(e) => return Err(e), - } - -- Ok(unsafe { net::UnixStream::from_raw_fd(socket) }) -+ Ok(socket) - } - - pub(crate) fn pair() -> io::Result<(net::UnixStream, net::UnixStream)> { -diff --git a/KubeOS-Rust/vendor/mio/src/sys/unix/waker.rs b/KubeOS-Rust/vendor/mio/src/sys/unix/waker.rs -index a7cf484e..968f1a87 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/unix/waker.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/unix/waker.rs -@@ -1,11 +1,80 @@ --#[cfg(any(target_os = "linux", target_os = "android"))] --mod eventfd { -+#[cfg(all( -+ not(mio_unsupported_force_poll_poll), -+ not(all( -+ not(mio_unsupported_force_waker_pipe), -+ any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ ) -+ )), -+ not(any(target_os = "solaris", target_os = "vita")), -+))] -+mod fdbased { -+ #[cfg(all( -+ not(mio_unsupported_force_waker_pipe), -+ any(target_os = "linux", target_os = "android"), -+ ))] -+ use crate::sys::unix::waker::eventfd::WakerInternal; -+ #[cfg(any( -+ mio_unsupported_force_waker_pipe, -+ target_os = "aix", -+ target_os = "dragonfly", -+ target_os = "illumos", -+ target_os = "netbsd", -+ target_os = "openbsd", -+ target_os = "redox", -+ ))] -+ use crate::sys::unix::waker::pipe::WakerInternal; - use crate::sys::Selector; - use crate::{Interest, Token}; -+ use std::io; -+ use std::os::unix::io::AsRawFd; -+ -+ #[derive(Debug)] -+ pub struct Waker { -+ waker: WakerInternal, -+ } - -+ impl Waker { -+ pub fn new(selector: &Selector, token: Token) -> io::Result { -+ let waker = WakerInternal::new()?; -+ selector.register(waker.as_raw_fd(), token, Interest::READABLE)?; -+ Ok(Waker { waker }) -+ } -+ -+ pub fn wake(&self) -> io::Result<()> { -+ self.waker.wake() -+ } -+ } -+} -+ -+#[cfg(all( -+ not(mio_unsupported_force_poll_poll), -+ not(all( -+ not(mio_unsupported_force_waker_pipe), -+ any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ ) -+ )), -+ not(any(target_os = "solaris", target_os = "vita")), -+))] -+pub use self::fdbased::Waker; -+ -+#[cfg(all( -+ not(mio_unsupported_force_waker_pipe), -+ any(target_os = "linux", target_os = "android", target_os = "espidf") -+))] -+mod eventfd { - use std::fs::File; - use std::io::{self, Read, Write}; -- use std::os::unix::io::FromRawFd; -+ use std::os::unix::io::{AsRawFd, FromRawFd, RawFd}; - - /// Waker backed by `eventfd`. - /// -@@ -14,20 +83,21 @@ mod eventfd { - /// unsigned integer and added to the count. Reads must also be 8 bytes and - /// reset the count to 0, returning the count. - #[derive(Debug)] -- pub struct Waker { -+ pub struct WakerInternal { - fd: File, - } - -- impl Waker { -- pub fn new(selector: &Selector, token: Token) -> io::Result { -- syscall!(eventfd(0, libc::EFD_CLOEXEC | libc::EFD_NONBLOCK)).and_then(|fd| { -- // Turn the file descriptor into a file first so we're ensured -- // it's closed when dropped, e.g. when register below fails. -- let file = unsafe { File::from_raw_fd(fd) }; -- selector -- .register(fd, token, Interest::READABLE) -- .map(|()| Waker { fd: file }) -- }) -+ impl WakerInternal { -+ pub fn new() -> io::Result { -+ #[cfg(not(target_os = "espidf"))] -+ let flags = libc::EFD_CLOEXEC | libc::EFD_NONBLOCK; -+ // ESP-IDF is EFD_NONBLOCK by default and errors if you try to pass this flag. -+ #[cfg(target_os = "espidf")] -+ let flags = 0; -+ let fd = syscall!(eventfd(0, flags))?; -+ -+ let file = unsafe { File::from_raw_fd(fd) }; -+ Ok(WakerInternal { fd: file }) - } - - pub fn wake(&self) -> io::Result<()> { -@@ -44,6 +114,11 @@ mod eventfd { - } - } - -+ #[cfg(mio_unsupported_force_poll_poll)] -+ pub fn ack_and_reset(&self) { -+ let _ = self.reset(); -+ } -+ - /// Reset the eventfd object, only need to call this if `wake` fails. - fn reset(&self) -> io::Result<()> { - let mut buf: [u8; 8] = 0u64.to_ne_bytes(); -@@ -56,12 +131,31 @@ mod eventfd { - } - } - } -+ -+ impl AsRawFd for WakerInternal { -+ fn as_raw_fd(&self) -> RawFd { -+ self.fd.as_raw_fd() -+ } -+ } - } - --#[cfg(any(target_os = "linux", target_os = "android"))] --pub use self::eventfd::Waker; -+#[cfg(all( -+ mio_unsupported_force_poll_poll, -+ not(mio_unsupported_force_waker_pipe), -+ any(target_os = "linux", target_os = "android", target_os = "espidf") -+))] -+pub(crate) use self::eventfd::WakerInternal; - --#[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+#[cfg(all( -+ not(mio_unsupported_force_waker_pipe), -+ any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ ) -+))] - mod kqueue { - use crate::sys::Selector; - use crate::Token; -@@ -82,11 +176,9 @@ mod kqueue { - - impl Waker { - pub fn new(selector: &Selector, token: Token) -> io::Result { -- selector.try_clone().and_then(|selector| { -- selector -- .setup_waker(token) -- .map(|()| Waker { selector, token }) -- }) -+ let selector = selector.try_clone()?; -+ selector.setup_waker(token)?; -+ Ok(Waker { selector, token }) - } - - pub fn wake(&self) -> io::Result<()> { -@@ -95,45 +187,51 @@ mod kqueue { - } - } - --#[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] -+#[cfg(all( -+ not(mio_unsupported_force_waker_pipe), -+ any( -+ target_os = "freebsd", -+ target_os = "ios", -+ target_os = "macos", -+ target_os = "tvos", -+ target_os = "watchos", -+ ) -+))] - pub use self::kqueue::Waker; - - #[cfg(any( -+ mio_unsupported_force_waker_pipe, -+ target_os = "aix", - target_os = "dragonfly", - target_os = "illumos", - target_os = "netbsd", - target_os = "openbsd", -- target_os = "solaris" -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "vita", - ))] - mod pipe { -- use crate::sys::unix::Selector; -- use crate::{Interest, Token}; -- -+ use crate::sys::unix::pipe; - use std::fs::File; - use std::io::{self, Read, Write}; -- use std::os::unix::io::FromRawFd; -+ use std::os::unix::io::{AsRawFd, FromRawFd, RawFd}; - - /// Waker backed by a unix pipe. - /// - /// Waker controls both the sending and receiving ends and empties the pipe - /// if writing to it (waking) fails. - #[derive(Debug)] -- pub struct Waker { -+ pub struct WakerInternal { - sender: File, - receiver: File, - } - -- impl Waker { -- pub fn new(selector: &Selector, token: Token) -> io::Result { -- let mut fds = [-1; 2]; -- syscall!(pipe2(fds.as_mut_ptr(), libc::O_NONBLOCK | libc::O_CLOEXEC))?; -- // Turn the file descriptors into files first so we're ensured -- // they're closed when dropped, e.g. when register below fails. -- let sender = unsafe { File::from_raw_fd(fds[1]) }; -- let receiver = unsafe { File::from_raw_fd(fds[0]) }; -- selector -- .register(fds[0], token, Interest::READABLE) -- .map(|()| Waker { sender, receiver }) -+ impl WakerInternal { -+ pub fn new() -> io::Result { -+ let [receiver, sender] = pipe::new_raw()?; -+ let sender = unsafe { File::from_raw_fd(sender) }; -+ let receiver = unsafe { File::from_raw_fd(receiver) }; -+ Ok(WakerInternal { sender, receiver }) - } - - pub fn wake(&self) -> io::Result<()> { -@@ -156,6 +254,15 @@ mod pipe { - } - } - -+ #[cfg(any( -+ mio_unsupported_force_poll_poll, -+ target_os = "solaris", -+ target_os = "vita" -+ ))] -+ pub fn ack_and_reset(&self) { -+ self.empty(); -+ } -+ - /// Empty the pipe's buffer, only need to call this if `wake` fails. - /// This ignores any errors. - fn empty(&self) { -@@ -168,13 +275,65 @@ mod pipe { - } - } - } -+ -+ impl AsRawFd for WakerInternal { -+ fn as_raw_fd(&self) -> RawFd { -+ self.receiver.as_raw_fd() -+ } -+ } - } - - #[cfg(any( -- target_os = "dragonfly", -- target_os = "illumos", -- target_os = "netbsd", -- target_os = "openbsd", -- target_os = "solaris" -+ all( -+ mio_unsupported_force_poll_poll, -+ any( -+ mio_unsupported_force_waker_pipe, -+ target_os = "aix", -+ target_os = "dragonfly", -+ target_os = "illumos", -+ target_os = "netbsd", -+ target_os = "openbsd", -+ target_os = "redox", -+ ) -+ ), -+ target_os = "solaris", -+ target_os = "vita", -+))] -+pub(crate) use self::pipe::WakerInternal; -+ -+#[cfg(any( -+ mio_unsupported_force_poll_poll, -+ target_os = "solaris", -+ target_os = "vita" -+))] -+mod poll { -+ use crate::sys::Selector; -+ use crate::Token; -+ use std::io; -+ -+ #[derive(Debug)] -+ pub struct Waker { -+ selector: Selector, -+ token: Token, -+ } -+ -+ impl Waker { -+ pub fn new(selector: &Selector, token: Token) -> io::Result { -+ Ok(Waker { -+ selector: selector.try_clone()?, -+ token, -+ }) -+ } -+ -+ pub fn wake(&self) -> io::Result<()> { -+ self.selector.wake(self.token) -+ } -+ } -+} -+ -+#[cfg(any( -+ mio_unsupported_force_poll_poll, -+ target_os = "solaris", -+ target_os = "vita" - ))] --pub use self::pipe::Waker; -+pub use self::poll::Waker; -diff --git a/KubeOS-Rust/vendor/mio/src/sys/wasi/mod.rs b/KubeOS-Rust/vendor/mio/src/sys/wasi/mod.rs -new file mode 100644 -index 00000000..b1a25fc9 ---- /dev/null -+++ b/KubeOS-Rust/vendor/mio/src/sys/wasi/mod.rs -@@ -0,0 +1,370 @@ -+//! # Notes -+//! -+//! The current implementation is somewhat limited. The `Waker` is not -+//! implemented, as at the time of writing there is no way to support to wake-up -+//! a thread from calling `poll_oneoff`. -+//! -+//! Furthermore the (re/de)register functions also don't work while concurrently -+//! polling as both registering and polling requires a lock on the -+//! `subscriptions`. -+//! -+//! Finally `Selector::try_clone`, required by `Registry::try_clone`, doesn't -+//! work. However this could be implemented by use of an `Arc`. -+//! -+//! In summary, this only (barely) works using a single thread. -+ -+use std::cmp::min; -+use std::io; -+#[cfg(all(feature = "net", debug_assertions))] -+use std::sync::atomic::{AtomicUsize, Ordering}; -+use std::sync::{Arc, Mutex}; -+use std::time::Duration; -+ -+#[cfg(feature = "net")] -+use crate::{Interest, Token}; -+ -+cfg_net! { -+ pub(crate) mod tcp { -+ use std::io; -+ use std::net::{self, SocketAddr}; -+ -+ pub(crate) fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { -+ let (stream, addr) = listener.accept()?; -+ stream.set_nonblocking(true)?; -+ Ok((stream, addr)) -+ } -+ } -+} -+ -+/// Unique id for use as `SelectorId`. -+#[cfg(all(debug_assertions, feature = "net"))] -+static NEXT_ID: AtomicUsize = AtomicUsize::new(1); -+ -+pub(crate) struct Selector { -+ #[cfg(all(debug_assertions, feature = "net"))] -+ id: usize, -+ /// Subscriptions (reads events) we're interested in. -+ subscriptions: Arc>>, -+} -+ -+impl Selector { -+ pub(crate) fn new() -> io::Result { -+ Ok(Selector { -+ #[cfg(all(debug_assertions, feature = "net"))] -+ id: NEXT_ID.fetch_add(1, Ordering::Relaxed), -+ subscriptions: Arc::new(Mutex::new(Vec::new())), -+ }) -+ } -+ -+ #[cfg(all(debug_assertions, feature = "net"))] -+ pub(crate) fn id(&self) -> usize { -+ self.id -+ } -+ -+ pub(crate) fn select(&self, events: &mut Events, timeout: Option) -> io::Result<()> { -+ events.clear(); -+ -+ let mut subscriptions = self.subscriptions.lock().unwrap(); -+ -+ // If we want to a use a timeout in the `wasi_poll_oneoff()` function -+ // we need another subscription to the list. -+ if let Some(timeout) = timeout { -+ subscriptions.push(timeout_subscription(timeout)); -+ } -+ -+ // `poll_oneoff` needs the same number of events as subscriptions. -+ let length = subscriptions.len(); -+ events.reserve(length); -+ -+ debug_assert!(events.capacity() >= length); -+ #[cfg(debug_assertions)] -+ if length == 0 { -+ warn!( -+ "calling mio::Poll::poll with empty subscriptions, this likely not what you want" -+ ); -+ } -+ -+ let res = unsafe { wasi::poll_oneoff(subscriptions.as_ptr(), events.as_mut_ptr(), length) }; -+ -+ // Remove the timeout subscription we possibly added above. -+ if timeout.is_some() { -+ let timeout_sub = subscriptions.pop(); -+ debug_assert_eq!( -+ timeout_sub.unwrap().u.tag, -+ wasi::EVENTTYPE_CLOCK.raw(), -+ "failed to remove timeout subscription" -+ ); -+ } -+ -+ drop(subscriptions); // Unlock. -+ -+ match res { -+ Ok(n_events) => { -+ // Safety: `poll_oneoff` initialises the `events` for us. -+ unsafe { events.set_len(n_events) }; -+ -+ // Remove the timeout event. -+ if timeout.is_some() { -+ if let Some(index) = events.iter().position(is_timeout_event) { -+ events.swap_remove(index); -+ } -+ } -+ -+ check_errors(&events) -+ } -+ Err(err) => Err(io_err(err)), -+ } -+ } -+ -+ pub(crate) fn try_clone(&self) -> io::Result { -+ Ok(Selector { -+ #[cfg(all(debug_assertions, feature = "net"))] -+ id: self.id, -+ subscriptions: self.subscriptions.clone(), -+ }) -+ } -+ -+ #[cfg(feature = "net")] -+ pub(crate) fn register( -+ &self, -+ fd: wasi::Fd, -+ token: Token, -+ interests: Interest, -+ ) -> io::Result<()> { -+ let mut subscriptions = self.subscriptions.lock().unwrap(); -+ -+ if interests.is_writable() { -+ let subscription = wasi::Subscription { -+ userdata: token.0 as wasi::Userdata, -+ u: wasi::SubscriptionU { -+ tag: wasi::EVENTTYPE_FD_WRITE.raw(), -+ u: wasi::SubscriptionUU { -+ fd_write: wasi::SubscriptionFdReadwrite { -+ file_descriptor: fd, -+ }, -+ }, -+ }, -+ }; -+ subscriptions.push(subscription); -+ } -+ -+ if interests.is_readable() { -+ let subscription = wasi::Subscription { -+ userdata: token.0 as wasi::Userdata, -+ u: wasi::SubscriptionU { -+ tag: wasi::EVENTTYPE_FD_READ.raw(), -+ u: wasi::SubscriptionUU { -+ fd_read: wasi::SubscriptionFdReadwrite { -+ file_descriptor: fd, -+ }, -+ }, -+ }, -+ }; -+ subscriptions.push(subscription); -+ } -+ -+ Ok(()) -+ } -+ -+ #[cfg(feature = "net")] -+ pub(crate) fn reregister( -+ &self, -+ fd: wasi::Fd, -+ token: Token, -+ interests: Interest, -+ ) -> io::Result<()> { -+ self.deregister(fd) -+ .and_then(|()| self.register(fd, token, interests)) -+ } -+ -+ #[cfg(feature = "net")] -+ pub(crate) fn deregister(&self, fd: wasi::Fd) -> io::Result<()> { -+ let mut subscriptions = self.subscriptions.lock().unwrap(); -+ -+ let predicate = |subscription: &wasi::Subscription| { -+ // Safety: `subscription.u.tag` defines the type of the union in -+ // `subscription.u.u`. -+ match subscription.u.tag { -+ t if t == wasi::EVENTTYPE_FD_WRITE.raw() => unsafe { -+ subscription.u.u.fd_write.file_descriptor == fd -+ }, -+ t if t == wasi::EVENTTYPE_FD_READ.raw() => unsafe { -+ subscription.u.u.fd_read.file_descriptor == fd -+ }, -+ _ => false, -+ } -+ }; -+ -+ let mut ret = Err(io::ErrorKind::NotFound.into()); -+ -+ while let Some(index) = subscriptions.iter().position(predicate) { -+ subscriptions.swap_remove(index); -+ ret = Ok(()) -+ } -+ -+ ret -+ } -+} -+ -+/// Token used to a add a timeout subscription, also used in removing it again. -+const TIMEOUT_TOKEN: wasi::Userdata = wasi::Userdata::max_value(); -+ -+/// Returns a `wasi::Subscription` for `timeout`. -+fn timeout_subscription(timeout: Duration) -> wasi::Subscription { -+ wasi::Subscription { -+ userdata: TIMEOUT_TOKEN, -+ u: wasi::SubscriptionU { -+ tag: wasi::EVENTTYPE_CLOCK.raw(), -+ u: wasi::SubscriptionUU { -+ clock: wasi::SubscriptionClock { -+ id: wasi::CLOCKID_MONOTONIC, -+ // Timestamp is in nanoseconds. -+ timeout: min(wasi::Timestamp::MAX as u128, timeout.as_nanos()) -+ as wasi::Timestamp, -+ // Give the implementation another millisecond to coalesce -+ // events. -+ precision: Duration::from_millis(1).as_nanos() as wasi::Timestamp, -+ // Zero means the `timeout` is considered relative to the -+ // current time. -+ flags: 0, -+ }, -+ }, -+ }, -+ } -+} -+ -+fn is_timeout_event(event: &wasi::Event) -> bool { -+ event.type_ == wasi::EVENTTYPE_CLOCK && event.userdata == TIMEOUT_TOKEN -+} -+ -+/// Check all events for possible errors, it returns the first error found. -+fn check_errors(events: &[Event]) -> io::Result<()> { -+ for event in events { -+ if event.error != wasi::ERRNO_SUCCESS { -+ return Err(io_err(event.error)); -+ } -+ } -+ Ok(()) -+} -+ -+/// Convert `wasi::Errno` into an `io::Error`. -+fn io_err(errno: wasi::Errno) -> io::Error { -+ // TODO: check if this is valid. -+ io::Error::from_raw_os_error(errno.raw() as i32) -+} -+ -+pub(crate) type Events = Vec; -+ -+pub(crate) type Event = wasi::Event; -+ -+pub(crate) mod event { -+ use std::fmt; -+ -+ use crate::sys::Event; -+ use crate::Token; -+ -+ pub(crate) fn token(event: &Event) -> Token { -+ Token(event.userdata as usize) -+ } -+ -+ pub(crate) fn is_readable(event: &Event) -> bool { -+ event.type_ == wasi::EVENTTYPE_FD_READ -+ } -+ -+ pub(crate) fn is_writable(event: &Event) -> bool { -+ event.type_ == wasi::EVENTTYPE_FD_WRITE -+ } -+ -+ pub(crate) fn is_error(_: &Event) -> bool { -+ // Not supported? It could be that `wasi::Event.error` could be used for -+ // this, but the docs say `error that occurred while processing the -+ // subscription request`, so it's checked in `Select::select` already. -+ false -+ } -+ -+ pub(crate) fn is_read_closed(event: &Event) -> bool { -+ event.type_ == wasi::EVENTTYPE_FD_READ -+ // Safety: checked the type of the union above. -+ && (event.fd_readwrite.flags & wasi::EVENTRWFLAGS_FD_READWRITE_HANGUP) != 0 -+ } -+ -+ pub(crate) fn is_write_closed(event: &Event) -> bool { -+ event.type_ == wasi::EVENTTYPE_FD_WRITE -+ // Safety: checked the type of the union above. -+ && (event.fd_readwrite.flags & wasi::EVENTRWFLAGS_FD_READWRITE_HANGUP) != 0 -+ } -+ -+ pub(crate) fn is_priority(_: &Event) -> bool { -+ // Not supported. -+ false -+ } -+ -+ pub(crate) fn is_aio(_: &Event) -> bool { -+ // Not supported. -+ false -+ } -+ -+ pub(crate) fn is_lio(_: &Event) -> bool { -+ // Not supported. -+ false -+ } -+ -+ pub(crate) fn debug_details(f: &mut fmt::Formatter<'_>, event: &Event) -> fmt::Result { -+ debug_detail!( -+ TypeDetails(wasi::Eventtype), -+ PartialEq::eq, -+ wasi::EVENTTYPE_CLOCK, -+ wasi::EVENTTYPE_FD_READ, -+ wasi::EVENTTYPE_FD_WRITE, -+ ); -+ -+ #[allow(clippy::trivially_copy_pass_by_ref)] -+ fn check_flag(got: &wasi::Eventrwflags, want: &wasi::Eventrwflags) -> bool { -+ (got & want) != 0 -+ } -+ debug_detail!( -+ EventrwflagsDetails(wasi::Eventrwflags), -+ check_flag, -+ wasi::EVENTRWFLAGS_FD_READWRITE_HANGUP, -+ ); -+ -+ struct EventFdReadwriteDetails(wasi::EventFdReadwrite); -+ -+ impl fmt::Debug for EventFdReadwriteDetails { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ f.debug_struct("EventFdReadwrite") -+ .field("nbytes", &self.0.nbytes) -+ .field("flags", &self.0.flags) -+ .finish() -+ } -+ } -+ -+ f.debug_struct("Event") -+ .field("userdata", &event.userdata) -+ .field("error", &event.error) -+ .field("type", &TypeDetails(event.type_)) -+ .field("fd_readwrite", &EventFdReadwriteDetails(event.fd_readwrite)) -+ .finish() -+ } -+} -+ -+cfg_os_poll! { -+ cfg_io_source! { -+ pub(crate) struct IoSourceState; -+ -+ impl IoSourceState { -+ pub(crate) fn new() -> IoSourceState { -+ IoSourceState -+ } -+ -+ pub(crate) fn do_io(&self, f: F, io: &T) -> io::Result -+ where -+ F: FnOnce(&T) -> io::Result, -+ { -+ // We don't hold state, so we can just call the function and -+ // return. -+ f(io) -+ } -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/afd.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/afd.rs -index 6241a45e..3bda4536 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/afd.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/afd.rs -@@ -1,17 +1,32 @@ --use ntapi::ntioapi::{IO_STATUS_BLOCK_u, IO_STATUS_BLOCK}; --use ntapi::ntioapi::{NtCancelIoFileEx, NtDeviceIoControlFile}; --use ntapi::ntrtl::RtlNtStatusToDosError; -+use std::ffi::c_void; - use std::fmt; - use std::fs::File; - use std::io; - use std::mem::size_of; - use std::os::windows::io::AsRawHandle; --use std::ptr::null_mut; --use winapi::shared::ntdef::{HANDLE, LARGE_INTEGER, NTSTATUS, PVOID, ULONG}; --use winapi::shared::ntstatus::{STATUS_NOT_FOUND, STATUS_PENDING, STATUS_SUCCESS}; - --const IOCTL_AFD_POLL: ULONG = 0x00012024; -+use windows_sys::Win32::Foundation::{ -+ RtlNtStatusToDosError, HANDLE, NTSTATUS, STATUS_NOT_FOUND, STATUS_PENDING, STATUS_SUCCESS, -+}; -+use windows_sys::Win32::System::WindowsProgramming::{ -+ NtDeviceIoControlFile, IO_STATUS_BLOCK, IO_STATUS_BLOCK_0, -+}; - -+const IOCTL_AFD_POLL: u32 = 0x00012024; -+ -+#[link(name = "ntdll")] -+extern "system" { -+ /// See -+ /// -+ /// This is an undocumented API and as such not part of -+ /// from which `windows-sys` is generated, and also unlikely to be added, so -+ /// we manually declare it here -+ fn NtCancelIoFileEx( -+ FileHandle: HANDLE, -+ IoRequestToCancel: *mut IO_STATUS_BLOCK, -+ IoStatusBlock: *mut IO_STATUS_BLOCK, -+ ) -> NTSTATUS; -+} - /// Winsock2 AFD driver instance. - /// - /// All operations are unsafe due to IO_STATUS_BLOCK parameter are being used by Afd driver during STATUS_PENDING before I/O Completion Port returns its result. -@@ -24,7 +39,7 @@ pub struct Afd { - #[derive(Debug)] - pub struct AfdPollHandleInfo { - pub handle: HANDLE, -- pub events: ULONG, -+ pub events: u32, - pub status: NTSTATUS, - } - -@@ -32,10 +47,10 @@ unsafe impl Send for AfdPollHandleInfo {} - - #[repr(C)] - pub struct AfdPollInfo { -- pub timeout: LARGE_INTEGER, -+ pub timeout: i64, - // Can have only value 1. -- pub number_of_handles: ULONG, -- pub exclusive: ULONG, -+ pub number_of_handles: u32, -+ pub exclusive: u32, - pub handles: [AfdPollHandleInfo; 1], - } - -@@ -58,13 +73,13 @@ impl Afd { - &self, - info: &mut AfdPollInfo, - iosb: *mut IO_STATUS_BLOCK, -- overlapped: PVOID, -+ overlapped: *mut c_void, - ) -> io::Result { -- let info_ptr: PVOID = info as *mut _ as PVOID; -- (*iosb).u.Status = STATUS_PENDING; -+ let info_ptr = info as *mut _ as *mut c_void; -+ (*iosb).Anonymous.Status = STATUS_PENDING; - let status = NtDeviceIoControlFile( -- self.fd.as_raw_handle(), -- null_mut(), -+ self.fd.as_raw_handle() as HANDLE, -+ 0, - None, - overlapped, - iosb, -@@ -93,15 +108,15 @@ impl Afd { - /// Use it only with request is still being polled so that you have valid `IO_STATUS_BLOCK` to use. - /// User should NOT deallocate there overlapped value after the `cancel` to prevent double free. - pub unsafe fn cancel(&self, iosb: *mut IO_STATUS_BLOCK) -> io::Result<()> { -- if (*iosb).u.Status != STATUS_PENDING { -+ if (*iosb).Anonymous.Status != STATUS_PENDING { - return Ok(()); - } - - let mut cancel_iosb = IO_STATUS_BLOCK { -- u: IO_STATUS_BLOCK_u { Status: 0 }, -+ Anonymous: IO_STATUS_BLOCK_0 { Status: 0 }, - Information: 0, - }; -- let status = NtCancelIoFileEx(self.fd.as_raw_handle(), iosb, &mut cancel_iosb); -+ let status = NtCancelIoFileEx(self.fd.as_raw_handle() as HANDLE, iosb, &mut cancel_iosb); - if status == STATUS_SUCCESS || status == STATUS_NOT_FOUND { - return Ok(()); - } -@@ -114,18 +129,21 @@ impl Afd { - cfg_io_source! { - use std::mem::zeroed; - use std::os::windows::io::{FromRawHandle, RawHandle}; -+ use std::ptr::null_mut; - use std::sync::atomic::{AtomicUsize, Ordering}; - -- use miow::iocp::CompletionPort; -- use ntapi::ntioapi::{NtCreateFile, FILE_OPEN}; -- use winapi::shared::ntdef::{OBJECT_ATTRIBUTES, UNICODE_STRING, USHORT, WCHAR}; -- use winapi::um::handleapi::INVALID_HANDLE_VALUE; -- use winapi::um::winbase::{SetFileCompletionNotificationModes, FILE_SKIP_SET_EVENT_ON_HANDLE}; -- use winapi::um::winnt::{SYNCHRONIZE, FILE_SHARE_READ, FILE_SHARE_WRITE}; -+ use super::iocp::CompletionPort; -+ use windows_sys::Win32::{ -+ Foundation::{UNICODE_STRING, INVALID_HANDLE_VALUE}, -+ System::WindowsProgramming::{ -+ OBJECT_ATTRIBUTES, FILE_SKIP_SET_EVENT_ON_HANDLE, -+ }, -+ Storage::FileSystem::{FILE_OPEN, NtCreateFile, SetFileCompletionNotificationModes, SYNCHRONIZE, FILE_SHARE_READ, FILE_SHARE_WRITE}, -+ }; - - const AFD_HELPER_ATTRIBUTES: OBJECT_ATTRIBUTES = OBJECT_ATTRIBUTES { -- Length: size_of::() as ULONG, -- RootDirectory: null_mut(), -+ Length: size_of::() as u32, -+ RootDirectory: 0, - ObjectName: &AFD_OBJ_NAME as *const _ as *mut _, - Attributes: 0, - SecurityDescriptor: null_mut(), -@@ -133,12 +151,12 @@ cfg_io_source! { - }; - - const AFD_OBJ_NAME: UNICODE_STRING = UNICODE_STRING { -- Length: (AFD_HELPER_NAME.len() * size_of::()) as USHORT, -- MaximumLength: (AFD_HELPER_NAME.len() * size_of::()) as USHORT, -+ Length: (AFD_HELPER_NAME.len() * size_of::()) as u16, -+ MaximumLength: (AFD_HELPER_NAME.len() * size_of::()) as u16, - Buffer: AFD_HELPER_NAME.as_ptr() as *mut _, - }; - -- const AFD_HELPER_NAME: &[WCHAR] = &[ -+ const AFD_HELPER_NAME: &[u16] = &[ - '\\' as _, - 'D' as _, - 'e' as _, -@@ -166,10 +184,10 @@ cfg_io_source! { - - impl Afd { - /// Create new Afd instance. -- pub fn new(cp: &CompletionPort) -> io::Result { -+ pub(crate) fn new(cp: &CompletionPort) -> io::Result { - let mut afd_helper_handle: HANDLE = INVALID_HANDLE_VALUE; - let mut iosb = IO_STATUS_BLOCK { -- u: IO_STATUS_BLOCK_u { Status: 0 }, -+ Anonymous: IO_STATUS_BLOCK_0 { Status: 0 }, - Information: 0, - }; - -@@ -180,12 +198,12 @@ cfg_io_source! { - &AFD_HELPER_ATTRIBUTES as *const _ as *mut _, - &mut iosb, - null_mut(), -- 0 as ULONG, -+ 0, - FILE_SHARE_READ | FILE_SHARE_WRITE, - FILE_OPEN, -- 0 as ULONG, -+ 0, - null_mut(), -- 0 as ULONG, -+ 0, - ); - if status != STATUS_SUCCESS { - let raw_err = io::Error::from_raw_os_error( -@@ -197,14 +215,14 @@ cfg_io_source! { - let fd = File::from_raw_handle(afd_helper_handle as RawHandle); - // Increment by 2 to reserve space for other types of handles. - // Non-AFD types (currently only NamedPipe), use odd numbered -- // tokens. This allows the selector to differentate between them -+ // tokens. This allows the selector to differentiate between them - // and dispatch events accordingly. - let token = NEXT_TOKEN.fetch_add(2, Ordering::Relaxed) + 2; - let afd = Afd { fd }; - cp.add_handle(token, &afd.fd)?; - match SetFileCompletionNotificationModes( - afd_helper_handle, -- FILE_SKIP_SET_EVENT_ON_HANDLE, -+ FILE_SKIP_SET_EVENT_ON_HANDLE as u8 // This is just 2, so fits in u8 - ) { - 0 => Err(io::Error::last_os_error()), - _ => Ok(afd), -@@ -214,18 +232,18 @@ cfg_io_source! { - } - } - --pub const POLL_RECEIVE: u32 = 0b000_000_001; --pub const POLL_RECEIVE_EXPEDITED: u32 = 0b000_000_010; --pub const POLL_SEND: u32 = 0b000_000_100; --pub const POLL_DISCONNECT: u32 = 0b000_001_000; --pub const POLL_ABORT: u32 = 0b000_010_000; --pub const POLL_LOCAL_CLOSE: u32 = 0b000_100_000; -+pub const POLL_RECEIVE: u32 = 0b0_0000_0001; -+pub const POLL_RECEIVE_EXPEDITED: u32 = 0b0_0000_0010; -+pub const POLL_SEND: u32 = 0b0_0000_0100; -+pub const POLL_DISCONNECT: u32 = 0b0_0000_1000; -+pub const POLL_ABORT: u32 = 0b0_0001_0000; -+pub const POLL_LOCAL_CLOSE: u32 = 0b0_0010_0000; - // Not used as it indicated in each event where a connection is connected, not - // just the first time a connection is established. - // Also see https://github.com/piscisaureus/wepoll/commit/8b7b340610f88af3d83f40fb728e7b850b090ece. --pub const POLL_CONNECT: u32 = 0b001_000_000; --pub const POLL_ACCEPT: u32 = 0b010_000_000; --pub const POLL_CONNECT_FAIL: u32 = 0b100_000_000; -+pub const POLL_CONNECT: u32 = 0b0_0100_0000; -+pub const POLL_ACCEPT: u32 = 0b0_1000_0000; -+pub const POLL_CONNECT_FAIL: u32 = 0b1_0000_0000; - - pub const KNOWN_EVENTS: u32 = POLL_RECEIVE - | POLL_RECEIVE_EXPEDITED -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/event.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/event.rs -index a49252a2..731bd606 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/event.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/event.rs -@@ -1,8 +1,7 @@ - use std::fmt; - --use miow::iocp::CompletionStatus; -- - use super::afd; -+use super::iocp::CompletionStatus; - use crate::Token; - - #[derive(Clone)] -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/handle.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/handle.rs -new file mode 100644 -index 00000000..5b9ac0b6 ---- /dev/null -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/handle.rs -@@ -0,0 +1,30 @@ -+use std::os::windows::io::RawHandle; -+use windows_sys::Win32::Foundation::{CloseHandle, HANDLE}; -+ -+/// Wrapper around a Windows HANDLE so that we close it upon drop in all scenarios -+#[derive(Debug)] -+pub struct Handle(HANDLE); -+ -+impl Handle { -+ #[inline] -+ pub fn new(handle: HANDLE) -> Self { -+ Self(handle) -+ } -+ -+ pub fn raw(&self) -> HANDLE { -+ self.0 -+ } -+ -+ pub fn into_raw(self) -> RawHandle { -+ let ret = self.0; -+ // This is super important so that drop is not called! -+ std::mem::forget(self); -+ ret as RawHandle -+ } -+} -+ -+impl Drop for Handle { -+ fn drop(&mut self) { -+ unsafe { CloseHandle(self.0) }; -+ } -+} -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/io_status_block.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/io_status_block.rs -index 3e603349..d7eda6a6 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/io_status_block.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/io_status_block.rs -@@ -1,17 +1,17 @@ - use std::fmt; - use std::ops::{Deref, DerefMut}; - --use ntapi::ntioapi::IO_STATUS_BLOCK; -+use windows_sys::Win32::System::WindowsProgramming::IO_STATUS_BLOCK; - - pub struct IoStatusBlock(IO_STATUS_BLOCK); - - cfg_io_source! { -- use ntapi::ntioapi::IO_STATUS_BLOCK_u; -+ use windows_sys::Win32::System::WindowsProgramming::{IO_STATUS_BLOCK_0}; - - impl IoStatusBlock { - pub fn zeroed() -> Self { - Self(IO_STATUS_BLOCK { -- u: IO_STATUS_BLOCK_u { Status: 0 }, -+ Anonymous: IO_STATUS_BLOCK_0 { Status: 0 }, - Information: 0, - }) - } -diff --git a/KubeOS-Rust/vendor/miow/src/iocp.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/iocp.rs -similarity index 60% -rename from KubeOS-Rust/vendor/miow/src/iocp.rs -rename to KubeOS-Rust/vendor/mio/src/sys/windows/iocp.rs -index d862d6bc..c71b695d 100644 ---- a/KubeOS-Rust/vendor/miow/src/iocp.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/iocp.rs -@@ -1,5 +1,6 @@ - //! Bindings to IOCP, I/O Completion Ports - -+use super::{Handle, Overlapped}; - use std::cmp; - use std::fmt; - use std::io; -@@ -7,17 +8,15 @@ use std::mem; - use std::os::windows::io::*; - use std::time::Duration; - --use crate::handle::Handle; --use crate::Overlapped; --use winapi::shared::basetsd::*; --use winapi::shared::ntdef::*; --use winapi::um::handleapi::*; --use winapi::um::ioapiset::*; --use winapi::um::minwinbase::*; -+use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE}; -+use windows_sys::Win32::System::IO::{ -+ CreateIoCompletionPort, GetQueuedCompletionStatusEx, PostQueuedCompletionStatus, OVERLAPPED, -+ OVERLAPPED_ENTRY, -+}; - - /// A handle to an Windows I/O Completion Port. - #[derive(Debug)] --pub struct CompletionPort { -+pub(crate) struct CompletionPort { - handle: Handle, - } - -@@ -27,10 +26,11 @@ pub struct CompletionPort { - /// provided to a completion port, or they are read out of a completion port. - /// The fields of each status are read through its accessor methods. - #[derive(Clone, Copy)] -+#[repr(transparent)] - pub struct CompletionStatus(OVERLAPPED_ENTRY); - - impl fmt::Debug for CompletionStatus { -- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "CompletionStatus(OVERLAPPED_ENTRY)") - } - } -@@ -45,8 +45,8 @@ impl CompletionPort { - /// allowed for threads associated with this port. Consult the Windows - /// documentation for more information about this value. - pub fn new(threads: u32) -> io::Result { -- let ret = unsafe { CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0 as *mut _, 0, threads) }; -- if ret.is_null() { -+ let ret = unsafe { CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, threads) }; -+ if ret == 0 { - Err(io::Error::last_os_error()) - } else { - Ok(CompletionPort { -@@ -64,72 +64,18 @@ impl CompletionPort { - /// Any object which is convertible to a `HANDLE` via the `AsRawHandle` - /// trait can be provided to this function, such as `std::fs::File` and - /// friends. -+ #[cfg(any(feature = "net", feature = "os-ext"))] - pub fn add_handle(&self, token: usize, t: &T) -> io::Result<()> { -- self._add(token, t.as_raw_handle()) -- } -- -- /// Associates a new `SOCKET` to this I/O completion port. -- /// -- /// This function will associate the given socket to this port with the -- /// given `token` to be returned in status messages whenever it receives a -- /// notification. -- /// -- /// Any object which is convertible to a `SOCKET` via the `AsRawSocket` -- /// trait can be provided to this function, such as `std::net::TcpStream` -- /// and friends. -- pub fn add_socket(&self, token: usize, t: &T) -> io::Result<()> { -- self._add(token, t.as_raw_socket() as HANDLE) -- } -- -- fn _add(&self, token: usize, handle: HANDLE) -> io::Result<()> { -- assert_eq!(mem::size_of_val(&token), mem::size_of::()); -- let ret = -- unsafe { CreateIoCompletionPort(handle, self.handle.raw(), token as ULONG_PTR, 0) }; -- if ret.is_null() { -+ let ret = unsafe { -+ CreateIoCompletionPort(t.as_raw_handle() as HANDLE, self.handle.raw(), token, 0) -+ }; -+ if ret == 0 { - Err(io::Error::last_os_error()) - } else { -- debug_assert_eq!(ret, self.handle.raw()); - Ok(()) - } - } - -- /// Dequeue a completion status from this I/O completion port. -- /// -- /// This function will associate the calling thread with this completion -- /// port and then wait for a status message to become available. The precise -- /// semantics on when this function returns depends on the concurrency value -- /// specified when the port was created. -- /// -- /// A timeout can optionally be specified to this function. If `None` is -- /// provided this function will not time out, and otherwise it will time out -- /// after the specified duration has passed. -- /// -- /// On success this will return the status message which was dequeued from -- /// this completion port. -- pub fn get(&self, timeout: Option) -> io::Result { -- let mut bytes = 0; -- let mut token = 0; -- let mut overlapped = 0 as *mut _; -- let timeout = crate::dur2ms(timeout); -- let ret = unsafe { -- GetQueuedCompletionStatus( -- self.handle.raw(), -- &mut bytes, -- &mut token, -- &mut overlapped, -- timeout, -- ) -- }; -- crate::cvt(ret).map(|_| { -- CompletionStatus(OVERLAPPED_ENTRY { -- dwNumberOfBytesTransferred: bytes, -- lpCompletionKey: token, -- lpOverlapped: overlapped, -- Internal: 0, -- }) -- }) -- } -- - /// Dequeues a number of completion statuses from this I/O completion port. - /// - /// This function is the same as `get` except that it may return more than -@@ -149,8 +95,8 @@ impl CompletionPort { - mem::size_of::() - ); - let mut removed = 0; -- let timeout = crate::dur2ms(timeout); -- let len = cmp::min(list.len(), ::max_value() as usize) as ULONG; -+ let timeout = duration_millis(timeout); -+ let len = cmp::min(list.len(), ::max_value() as usize) as u32; - let ret = unsafe { - GetQueuedCompletionStatusEx( - self.handle.raw(), -@@ -158,12 +104,14 @@ impl CompletionPort { - len, - &mut removed, - timeout, -- FALSE as i32, -+ 0, - ) - }; -- match crate::cvt(ret) { -- Ok(_) => Ok(&mut list[..removed as usize]), -- Err(e) => Err(e), -+ -+ if ret == 0 { -+ Err(io::Error::last_os_error()) -+ } else { -+ Ok(&mut list[..removed as usize]) - } - } - -@@ -181,26 +129,31 @@ impl CompletionPort { - status.0.lpOverlapped, - ) - }; -- crate::cvt(ret).map(|_| ()) -+ -+ if ret == 0 { -+ Err(io::Error::last_os_error()) -+ } else { -+ Ok(()) -+ } - } - } - - impl AsRawHandle for CompletionPort { -- fn as_raw_handle(&self) -> HANDLE { -- self.handle.raw() -+ fn as_raw_handle(&self) -> RawHandle { -+ self.handle.raw() as RawHandle - } - } - - impl FromRawHandle for CompletionPort { -- unsafe fn from_raw_handle(handle: HANDLE) -> CompletionPort { -+ unsafe fn from_raw_handle(handle: RawHandle) -> CompletionPort { - CompletionPort { -- handle: Handle::new(handle), -+ handle: Handle::new(handle as HANDLE), - } - } - } - - impl IntoRawHandle for CompletionPort { -- fn into_raw_handle(self) -> HANDLE { -+ fn into_raw_handle(self) -> RawHandle { - self.handle.into_raw() - } - } -@@ -211,11 +164,10 @@ impl CompletionStatus { - /// This function is useful when creating a status to send to a port with - /// the `post` method. The parameters are opaquely passed through and not - /// interpreted by the system at all. -- pub fn new(bytes: u32, token: usize, overlapped: *mut Overlapped) -> CompletionStatus { -- assert_eq!(mem::size_of_val(&token), mem::size_of::()); -+ pub(crate) fn new(bytes: u32, token: usize, overlapped: *mut Overlapped) -> Self { - CompletionStatus(OVERLAPPED_ENTRY { - dwNumberOfBytesTransferred: bytes, -- lpCompletionKey: token as ULONG_PTR, -+ lpCompletionKey: token, - lpOverlapped: overlapped as *mut _, - Internal: 0, - }) -@@ -226,7 +178,11 @@ impl CompletionStatus { - /// - /// This method will wrap the `OVERLAPPED_ENTRY` in a `CompletionStatus`, - /// returning the wrapped structure. -- pub fn from_entry(entry: &OVERLAPPED_ENTRY) -> &CompletionStatus { -+ #[cfg(feature = "os-ext")] -+ pub fn from_entry(entry: &OVERLAPPED_ENTRY) -> &Self { -+ // Safety: CompletionStatus is repr(transparent) w/ OVERLAPPED_ENTRY, so -+ // a reference to one is guaranteed to be layout compatible with the -+ // reference to another. - unsafe { &*(entry as *const _ as *const _) } - } - -@@ -234,8 +190,8 @@ impl CompletionStatus { - /// - /// This function is useful when creating a stack buffer or vector of - /// completion statuses to be passed to the `get_many` function. -- pub fn zero() -> CompletionStatus { -- CompletionStatus::new(0, 0, 0 as *mut _) -+ pub fn zero() -> Self { -+ Self::new(0, 0, std::ptr::null_mut()) - } - - /// Returns the number of bytes that were transferred for the I/O operation -@@ -265,15 +221,26 @@ impl CompletionStatus { - } - } - -+#[inline] -+fn duration_millis(dur: Option) -> u32 { -+ if let Some(dur) = dur { -+ // `Duration::as_millis` truncates, so round up. This avoids -+ // turning sub-millisecond timeouts into a zero timeout, unless -+ // the caller explicitly requests that by specifying a zero -+ // timeout. -+ let dur_ms = dur -+ .checked_add(Duration::from_nanos(999_999)) -+ .unwrap_or(dur) -+ .as_millis(); -+ cmp::min(dur_ms, u32::MAX as u128) as u32 -+ } else { -+ u32::MAX -+ } -+} -+ - #[cfg(test)] - mod tests { -- use std::mem; -- use std::time::Duration; -- -- use winapi::shared::basetsd::*; -- use winapi::shared::winerror::*; -- -- use crate::iocp::{CompletionPort, CompletionStatus}; -+ use super::{CompletionPort, CompletionStatus}; - - #[test] - fn is_send_sync() { -@@ -281,28 +248,6 @@ mod tests { - is_send_sync::(); - } - -- #[test] -- fn token_right_size() { -- assert_eq!(mem::size_of::(), mem::size_of::()); -- } -- -- #[test] -- fn timeout() { -- let c = CompletionPort::new(1).unwrap(); -- let err = c.get(Some(Duration::from_millis(1))).unwrap_err(); -- assert_eq!(err.raw_os_error(), Some(WAIT_TIMEOUT as i32)); -- } -- -- #[test] -- fn get() { -- let c = CompletionPort::new(1).unwrap(); -- c.post(CompletionStatus::new(1, 2, 3 as *mut _)).unwrap(); -- let s = c.get(None).unwrap(); -- assert_eq!(s.bytes_transferred(), 1); -- assert_eq!(s.token(), 2); -- assert_eq!(s.overlapped(), 3 as *mut _); -- } -- - #[test] - fn get_many() { - let c = CompletionPort::new(1).unwrap(); -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/mod.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/mod.rs -index 98b6fc63..f8b72fc4 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/mod.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/mod.rs -@@ -1,15 +1,20 @@ - mod afd; --mod io_status_block; - - pub mod event; - pub use event::{Event, Events}; - --mod selector; --pub use selector::{Selector, SelectorInner, SockState}; -+mod handle; -+use handle::Handle; -+ -+mod io_status_block; -+mod iocp; - - mod overlapped; - use overlapped::Overlapped; - -+mod selector; -+pub use selector::{Selector, SelectorInner, SockState}; -+ - // Macros must be defined before the modules that use them - cfg_net! { - /// Helper macro to execute a system call that returns an `io::Result`. -@@ -45,7 +50,7 @@ cfg_io_source! { - use std::pin::Pin; - use std::sync::{Arc, Mutex}; - -- use crate::{poll, Interest, Registry, Token}; -+ use crate::{Interest, Registry, Token}; - - struct InternalState { - selector: Arc, -@@ -101,7 +106,8 @@ cfg_io_source! { - if self.inner.is_some() { - Err(io::ErrorKind::AlreadyExists.into()) - } else { -- poll::selector(registry) -+ registry -+ .selector() - .register(socket, token, interests) - .map(|state| { - self.inner = Some(Box::new(state)); -@@ -117,7 +123,8 @@ cfg_io_source! { - ) -> io::Result<()> { - match self.inner.as_mut() { - Some(state) => { -- poll::selector(registry) -+ registry -+ .selector() - .reregister(state.sock_state.clone(), token, interests) - .map(|()| { - state.token = token; -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/named_pipe.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/named_pipe.rs -index 0b309543..23f85d1e 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/named_pipe.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/named_pipe.rs -@@ -1,20 +1,30 @@ - use std::ffi::OsStr; - use std::io::{self, Read, Write}; --use std::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle}; -+use std::os::windows::io::{AsRawHandle, FromRawHandle, RawHandle}; - use std::sync::atomic::Ordering::{Relaxed, SeqCst}; - use std::sync::atomic::{AtomicBool, AtomicUsize}; - use std::sync::{Arc, Mutex}; - use std::{fmt, mem, slice}; - --use miow::iocp::{CompletionPort, CompletionStatus}; --use miow::pipe; --use winapi::shared::winerror::{ERROR_BROKEN_PIPE, ERROR_PIPE_LISTENING}; --use winapi::um::ioapiset::CancelIoEx; --use winapi::um::minwinbase::{OVERLAPPED, OVERLAPPED_ENTRY}; -+use windows_sys::Win32::Foundation::{ -+ ERROR_BROKEN_PIPE, ERROR_IO_INCOMPLETE, ERROR_IO_PENDING, ERROR_NO_DATA, ERROR_PIPE_CONNECTED, -+ ERROR_PIPE_LISTENING, HANDLE, INVALID_HANDLE_VALUE, -+}; -+use windows_sys::Win32::Storage::FileSystem::{ -+ ReadFile, WriteFile, FILE_FLAG_FIRST_PIPE_INSTANCE, FILE_FLAG_OVERLAPPED, PIPE_ACCESS_DUPLEX, -+}; -+use windows_sys::Win32::System::Pipes::{ -+ ConnectNamedPipe, CreateNamedPipeW, DisconnectNamedPipe, PIPE_TYPE_BYTE, -+ PIPE_UNLIMITED_INSTANCES, -+}; -+use windows_sys::Win32::System::IO::{ -+ CancelIoEx, GetOverlappedResult, OVERLAPPED, OVERLAPPED_ENTRY, -+}; - - use crate::event::Source; --use crate::sys::windows::{Event, Overlapped}; --use crate::{poll, Registry}; -+use crate::sys::windows::iocp::{CompletionPort, CompletionStatus}; -+use crate::sys::windows::{Event, Handle, Overlapped}; -+use crate::Registry; - use crate::{Interest, Token}; - - /// Non-blocking windows named pipe. -@@ -75,7 +85,7 @@ struct Inner { - read: Overlapped, - write: Overlapped, - // END NOTE. -- handle: pipe::NamedPipe, -+ handle: Handle, - connecting: AtomicBool, - io: Mutex, - pool: Mutex, -@@ -103,6 +113,193 @@ impl Inner { - // `read` is after `connect: Overlapped` and `read: Overlapped`. - (ptr as *mut Overlapped).wrapping_sub(2) as *const Inner - } -+ -+ /// Issue a connection request with the specified overlapped operation. -+ /// -+ /// This function will issue a request to connect a client to this server, -+ /// returning immediately after starting the overlapped operation. -+ /// -+ /// If this function immediately succeeds then `Ok(true)` is returned. If -+ /// the overlapped operation is enqueued and pending, then `Ok(false)` is -+ /// returned. Otherwise an error is returned indicating what went wrong. -+ /// -+ /// # Unsafety -+ /// -+ /// This function is unsafe because the kernel requires that the -+ /// `overlapped` pointer is valid until the end of the I/O operation. The -+ /// kernel also requires that `overlapped` is unique for this I/O operation -+ /// and is not in use for any other I/O. -+ /// -+ /// To safely use this function callers must ensure that this pointer is -+ /// valid until the I/O operation is completed, typically via completion -+ /// ports and waiting to receive the completion notification on the port. -+ pub unsafe fn connect_overlapped(&self, overlapped: *mut OVERLAPPED) -> io::Result { -+ if ConnectNamedPipe(self.handle.raw(), overlapped) != 0 { -+ return Ok(true); -+ } -+ -+ let err = io::Error::last_os_error(); -+ -+ match err.raw_os_error().map(|e| e as u32) { -+ Some(ERROR_PIPE_CONNECTED) => Ok(true), -+ Some(ERROR_NO_DATA) => Ok(true), -+ Some(ERROR_IO_PENDING) => Ok(false), -+ _ => Err(err), -+ } -+ } -+ -+ /// Disconnects this named pipe from any connected client. -+ pub fn disconnect(&self) -> io::Result<()> { -+ if unsafe { DisconnectNamedPipe(self.handle.raw()) } == 0 { -+ Err(io::Error::last_os_error()) -+ } else { -+ Ok(()) -+ } -+ } -+ -+ /// Issues an overlapped read operation to occur on this pipe. -+ /// -+ /// This function will issue an asynchronous read to occur in an overlapped -+ /// fashion, returning immediately. The `buf` provided will be filled in -+ /// with data and the request is tracked by the `overlapped` function -+ /// provided. -+ /// -+ /// If the operation succeeds immediately, `Ok(Some(n))` is returned where -+ /// `n` is the number of bytes read. If an asynchronous operation is -+ /// enqueued, then `Ok(None)` is returned. Otherwise if an error occurred -+ /// it is returned. -+ /// -+ /// When this operation completes (or if it completes immediately), another -+ /// mechanism must be used to learn how many bytes were transferred (such as -+ /// looking at the filed in the IOCP status message). -+ /// -+ /// # Unsafety -+ /// -+ /// This function is unsafe because the kernel requires that the `buf` and -+ /// `overlapped` pointers to be valid until the end of the I/O operation. -+ /// The kernel also requires that `overlapped` is unique for this I/O -+ /// operation and is not in use for any other I/O. -+ /// -+ /// To safely use this function callers must ensure that the pointers are -+ /// valid until the I/O operation is completed, typically via completion -+ /// ports and waiting to receive the completion notification on the port. -+ pub unsafe fn read_overlapped( -+ &self, -+ buf: &mut [u8], -+ overlapped: *mut OVERLAPPED, -+ ) -> io::Result> { -+ let len = std::cmp::min(buf.len(), u32::MAX as usize) as u32; -+ let res = ReadFile( -+ self.handle.raw(), -+ buf.as_mut_ptr() as *mut _, -+ len, -+ std::ptr::null_mut(), -+ overlapped, -+ ); -+ if res == 0 { -+ let err = io::Error::last_os_error(); -+ if err.raw_os_error() != Some(ERROR_IO_PENDING as i32) { -+ return Err(err); -+ } -+ } -+ -+ let mut bytes = 0; -+ let res = GetOverlappedResult(self.handle.raw(), overlapped, &mut bytes, 0); -+ if res == 0 { -+ let err = io::Error::last_os_error(); -+ if err.raw_os_error() == Some(ERROR_IO_INCOMPLETE as i32) { -+ Ok(None) -+ } else { -+ Err(err) -+ } -+ } else { -+ Ok(Some(bytes as usize)) -+ } -+ } -+ -+ /// Issues an overlapped write operation to occur on this pipe. -+ /// -+ /// This function will issue an asynchronous write to occur in an overlapped -+ /// fashion, returning immediately. The `buf` provided will be filled in -+ /// with data and the request is tracked by the `overlapped` function -+ /// provided. -+ /// -+ /// If the operation succeeds immediately, `Ok(Some(n))` is returned where -+ /// `n` is the number of bytes written. If an asynchronous operation is -+ /// enqueued, then `Ok(None)` is returned. Otherwise if an error occurred -+ /// it is returned. -+ /// -+ /// When this operation completes (or if it completes immediately), another -+ /// mechanism must be used to learn how many bytes were transferred (such as -+ /// looking at the filed in the IOCP status message). -+ /// -+ /// # Unsafety -+ /// -+ /// This function is unsafe because the kernel requires that the `buf` and -+ /// `overlapped` pointers to be valid until the end of the I/O operation. -+ /// The kernel also requires that `overlapped` is unique for this I/O -+ /// operation and is not in use for any other I/O. -+ /// -+ /// To safely use this function callers must ensure that the pointers are -+ /// valid until the I/O operation is completed, typically via completion -+ /// ports and waiting to receive the completion notification on the port. -+ pub unsafe fn write_overlapped( -+ &self, -+ buf: &[u8], -+ overlapped: *mut OVERLAPPED, -+ ) -> io::Result> { -+ let len = std::cmp::min(buf.len(), u32::MAX as usize) as u32; -+ let res = WriteFile( -+ self.handle.raw(), -+ buf.as_ptr() as *const _, -+ len, -+ std::ptr::null_mut(), -+ overlapped, -+ ); -+ if res == 0 { -+ let err = io::Error::last_os_error(); -+ if err.raw_os_error() != Some(ERROR_IO_PENDING as i32) { -+ return Err(err); -+ } -+ } -+ -+ let mut bytes = 0; -+ let res = GetOverlappedResult(self.handle.raw(), overlapped, &mut bytes, 0); -+ if res == 0 { -+ let err = io::Error::last_os_error(); -+ if err.raw_os_error() == Some(ERROR_IO_INCOMPLETE as i32) { -+ Ok(None) -+ } else { -+ Err(err) -+ } -+ } else { -+ Ok(Some(bytes as usize)) -+ } -+ } -+ -+ /// Calls the `GetOverlappedResult` function to get the result of an -+ /// overlapped operation for this handle. -+ /// -+ /// This function takes the `OVERLAPPED` argument which must have been used -+ /// to initiate an overlapped I/O operation, and returns either the -+ /// successful number of bytes transferred during the operation or an error -+ /// if one occurred. -+ /// -+ /// # Unsafety -+ /// -+ /// This function is unsafe as `overlapped` must have previously been used -+ /// to execute an operation for this handle, and it must also be a valid -+ /// pointer to an `Overlapped` instance. -+ #[inline] -+ unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result { -+ let mut transferred = 0; -+ let r = GetOverlappedResult(self.handle.raw(), overlapped, &mut transferred, 0); -+ if r == 0 { -+ Err(io::Error::last_os_error()) -+ } else { -+ Ok(transferred as usize) -+ } -+ } - } - - #[test] -@@ -135,9 +332,7 @@ struct Io { - // Token used to identify events - token: Option, - read: State, -- read_interest: bool, - write: State, -- write_interest: bool, - connect_error: Option, - } - -@@ -160,10 +355,30 @@ impl NamedPipe { - /// Creates a new named pipe at the specified `addr` given a "reasonable - /// set" of initial configuration options. - pub fn new>(addr: A) -> io::Result { -- let pipe = pipe::NamedPipe::new(addr)?; -- // Safety: nothing actually unsafe about this. The trait fn includes -- // `unsafe`. -- Ok(unsafe { NamedPipe::from_raw_handle(pipe.into_raw_handle()) }) -+ use std::os::windows::ffi::OsStrExt; -+ let name: Vec<_> = addr.as_ref().encode_wide().chain(Some(0)).collect(); -+ -+ // Safety: syscall -+ let h = unsafe { -+ CreateNamedPipeW( -+ name.as_ptr(), -+ PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_OVERLAPPED, -+ PIPE_TYPE_BYTE, -+ PIPE_UNLIMITED_INSTANCES, -+ 65536, -+ 65536, -+ 0, -+ std::ptr::null_mut(), -+ ) -+ }; -+ -+ if h == INVALID_HANDLE_VALUE { -+ Err(io::Error::last_os_error()) -+ } else { -+ // Safety: nothing actually unsafe about this. The trait fn includes -+ // `unsafe`. -+ Ok(unsafe { Self::from_raw_handle(h as RawHandle) }) -+ } - } - - /// Attempts to call `ConnectNamedPipe`, if possible. -@@ -198,7 +413,7 @@ impl NamedPipe { - // internal state accordingly. - let res = unsafe { - let overlapped = self.inner.connect.as_ptr() as *mut _; -- self.inner.handle.connect_overlapped(overlapped) -+ self.inner.connect_overlapped(overlapped) - }; - - match res { -@@ -250,7 +465,7 @@ impl NamedPipe { - /// After a `disconnect` is issued, then a `connect` may be called again to - /// connect to another client. - pub fn disconnect(&self) -> io::Result<()> { -- self.inner.handle.disconnect() -+ self.inner.disconnect() - } - } - -@@ -258,10 +473,7 @@ impl FromRawHandle for NamedPipe { - unsafe fn from_raw_handle(handle: RawHandle) -> NamedPipe { - NamedPipe { - inner: Arc::new(Inner { -- // Safety: not really unsafe -- handle: pipe::NamedPipe::from_raw_handle(handle), -- // transmutes to straddle winapi versions (mio 0.6 is on an -- // older winapi) -+ handle: Handle::new(handle as HANDLE), - connect: Overlapped::new(connect_done), - connecting: AtomicBool::new(false), - read: Overlapped::new(read_done), -@@ -270,9 +482,7 @@ impl FromRawHandle for NamedPipe { - cp: None, - token: None, - read: State::None, -- read_interest: false, - write: State::None, -- write_interest: false, - connect_error: None, - }), - pool: Mutex::new(BufferPool::with_capacity(2)), -@@ -387,12 +597,7 @@ impl<'a> Write for &'a NamedPipe { - } - - impl Source for NamedPipe { -- fn register( -- &mut self, -- registry: &Registry, -- token: Token, -- interest: Interest, -- ) -> io::Result<()> { -+ fn register(&mut self, registry: &Registry, token: Token, _: Interest) -> io::Result<()> { - let mut io = self.inner.io.lock().unwrap(); - - io.check_association(registry, false)?; -@@ -405,18 +610,15 @@ impl Source for NamedPipe { - } - - if io.cp.is_none() { -- io.cp = Some(poll::selector(registry).clone_port()); -+ let selector = registry.selector(); -+ -+ io.cp = Some(selector.clone_port()); - - let inner_token = NEXT_TOKEN.fetch_add(2, Relaxed) + 2; -- poll::selector(registry) -- .inner -- .cp -- .add_handle(inner_token, &self.inner.handle)?; -+ selector.inner.cp.add_handle(inner_token, self)?; - } - - io.token = Some(token); -- io.read_interest = interest.is_readable(); -- io.write_interest = interest.is_writable(); - drop(io); - - Inner::post_register(&self.inner, None); -@@ -424,19 +626,12 @@ impl Source for NamedPipe { - Ok(()) - } - -- fn reregister( -- &mut self, -- registry: &Registry, -- token: Token, -- interest: Interest, -- ) -> io::Result<()> { -+ fn reregister(&mut self, registry: &Registry, token: Token, _: Interest) -> io::Result<()> { - let mut io = self.inner.io.lock().unwrap(); - - io.check_association(registry, true)?; - - io.token = Some(token); -- io.read_interest = interest.is_readable(); -- io.write_interest = interest.is_writable(); - drop(io); - - Inner::post_register(&self.inner, None); -@@ -463,7 +658,7 @@ impl Source for NamedPipe { - - impl AsRawHandle for NamedPipe { - fn as_raw_handle(&self) -> RawHandle { -- self.inner.handle.as_raw_handle() -+ self.inner.handle.raw() as RawHandle - } - } - -@@ -483,12 +678,8 @@ impl Drop for NamedPipe { - } - - let io = self.inner.io.lock().unwrap(); -- -- match io.read { -- State::Pending(..) => { -- drop(cancel(&self.inner.handle, &self.inner.read)); -- } -- _ => {} -+ if let State::Pending(..) = io.read { -+ drop(cancel(&self.inner.handle, &self.inner.read)); - } - } - } -@@ -514,7 +705,7 @@ impl Inner { - let e = unsafe { - let overlapped = me.read.as_ptr() as *mut _; - let slice = slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.capacity()); -- me.handle.read_overlapped(slice, overlapped) -+ me.read_overlapped(slice, overlapped) - }; - - match e { -@@ -553,7 +744,7 @@ impl Inner { - // Very similar to `schedule_read` above, just done for the write half. - let e = unsafe { - let overlapped = me.write.as_ptr() as *mut _; -- me.handle.write_overlapped(&buf[pos..], overlapped) -+ me.write_overlapped(&buf[pos..], overlapped) - }; - - // See `connect` above for the rationale behind `forget` -@@ -603,7 +794,8 @@ impl Inner { - - fn post_register(me: &Arc, mut events: Option<&mut Vec>) { - let mut io = me.io.lock().unwrap(); -- if Inner::schedule_read(&me, &mut io, events.as_mut().map(|ptr| &mut **ptr)) { -+ #[allow(clippy::needless_option_as_deref)] -+ if Inner::schedule_read(me, &mut io, events.as_deref_mut()) { - if let State::None = io.write { - io.notify_writable(events); - } -@@ -619,8 +811,8 @@ impl Inner { - } - } - --unsafe fn cancel(handle: &T, overlapped: &Overlapped) -> io::Result<()> { -- let ret = CancelIoEx(handle.as_raw_handle(), overlapped.as_ptr() as *mut _); -+unsafe fn cancel(handle: &Handle, overlapped: &Overlapped) -> io::Result<()> { -+ let ret = CancelIoEx(handle.raw(), overlapped.as_ptr()); - // `CancelIoEx` returns 0 on error: - // https://docs.microsoft.com/en-us/windows/win32/fileio/cancelioex-func - if ret == 0 { -@@ -645,7 +837,7 @@ fn connect_done(status: &OVERLAPPED_ENTRY, events: Option<&mut Vec>) { - // Stash away our connect error if one happened - debug_assert_eq!(status.bytes_transferred(), 0); - unsafe { -- match me.handle.result(status.overlapped()) { -+ match me.result(status.overlapped()) { - Ok(n) => debug_assert_eq!(n, 0), - Err(e) => me.io.lock().unwrap().connect_error = Some(e), - } -@@ -671,7 +863,7 @@ fn read_done(status: &OVERLAPPED_ENTRY, events: Option<&mut Vec>) { - _ => unreachable!(), - }; - unsafe { -- match me.handle.result(status.overlapped()) { -+ match me.result(status.overlapped()) { - Ok(n) => { - debug_assert_eq!(status.bytes_transferred() as usize, n); - buf.set_len(status.bytes_transferred() as usize); -@@ -711,7 +903,7 @@ fn write_done(status: &OVERLAPPED_ENTRY, events: Option<&mut Vec>) { - }; - - unsafe { -- match me.handle.result(status.overlapped()) { -+ match me.result(status.overlapped()) { - Ok(n) => { - debug_assert_eq!(status.bytes_transferred() as usize, n); - let new_pos = pos + (status.bytes_transferred() as usize); -@@ -734,7 +926,7 @@ fn write_done(status: &OVERLAPPED_ENTRY, events: Option<&mut Vec>) { - impl Io { - fn check_association(&self, registry: &Registry, required: bool) -> io::Result<()> { - match self.cp { -- Some(ref cp) if !poll::selector(registry).same_port(cp) => Err(io::Error::new( -+ Some(ref cp) if !registry.selector().same_port(cp) => Err(io::Error::new( - io::ErrorKind::AlreadyExists, - "I/O source already registered with a different `Registry`", - )), -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/net.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/net.rs -index 2de98fa7..5cc23533 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/net.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/net.rs -@@ -3,15 +3,14 @@ use std::mem; - use std::net::SocketAddr; - use std::sync::Once; - --use winapi::ctypes::c_int; --use winapi::shared::inaddr::{in_addr_S_un, IN_ADDR}; --use winapi::shared::in6addr::{in6_addr_u, IN6_ADDR}; --use winapi::shared::ws2def::{AF_INET, AF_INET6, ADDRESS_FAMILY, SOCKADDR, SOCKADDR_IN}; --use winapi::shared::ws2ipdef::{SOCKADDR_IN6_LH, SOCKADDR_IN6_LH_u}; --use winapi::um::winsock2::{ioctlsocket, socket, FIONBIO, INVALID_SOCKET, SOCKET}; -+use windows_sys::Win32::Networking::WinSock::{ -+ closesocket, ioctlsocket, socket, AF_INET, AF_INET6, FIONBIO, IN6_ADDR, IN6_ADDR_0, -+ INVALID_SOCKET, IN_ADDR, IN_ADDR_0, SOCKADDR, SOCKADDR_IN, SOCKADDR_IN6, SOCKADDR_IN6_0, -+ SOCKET, -+}; - - /// Initialise the network stack for Windows. --pub(crate) fn init() { -+fn init() { - static INIT: Once = Once::new(); - INIT.call_once(|| { - // Let standard library call `WSAStartup` for us, we can't do it -@@ -22,26 +21,30 @@ pub(crate) fn init() { - } - - /// Create a new non-blocking socket. --pub(crate) fn new_ip_socket(addr: SocketAddr, socket_type: c_int) -> io::Result { -- use winapi::um::winsock2::{PF_INET, PF_INET6}; -- -+pub(crate) fn new_ip_socket(addr: SocketAddr, socket_type: i32) -> io::Result { - let domain = match addr { -- SocketAddr::V4(..) => PF_INET, -- SocketAddr::V6(..) => PF_INET6, -+ SocketAddr::V4(..) => AF_INET, -+ SocketAddr::V6(..) => AF_INET6, - }; - -- new_socket(domain, socket_type) -+ new_socket(domain.into(), socket_type) - } - --pub(crate) fn new_socket(domain: c_int, socket_type: c_int) -> io::Result { -- syscall!( -- socket(domain, socket_type, 0), -+pub(crate) fn new_socket(domain: u32, socket_type: i32) -> io::Result { -+ init(); -+ -+ let socket = syscall!( -+ socket(domain as i32, socket_type, 0), - PartialEq::eq, - INVALID_SOCKET -- ) -- .and_then(|socket| { -- syscall!(ioctlsocket(socket, FIONBIO, &mut 1), PartialEq::ne, 0).map(|_| socket as SOCKET) -- }) -+ )?; -+ -+ if let Err(err) = syscall!(ioctlsocket(socket, FIONBIO, &mut 1), PartialEq::ne, 0) { -+ let _ = unsafe { closesocket(socket) }; -+ return Err(err); -+ } -+ -+ Ok(socket as SOCKET) - } - - /// A type with the same memory layout as `SOCKADDR`. Used in converting Rust level -@@ -51,7 +54,7 @@ pub(crate) fn new_socket(domain: c_int, socket_type: c_int) -> io::Result (SocketAddrCRepr, c_int) { -+pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, i32) { - match addr { - SocketAddr::V4(ref addr) => { - // `s_addr` is stored as BE on all machine and the array is in BE order. - // So the native endian conversion method is used so that it's never swapped. - let sin_addr = unsafe { -- let mut s_un = mem::zeroed::(); -- *s_un.S_addr_mut() = u32::from_ne_bytes(addr.ip().octets()); -+ let mut s_un = mem::zeroed::(); -+ s_un.S_addr = u32::from_ne_bytes(addr.ip().octets()); - IN_ADDR { S_un: s_un } - }; - - let sockaddr_in = SOCKADDR_IN { -- sin_family: AF_INET as ADDRESS_FAMILY, -+ sin_family: AF_INET as u16, // 1 - sin_port: addr.port().to_be(), - sin_addr, - sin_zero: [0; 8], - }; - - let sockaddr = SocketAddrCRepr { v4: sockaddr_in }; -- (sockaddr, mem::size_of::() as c_int) -- }, -+ (sockaddr, mem::size_of::() as i32) -+ } - SocketAddr::V6(ref addr) => { - let sin6_addr = unsafe { -- let mut u = mem::zeroed::(); -- *u.Byte_mut() = addr.ip().octets(); -+ let mut u = mem::zeroed::(); -+ u.Byte = addr.ip().octets(); - IN6_ADDR { u } - }; - let u = unsafe { -- let mut u = mem::zeroed::(); -- *u.sin6_scope_id_mut() = addr.scope_id(); -+ let mut u = mem::zeroed::(); -+ u.sin6_scope_id = addr.scope_id(); - u - }; - -- let sockaddr_in6 = SOCKADDR_IN6_LH { -- sin6_family: AF_INET6 as ADDRESS_FAMILY, -+ let sockaddr_in6 = SOCKADDR_IN6 { -+ sin6_family: AF_INET6 as u16, // 23 - sin6_port: addr.port().to_be(), - sin6_addr, - sin6_flowinfo: addr.flowinfo(), -- u, -+ Anonymous: u, - }; - - let sockaddr = SocketAddrCRepr { v6: sockaddr_in6 }; -- (sockaddr, mem::size_of::() as c_int) -+ (sockaddr, mem::size_of::() as i32) - } - } - } -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/overlapped.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/overlapped.rs -index 837b78b6..d1456ded 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/overlapped.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/overlapped.rs -@@ -3,13 +3,11 @@ use crate::sys::windows::Event; - use std::cell::UnsafeCell; - use std::fmt; - --#[cfg(feature = "os-ext")] --use winapi::um::minwinbase::OVERLAPPED; --use winapi::um::minwinbase::OVERLAPPED_ENTRY; -+use windows_sys::Win32::System::IO::{OVERLAPPED, OVERLAPPED_ENTRY}; - - #[repr(C)] - pub(crate) struct Overlapped { -- inner: UnsafeCell, -+ inner: UnsafeCell, - pub(crate) callback: fn(&OVERLAPPED_ENTRY, Option<&mut Vec>), - } - -@@ -17,13 +15,13 @@ pub(crate) struct Overlapped { - impl Overlapped { - pub(crate) fn new(cb: fn(&OVERLAPPED_ENTRY, Option<&mut Vec>)) -> Overlapped { - Overlapped { -- inner: UnsafeCell::new(miow::Overlapped::zero()), -+ inner: UnsafeCell::new(unsafe { std::mem::zeroed() }), - callback: cb, - } - } - - pub(crate) fn as_ptr(&self) -> *const OVERLAPPED { -- unsafe { (*self.inner.get()).raw() } -+ self.inner.get() - } - } - -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/selector.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/selector.rs -index 572a9a90..23d7bc5c 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/selector.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/selector.rs -@@ -10,8 +10,9 @@ cfg_net! { - use crate::Interest; - } - --use miow::iocp::{CompletionPort, CompletionStatus}; -+use super::iocp::{CompletionPort, CompletionStatus}; - use std::collections::VecDeque; -+use std::ffi::c_void; - use std::io; - use std::marker::PhantomPinned; - use std::os::windows::io::RawSocket; -@@ -21,14 +22,15 @@ use std::sync::atomic::AtomicUsize; - use std::sync::atomic::{AtomicBool, Ordering}; - use std::sync::{Arc, Mutex}; - use std::time::Duration; --use winapi::shared::ntdef::NT_SUCCESS; --use winapi::shared::ntdef::{HANDLE, PVOID}; --use winapi::shared::ntstatus::STATUS_CANCELLED; --use winapi::shared::winerror::{ERROR_INVALID_HANDLE, ERROR_IO_PENDING, WAIT_TIMEOUT}; --use winapi::um::minwinbase::OVERLAPPED; -+ -+use windows_sys::Win32::Foundation::{ -+ ERROR_INVALID_HANDLE, ERROR_IO_PENDING, HANDLE, STATUS_CANCELLED, WAIT_TIMEOUT, -+}; -+use windows_sys::Win32::System::IO::OVERLAPPED; - - #[derive(Debug)] - struct AfdGroup { -+ #[cfg_attr(not(feature = "net"), allow(dead_code))] - cp: Arc, - afd_group: Mutex>>, - } -@@ -43,7 +45,7 @@ impl AfdGroup { - - pub fn release_unused_afd(&self) { - let mut afd_group = self.afd_group.lock().unwrap(); -- afd_group.retain(|g| Arc::strong_count(&g) > 1); -+ afd_group.retain(|g| Arc::strong_count(g) > 1); - } - } - -@@ -57,7 +59,7 @@ cfg_io_source! { - self._alloc_afd_group(&mut afd_group)?; - } else { - // + 1 reference in Vec -- if Arc::strong_count(afd_group.last().unwrap()) >= POLL_GROUP__MAX_GROUP_SIZE + 1 { -+ if Arc::strong_count(afd_group.last().unwrap()) > POLL_GROUP__MAX_GROUP_SIZE { - self._alloc_afd_group(&mut afd_group)?; - } - } -@@ -93,7 +95,6 @@ pub struct SockState { - poll_info: AfdPollInfo, - afd: Arc, - -- raw_socket: RawSocket, - base_socket: RawSocket, - - user_evts: u32, -@@ -107,7 +108,7 @@ pub struct SockState { - // last raw os error - error: Option, - -- pinned: PhantomPinned, -+ _pinned: PhantomPinned, - } - - impl SockState { -@@ -141,7 +142,7 @@ impl SockState { - /* No poll operation is pending; start one. */ - self.poll_info.exclusive = 0; - self.poll_info.number_of_handles = 1; -- *unsafe { self.poll_info.timeout.QuadPart_mut() } = std::i64::MAX; -+ self.poll_info.timeout = i64::MAX; - self.poll_info.handles[0].handle = self.base_socket as HANDLE; - self.poll_info.handles[0].status = 0; - self.poll_info.handles[0].events = self.user_evts | afd::POLL_LOCAL_CLOSE; -@@ -204,9 +205,9 @@ impl SockState { - unsafe { - if self.delete_pending { - return None; -- } else if self.iosb.u.Status == STATUS_CANCELLED { -+ } else if self.iosb.Anonymous.Status == STATUS_CANCELLED { - /* The poll request was cancelled by CancelIoEx. */ -- } else if !NT_SUCCESS(self.iosb.u.Status) { -+ } else if self.iosb.Anonymous.Status < 0 { - /* The overlapped request itself failed in an unexpected way. */ - afd_events = afd::POLL_CONNECT_FAIL; - } else if self.poll_info.number_of_handles < 1 { -@@ -263,7 +264,6 @@ cfg_io_source! { - iosb: IoStatusBlock::zeroed(), - poll_info: AfdPollInfo::zeroed(), - afd, -- raw_socket, - base_socket: get_base_socket(raw_socket)?, - user_evts: 0, - pending_evts: 0, -@@ -271,7 +271,7 @@ cfg_io_source! { - poll_status: SockPollStatus::Idle, - delete_pending: false, - error: None, -- pinned: PhantomPinned, -+ _pinned: PhantomPinned, - }) - } - -@@ -296,7 +296,7 @@ impl Drop for SockState { - - /// Converts the pointer to a `SockState` into a raw pointer. - /// To revert see `from_overlapped`. --fn into_overlapped(sock_state: Pin>>) -> PVOID { -+fn into_overlapped(sock_state: Pin>>) -> *mut c_void { - let overlapped_ptr: *const Mutex = - unsafe { Arc::into_raw(Pin::into_inner_unchecked(sock_state)) }; - overlapped_ptr as *mut _ -@@ -317,7 +317,7 @@ fn from_overlapped(ptr: *mut OVERLAPPED) -> Pin>> { - #[cfg(debug_assertions)] - static NEXT_ID: AtomicUsize = AtomicUsize::new(0); - --/// Windows implementaion of `sys::Selector` -+/// Windows implementation of `sys::Selector` - /// - /// Edge-triggered event notification is simulated by resetting internal event flag of each socket state `SockState` - /// and setting all events back by intercepting all requests that could cause `io::ErrorKind::WouldBlock` happening. -@@ -328,8 +328,6 @@ pub struct Selector { - #[cfg(debug_assertions)] - id: usize, - pub(super) inner: Arc, -- #[cfg(debug_assertions)] -- has_waker: AtomicBool, - } - - impl Selector { -@@ -341,8 +339,6 @@ impl Selector { - #[cfg(debug_assertions)] - id, - inner: Arc::new(inner), -- #[cfg(debug_assertions)] -- has_waker: AtomicBool::new(false), - } - }) - } -@@ -352,8 +348,6 @@ impl Selector { - #[cfg(debug_assertions)] - id: self.id, - inner: Arc::clone(&self.inner), -- #[cfg(debug_assertions)] -- has_waker: AtomicBool::new(self.has_waker.load(Ordering::Acquire)), - }) - } - -@@ -365,11 +359,6 @@ impl Selector { - self.inner.select(events, timeout) - } - -- #[cfg(debug_assertions)] -- pub fn register_waker(&self) -> bool { -- self.has_waker.swap(true, Ordering::AcqRel) -- } -- - pub(super) fn clone_port(&self) -> Arc { - self.inner.cp.clone() - } -@@ -448,11 +437,11 @@ impl SelectorInner { - if len == 0 { - continue; - } -- return Ok(()); -+ break Ok(()); - } - } else { - self.select2(&mut events.statuses, &mut events.events, timeout)?; -- return Ok(()); -+ Ok(()) - } - } - -@@ -462,7 +451,7 @@ impl SelectorInner { - events: &mut Vec, - timeout: Option, - ) -> io::Result { -- assert_eq!(self.is_polling.swap(true, Ordering::AcqRel), false); -+ assert!(!self.is_polling.swap(true, Ordering::AcqRel)); - - unsafe { self.update_sockets_events() }?; - -@@ -482,7 +471,7 @@ impl SelectorInner { - for sock in update_queue.iter_mut() { - let mut sock_internal = sock.lock().unwrap(); - if !sock_internal.is_pending_deletion() { -- sock_internal.update(&sock)?; -+ sock_internal.update(sock)?; - } - } - -@@ -518,12 +507,9 @@ impl SelectorInner { - - let sock_state = from_overlapped(iocp_event.overlapped()); - let mut sock_guard = sock_state.lock().unwrap(); -- match sock_guard.feed_event() { -- Some(e) => { -- events.push(e); -- n += 1; -- } -- None => {} -+ if let Some(e) = sock_guard.feed_event() { -+ events.push(e); -+ n += 1; - } - - if !sock_guard.is_pending_deletion() { -@@ -538,9 +524,12 @@ impl SelectorInner { - cfg_io_source! { - use std::mem::size_of; - use std::ptr::null_mut; -- use winapi::um::mswsock; -- use winapi::um::winsock2::WSAGetLastError; -- use winapi::um::winsock2::{WSAIoctl, SOCKET_ERROR}; -+ -+ use windows_sys::Win32::Networking::WinSock::{ -+ WSAGetLastError, WSAIoctl, SIO_BASE_HANDLE, SIO_BSP_HANDLE, -+ SIO_BSP_HANDLE_POLL, SIO_BSP_HANDLE_SELECT, SOCKET_ERROR, -+ }; -+ - - impl SelectorInner { - fn register( -@@ -644,7 +633,7 @@ cfg_io_source! { - ioctl, - null_mut(), - 0, -- &mut base_socket as *mut _ as PVOID, -+ &mut base_socket as *mut _ as *mut c_void, - size_of::() as u32, - &mut bytes, - null_mut(), -@@ -659,7 +648,7 @@ cfg_io_source! { - } - - fn get_base_socket(raw_socket: RawSocket) -> io::Result { -- let res = try_get_base_socket(raw_socket, mswsock::SIO_BASE_HANDLE); -+ let res = try_get_base_socket(raw_socket, SIO_BASE_HANDLE); - if let Ok(base_socket) = res { - return Ok(base_socket); - } -@@ -670,9 +659,9 @@ cfg_io_source! { - // However, at least one known LSP deliberately breaks it, so we try - // some alternative IOCTLs, starting with the most appropriate one. - for &ioctl in &[ -- mswsock::SIO_BSP_HANDLE_SELECT, -- mswsock::SIO_BSP_HANDLE_POLL, -- mswsock::SIO_BSP_HANDLE, -+ SIO_BSP_HANDLE_SELECT, -+ SIO_BSP_HANDLE_POLL, -+ SIO_BSP_HANDLE, - ] { - if let Ok(base_socket) = try_get_base_socket(raw_socket, ioctl) { - // Since we know now that we're dealing with an LSP (otherwise -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/tcp.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/tcp.rs -index 6757b447..addd1e8d 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/tcp.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/tcp.rs -@@ -1,321 +1,62 @@ - use std::io; --use std::convert::TryInto; --use std::mem::size_of; --use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6}; --use std::time::Duration; --use std::ptr; --use std::os::windows::io::FromRawSocket; --use std::os::windows::raw::SOCKET as StdSocket; // winapi uses usize, stdlib uses u32/u64. -+use std::net::{self, SocketAddr}; -+use std::os::windows::io::AsRawSocket; - --use winapi::ctypes::{c_char, c_int, c_ushort, c_ulong}; --use winapi::shared::ws2def::{SOCKADDR_STORAGE, AF_INET, AF_INET6, SOCKADDR_IN}; --use winapi::shared::ws2ipdef::SOCKADDR_IN6_LH; --use winapi::shared::mstcpip; -+use windows_sys::Win32::Networking::WinSock::{self, SOCKET, SOCKET_ERROR, SOCK_STREAM}; - --use winapi::shared::minwindef::{BOOL, TRUE, FALSE, DWORD, LPVOID, LPDWORD}; --use winapi::um::winsock2::{ -- self, closesocket, linger, setsockopt, getsockopt, getsockname, PF_INET, PF_INET6, SOCKET, SOCKET_ERROR, -- SOCK_STREAM, SOL_SOCKET, SO_LINGER, SO_REUSEADDR, SO_RCVBUF, SO_SNDBUF, SO_KEEPALIVE, WSAIoctl, LPWSAOVERLAPPED, --}; -+use crate::sys::windows::net::{new_ip_socket, socket_addr}; - --use crate::sys::windows::net::{init, new_socket, socket_addr}; --use crate::net::TcpKeepalive; -- --pub(crate) type TcpSocket = SOCKET; -- --pub(crate) fn new_v4_socket() -> io::Result { -- init(); -- new_socket(PF_INET, SOCK_STREAM) -+pub(crate) fn new_for_addr(address: SocketAddr) -> io::Result { -+ new_ip_socket(address, SOCK_STREAM) - } - --pub(crate) fn new_v6_socket() -> io::Result { -- init(); -- new_socket(PF_INET6, SOCK_STREAM) --} -- --pub(crate) fn bind(socket: TcpSocket, addr: SocketAddr) -> io::Result<()> { -- use winsock2::bind; -+pub(crate) fn bind(socket: &net::TcpListener, addr: SocketAddr) -> io::Result<()> { -+ use WinSock::bind; - - let (raw_addr, raw_addr_length) = socket_addr(&addr); - syscall!( -- bind(socket, raw_addr.as_ptr(), raw_addr_length), -+ bind( -+ socket.as_raw_socket() as _, -+ raw_addr.as_ptr(), -+ raw_addr_length -+ ), - PartialEq::eq, - SOCKET_ERROR - )?; - Ok(()) - } - --pub(crate) fn connect(socket: TcpSocket, addr: SocketAddr) -> io::Result { -- use winsock2::connect; -+pub(crate) fn connect(socket: &net::TcpStream, addr: SocketAddr) -> io::Result<()> { -+ use WinSock::connect; - - let (raw_addr, raw_addr_length) = socket_addr(&addr); -- - let res = syscall!( -- connect(socket, raw_addr.as_ptr(), raw_addr_length), -+ connect( -+ socket.as_raw_socket() as _, -+ raw_addr.as_ptr(), -+ raw_addr_length -+ ), - PartialEq::eq, - SOCKET_ERROR - ); - - match res { -- Err(err) if err.kind() != io::ErrorKind::WouldBlock => { -- Err(err) -- } -- _ => { -- Ok(unsafe { net::TcpStream::from_raw_socket(socket as StdSocket) }) -- } -+ Err(err) if err.kind() != io::ErrorKind::WouldBlock => Err(err), -+ _ => Ok(()), - } - } - --pub(crate) fn listen(socket: TcpSocket, backlog: u32) -> io::Result { -- use winsock2::listen; -+pub(crate) fn listen(socket: &net::TcpListener, backlog: u32) -> io::Result<()> { - use std::convert::TryInto; -+ use WinSock::listen; - - let backlog = backlog.try_into().unwrap_or(i32::max_value()); -- syscall!(listen(socket, backlog), PartialEq::eq, SOCKET_ERROR)?; -- Ok(unsafe { net::TcpListener::from_raw_socket(socket as StdSocket) }) --} -- --pub(crate) fn close(socket: TcpSocket) { -- let _ = unsafe { closesocket(socket) }; --} -- --pub(crate) fn set_reuseaddr(socket: TcpSocket, reuseaddr: bool) -> io::Result<()> { -- let val: BOOL = if reuseaddr { TRUE } else { FALSE }; -- -- match unsafe { setsockopt( -- socket, -- SOL_SOCKET, -- SO_REUSEADDR, -- &val as *const _ as *const c_char, -- size_of::() as c_int, -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(()), -- } --} -- --pub(crate) fn get_reuseaddr(socket: TcpSocket) -> io::Result { -- let mut optval: c_char = 0; -- let mut optlen = size_of::() as c_int; -- -- match unsafe { getsockopt( -- socket, -- SOL_SOCKET, -- SO_REUSEADDR, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(optval != 0), -- } --} -- --pub(crate) fn get_localaddr(socket: TcpSocket) -> io::Result { -- let mut storage: SOCKADDR_STORAGE = unsafe { std::mem::zeroed() }; -- let mut length = std::mem::size_of_val(&storage) as c_int; -- -- match unsafe { getsockname( -- socket, -- &mut storage as *mut _ as *mut _, -- &mut length -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => { -- if storage.ss_family as c_int == AF_INET { -- // Safety: if the ss_family field is AF_INET then storage must be a sockaddr_in. -- let addr: &SOCKADDR_IN = unsafe { &*(&storage as *const _ as *const SOCKADDR_IN) }; -- let ip_bytes = unsafe { addr.sin_addr.S_un.S_un_b() }; -- let ip = Ipv4Addr::from([ip_bytes.s_b1, ip_bytes.s_b2, ip_bytes.s_b3, ip_bytes.s_b4]); -- let port = u16::from_be(addr.sin_port); -- Ok(SocketAddr::V4(SocketAddrV4::new(ip, port))) -- } else if storage.ss_family as c_int == AF_INET6 { -- // Safety: if the ss_family field is AF_INET6 then storage must be a sockaddr_in6. -- let addr: &SOCKADDR_IN6_LH = unsafe { &*(&storage as *const _ as *const SOCKADDR_IN6_LH) }; -- let ip = Ipv6Addr::from(*unsafe { addr.sin6_addr.u.Byte() }); -- let port = u16::from_be(addr.sin6_port); -- let scope_id = unsafe { *addr.u.sin6_scope_id() }; -- Ok(SocketAddr::V6(SocketAddrV6::new(ip, port, addr.sin6_flowinfo, scope_id))) -- } else { -- Err(std::io::ErrorKind::InvalidInput.into()) -- } -- }, -- } --} -- --pub(crate) fn set_linger(socket: TcpSocket, dur: Option) -> io::Result<()> { -- let val: linger = linger { -- l_onoff: if dur.is_some() { 1 } else { 0 }, -- l_linger: dur.map(|dur| dur.as_secs() as c_ushort).unwrap_or_default(), -- }; -- -- match unsafe { setsockopt( -- socket, -- SOL_SOCKET, -- SO_LINGER, -- &val as *const _ as *const c_char, -- size_of::() as c_int, -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(()), -- } --} -- --pub(crate) fn get_linger(socket: TcpSocket) -> io::Result> { -- let mut val: linger = unsafe { std::mem::zeroed() }; -- let mut len = size_of::() as c_int; -- -- match unsafe { getsockopt( -- socket, -- SOL_SOCKET, -- SO_LINGER, -- &mut val as *mut _ as *mut _, -- &mut len, -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => { -- if val.l_onoff == 0 { -- Ok(None) -- } else { -- Ok(Some(Duration::from_secs(val.l_linger as u64))) -- } -- }, -- } --} -- -- --pub(crate) fn set_recv_buffer_size(socket: TcpSocket, size: u32) -> io::Result<()> { -- let size = size.try_into().ok().unwrap_or_else(i32::max_value); -- match unsafe { setsockopt( -- socket, -- SOL_SOCKET, -- SO_RCVBUF, -- &size as *const _ as *const c_char, -- size_of::() as c_int -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(()), -- } --} -- --pub(crate) fn get_recv_buffer_size(socket: TcpSocket) -> io::Result { -- let mut optval: c_int = 0; -- let mut optlen = size_of::() as c_int; -- match unsafe { getsockopt( -- socket, -- SOL_SOCKET, -- SO_RCVBUF, -- &mut optval as *mut _ as *mut _, -- &mut optlen as *mut _, -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(optval as u32), -- } --} -- --pub(crate) fn set_send_buffer_size(socket: TcpSocket, size: u32) -> io::Result<()> { -- let size = size.try_into().ok().unwrap_or_else(i32::max_value); -- match unsafe { setsockopt( -- socket, -- SOL_SOCKET, -- SO_SNDBUF, -- &size as *const _ as *const c_char, -- size_of::() as c_int -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(()), -- } --} -- --pub(crate) fn get_send_buffer_size(socket: TcpSocket) -> io::Result { -- let mut optval: c_int = 0; -- let mut optlen = size_of::() as c_int; -- match unsafe { getsockopt( -- socket, -- SOL_SOCKET, -- SO_SNDBUF, -- &mut optval as *mut _ as *mut _, -- &mut optlen as *mut _, -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(optval as u32), -- } --} -- --pub(crate) fn set_keepalive(socket: TcpSocket, keepalive: bool) -> io::Result<()> { -- let val: BOOL = if keepalive { TRUE } else { FALSE }; -- match unsafe { setsockopt( -- socket, -- SOL_SOCKET, -- SO_KEEPALIVE, -- &val as *const _ as *const c_char, -- size_of::() as c_int -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(()), -- } --} -- --pub(crate) fn get_keepalive(socket: TcpSocket) -> io::Result { -- let mut optval: c_char = 0; -- let mut optlen = size_of::() as c_int; -- -- match unsafe { getsockopt( -- socket, -- SOL_SOCKET, -- SO_KEEPALIVE, -- &mut optval as *mut _ as *mut _, -- &mut optlen, -- ) } { -- SOCKET_ERROR => Err(io::Error::last_os_error()), -- _ => Ok(optval != FALSE as c_char), -- } --} -- --pub(crate) fn set_keepalive_params(socket: TcpSocket, keepalive: TcpKeepalive) -> io::Result<()> { -- /// Windows configures keepalive time/interval in a u32 of milliseconds. -- fn dur_to_ulong_ms(dur: Duration) -> c_ulong { -- dur.as_millis().try_into().ok().unwrap_or_else(u32::max_value) -- } -- -- // If any of the fields on the `tcp_keepalive` struct were not provided by -- // the user, just leaving them zero will clobber any existing value. -- // Unfortunately, we can't access the current value, so we will use the -- // defaults if a value for the time or interval was not not provided. -- let time = keepalive.time.unwrap_or_else(|| { -- // The default value is two hours, as per -- // https://docs.microsoft.com/en-us/windows/win32/winsock/sio-keepalive-vals -- let two_hours = 2 * 60 * 60; -- Duration::from_secs(two_hours) -- }); -- -- let interval = keepalive.interval.unwrap_or_else(|| { -- // The default value is one second, as per -- // https://docs.microsoft.com/en-us/windows/win32/winsock/sio-keepalive-vals -- Duration::from_secs(1) -- }); -- -- let mut keepalive = mstcpip::tcp_keepalive { -- // Enable keepalive -- onoff: 1, -- keepalivetime: dur_to_ulong_ms(time), -- keepaliveinterval: dur_to_ulong_ms(interval), -- }; -- -- let mut out = 0; -- match unsafe { WSAIoctl( -- socket, -- mstcpip::SIO_KEEPALIVE_VALS, -- &mut keepalive as *mut _ as LPVOID, -- size_of::() as DWORD, -- ptr::null_mut() as LPVOID, -- 0 as DWORD, -- &mut out as *mut _ as LPDWORD, -- 0 as LPWSAOVERLAPPED, -- None, -- ) } { -- 0 => Ok(()), -- _ => Err(io::Error::last_os_error()) -- } -+ syscall!( -+ listen(socket.as_raw_socket() as _, backlog), -+ PartialEq::eq, -+ SOCKET_ERROR -+ )?; -+ Ok(()) - } - - pub(crate) fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/udp.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/udp.rs -index 825ecccf..87e269fa 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/udp.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/udp.rs -@@ -2,43 +2,36 @@ use std::io; - use std::mem::{self, MaybeUninit}; - use std::net::{self, SocketAddr}; - use std::os::windows::io::{AsRawSocket, FromRawSocket}; --use std::os::windows::raw::SOCKET as StdSocket; // winapi uses usize, stdlib uses u32/u64. -+use std::os::windows::raw::SOCKET as StdSocket; // windows-sys uses usize, stdlib uses u32/u64. - --use winapi::ctypes::c_int; --use winapi::shared::ws2def::IPPROTO_IPV6; --use winapi::shared::ws2ipdef::IPV6_V6ONLY; --use winapi::um::winsock2::{bind as win_bind, closesocket, getsockopt, SOCKET_ERROR, SOCK_DGRAM}; -- --use crate::sys::windows::net::{init, new_ip_socket, socket_addr}; -+use crate::sys::windows::net::{new_ip_socket, socket_addr}; -+use windows_sys::Win32::Networking::WinSock::{ -+ bind as win_bind, getsockopt, IPPROTO_IPV6, IPV6_V6ONLY, SOCKET_ERROR, SOCK_DGRAM, -+}; - - pub fn bind(addr: SocketAddr) -> io::Result { -- init(); -- new_ip_socket(addr, SOCK_DGRAM).and_then(|socket| { -- let (raw_addr, raw_addr_length) = socket_addr(&addr); -- syscall!( -- win_bind(socket, raw_addr.as_ptr(), raw_addr_length,), -- PartialEq::eq, -- SOCKET_ERROR -- ) -- .map_err(|err| { -- // Close the socket if we hit an error, ignoring the error -- // from closing since we can't pass back two errors. -- let _ = unsafe { closesocket(socket) }; -- err -- }) -- .map(|_| unsafe { net::UdpSocket::from_raw_socket(socket as StdSocket) }) -- }) -+ let raw_socket = new_ip_socket(addr, SOCK_DGRAM)?; -+ let socket = unsafe { net::UdpSocket::from_raw_socket(raw_socket as StdSocket) }; -+ -+ let (raw_addr, raw_addr_length) = socket_addr(&addr); -+ syscall!( -+ win_bind(raw_socket, raw_addr.as_ptr(), raw_addr_length), -+ PartialEq::eq, -+ SOCKET_ERROR -+ )?; -+ -+ Ok(socket) - } - - pub(crate) fn only_v6(socket: &net::UdpSocket) -> io::Result { -- let mut optval: MaybeUninit = MaybeUninit::uninit(); -- let mut optlen = mem::size_of::() as c_int; -+ let mut optval: MaybeUninit = MaybeUninit::uninit(); -+ let mut optlen = mem::size_of::() as i32; - - syscall!( - getsockopt( - socket.as_raw_socket() as usize, -- IPPROTO_IPV6 as c_int, -- IPV6_V6ONLY as c_int, -+ IPPROTO_IPV6 as i32, -+ IPV6_V6ONLY as i32, - optval.as_mut_ptr().cast(), - &mut optlen, - ), -@@ -46,7 +39,7 @@ pub(crate) fn only_v6(socket: &net::UdpSocket) -> io::Result { - SOCKET_ERROR - )?; - -- debug_assert_eq!(optlen as usize, mem::size_of::()); -+ debug_assert_eq!(optlen as usize, mem::size_of::()); - // Safety: `getsockopt` initialised `optval` for us. - let optval = unsafe { optval.assume_init() }; - Ok(optval != 0) -diff --git a/KubeOS-Rust/vendor/mio/src/sys/windows/waker.rs b/KubeOS-Rust/vendor/mio/src/sys/windows/waker.rs -index ab12c3c6..103aa01a 100644 ---- a/KubeOS-Rust/vendor/mio/src/sys/windows/waker.rs -+++ b/KubeOS-Rust/vendor/mio/src/sys/windows/waker.rs -@@ -2,7 +2,7 @@ use crate::sys::windows::Event; - use crate::sys::windows::Selector; - use crate::Token; - --use miow::iocp::CompletionPort; -+use super::iocp::CompletionPort; - use std::io; - use std::sync::Arc; - -diff --git a/KubeOS-Rust/vendor/mio/src/token.rs b/KubeOS-Rust/vendor/mio/src/token.rs -index d8a1fd16..91601cde 100644 ---- a/KubeOS-Rust/vendor/mio/src/token.rs -+++ b/KubeOS-Rust/vendor/mio/src/token.rs -@@ -17,8 +17,8 @@ - /// - /// [`slab`]: https://crates.io/crates/slab - /// --#[cfg_attr(all(feature = "os-poll", features = "net"), doc = "```")] --#[cfg_attr(not(all(feature = "os-poll", features = "net")), doc = "```ignore")] -+#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] -+#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] - /// # use std::error::Error; - /// # fn main() -> Result<(), Box> { - /// use mio::{Events, Interest, Poll, Token}; -diff --git a/KubeOS-Rust/vendor/mio/src/waker.rs b/KubeOS-Rust/vendor/mio/src/waker.rs -index bc73029d..92fdb4c1 100644 ---- a/KubeOS-Rust/vendor/mio/src/waker.rs -+++ b/KubeOS-Rust/vendor/mio/src/waker.rs -@@ -1,4 +1,4 @@ --use crate::{poll, sys, Registry, Token}; -+use crate::{sys, Registry, Token}; - - use std::io; - -@@ -19,7 +19,7 @@ use std::io; - /// Only a single `Waker` can be active per [`Poll`], if multiple threads need - /// access to the `Waker` it can be shared via for example an `Arc`. What - /// happens if multiple `Waker`s are registered with the same `Poll` is --/// undefined. -+/// unspecified. - /// - /// # Implementation notes - /// -@@ -28,7 +28,7 @@ use std::io; - /// kqueue. On Linux it uses [eventfd]. - /// - /// [implementation notes of `Poll`]: struct.Poll.html#implementation-notes --/// [eventfd]: http://man7.org/linux/man-pages/man2/eventfd.2.html -+/// [eventfd]: https://man7.org/linux/man-pages/man2/eventfd.2.html - /// - /// # Examples - /// -@@ -84,7 +84,7 @@ impl Waker { - pub fn new(registry: &Registry, token: Token) -> io::Result { - #[cfg(debug_assertions)] - registry.register_waker(); -- sys::Waker::new(poll::selector(®istry), token).map(|inner| Waker { inner }) -+ sys::Waker::new(registry.selector(), token).map(|inner| Waker { inner }) - } - - /// Wake up the [`Poll`] associated with this `Waker`. -diff --git a/KubeOS-Rust/vendor/miow/.cargo-checksum.json b/KubeOS-Rust/vendor/miow/.cargo-checksum.json -deleted file mode 100644 -index 1b3575ee..00000000 ---- a/KubeOS-Rust/vendor/miow/.cargo-checksum.json -+++ /dev/null -@@ -1 +0,0 @@ --{"files":{"CHANGELOG.md":"588aa2a1146d5f0a0fe15b633a07b047f0dd333c8beb6fd9eb959a7493f3fdbc","Cargo.toml":"4ef0d55cf903edac87248410e260dfb8fef8fe19322e2917053a1fd757448876","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"3ea75d353de268b9dbec44e2e9f56c12cd391579ec4ac5855a4eb68dea216ef2","appveyor.yml":"ffdfb9572a6362866bea6787a726b0d4e43f6bb6516f3a38ebdd561859531602","src/handle.rs":"683af650dcd2975e066891bcd570454e14958f9fb291e0d6ee1d563d2ac1e4ce","src/iocp.rs":"7d11b2269ec05288f0ad693142186f90da60a11dcda264aca3f4ff2f2f78fc57","src/lib.rs":"816e6b1806daa5bf6c354829b974f3ec8bf021fa82e1dd11ef8a4030d6868163","src/net.rs":"a3477bf3f4da11dd062d2f1a482588c9f85d7c9218554516a6a0d64aba66bc03","src/overlapped.rs":"90c65c36dbeb95fb1b402b06e97f957c01be2ebb9d43b612bd735ca6e60d3c14","src/pipe.rs":"ee1aecf7114919cec801465a9ce355b18a5cfddeb9cde3a7ad3153ebe717675d"},"package":"b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"} -\ No newline at end of file -diff --git a/KubeOS-Rust/vendor/miow/CHANGELOG.md b/KubeOS-Rust/vendor/miow/CHANGELOG.md -deleted file mode 100644 -index e16937d5..00000000 ---- a/KubeOS-Rust/vendor/miow/CHANGELOG.md -+++ /dev/null -@@ -1,5 +0,0 @@ -- --## [v0.3.7] - 2021-03-22 --### Changed --- Upgrade `rand` dev-dependency from 0.4 -> 0.8 --- Upgrade `socket2` dependency from 0.3 to 0.4 and make it a dev-dependency -diff --git a/KubeOS-Rust/vendor/miow/Cargo.toml b/KubeOS-Rust/vendor/miow/Cargo.toml -deleted file mode 100644 -index c32cc3cc..00000000 ---- a/KubeOS-Rust/vendor/miow/Cargo.toml -+++ /dev/null -@@ -1,35 +0,0 @@ --# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO --# --# When uploading crates to the registry Cargo will automatically --# "normalize" Cargo.toml files for maximal compatibility --# with all versions of Cargo and also rewrite `path` dependencies --# to registry (e.g., crates.io) dependencies --# --# If you believe there's an error in this file please file an --# issue against the rust-lang/cargo repository. If you're --# editing this file be aware that the upstream Cargo.toml --# will likely look very different (and much more reasonable) -- --[package] --edition = "2018" --name = "miow" --version = "0.3.7" --authors = ["Alex Crichton "] --description = "A zero overhead I/O library for Windows, focusing on IOCP and Async I/O\nabstractions.\n" --homepage = "https://github.com/yoshuawuyts/miow" --documentation = "https://docs.rs/miow/0.3/x86_64-pc-windows-msvc/miow/" --readme = "README.md" --keywords = ["iocp", "windows", "io", "overlapped"] --license = "MIT/Apache-2.0" --repository = "https://github.com/yoshuawuyts/miow" --[package.metadata.docs.rs] --default-target = "x86_64-pc-windows-msvc" --targets = ["aarch64-pc-windows-msvc", "i686-pc-windows-msvc", "x86_64-pc-windows-msvc"] --[dependencies.winapi] --version = "0.3.3" --features = ["std", "fileapi", "handleapi", "ioapiset", "minwindef", "namedpipeapi", "ntdef", "synchapi", "winerror", "winsock2", "ws2def", "ws2ipdef"] --[dev-dependencies.rand] --version = "0.8.0" -- --[dev-dependencies.socket2] --version = "0.4.0" -diff --git a/KubeOS-Rust/vendor/miow/LICENSE-APACHE b/KubeOS-Rust/vendor/miow/LICENSE-APACHE -deleted file mode 100644 -index 16fe87b0..00000000 ---- a/KubeOS-Rust/vendor/miow/LICENSE-APACHE -+++ /dev/null -@@ -1,201 +0,0 @@ -- Apache License -- Version 2.0, January 2004 -- http://www.apache.org/licenses/ -- --TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION -- --1. Definitions. -- -- "License" shall mean the terms and conditions for use, reproduction, -- and distribution as defined by Sections 1 through 9 of this document. -- -- "Licensor" shall mean the copyright owner or entity authorized by -- the copyright owner that is granting the License. -- -- "Legal Entity" shall mean the union of the acting entity and all -- other entities that control, are controlled by, or are under common -- control with that entity. For the purposes of this definition, -- "control" means (i) the power, direct or indirect, to cause the -- direction or management of such entity, whether by contract or -- otherwise, or (ii) ownership of fifty percent (50%) or more of the -- outstanding shares, or (iii) beneficial ownership of such entity. -- -- "You" (or "Your") shall mean an individual or Legal Entity -- exercising permissions granted by this License. -- -- "Source" form shall mean the preferred form for making modifications, -- including but not limited to software source code, documentation -- source, and configuration files. -- -- "Object" form shall mean any form resulting from mechanical -- transformation or translation of a Source form, including but -- not limited to compiled object code, generated documentation, -- and conversions to other media types. -- -- "Work" shall mean the work of authorship, whether in Source or -- Object form, made available under the License, as indicated by a -- copyright notice that is included in or attached to the work -- (an example is provided in the Appendix below). -- -- "Derivative Works" shall mean any work, whether in Source or Object -- form, that is based on (or derived from) the Work and for which the -- editorial revisions, annotations, elaborations, or other modifications -- represent, as a whole, an original work of authorship. For the purposes -- of this License, Derivative Works shall not include works that remain -- separable from, or merely link (or bind by name) to the interfaces of, -- the Work and Derivative Works thereof. -- -- "Contribution" shall mean any work of authorship, including -- the original version of the Work and any modifications or additions -- to that Work or Derivative Works thereof, that is intentionally -- submitted to Licensor for inclusion in the Work by the copyright owner -- or by an individual or Legal Entity authorized to submit on behalf of -- the copyright owner. For the purposes of this definition, "submitted" -- means any form of electronic, verbal, or written communication sent -- to the Licensor or its representatives, including but not limited to -- communication on electronic mailing lists, source code control systems, -- and issue tracking systems that are managed by, or on behalf of, the -- Licensor for the purpose of discussing and improving the Work, but -- excluding communication that is conspicuously marked or otherwise -- designated in writing by the copyright owner as "Not a Contribution." -- -- "Contributor" shall mean Licensor and any individual or Legal Entity -- on behalf of whom a Contribution has been received by Licensor and -- subsequently incorporated within the Work. -- --2. Grant of Copyright License. Subject to the terms and conditions of -- this License, each Contributor hereby grants to You a perpetual, -- worldwide, non-exclusive, no-charge, royalty-free, irrevocable -- copyright license to reproduce, prepare Derivative Works of, -- publicly display, publicly perform, sublicense, and distribute the -- Work and such Derivative Works in Source or Object form. -- --3. Grant of Patent License. Subject to the terms and conditions of -- this License, each Contributor hereby grants to You a perpetual, -- worldwide, non-exclusive, no-charge, royalty-free, irrevocable -- (except as stated in this section) patent license to make, have made, -- use, offer to sell, sell, import, and otherwise transfer the Work, -- where such license applies only to those patent claims licensable -- by such Contributor that are necessarily infringed by their -- Contribution(s) alone or by combination of their Contribution(s) -- with the Work to which such Contribution(s) was submitted. If You -- institute patent litigation against any entity (including a -- cross-claim or counterclaim in a lawsuit) alleging that the Work -- or a Contribution incorporated within the Work constitutes direct -- or contributory patent infringement, then any patent licenses -- granted to You under this License for that Work shall terminate -- as of the date such litigation is filed. -- --4. Redistribution. You may reproduce and distribute copies of the -- Work or Derivative Works thereof in any medium, with or without -- modifications, and in Source or Object form, provided that You -- meet the following conditions: -- -- (a) You must give any other recipients of the Work or -- Derivative Works a copy of this License; and -- -- (b) You must cause any modified files to carry prominent notices -- stating that You changed the files; and -- -- (c) You must retain, in the Source form of any Derivative Works -- that You distribute, all copyright, patent, trademark, and -- attribution notices from the Source form of the Work, -- excluding those notices that do not pertain to any part of -- the Derivative Works; and -- -- (d) If the Work includes a "NOTICE" text file as part of its -- distribution, then any Derivative Works that You distribute must -- include a readable copy of the attribution notices contained -- within such NOTICE file, excluding those notices that do not -- pertain to any part of the Derivative Works, in at least one -- of the following places: within a NOTICE text file distributed -- as part of the Derivative Works; within the Source form or -- documentation, if provided along with the Derivative Works; or, -- within a display generated by the Derivative Works, if and -- wherever such third-party notices normally appear. The contents -- of the NOTICE file are for informational purposes only and -- do not modify the License. You may add Your own attribution -- notices within Derivative Works that You distribute, alongside -- or as an addendum to the NOTICE text from the Work, provided -- that such additional attribution notices cannot be construed -- as modifying the License. -- -- You may add Your own copyright statement to Your modifications and -- may provide additional or different license terms and conditions -- for use, reproduction, or distribution of Your modifications, or -- for any such Derivative Works as a whole, provided Your use, -- reproduction, and distribution of the Work otherwise complies with -- the conditions stated in this License. -- --5. Submission of Contributions. Unless You explicitly state otherwise, -- any Contribution intentionally submitted for inclusion in the Work -- by You to the Licensor shall be under the terms and conditions of -- this License, without any additional terms or conditions. -- Notwithstanding the above, nothing herein shall supersede or modify -- the terms of any separate license agreement you may have executed -- with Licensor regarding such Contributions. -- --6. Trademarks. This License does not grant permission to use the trade -- names, trademarks, service marks, or product names of the Licensor, -- except as required for reasonable and customary use in describing the -- origin of the Work and reproducing the content of the NOTICE file. -- --7. Disclaimer of Warranty. Unless required by applicable law or -- agreed to in writing, Licensor provides the Work (and each -- Contributor provides its Contributions) on an "AS IS" BASIS, -- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -- implied, including, without limitation, any warranties or conditions -- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A -- PARTICULAR PURPOSE. You are solely responsible for determining the -- appropriateness of using or redistributing the Work and assume any -- risks associated with Your exercise of permissions under this License. -- --8. Limitation of Liability. In no event and under no legal theory, -- whether in tort (including negligence), contract, or otherwise, -- unless required by applicable law (such as deliberate and grossly -- negligent acts) or agreed to in writing, shall any Contributor be -- liable to You for damages, including any direct, indirect, special, -- incidental, or consequential damages of any character arising as a -- result of this License or out of the use or inability to use the -- Work (including but not limited to damages for loss of goodwill, -- work stoppage, computer failure or malfunction, or any and all -- other commercial damages or losses), even if such Contributor -- has been advised of the possibility of such damages. -- --9. Accepting Warranty or Additional Liability. While redistributing -- the Work or Derivative Works thereof, You may choose to offer, -- and charge a fee for, acceptance of support, warranty, indemnity, -- or other liability obligations and/or rights consistent with this -- License. However, in accepting such obligations, You may act only -- on Your own behalf and on Your sole responsibility, not on behalf -- of any other Contributor, and only if You agree to indemnify, -- defend, and hold each Contributor harmless for any liability -- incurred by, or claims asserted against, such Contributor by reason -- of your accepting any such warranty or additional liability. -- --END OF TERMS AND CONDITIONS -- --APPENDIX: How to apply the Apache License to your work. -- -- To apply the Apache License to your work, attach the following -- boilerplate notice, with the fields enclosed by brackets "[]" -- replaced with your own identifying information. (Don't include -- the brackets!) The text should be enclosed in the appropriate -- comment syntax for the file format. We also recommend that a -- file or class name and description of purpose be included on the -- same "printed page" as the copyright notice for easier -- identification within third-party archives. -- --Copyright [yyyy] [name of copyright owner] -- --Licensed under the Apache License, Version 2.0 (the "License"); --you may not use this file except in compliance with the License. --You may obtain a copy of the License at -- -- http://www.apache.org/licenses/LICENSE-2.0 -- --Unless required by applicable law or agreed to in writing, software --distributed under the License is distributed on an "AS IS" BASIS, --WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. --See the License for the specific language governing permissions and --limitations under the License. -diff --git a/KubeOS-Rust/vendor/miow/LICENSE-MIT b/KubeOS-Rust/vendor/miow/LICENSE-MIT -deleted file mode 100644 -index 39e0ed66..00000000 ---- a/KubeOS-Rust/vendor/miow/LICENSE-MIT -+++ /dev/null -@@ -1,25 +0,0 @@ --Copyright (c) 2014 Alex Crichton -- --Permission is hereby granted, free of charge, to any --person obtaining a copy of this software and associated --documentation files (the "Software"), to deal in the --Software without restriction, including without --limitation the rights to use, copy, modify, merge, --publish, distribute, sublicense, and/or sell copies of --the Software, and to permit persons to whom the Software --is furnished to do so, subject to the following --conditions: -- --The above copyright notice and this permission notice --shall be included in all copies or substantial portions --of the Software. -- --THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF --ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED --TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A --PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT --SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY --CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION --OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR --IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER --DEALINGS IN THE SOFTWARE. -diff --git a/KubeOS-Rust/vendor/miow/README.md b/KubeOS-Rust/vendor/miow/README.md -deleted file mode 100644 -index e6cdddb2..00000000 ---- a/KubeOS-Rust/vendor/miow/README.md -+++ /dev/null -@@ -1,31 +0,0 @@ --# miow -- --[![Build status](https://ci.appveyor.com/api/projects/status/tc5lsxokjk86949l?svg=true)](https://ci.appveyor.com/project/alexcrichton/miow) -- --[Documentation](https://docs.rs/miow/0.3/x86_64-pc-windows-msvc/miow/) -- --A zero overhead Windows I/O library focusing on IOCP and other async I/O --features. -- --```toml --# Cargo.toml --[dependencies] --miow = "0.3.6" --``` -- --# License -- --This project is licensed under either of -- -- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or -- http://www.apache.org/licenses/LICENSE-2.0) -- * MIT license ([LICENSE-MIT](LICENSE-MIT) or -- http://opensource.org/licenses/MIT) -- --at your option. -- --### Contribution -- --Unless you explicitly state otherwise, any contribution intentionally submitted --for inclusion in miow by you, as defined in the Apache-2.0 license, shall be --dual licensed as above, without any additional terms or conditions. -diff --git a/KubeOS-Rust/vendor/miow/appveyor.yml b/KubeOS-Rust/vendor/miow/appveyor.yml -deleted file mode 100644 -index 2700e425..00000000 ---- a/KubeOS-Rust/vendor/miow/appveyor.yml -+++ /dev/null -@@ -1,20 +0,0 @@ --environment: -- matrix: -- - TARGET: x86_64-pc-windows-msvc -- - TARGET: i686-pc-windows-msvc -- - TARGET: i686-pc-windows-gnu -- GH_TOKEN: -- secure: nHB4fVo+y/Aak+L0nYfrT8Rcs8OfUNm0F2xcIVFVYJ9ehf0CzvCmSMUvWguM0kKp -- --install: -- - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe" -- - rust-nightly-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust" -- - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin -- - SET PATH=%PATH%;C:\MinGW\bin -- - rustc -V -- - cargo -V -- --build: false -- --test_script: -- - cargo test --target %TARGET% -diff --git a/KubeOS-Rust/vendor/miow/src/handle.rs b/KubeOS-Rust/vendor/miow/src/handle.rs -deleted file mode 100644 -index a749fb32..00000000 ---- a/KubeOS-Rust/vendor/miow/src/handle.rs -+++ /dev/null -@@ -1,177 +0,0 @@ --use std::cmp; --use std::io; --use std::ptr; -- --use winapi::shared::minwindef::*; --use winapi::shared::ntdef::{BOOLEAN, FALSE, HANDLE, TRUE}; --use winapi::shared::winerror::*; --use winapi::um::fileapi::*; --use winapi::um::handleapi::*; --use winapi::um::ioapiset::*; --use winapi::um::minwinbase::*; -- --#[derive(Debug)] --pub struct Handle(HANDLE); -- --unsafe impl Send for Handle {} --unsafe impl Sync for Handle {} -- --impl Handle { -- pub fn new(handle: HANDLE) -> Handle { -- Handle(handle) -- } -- -- pub fn raw(&self) -> HANDLE { -- self.0 -- } -- -- pub fn into_raw(self) -> HANDLE { -- use std::mem; -- -- let ret = self.0; -- mem::forget(self); -- ret -- } -- -- pub fn write(&self, buf: &[u8]) -> io::Result { -- let mut bytes = 0; -- let len = cmp::min(buf.len(), ::max_value() as usize) as DWORD; -- crate::cvt(unsafe { -- WriteFile( -- self.0, -- buf.as_ptr() as *const _, -- len, -- &mut bytes, -- 0 as *mut _, -- ) -- })?; -- Ok(bytes as usize) -- } -- -- pub fn read(&self, buf: &mut [u8]) -> io::Result { -- let mut bytes = 0; -- let len = cmp::min(buf.len(), ::max_value() as usize) as DWORD; -- crate::cvt(unsafe { -- ReadFile( -- self.0, -- buf.as_mut_ptr() as *mut _, -- len, -- &mut bytes, -- 0 as *mut _, -- ) -- })?; -- Ok(bytes as usize) -- } -- -- pub unsafe fn read_overlapped( -- &self, -- buf: &mut [u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- self.read_overlapped_helper(buf, overlapped, FALSE) -- } -- -- pub unsafe fn read_overlapped_wait( -- &self, -- buf: &mut [u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result { -- match self.read_overlapped_helper(buf, overlapped, TRUE) { -- Ok(Some(bytes)) => Ok(bytes), -- Ok(None) => panic!("logic error"), -- Err(e) => Err(e), -- } -- } -- -- pub unsafe fn read_overlapped_helper( -- &self, -- buf: &mut [u8], -- overlapped: *mut OVERLAPPED, -- wait: BOOLEAN, -- ) -> io::Result> { -- let len = cmp::min(buf.len(), ::max_value() as usize) as DWORD; -- let res = crate::cvt({ -- ReadFile( -- self.0, -- buf.as_mut_ptr() as *mut _, -- len, -- ptr::null_mut(), -- overlapped, -- ) -- }); -- match res { -- Ok(_) => (), -- Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32) => (), -- Err(e) => return Err(e), -- } -- -- let mut bytes = 0; -- let res = crate::cvt({ GetOverlappedResult(self.0, overlapped, &mut bytes, wait as BOOL) }); -- match res { -- Ok(_) => Ok(Some(bytes as usize)), -- Err(ref e) if e.raw_os_error() == Some(ERROR_IO_INCOMPLETE as i32) && wait == FALSE => { -- Ok(None) -- } -- Err(e) => Err(e), -- } -- } -- -- pub unsafe fn write_overlapped( -- &self, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- self.write_overlapped_helper(buf, overlapped, FALSE) -- } -- -- pub unsafe fn write_overlapped_wait( -- &self, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result { -- match self.write_overlapped_helper(buf, overlapped, TRUE) { -- Ok(Some(bytes)) => Ok(bytes), -- Ok(None) => panic!("logic error"), -- Err(e) => Err(e), -- } -- } -- -- unsafe fn write_overlapped_helper( -- &self, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- wait: BOOLEAN, -- ) -> io::Result> { -- let len = cmp::min(buf.len(), ::max_value() as usize) as DWORD; -- let res = crate::cvt({ -- WriteFile( -- self.0, -- buf.as_ptr() as *const _, -- len, -- ptr::null_mut(), -- overlapped, -- ) -- }); -- match res { -- Ok(_) => (), -- Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32) => (), -- Err(e) => return Err(e), -- } -- -- let mut bytes = 0; -- let res = crate::cvt({ GetOverlappedResult(self.0, overlapped, &mut bytes, wait as BOOL) }); -- match res { -- Ok(_) => Ok(Some(bytes as usize)), -- Err(ref e) if e.raw_os_error() == Some(ERROR_IO_INCOMPLETE as i32) && wait == FALSE => { -- Ok(None) -- } -- Err(e) => Err(e), -- } -- } --} -- --impl Drop for Handle { -- fn drop(&mut self) { -- unsafe { CloseHandle(self.0) }; -- } --} -diff --git a/KubeOS-Rust/vendor/miow/src/lib.rs b/KubeOS-Rust/vendor/miow/src/lib.rs -deleted file mode 100644 -index 53c01aee..00000000 ---- a/KubeOS-Rust/vendor/miow/src/lib.rs -+++ /dev/null -@@ -1,52 +0,0 @@ --//! A zero overhead Windows I/O library -- --#![cfg(windows)] --#![deny(missing_docs)] --#![allow(bad_style)] --#![doc(html_root_url = "https://docs.rs/miow/0.3/x86_64-pc-windows-msvc/")] -- --use std::cmp; --use std::io; --use std::time::Duration; -- --use winapi::shared::minwindef::*; --use winapi::um::winbase::*; -- --#[cfg(test)] --macro_rules! t { -- ($e:expr) => { -- match $e { -- Ok(e) => e, -- Err(e) => panic!("{} failed with {:?}", stringify!($e), e), -- } -- }; --} -- --mod handle; --mod overlapped; -- --pub mod iocp; --pub mod net; --pub mod pipe; -- --pub use crate::overlapped::Overlapped; -- --fn cvt(i: BOOL) -> io::Result { -- if i == 0 { -- Err(io::Error::last_os_error()) -- } else { -- Ok(i) -- } --} -- --fn dur2ms(dur: Option) -> u32 { -- let dur = match dur { -- Some(dur) => dur, -- None => return INFINITE, -- }; -- let ms = dur.as_secs().checked_mul(1_000); -- let ms_extra = dur.subsec_nanos() / 1_000_000; -- ms.and_then(|ms| ms.checked_add(ms_extra as u64)) -- .map(|ms| cmp::min(u32::max_value() as u64, ms) as u32) -- .unwrap_or(INFINITE - 1) --} -diff --git a/KubeOS-Rust/vendor/miow/src/net.rs b/KubeOS-Rust/vendor/miow/src/net.rs -deleted file mode 100644 -index e30bc2d2..00000000 ---- a/KubeOS-Rust/vendor/miow/src/net.rs -+++ /dev/null -@@ -1,1332 +0,0 @@ --//! Extensions and types for the standard networking primitives. --//! --//! This module contains a number of extension traits for the types in --//! `std::net` for Windows-specific functionality. -- --use std::cmp; --use std::io; --use std::mem; --use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6}; --use std::net::{SocketAddr, TcpListener, TcpStream, UdpSocket}; --use std::os::windows::prelude::*; --use std::sync::atomic::{AtomicUsize, Ordering}; -- --use winapi::ctypes::*; --use winapi::shared::guiddef::*; --use winapi::shared::in6addr::{in6_addr_u, IN6_ADDR}; --use winapi::shared::inaddr::{in_addr_S_un, IN_ADDR}; --use winapi::shared::minwindef::*; --use winapi::shared::minwindef::{FALSE, TRUE}; --use winapi::shared::ntdef::*; --use winapi::shared::ws2def::SOL_SOCKET; --use winapi::shared::ws2def::*; --use winapi::shared::ws2ipdef::*; --use winapi::um::minwinbase::*; --use winapi::um::winsock2::*; -- --/// A type to represent a buffer in which a socket address will be stored. --/// --/// This type is used with the `recv_from_overlapped` function on the --/// `UdpSocketExt` trait to provide space for the overlapped I/O operation to --/// fill in the address upon completion. --#[derive(Clone, Copy)] --pub struct SocketAddrBuf { -- buf: SOCKADDR_STORAGE, -- len: c_int, --} -- --/// A type to represent a buffer in which an accepted socket's address will be --/// stored. --/// --/// This type is used with the `accept_overlapped` method on the --/// `TcpListenerExt` trait to provide space for the overlapped I/O operation to --/// fill in the socket addresses upon completion. --#[repr(C)] --pub struct AcceptAddrsBuf { -- // For AcceptEx we've got the restriction that the addresses passed in that -- // buffer need to be at least 16 bytes more than the maximum address length -- // for the protocol in question, so add some extra here and there -- local: SOCKADDR_STORAGE, -- _pad1: [u8; 16], -- remote: SOCKADDR_STORAGE, -- _pad2: [u8; 16], --} -- --/// The parsed return value of `AcceptAddrsBuf`. --pub struct AcceptAddrs<'a> { -- local: LPSOCKADDR, -- local_len: c_int, -- remote: LPSOCKADDR, -- remote_len: c_int, -- _data: &'a AcceptAddrsBuf, --} -- --struct WsaExtension { -- guid: GUID, -- val: AtomicUsize, --} -- --/// Additional methods for the `TcpStream` type in the standard library. --pub trait TcpStreamExt { -- /// Execute an overlapped read I/O operation on this TCP stream. -- /// -- /// This function will issue an overlapped I/O read (via `WSARecv`) on this -- /// socket. The provided buffer will be filled in when the operation -- /// completes and the given `OVERLAPPED` instance is used to track the -- /// overlapped operation. -- /// -- /// If the operation succeeds, `Ok(Some(n))` is returned indicating how -- /// many bytes were read. If the operation returns an error indicating that -- /// the I/O is currently pending, `Ok(None)` is returned. Otherwise, the -- /// error associated with the operation is returned and no overlapped -- /// operation is enqueued. -- /// -- /// The number of bytes read will be returned as part of the completion -- /// notification when the I/O finishes. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the `buf` and -- /// `overlapped` pointers are valid until the end of the I/O operation. The -- /// kernel also requires that `overlapped` is unique for this I/O operation -- /// and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that these two input -- /// pointers are valid until the I/O operation is completed, typically via -- /// completion ports and waiting to receive the completion notification on -- /// the port. -- unsafe fn read_overlapped( -- &self, -- buf: &mut [u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result>; -- -- /// Execute an overlapped write I/O operation on this TCP stream. -- /// -- /// This function will issue an overlapped I/O write (via `WSASend`) on this -- /// socket. The provided buffer will be written when the operation completes -- /// and the given `OVERLAPPED` instance is used to track the overlapped -- /// operation. -- /// -- /// If the operation succeeds, `Ok(Some(n))` is returned where `n` is the -- /// number of bytes that were written. If the operation returns an error -- /// indicating that the I/O is currently pending, `Ok(None)` is returned. -- /// Otherwise, the error associated with the operation is returned and no -- /// overlapped operation is enqueued. -- /// -- /// The number of bytes written will be returned as part of the completion -- /// notification when the I/O finishes. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the `buf` and -- /// `overlapped` pointers are valid until the end of the I/O operation. The -- /// kernel also requires that `overlapped` is unique for this I/O operation -- /// and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that these two input -- /// pointers are valid until the I/O operation is completed, typically via -- /// completion ports and waiting to receive the completion notification on -- /// the port. -- unsafe fn write_overlapped( -- &self, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result>; -- -- /// Attempt to consume the internal socket in this builder by executing an -- /// overlapped connect operation. -- /// -- /// This function will issue a connect operation to the address specified on -- /// the underlying socket, flagging it as an overlapped operation which will -- /// complete asynchronously. If successful this function will return the -- /// corresponding TCP stream. -- /// -- /// The `buf` argument provided is an initial buffer of data that should be -- /// sent after the connection is initiated. It's acceptable to -- /// pass an empty slice here. -- /// -- /// This function will also return whether the connect immediately -- /// succeeded or not. If `None` is returned then the I/O operation is still -- /// pending and will complete at a later date, and if `Some(bytes)` is -- /// returned then that many bytes were transferred. -- /// -- /// Note that to succeed this requires that the underlying socket has -- /// previously been bound via a call to `bind` to a local address. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the -- /// `overlapped` and `buf` pointers to be valid until the end of the I/O -- /// operation. The kernel also requires that `overlapped` is unique for -- /// this I/O operation and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that this pointer is -- /// valid until the I/O operation is completed, typically via completion -- /// ports and waiting to receive the completion notification on the port. -- unsafe fn connect_overlapped( -- &self, -- addr: &SocketAddr, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result>; -- -- /// Once a `connect_overlapped` has finished, this function needs to be -- /// called to finish the connect operation. -- /// -- /// Currently this just calls `setsockopt` with `SO_UPDATE_CONNECT_CONTEXT` -- /// to ensure that further functions like `getpeername` and `getsockname` -- /// work correctly. -- fn connect_complete(&self) -> io::Result<()>; -- -- /// Calls the `GetOverlappedResult` function to get the result of an -- /// overlapped operation for this handle. -- /// -- /// This function takes the `OVERLAPPED` argument which must have been used -- /// to initiate an overlapped I/O operation, and returns either the -- /// successful number of bytes transferred during the operation or an error -- /// if one occurred, along with the results of the `lpFlags` parameter of -- /// the relevant operation, if applicable. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe as `overlapped` must have previously been used -- /// to execute an operation for this handle, and it must also be a valid -- /// pointer to an `OVERLAPPED` instance. -- /// -- /// # Panics -- /// -- /// This function will panic -- unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)>; --} -- --/// Additional methods for the `UdpSocket` type in the standard library. --pub trait UdpSocketExt { -- /// Execute an overlapped receive I/O operation on this UDP socket. -- /// -- /// This function will issue an overlapped I/O read (via `WSARecvFrom`) on -- /// this socket. The provided buffer will be filled in when the operation -- /// completes, the source from where the data came from will be written to -- /// `addr`, and the given `OVERLAPPED` instance is used to track the -- /// overlapped operation. -- /// -- /// If the operation succeeds, `Ok(Some(n))` is returned where `n` is the -- /// number of bytes that were read. If the operation returns an error -- /// indicating that the I/O is currently pending, `Ok(None)` is returned. -- /// Otherwise, the error associated with the operation is returned and no -- /// overlapped operation is enqueued. -- /// -- /// The number of bytes read will be returned as part of the completion -- /// notification when the I/O finishes. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the `buf`, -- /// `addr`, and `overlapped` pointers are valid until the end of the I/O -- /// operation. The kernel also requires that `overlapped` is unique for this -- /// I/O operation and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that these two input -- /// pointers are valid until the I/O operation is completed, typically via -- /// completion ports and waiting to receive the completion notification on -- /// the port. -- unsafe fn recv_from_overlapped( -- &self, -- buf: &mut [u8], -- addr: *mut SocketAddrBuf, -- overlapped: *mut OVERLAPPED, -- ) -> io::Result>; -- -- /// Execute an overlapped receive I/O operation on this UDP socket. -- /// -- /// This function will issue an overlapped I/O read (via `WSARecv`) on -- /// this socket. The provided buffer will be filled in when the operation -- /// completes, the source from where the data came from will be written to -- /// `addr`, and the given `OVERLAPPED` instance is used to track the -- /// overlapped operation. -- /// -- /// If the operation succeeds, `Ok(Some(n))` is returned where `n` is the -- /// number of bytes that were read. If the operation returns an error -- /// indicating that the I/O is currently pending, `Ok(None)` is returned. -- /// Otherwise, the error associated with the operation is returned and no -- /// overlapped operation is enqueued. -- /// -- /// The number of bytes read will be returned as part of the completion -- /// notification when the I/O finishes. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the `buf`, -- /// and `overlapped` pointers are valid until the end of the I/O -- /// operation. The kernel also requires that `overlapped` is unique for this -- /// I/O operation and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that these two input -- /// pointers are valid until the I/O operation is completed, typically via -- /// completion ports and waiting to receive the completion notification on -- /// the port. -- unsafe fn recv_overlapped( -- &self, -- buf: &mut [u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result>; -- -- /// Execute an overlapped send I/O operation on this UDP socket. -- /// -- /// This function will issue an overlapped I/O write (via `WSASendTo`) on -- /// this socket to the address specified by `addr`. The provided buffer will -- /// be written when the operation completes and the given `OVERLAPPED` -- /// instance is used to track the overlapped operation. -- /// -- /// If the operation succeeds, `Ok(Some(n0)` is returned where `n` byte -- /// were written. If the operation returns an error indicating that the I/O -- /// is currently pending, `Ok(None)` is returned. Otherwise, the error -- /// associated with the operation is returned and no overlapped operation -- /// is enqueued. -- /// -- /// The number of bytes written will be returned as part of the completion -- /// notification when the I/O finishes. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the `buf` and -- /// `overlapped` pointers are valid until the end of the I/O operation. The -- /// kernel also requires that `overlapped` is unique for this I/O operation -- /// and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that these two input -- /// pointers are valid until the I/O operation is completed, typically via -- /// completion ports and waiting to receive the completion notification on -- /// the port. -- unsafe fn send_to_overlapped( -- &self, -- buf: &[u8], -- addr: &SocketAddr, -- overlapped: *mut OVERLAPPED, -- ) -> io::Result>; -- -- /// Execute an overlapped send I/O operation on this UDP socket. -- /// -- /// This function will issue an overlapped I/O write (via `WSASend`) on -- /// this socket to the address it was previously connected to. The provided -- /// buffer will be written when the operation completes and the given `OVERLAPPED` -- /// instance is used to track the overlapped operation. -- /// -- /// If the operation succeeds, `Ok(Some(n0)` is returned where `n` byte -- /// were written. If the operation returns an error indicating that the I/O -- /// is currently pending, `Ok(None)` is returned. Otherwise, the error -- /// associated with the operation is returned and no overlapped operation -- /// is enqueued. -- /// -- /// The number of bytes written will be returned as part of the completion -- /// notification when the I/O finishes. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the `buf` and -- /// `overlapped` pointers are valid until the end of the I/O operation. The -- /// kernel also requires that `overlapped` is unique for this I/O operation -- /// and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that these two input -- /// pointers are valid until the I/O operation is completed, typically via -- /// completion ports and waiting to receive the completion notification on -- /// the port. -- unsafe fn send_overlapped( -- &self, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result>; -- -- /// Calls the `GetOverlappedResult` function to get the result of an -- /// overlapped operation for this handle. -- /// -- /// This function takes the `OVERLAPPED` argument which must have been used -- /// to initiate an overlapped I/O operation, and returns either the -- /// successful number of bytes transferred during the operation or an error -- /// if one occurred, along with the results of the `lpFlags` parameter of -- /// the relevant operation, if applicable. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe as `overlapped` must have previously been used -- /// to execute an operation for this handle, and it must also be a valid -- /// pointer to an `OVERLAPPED` instance. -- /// -- /// # Panics -- /// -- /// This function will panic -- unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)>; --} -- --/// Additional methods for the `TcpListener` type in the standard library. --pub trait TcpListenerExt { -- /// Perform an accept operation on this listener, accepting a connection in -- /// an overlapped fashion. -- /// -- /// This function will issue an I/O request to accept an incoming connection -- /// with the specified overlapped instance. The `socket` provided must be a -- /// configured but not bound or connected socket, and if successful this -- /// will consume the internal socket of the builder to return a TCP stream. -- /// -- /// The `addrs` buffer provided will be filled in with the local and remote -- /// addresses of the connection upon completion. -- /// -- /// If the accept succeeds immediately, `Ok(true)` is returned. If -- /// the connect indicates that the I/O is currently pending, `Ok(false)` is -- /// returned. Otherwise, the error associated with the operation is -- /// returned and no overlapped operation is enqueued. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the -- /// `addrs` and `overlapped` pointers are valid until the end of the I/O -- /// operation. The kernel also requires that `overlapped` is unique for this -- /// I/O operation and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that the pointers are -- /// valid until the I/O operation is completed, typically via completion -- /// ports and waiting to receive the completion notification on the port. -- unsafe fn accept_overlapped( -- &self, -- socket: &TcpStream, -- addrs: &mut AcceptAddrsBuf, -- overlapped: *mut OVERLAPPED, -- ) -> io::Result; -- -- /// Once an `accept_overlapped` has finished, this function needs to be -- /// called to finish the accept operation. -- /// -- /// Currently this just calls `setsockopt` with `SO_UPDATE_ACCEPT_CONTEXT` -- /// to ensure that further functions like `getpeername` and `getsockname` -- /// work correctly. -- fn accept_complete(&self, socket: &TcpStream) -> io::Result<()>; -- -- /// Calls the `GetOverlappedResult` function to get the result of an -- /// overlapped operation for this handle. -- /// -- /// This function takes the `OVERLAPPED` argument which must have been used -- /// to initiate an overlapped I/O operation, and returns either the -- /// successful number of bytes transferred during the operation or an error -- /// if one occurred, along with the results of the `lpFlags` parameter of -- /// the relevant operation, if applicable. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe as `overlapped` must have previously been used -- /// to execute an operation for this handle, and it must also be a valid -- /// pointer to an `OVERLAPPED` instance. -- /// -- /// # Panics -- /// -- /// This function will panic -- unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)>; --} -- --#[doc(hidden)] --trait NetInt { -- fn from_be(i: Self) -> Self; -- fn to_be(&self) -> Self; --} --macro_rules! doit { -- ($($t:ident)*) => ($(impl NetInt for $t { -- fn from_be(i: Self) -> Self { <$t>::from_be(i) } -- fn to_be(&self) -> Self { <$t>::to_be(*self) } -- })*) --} --doit! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize } -- --// fn hton(i: I) -> I { i.to_be() } --fn ntoh(i: I) -> I { -- I::from_be(i) --} -- --fn last_err() -> io::Result> { -- let err = unsafe { WSAGetLastError() }; -- if err == WSA_IO_PENDING as i32 { -- Ok(None) -- } else { -- Err(io::Error::from_raw_os_error(err)) -- } --} -- --fn cvt(i: c_int, size: DWORD) -> io::Result> { -- if i == SOCKET_ERROR { -- last_err() -- } else { -- Ok(Some(size as usize)) -- } --} -- --/// A type with the same memory layout as `SOCKADDR`. Used in converting Rust level --/// SocketAddr* types into their system representation. The benefit of this specific --/// type over using `SOCKADDR_STORAGE` is that this type is exactly as large as it --/// needs to be and not a lot larger. And it can be initialized cleaner from Rust. --#[repr(C)] --pub(crate) union SocketAddrCRepr { -- v4: SOCKADDR_IN, -- v6: SOCKADDR_IN6_LH, --} -- --impl SocketAddrCRepr { -- pub(crate) fn as_ptr(&self) -> *const SOCKADDR { -- self as *const _ as *const SOCKADDR -- } --} -- --fn socket_addr_to_ptrs(addr: &SocketAddr) -> (SocketAddrCRepr, c_int) { -- match *addr { -- SocketAddr::V4(ref a) => { -- let sin_addr = unsafe { -- let mut s_un = mem::zeroed::(); -- *s_un.S_addr_mut() = u32::from_ne_bytes(a.ip().octets()); -- IN_ADDR { S_un: s_un } -- }; -- -- let sockaddr_in = SOCKADDR_IN { -- sin_family: AF_INET as ADDRESS_FAMILY, -- sin_port: a.port().to_be(), -- sin_addr, -- sin_zero: [0; 8], -- }; -- -- let sockaddr = SocketAddrCRepr { v4: sockaddr_in }; -- (sockaddr, mem::size_of::() as c_int) -- } -- SocketAddr::V6(ref a) => { -- let sin6_addr = unsafe { -- let mut u = mem::zeroed::(); -- *u.Byte_mut() = a.ip().octets(); -- IN6_ADDR { u } -- }; -- let u = unsafe { -- let mut u = mem::zeroed::(); -- *u.sin6_scope_id_mut() = a.scope_id(); -- u -- }; -- -- let sockaddr_in6 = SOCKADDR_IN6_LH { -- sin6_family: AF_INET6 as ADDRESS_FAMILY, -- sin6_port: a.port().to_be(), -- sin6_addr, -- sin6_flowinfo: a.flowinfo(), -- u, -- }; -- -- let sockaddr = SocketAddrCRepr { v6: sockaddr_in6 }; -- (sockaddr, mem::size_of::() as c_int) -- } -- } --} -- --unsafe fn ptrs_to_socket_addr(ptr: *const SOCKADDR, len: c_int) -> Option { -- if (len as usize) < mem::size_of::() { -- return None; -- } -- match (*ptr).sa_family as i32 { -- AF_INET if len as usize >= mem::size_of::() => { -- let b = &*(ptr as *const SOCKADDR_IN); -- let ip = ntoh(*b.sin_addr.S_un.S_addr()); -- let ip = Ipv4Addr::new( -- (ip >> 24) as u8, -- (ip >> 16) as u8, -- (ip >> 8) as u8, -- (ip >> 0) as u8, -- ); -- Some(SocketAddr::V4(SocketAddrV4::new(ip, ntoh(b.sin_port)))) -- } -- AF_INET6 if len as usize >= mem::size_of::() => { -- let b = &*(ptr as *const SOCKADDR_IN6_LH); -- let arr = b.sin6_addr.u.Byte(); -- let ip = Ipv6Addr::new( -- ((arr[0] as u16) << 8) | (arr[1] as u16), -- ((arr[2] as u16) << 8) | (arr[3] as u16), -- ((arr[4] as u16) << 8) | (arr[5] as u16), -- ((arr[6] as u16) << 8) | (arr[7] as u16), -- ((arr[8] as u16) << 8) | (arr[9] as u16), -- ((arr[10] as u16) << 8) | (arr[11] as u16), -- ((arr[12] as u16) << 8) | (arr[13] as u16), -- ((arr[14] as u16) << 8) | (arr[15] as u16), -- ); -- let addr = SocketAddrV6::new( -- ip, -- ntoh(b.sin6_port), -- ntoh(b.sin6_flowinfo), -- ntoh(*b.u.sin6_scope_id()), -- ); -- Some(SocketAddr::V6(addr)) -- } -- _ => None, -- } --} -- --unsafe fn slice2buf(slice: &[u8]) -> WSABUF { -- WSABUF { -- len: cmp::min(slice.len(), ::max_value() as usize) as u_long, -- buf: slice.as_ptr() as *mut _, -- } --} -- --unsafe fn result(socket: SOCKET, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)> { -- let mut transferred = 0; -- let mut flags = 0; -- let r = WSAGetOverlappedResult(socket, overlapped, &mut transferred, FALSE, &mut flags); -- if r == 0 { -- Err(io::Error::last_os_error()) -- } else { -- Ok((transferred as usize, flags)) -- } --} -- --impl TcpStreamExt for TcpStream { -- unsafe fn read_overlapped( -- &self, -- buf: &mut [u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- let mut buf = slice2buf(buf); -- let mut flags = 0; -- let mut bytes_read: DWORD = 0; -- let r = WSARecv( -- self.as_raw_socket() as SOCKET, -- &mut buf, -- 1, -- &mut bytes_read, -- &mut flags, -- overlapped, -- None, -- ); -- cvt(r, bytes_read) -- } -- -- unsafe fn write_overlapped( -- &self, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- let mut buf = slice2buf(buf); -- let mut bytes_written = 0; -- -- // Note here that we capture the number of bytes written. The -- // documentation on MSDN, however, states: -- // -- // > Use NULL for this parameter if the lpOverlapped parameter is not -- // > NULL to avoid potentially erroneous results. This parameter can be -- // > NULL only if the lpOverlapped parameter is not NULL. -- // -- // If we're not passing a null overlapped pointer here, then why are we -- // then capturing the number of bytes! Well so it turns out that this is -- // clearly faster to learn the bytes here rather than later calling -- // `WSAGetOverlappedResult`, and in practice almost all implementations -- // use this anyway [1]. -- // -- // As a result we use this to and report back the result. -- // -- // [1]: https://github.com/carllerche/mio/pull/520#issuecomment-273983823 -- let r = WSASend( -- self.as_raw_socket() as SOCKET, -- &mut buf, -- 1, -- &mut bytes_written, -- 0, -- overlapped, -- None, -- ); -- cvt(r, bytes_written) -- } -- -- unsafe fn connect_overlapped( -- &self, -- addr: &SocketAddr, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- connect_overlapped(self.as_raw_socket() as SOCKET, addr, buf, overlapped) -- } -- -- fn connect_complete(&self) -> io::Result<()> { -- const SO_UPDATE_CONNECT_CONTEXT: c_int = 0x7010; -- let result = unsafe { -- setsockopt( -- self.as_raw_socket() as SOCKET, -- SOL_SOCKET, -- SO_UPDATE_CONNECT_CONTEXT, -- 0 as *const _, -- 0, -- ) -- }; -- if result == 0 { -- Ok(()) -- } else { -- Err(io::Error::last_os_error()) -- } -- } -- -- unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)> { -- result(self.as_raw_socket() as SOCKET, overlapped) -- } --} -- --unsafe fn connect_overlapped( -- socket: SOCKET, -- addr: &SocketAddr, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, --) -> io::Result> { -- static CONNECTEX: WsaExtension = WsaExtension { -- guid: GUID { -- Data1: 0x25a207b9, -- Data2: 0xddf3, -- Data3: 0x4660, -- Data4: [0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e], -- }, -- val: AtomicUsize::new(0), -- }; -- type ConnectEx = unsafe extern "system" fn( -- SOCKET, -- *const SOCKADDR, -- c_int, -- PVOID, -- DWORD, -- LPDWORD, -- LPOVERLAPPED, -- ) -> BOOL; -- -- let ptr = CONNECTEX.get(socket)?; -- assert!(ptr != 0); -- let connect_ex = mem::transmute::<_, ConnectEx>(ptr); -- -- let (addr_buf, addr_len) = socket_addr_to_ptrs(addr); -- let mut bytes_sent: DWORD = 0; -- let r = connect_ex( -- socket, -- addr_buf.as_ptr(), -- addr_len, -- buf.as_ptr() as *mut _, -- buf.len() as u32, -- &mut bytes_sent, -- overlapped, -- ); -- if r == TRUE { -- Ok(Some(bytes_sent as usize)) -- } else { -- last_err() -- } --} -- --impl UdpSocketExt for UdpSocket { -- unsafe fn recv_from_overlapped( -- &self, -- buf: &mut [u8], -- addr: *mut SocketAddrBuf, -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- let mut buf = slice2buf(buf); -- let mut flags = 0; -- let mut received_bytes: DWORD = 0; -- let r = WSARecvFrom( -- self.as_raw_socket() as SOCKET, -- &mut buf, -- 1, -- &mut received_bytes, -- &mut flags, -- &mut (*addr).buf as *mut _ as *mut _, -- &mut (*addr).len, -- overlapped, -- None, -- ); -- cvt(r, received_bytes) -- } -- -- unsafe fn recv_overlapped( -- &self, -- buf: &mut [u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- let mut buf = slice2buf(buf); -- let mut flags = 0; -- let mut received_bytes: DWORD = 0; -- let r = WSARecv( -- self.as_raw_socket() as SOCKET, -- &mut buf, -- 1, -- &mut received_bytes, -- &mut flags, -- overlapped, -- None, -- ); -- cvt(r, received_bytes) -- } -- -- unsafe fn send_to_overlapped( -- &self, -- buf: &[u8], -- addr: &SocketAddr, -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- let (addr_buf, addr_len) = socket_addr_to_ptrs(addr); -- let mut buf = slice2buf(buf); -- let mut sent_bytes = 0; -- let r = WSASendTo( -- self.as_raw_socket() as SOCKET, -- &mut buf, -- 1, -- &mut sent_bytes, -- 0, -- addr_buf.as_ptr() as *const _, -- addr_len, -- overlapped, -- None, -- ); -- cvt(r, sent_bytes) -- } -- -- unsafe fn send_overlapped( -- &self, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- let mut buf = slice2buf(buf); -- let mut sent_bytes = 0; -- let r = WSASend( -- self.as_raw_socket() as SOCKET, -- &mut buf, -- 1, -- &mut sent_bytes, -- 0, -- overlapped, -- None, -- ); -- cvt(r, sent_bytes) -- } -- -- unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)> { -- result(self.as_raw_socket() as SOCKET, overlapped) -- } --} -- --impl TcpListenerExt for TcpListener { -- unsafe fn accept_overlapped( -- &self, -- socket: &TcpStream, -- addrs: &mut AcceptAddrsBuf, -- overlapped: *mut OVERLAPPED, -- ) -> io::Result { -- static ACCEPTEX: WsaExtension = WsaExtension { -- guid: GUID { -- Data1: 0xb5367df1, -- Data2: 0xcbac, -- Data3: 0x11cf, -- Data4: [0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92], -- }, -- val: AtomicUsize::new(0), -- }; -- type AcceptEx = unsafe extern "system" fn( -- SOCKET, -- SOCKET, -- PVOID, -- DWORD, -- DWORD, -- DWORD, -- LPDWORD, -- LPOVERLAPPED, -- ) -> BOOL; -- -- let ptr = ACCEPTEX.get(self.as_raw_socket() as SOCKET)?; -- assert!(ptr != 0); -- let accept_ex = mem::transmute::<_, AcceptEx>(ptr); -- -- let mut bytes = 0; -- let (a, b, c, d) = (*addrs).args(); -- let r = accept_ex( -- self.as_raw_socket() as SOCKET, -- socket.as_raw_socket() as SOCKET, -- a, -- b, -- c, -- d, -- &mut bytes, -- overlapped, -- ); -- let succeeded = if r == TRUE { -- true -- } else { -- last_err()?; -- false -- }; -- Ok(succeeded) -- } -- -- fn accept_complete(&self, socket: &TcpStream) -> io::Result<()> { -- const SO_UPDATE_ACCEPT_CONTEXT: c_int = 0x700B; -- let me = self.as_raw_socket(); -- let result = unsafe { -- setsockopt( -- socket.as_raw_socket() as SOCKET, -- SOL_SOCKET, -- SO_UPDATE_ACCEPT_CONTEXT, -- &me as *const _ as *const _, -- mem::size_of_val(&me) as c_int, -- ) -- }; -- if result == 0 { -- Ok(()) -- } else { -- Err(io::Error::last_os_error()) -- } -- } -- -- unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)> { -- result(self.as_raw_socket() as SOCKET, overlapped) -- } --} -- --impl SocketAddrBuf { -- /// Creates a new blank socket address buffer. -- /// -- /// This should be used before a call to `recv_from_overlapped` overlapped -- /// to create an instance to pass down. -- pub fn new() -> SocketAddrBuf { -- SocketAddrBuf { -- buf: unsafe { mem::zeroed() }, -- len: mem::size_of::() as c_int, -- } -- } -- -- /// Parses this buffer to return a standard socket address. -- /// -- /// This function should be called after the buffer has been filled in with -- /// a call to `recv_from_overlapped` being completed. It will interpret the -- /// address filled in and return the standard socket address type. -- /// -- /// If an error is encountered then `None` is returned. -- pub fn to_socket_addr(&self) -> Option { -- unsafe { ptrs_to_socket_addr(&self.buf as *const _ as *const _, self.len) } -- } --} -- --static GETACCEPTEXSOCKADDRS: WsaExtension = WsaExtension { -- guid: GUID { -- Data1: 0xb5367df2, -- Data2: 0xcbac, -- Data3: 0x11cf, -- Data4: [0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92], -- }, -- val: AtomicUsize::new(0), --}; --type GetAcceptExSockaddrs = unsafe extern "system" fn( -- PVOID, -- DWORD, -- DWORD, -- DWORD, -- *mut LPSOCKADDR, -- LPINT, -- *mut LPSOCKADDR, -- LPINT, --); -- --impl AcceptAddrsBuf { -- /// Creates a new blank buffer ready to be passed to a call to -- /// `accept_overlapped`. -- pub fn new() -> AcceptAddrsBuf { -- unsafe { mem::zeroed() } -- } -- -- /// Parses the data contained in this address buffer, returning the parsed -- /// result if successful. -- /// -- /// This function can be called after a call to `accept_overlapped` has -- /// succeeded to parse out the data that was written in. -- pub fn parse(&self, socket: &TcpListener) -> io::Result { -- let mut ret = AcceptAddrs { -- local: 0 as *mut _, -- local_len: 0, -- remote: 0 as *mut _, -- remote_len: 0, -- _data: self, -- }; -- let ptr = GETACCEPTEXSOCKADDRS.get(socket.as_raw_socket() as SOCKET)?; -- assert!(ptr != 0); -- unsafe { -- let get_sockaddrs = mem::transmute::<_, GetAcceptExSockaddrs>(ptr); -- let (a, b, c, d) = self.args(); -- get_sockaddrs( -- a, -- b, -- c, -- d, -- &mut ret.local, -- &mut ret.local_len, -- &mut ret.remote, -- &mut ret.remote_len, -- ); -- Ok(ret) -- } -- } -- -- fn args(&self) -> (PVOID, DWORD, DWORD, DWORD) { -- let remote_offset = unsafe { &(*(0 as *const AcceptAddrsBuf)).remote as *const _ as usize }; -- ( -- self as *const _ as *mut _, -- 0, -- remote_offset as DWORD, -- (mem::size_of_val(self) - remote_offset) as DWORD, -- ) -- } --} -- --impl<'a> AcceptAddrs<'a> { -- /// Returns the local socket address contained in this buffer. -- pub fn local(&self) -> Option { -- unsafe { ptrs_to_socket_addr(self.local, self.local_len) } -- } -- -- /// Returns the remote socket address contained in this buffer. -- pub fn remote(&self) -> Option { -- unsafe { ptrs_to_socket_addr(self.remote, self.remote_len) } -- } --} -- --impl WsaExtension { -- fn get(&self, socket: SOCKET) -> io::Result { -- let prev = self.val.load(Ordering::SeqCst); -- if prev != 0 && !cfg!(debug_assertions) { -- return Ok(prev); -- } -- let mut ret = 0 as usize; -- let mut bytes = 0; -- let r = unsafe { -- WSAIoctl( -- socket, -- SIO_GET_EXTENSION_FUNCTION_POINTER, -- &self.guid as *const _ as *mut _, -- mem::size_of_val(&self.guid) as DWORD, -- &mut ret as *mut _ as *mut _, -- mem::size_of_val(&ret) as DWORD, -- &mut bytes, -- 0 as *mut _, -- None, -- ) -- }; -- cvt(r, 0).map(|_| { -- debug_assert_eq!(bytes as usize, mem::size_of_val(&ret)); -- debug_assert!(prev == 0 || prev == ret); -- self.val.store(ret, Ordering::SeqCst); -- ret -- }) -- } --} -- --#[cfg(test)] --mod tests { -- use std::io::prelude::*; -- use std::net::{ -- IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV6, TcpListener, TcpStream, UdpSocket, -- }; -- use std::slice; -- use std::thread; -- -- use socket2::{Domain, Socket, Type}; -- -- use crate::iocp::CompletionPort; -- use crate::net::{AcceptAddrsBuf, TcpListenerExt}; -- use crate::net::{SocketAddrBuf, TcpStreamExt, UdpSocketExt}; -- use crate::Overlapped; -- -- fn each_ip(f: &mut dyn FnMut(SocketAddr)) { -- f(t!("127.0.0.1:0".parse())); -- f(t!("[::1]:0".parse())); -- } -- -- #[test] -- fn tcp_read() { -- each_ip(&mut |addr| { -- let l = t!(TcpListener::bind(addr)); -- let addr = t!(l.local_addr()); -- let t = thread::spawn(move || { -- let mut a = t!(l.accept()).0; -- t!(a.write_all(&[1, 2, 3])); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- let s = t!(TcpStream::connect(addr)); -- t!(cp.add_socket(1, &s)); -- -- let mut b = [0; 10]; -- let a = Overlapped::zero(); -- unsafe { -- t!(s.read_overlapped(&mut b, a.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 3); -- assert_eq!(status.token(), 1); -- assert_eq!(status.overlapped(), a.raw()); -- assert_eq!(&b[0..3], &[1, 2, 3]); -- -- t!(t.join()); -- }) -- } -- -- #[test] -- fn tcp_write() { -- each_ip(&mut |addr| { -- let l = t!(TcpListener::bind(addr)); -- let addr = t!(l.local_addr()); -- let t = thread::spawn(move || { -- let mut a = t!(l.accept()).0; -- let mut b = [0; 10]; -- let n = t!(a.read(&mut b)); -- assert_eq!(n, 3); -- assert_eq!(&b[0..3], &[1, 2, 3]); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- let s = t!(TcpStream::connect(addr)); -- t!(cp.add_socket(1, &s)); -- -- let b = [1, 2, 3]; -- let a = Overlapped::zero(); -- unsafe { -- t!(s.write_overlapped(&b, a.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 3); -- assert_eq!(status.token(), 1); -- assert_eq!(status.overlapped(), a.raw()); -- -- t!(t.join()); -- }) -- } -- -- #[test] -- fn tcp_connect() { -- each_ip(&mut |addr_template| { -- let l = t!(TcpListener::bind(addr_template)); -- let addr = t!(l.local_addr()); -- let t = thread::spawn(move || { -- t!(l.accept()); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- let domain = Domain::for_address(addr); -- let socket = t!(Socket::new(domain, Type::STREAM, None)); -- t!(socket.bind(&addr_template.into())); -- let socket = TcpStream::from(socket); -- t!(cp.add_socket(1, &socket)); -- -- let a = Overlapped::zero(); -- unsafe { -- t!(socket.connect_overlapped(&addr, &[], a.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 0); -- assert_eq!(status.token(), 1); -- assert_eq!(status.overlapped(), a.raw()); -- t!(socket.connect_complete()); -- -- t!(t.join()); -- }) -- } -- -- #[test] -- fn udp_recv_from() { -- each_ip(&mut |addr| { -- let a = t!(UdpSocket::bind(addr)); -- let b = t!(UdpSocket::bind(addr)); -- let a_addr = t!(a.local_addr()); -- let b_addr = t!(b.local_addr()); -- let t = thread::spawn(move || { -- t!(a.send_to(&[1, 2, 3], b_addr)); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- t!(cp.add_socket(1, &b)); -- -- let mut buf = [0; 10]; -- let a = Overlapped::zero(); -- let mut addr = SocketAddrBuf::new(); -- unsafe { -- t!(b.recv_from_overlapped(&mut buf, &mut addr, a.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 3); -- assert_eq!(status.token(), 1); -- assert_eq!(status.overlapped(), a.raw()); -- assert_eq!(&buf[..3], &[1, 2, 3]); -- assert_eq!(addr.to_socket_addr(), Some(a_addr)); -- -- t!(t.join()); -- }) -- } -- -- #[test] -- fn udp_recv() { -- each_ip(&mut |addr| { -- let a = t!(UdpSocket::bind(addr)); -- let b = t!(UdpSocket::bind(addr)); -- let a_addr = t!(a.local_addr()); -- let b_addr = t!(b.local_addr()); -- assert!(b.connect(a_addr).is_ok()); -- assert!(a.connect(b_addr).is_ok()); -- let t = thread::spawn(move || { -- t!(a.send_to(&[1, 2, 3], b_addr)); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- t!(cp.add_socket(1, &b)); -- -- let mut buf = [0; 10]; -- let a = Overlapped::zero(); -- unsafe { -- t!(b.recv_overlapped(&mut buf, a.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 3); -- assert_eq!(status.token(), 1); -- assert_eq!(status.overlapped(), a.raw()); -- assert_eq!(&buf[..3], &[1, 2, 3]); -- -- t!(t.join()); -- }) -- } -- -- #[test] -- fn udp_send_to() { -- each_ip(&mut |addr| { -- let a = t!(UdpSocket::bind(addr)); -- let b = t!(UdpSocket::bind(addr)); -- let a_addr = t!(a.local_addr()); -- let b_addr = t!(b.local_addr()); -- let t = thread::spawn(move || { -- let mut b = [0; 100]; -- let (n, addr) = t!(a.recv_from(&mut b)); -- assert_eq!(n, 3); -- assert_eq!(addr, b_addr); -- assert_eq!(&b[..3], &[1, 2, 3]); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- t!(cp.add_socket(1, &b)); -- -- let a = Overlapped::zero(); -- unsafe { -- t!(b.send_to_overlapped(&[1, 2, 3], &a_addr, a.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 3); -- assert_eq!(status.token(), 1); -- assert_eq!(status.overlapped(), a.raw()); -- -- t!(t.join()); -- }) -- } -- -- #[test] -- fn udp_send() { -- each_ip(&mut |addr| { -- let a = t!(UdpSocket::bind(addr)); -- let b = t!(UdpSocket::bind(addr)); -- let a_addr = t!(a.local_addr()); -- let b_addr = t!(b.local_addr()); -- assert!(b.connect(a_addr).is_ok()); -- assert!(a.connect(b_addr).is_ok()); -- let t = thread::spawn(move || { -- let mut b = [0; 100]; -- let (n, addr) = t!(a.recv_from(&mut b)); -- assert_eq!(n, 3); -- assert_eq!(addr, b_addr); -- assert_eq!(&b[..3], &[1, 2, 3]); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- t!(cp.add_socket(1, &b)); -- -- let a = Overlapped::zero(); -- unsafe { -- t!(b.send_overlapped(&[1, 2, 3], a.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 3); -- assert_eq!(status.token(), 1); -- assert_eq!(status.overlapped(), a.raw()); -- -- t!(t.join()); -- }) -- } -- -- #[test] -- fn tcp_accept() { -- each_ip(&mut |addr_template| { -- let l = t!(TcpListener::bind(addr_template)); -- let addr = t!(l.local_addr()); -- let t = thread::spawn(move || { -- let socket = t!(TcpStream::connect(addr)); -- (socket.local_addr().unwrap(), socket.peer_addr().unwrap()) -- }); -- -- let cp = t!(CompletionPort::new(1)); -- let domain = Domain::for_address(addr); -- let socket = TcpStream::from(t!(Socket::new(domain, Type::STREAM, None))); -- t!(cp.add_socket(1, &l)); -- -- let a = Overlapped::zero(); -- let mut addrs = AcceptAddrsBuf::new(); -- unsafe { -- t!(l.accept_overlapped(&socket, &mut addrs, a.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 0); -- assert_eq!(status.token(), 1); -- assert_eq!(status.overlapped(), a.raw()); -- t!(l.accept_complete(&socket)); -- -- let (remote, local) = t!(t.join()); -- let addrs = addrs.parse(&l).unwrap(); -- assert_eq!(addrs.local(), Some(local)); -- assert_eq!(addrs.remote(), Some(remote)); -- }) -- } -- -- #[test] -- fn sockaddr_convert_4() { -- let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(3, 4, 5, 6)), 0xabcd); -- let (raw_addr, addr_len) = super::socket_addr_to_ptrs(&addr); -- assert_eq!(addr_len, 16); -- let addr_bytes = -- unsafe { slice::from_raw_parts(raw_addr.as_ptr() as *const u8, addr_len as usize) }; -- assert_eq!( -- addr_bytes, -- &[2, 0, 0xab, 0xcd, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0] -- ); -- } -- -- #[test] -- fn sockaddr_convert_v6() { -- let port = 0xabcd; -- let flowinfo = 0x12345678; -- let scope_id = 0x87654321; -- let addr = SocketAddr::V6(SocketAddrV6::new( -- Ipv6Addr::new( -- 0x0102, 0x0304, 0x0506, 0x0708, 0x090a, 0x0b0c, 0x0d0e, 0x0f10, -- ), -- port, -- flowinfo, -- scope_id, -- )); -- let (raw_addr, addr_len) = super::socket_addr_to_ptrs(&addr); -- assert_eq!(addr_len, 28); -- let addr_bytes = -- unsafe { slice::from_raw_parts(raw_addr.as_ptr() as *const u8, addr_len as usize) }; -- assert_eq!( -- addr_bytes, -- &[ -- 23, 0, // AF_INET6 -- 0xab, 0xcd, // Port -- 0x78, 0x56, 0x34, 0x12, // flowinfo -- 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, -- 0x0f, 0x10, // IP -- 0x21, 0x43, 0x65, 0x87, // scope_id -- ] -- ); -- } --} -diff --git a/KubeOS-Rust/vendor/miow/src/overlapped.rs b/KubeOS-Rust/vendor/miow/src/overlapped.rs -deleted file mode 100644 -index abe2d37c..00000000 ---- a/KubeOS-Rust/vendor/miow/src/overlapped.rs -+++ /dev/null -@@ -1,92 +0,0 @@ --use std::fmt; --use std::io; --use std::mem; --use std::ptr; -- --use winapi::shared::ntdef::{HANDLE, NULL}; --use winapi::um::minwinbase::*; --use winapi::um::synchapi::*; -- --/// A wrapper around `OVERLAPPED` to provide "rustic" accessors and --/// initializers. --pub struct Overlapped(OVERLAPPED); -- --impl fmt::Debug for Overlapped { -- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { -- write!(f, "OVERLAPPED") -- } --} -- --unsafe impl Send for Overlapped {} --unsafe impl Sync for Overlapped {} -- --impl Overlapped { -- /// Creates a new zeroed out instance of an overlapped I/O tracking state. -- /// -- /// This is suitable for passing to methods which will then later get -- /// notified via an I/O Completion Port. -- pub fn zero() -> Overlapped { -- Overlapped(unsafe { mem::zeroed() }) -- } -- -- /// Creates a new `Overlapped` with an initialized non-null `hEvent`. The caller is -- /// responsible for calling `CloseHandle` on the `hEvent` field of the returned -- /// `Overlapped`. The event is created with `bManualReset` set to `FALSE`, meaning after a -- /// single thread waits on the event, it will be reset. -- pub fn initialize_with_autoreset_event() -> io::Result { -- let event = unsafe { CreateEventW(ptr::null_mut(), 0i32, 0i32, ptr::null()) }; -- if event == NULL { -- return Err(io::Error::last_os_error()); -- } -- let mut overlapped = Self::zero(); -- overlapped.set_event(event); -- Ok(overlapped) -- } -- -- /// Creates a new `Overlapped` function pointer from the underlying -- /// `OVERLAPPED`, wrapping in the "rusty" wrapper for working with -- /// accessors. -- /// -- /// # Unsafety -- /// -- /// This function doesn't validate `ptr` nor the lifetime of the returned -- /// pointer at all, it's recommended to use this method with extreme -- /// caution. -- pub unsafe fn from_raw<'a>(ptr: *mut OVERLAPPED) -> &'a mut Overlapped { -- &mut *(ptr as *mut Overlapped) -- } -- -- /// Gain access to the raw underlying data -- pub fn raw(&self) -> *mut OVERLAPPED { -- &self.0 as *const _ as *mut _ -- } -- -- /// Sets the offset inside this overlapped structure. -- /// -- /// Note that for I/O operations in general this only has meaning for I/O -- /// handles that are on a seeking device that supports the concept of an -- /// offset. -- pub fn set_offset(&mut self, offset: u64) { -- let s = unsafe { self.0.u.s_mut() }; -- s.Offset = offset as u32; -- s.OffsetHigh = (offset >> 32) as u32; -- } -- -- /// Reads the offset inside this overlapped structure. -- pub fn offset(&self) -> u64 { -- let s = unsafe { self.0.u.s() }; -- (s.Offset as u64) | ((s.OffsetHigh as u64) << 32) -- } -- -- /// Sets the `hEvent` field of this structure. -- /// -- /// The event specified can be null. -- pub fn set_event(&mut self, event: HANDLE) { -- self.0.hEvent = event; -- } -- -- /// Reads the `hEvent` field of this structure, may return null. -- pub fn event(&self) -> HANDLE { -- self.0.hEvent -- } --} -diff --git a/KubeOS-Rust/vendor/miow/src/pipe.rs b/KubeOS-Rust/vendor/miow/src/pipe.rs -deleted file mode 100644 -index 5088021a..00000000 ---- a/KubeOS-Rust/vendor/miow/src/pipe.rs -+++ /dev/null -@@ -1,788 +0,0 @@ --//! Interprocess Communication pipes --//! --//! A pipe is a section of shared memory that processes use for communication. --//! The process that creates a pipe is the _pipe server_. A process that connects --//! to a pipe is a _pipe client_. One process writes information to the pipe, then --//! the other process reads the information from the pipe. This overview --//! describes how to create, manage, and use pipes. --//! --//! There are two types of pipes: [anonymous pipes](#fn.anonymous.html) and --//! [named pipes](#fn.named.html). Anonymous pipes require less overhead than --//! named pipes, but offer limited services. --//! --//! # Anonymous pipes --//! --//! An anonymous pipe is an unnamed, one-way pipe that typically transfers data --//! between a parent process and a child process. Anonymous pipes are always --//! local; they cannot be used for communication over a network. --//! --//! # Named pipes --//! --//! A *named pipe* is a named, one-way or duplex pipe for communication between --//! the pipe server and one or more pipe clients. All instances of a named pipe --//! share the same pipe name, but each instance has its own buffers and handles, --//! and provides a separate conduit for client/server communication. The use of --//! instances enables multiple pipe clients to use the same named pipe --//! simultaneously. --//! --//! Any process can access named pipes, subject to security checks, making named --//! pipes an easy form of communication between related or unrelated processes. --//! --//! Any process can act as both a server and a client, making peer-to-peer --//! communication possible. As used here, the term pipe server refers to a --//! process that creates a named pipe, and the term pipe client refers to a --//! process that connects to an instance of a named pipe. --//! --//! Named pipes can be used to provide communication between processes on the --//! same computer or between processes on different computers across a network. --//! If the server service is running, all named pipes are accessible remotely. If --//! you intend to use a named pipe locally only, deny access to NT --//! AUTHORITY\\NETWORK or switch to local RPC. --//! --//! # References --//! --//! - [win32 pipe docs](https://github.com/MicrosoftDocs/win32/blob/docs/desktop-src/ipc/pipes.md) -- --use std::cell::RefCell; --use std::ffi::OsStr; --use std::fs::{File, OpenOptions}; --use std::io; --use std::io::prelude::*; --use std::os::windows::ffi::*; --use std::os::windows::io::*; --use std::time::Duration; -- --use crate::handle::Handle; --use crate::overlapped::Overlapped; --use winapi::shared::minwindef::*; --use winapi::shared::ntdef::HANDLE; --use winapi::shared::winerror::*; --use winapi::um::fileapi::*; --use winapi::um::handleapi::*; --use winapi::um::ioapiset::*; --use winapi::um::minwinbase::*; --use winapi::um::namedpipeapi::*; --use winapi::um::winbase::*; -- --/// Readable half of an anonymous pipe. --#[derive(Debug)] --pub struct AnonRead(Handle); -- --/// Writable half of an anonymous pipe. --#[derive(Debug)] --pub struct AnonWrite(Handle); -- --/// A named pipe that can accept connections. --#[derive(Debug)] --pub struct NamedPipe(Handle); -- --/// A builder structure for creating a new named pipe. --#[derive(Debug)] --pub struct NamedPipeBuilder { -- name: Vec, -- dwOpenMode: DWORD, -- dwPipeMode: DWORD, -- nMaxInstances: DWORD, -- nOutBufferSize: DWORD, -- nInBufferSize: DWORD, -- nDefaultTimeOut: DWORD, --} -- --/// Creates a new anonymous in-memory pipe, returning the read/write ends of the --/// pipe. --/// --/// The buffer size for this pipe may also be specified, but the system will --/// normally use this as a suggestion and it's not guaranteed that the buffer --/// will be precisely this size. --pub fn anonymous(buffer_size: u32) -> io::Result<(AnonRead, AnonWrite)> { -- let mut read = 0 as HANDLE; -- let mut write = 0 as HANDLE; -- crate::cvt(unsafe { CreatePipe(&mut read, &mut write, 0 as *mut _, buffer_size) })?; -- Ok((AnonRead(Handle::new(read)), AnonWrite(Handle::new(write)))) --} -- --impl Read for AnonRead { -- fn read(&mut self, buf: &mut [u8]) -> io::Result { -- self.0.read(buf) -- } --} --impl<'a> Read for &'a AnonRead { -- fn read(&mut self, buf: &mut [u8]) -> io::Result { -- self.0.read(buf) -- } --} -- --impl AsRawHandle for AnonRead { -- fn as_raw_handle(&self) -> HANDLE { -- self.0.raw() -- } --} --impl FromRawHandle for AnonRead { -- unsafe fn from_raw_handle(handle: HANDLE) -> AnonRead { -- AnonRead(Handle::new(handle)) -- } --} --impl IntoRawHandle for AnonRead { -- fn into_raw_handle(self) -> HANDLE { -- self.0.into_raw() -- } --} -- --impl Write for AnonWrite { -- fn write(&mut self, buf: &[u8]) -> io::Result { -- self.0.write(buf) -- } -- fn flush(&mut self) -> io::Result<()> { -- Ok(()) -- } --} --impl<'a> Write for &'a AnonWrite { -- fn write(&mut self, buf: &[u8]) -> io::Result { -- self.0.write(buf) -- } -- fn flush(&mut self) -> io::Result<()> { -- Ok(()) -- } --} -- --impl AsRawHandle for AnonWrite { -- fn as_raw_handle(&self) -> HANDLE { -- self.0.raw() -- } --} --impl FromRawHandle for AnonWrite { -- unsafe fn from_raw_handle(handle: HANDLE) -> AnonWrite { -- AnonWrite(Handle::new(handle)) -- } --} --impl IntoRawHandle for AnonWrite { -- fn into_raw_handle(self) -> HANDLE { -- self.0.into_raw() -- } --} -- --/// A convenience function to connect to a named pipe. --/// --/// This function will block the calling process until it can connect to the --/// pipe server specified by `addr`. This will use `NamedPipe::wait` internally --/// to block until it can connect. --pub fn connect>(addr: A) -> io::Result { -- _connect(addr.as_ref()) --} -- --fn _connect(addr: &OsStr) -> io::Result { -- let mut r = OpenOptions::new(); -- let mut w = OpenOptions::new(); -- let mut rw = OpenOptions::new(); -- r.read(true); -- w.write(true); -- rw.read(true).write(true); -- loop { -- let res = rw -- .open(addr) -- .or_else(|_| r.open(addr)) -- .or_else(|_| w.open(addr)); -- match res { -- Ok(f) => return Ok(f), -- Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => {} -- Err(e) => return Err(e), -- } -- -- NamedPipe::wait(addr, Some(Duration::new(20, 0)))?; -- } --} -- --impl NamedPipe { -- /// Creates a new initial named pipe. -- /// -- /// This function is equivalent to: -- /// -- /// ``` -- /// use miow::pipe::NamedPipeBuilder; -- /// -- /// # let addr = "foo"; -- /// NamedPipeBuilder::new(addr) -- /// .first(true) -- /// .inbound(true) -- /// .outbound(true) -- /// .out_buffer_size(65536) -- /// .in_buffer_size(65536) -- /// .create(); -- /// ``` -- pub fn new>(addr: A) -> io::Result { -- NamedPipeBuilder::new(addr).create() -- } -- -- /// Waits until either a time-out interval elapses or an instance of the -- /// specified named pipe is available for connection. -- /// -- /// If this function succeeds the process can create a `File` to connect to -- /// the named pipe. -- pub fn wait>(addr: A, timeout: Option) -> io::Result<()> { -- NamedPipe::_wait(addr.as_ref(), timeout) -- } -- -- fn _wait(addr: &OsStr, timeout: Option) -> io::Result<()> { -- let addr = addr.encode_wide().chain(Some(0)).collect::>(); -- let timeout = crate::dur2ms(timeout); -- crate::cvt(unsafe { WaitNamedPipeW(addr.as_ptr(), timeout) }).map(|_| ()) -- } -- -- /// Connects this named pipe to a client, blocking until one becomes -- /// available. -- /// -- /// This function will call the `ConnectNamedPipe` function to await for a -- /// client to connect. This can be called immediately after the pipe is -- /// created, or after it has been disconnected from a previous client. -- pub fn connect(&self) -> io::Result<()> { -- match crate::cvt(unsafe { ConnectNamedPipe(self.0.raw(), 0 as *mut _) }) { -- Ok(_) => Ok(()), -- Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_CONNECTED as i32) => Ok(()), -- Err(e) => Err(e), -- } -- } -- -- /// Issue a connection request with the specified overlapped operation. -- /// -- /// This function will issue a request to connect a client to this server, -- /// returning immediately after starting the overlapped operation. -- /// -- /// If this function immediately succeeds then `Ok(true)` is returned. If -- /// the overlapped operation is enqueued and pending, then `Ok(false)` is -- /// returned. Otherwise an error is returned indicating what went wrong. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the -- /// `overlapped` pointer is valid until the end of the I/O operation. The -- /// kernel also requires that `overlapped` is unique for this I/O operation -- /// and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that this pointer is -- /// valid until the I/O operation is completed, typically via completion -- /// ports and waiting to receive the completion notification on the port. -- pub unsafe fn connect_overlapped(&self, overlapped: *mut OVERLAPPED) -> io::Result { -- match crate::cvt(ConnectNamedPipe(self.0.raw(), overlapped)) { -- Ok(_) => Ok(true), -- Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_CONNECTED as i32) => Ok(true), -- Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32) => Ok(false), -- Err(ref e) if e.raw_os_error() == Some(ERROR_NO_DATA as i32) => Ok(true), -- Err(e) => Err(e), -- } -- } -- -- /// Disconnects this named pipe from any connected client. -- pub fn disconnect(&self) -> io::Result<()> { -- crate::cvt(unsafe { DisconnectNamedPipe(self.0.raw()) }).map(|_| ()) -- } -- -- /// Issues an overlapped read operation to occur on this pipe. -- /// -- /// This function will issue an asynchronous read to occur in an overlapped -- /// fashion, returning immediately. The `buf` provided will be filled in -- /// with data and the request is tracked by the `overlapped` function -- /// provided. -- /// -- /// If the operation succeeds immediately, `Ok(Some(n))` is returned where -- /// `n` is the number of bytes read. If an asynchronous operation is -- /// enqueued, then `Ok(None)` is returned. Otherwise if an error occurred -- /// it is returned. -- /// -- /// When this operation completes (or if it completes immediately), another -- /// mechanism must be used to learn how many bytes were transferred (such as -- /// looking at the filed in the IOCP status message). -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the `buf` and -- /// `overlapped` pointers to be valid until the end of the I/O operation. -- /// The kernel also requires that `overlapped` is unique for this I/O -- /// operation and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that the pointers are -- /// valid until the I/O operation is completed, typically via completion -- /// ports and waiting to receive the completion notification on the port. -- pub unsafe fn read_overlapped( -- &self, -- buf: &mut [u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- self.0.read_overlapped(buf, overlapped) -- } -- -- /// Issues an overlapped write operation to occur on this pipe. -- /// -- /// This function will issue an asynchronous write to occur in an overlapped -- /// fashion, returning immediately. The `buf` provided will be filled in -- /// with data and the request is tracked by the `overlapped` function -- /// provided. -- /// -- /// If the operation succeeds immediately, `Ok(Some(n))` is returned where -- /// `n` is the number of bytes written. If an asynchronous operation is -- /// enqueued, then `Ok(None)` is returned. Otherwise if an error occurred -- /// it is returned. -- /// -- /// When this operation completes (or if it completes immediately), another -- /// mechanism must be used to learn how many bytes were transferred (such as -- /// looking at the filed in the IOCP status message). -- /// -- /// # Unsafety -- /// -- /// This function is unsafe because the kernel requires that the `buf` and -- /// `overlapped` pointers to be valid until the end of the I/O operation. -- /// The kernel also requires that `overlapped` is unique for this I/O -- /// operation and is not in use for any other I/O. -- /// -- /// To safely use this function callers must ensure that the pointers are -- /// valid until the I/O operation is completed, typically via completion -- /// ports and waiting to receive the completion notification on the port. -- pub unsafe fn write_overlapped( -- &self, -- buf: &[u8], -- overlapped: *mut OVERLAPPED, -- ) -> io::Result> { -- self.0.write_overlapped(buf, overlapped) -- } -- -- /// Calls the `GetOverlappedResult` function to get the result of an -- /// overlapped operation for this handle. -- /// -- /// This function takes the `OVERLAPPED` argument which must have been used -- /// to initiate an overlapped I/O operation, and returns either the -- /// successful number of bytes transferred during the operation or an error -- /// if one occurred. -- /// -- /// # Unsafety -- /// -- /// This function is unsafe as `overlapped` must have previously been used -- /// to execute an operation for this handle, and it must also be a valid -- /// pointer to an `Overlapped` instance. -- /// -- /// # Panics -- /// -- /// This function will panic -- pub unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result { -- let mut transferred = 0; -- let r = GetOverlappedResult(self.0.raw(), overlapped, &mut transferred, FALSE); -- if r == 0 { -- Err(io::Error::last_os_error()) -- } else { -- Ok(transferred as usize) -- } -- } --} -- --thread_local! { -- static NAMED_PIPE_OVERLAPPED: RefCell> = RefCell::new(None); --} -- --/// Call a function with a threadlocal `Overlapped`. The function `f` should be --/// sure that the event is reset, either manually or by a thread being released. --fn with_threadlocal_overlapped(f: F) -> io::Result --where -- F: FnOnce(&Overlapped) -> io::Result, --{ -- NAMED_PIPE_OVERLAPPED.with(|overlapped| { -- let mut mborrow = overlapped.borrow_mut(); -- if let None = *mborrow { -- let op = Overlapped::initialize_with_autoreset_event()?; -- *mborrow = Some(op); -- } -- f(mborrow.as_ref().unwrap()) -- }) --} -- --impl Read for NamedPipe { -- fn read(&mut self, buf: &mut [u8]) -> io::Result { -- // This is necessary because the pipe is opened with `FILE_FLAG_OVERLAPPED`. -- with_threadlocal_overlapped(|overlapped| unsafe { -- self.0 -- .read_overlapped_wait(buf, overlapped.raw() as *mut OVERLAPPED) -- }) -- } --} --impl<'a> Read for &'a NamedPipe { -- fn read(&mut self, buf: &mut [u8]) -> io::Result { -- // This is necessary because the pipe is opened with `FILE_FLAG_OVERLAPPED`. -- with_threadlocal_overlapped(|overlapped| unsafe { -- self.0 -- .read_overlapped_wait(buf, overlapped.raw() as *mut OVERLAPPED) -- }) -- } --} -- --impl Write for NamedPipe { -- fn write(&mut self, buf: &[u8]) -> io::Result { -- // This is necessary because the pipe is opened with `FILE_FLAG_OVERLAPPED`. -- with_threadlocal_overlapped(|overlapped| unsafe { -- self.0 -- .write_overlapped_wait(buf, overlapped.raw() as *mut OVERLAPPED) -- }) -- } -- fn flush(&mut self) -> io::Result<()> { -- <&NamedPipe as Write>::flush(&mut &*self) -- } --} --impl<'a> Write for &'a NamedPipe { -- fn write(&mut self, buf: &[u8]) -> io::Result { -- // This is necessary because the pipe is opened with `FILE_FLAG_OVERLAPPED`. -- with_threadlocal_overlapped(|overlapped| unsafe { -- self.0 -- .write_overlapped_wait(buf, overlapped.raw() as *mut OVERLAPPED) -- }) -- } -- fn flush(&mut self) -> io::Result<()> { -- crate::cvt(unsafe { FlushFileBuffers(self.0.raw()) }).map(|_| ()) -- } --} -- --impl AsRawHandle for NamedPipe { -- fn as_raw_handle(&self) -> HANDLE { -- self.0.raw() -- } --} --impl FromRawHandle for NamedPipe { -- unsafe fn from_raw_handle(handle: HANDLE) -> NamedPipe { -- NamedPipe(Handle::new(handle)) -- } --} --impl IntoRawHandle for NamedPipe { -- fn into_raw_handle(self) -> HANDLE { -- self.0.into_raw() -- } --} -- --fn flag(slot: &mut DWORD, on: bool, val: DWORD) { -- if on { -- *slot |= val; -- } else { -- *slot &= !val; -- } --} -- --impl NamedPipeBuilder { -- /// Creates a new named pipe builder with the default settings. -- pub fn new>(addr: A) -> NamedPipeBuilder { -- NamedPipeBuilder { -- name: addr.as_ref().encode_wide().chain(Some(0)).collect(), -- dwOpenMode: PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_OVERLAPPED, -- dwPipeMode: PIPE_TYPE_BYTE, -- nMaxInstances: PIPE_UNLIMITED_INSTANCES, -- nOutBufferSize: 65536, -- nInBufferSize: 65536, -- nDefaultTimeOut: 0, -- } -- } -- -- /// Indicates whether data is allowed to flow from the client to the server. -- pub fn inbound(&mut self, allowed: bool) -> &mut Self { -- flag(&mut self.dwOpenMode, allowed, PIPE_ACCESS_INBOUND); -- self -- } -- -- /// Indicates whether data is allowed to flow from the server to the client. -- pub fn outbound(&mut self, allowed: bool) -> &mut Self { -- flag(&mut self.dwOpenMode, allowed, PIPE_ACCESS_OUTBOUND); -- self -- } -- -- /// Indicates that this pipe must be the first instance. -- /// -- /// If set to true, then creation will fail if there's already an instance -- /// elsewhere. -- pub fn first(&mut self, first: bool) -> &mut Self { -- flag(&mut self.dwOpenMode, first, FILE_FLAG_FIRST_PIPE_INSTANCE); -- self -- } -- -- /// Indicates whether this server can accept remote clients or not. -- pub fn accept_remote(&mut self, accept: bool) -> &mut Self { -- flag(&mut self.dwPipeMode, !accept, PIPE_REJECT_REMOTE_CLIENTS); -- self -- } -- -- /// Specifies the maximum number of instances of the server pipe that are -- /// allowed. -- /// -- /// The first instance of a pipe can specify this value. A value of 255 -- /// indicates that there is no limit to the number of instances. -- pub fn max_instances(&mut self, instances: u8) -> &mut Self { -- self.nMaxInstances = instances as DWORD; -- self -- } -- -- /// Specifies the number of bytes to reserver for the output buffer -- pub fn out_buffer_size(&mut self, buffer: u32) -> &mut Self { -- self.nOutBufferSize = buffer as DWORD; -- self -- } -- -- /// Specifies the number of bytes to reserver for the input buffer -- pub fn in_buffer_size(&mut self, buffer: u32) -> &mut Self { -- self.nInBufferSize = buffer as DWORD; -- self -- } -- -- /// Using the options in this builder, attempt to create a new named pipe. -- /// -- /// This function will call the `CreateNamedPipe` function and return the -- /// result. -- pub fn create(&mut self) -> io::Result { -- unsafe { self.with_security_attributes(::std::ptr::null_mut()) } -- } -- -- /// Using the options in the builder and the provided security attributes, attempt to create a -- /// new named pipe. This function has to be called with a valid pointer to a -- /// `SECURITY_ATTRIBUTES` struct that will stay valid for the lifetime of this function or a -- /// null pointer. -- /// -- /// This function will call the `CreateNamedPipe` function and return the -- /// result. -- pub unsafe fn with_security_attributes( -- &mut self, -- attrs: *mut SECURITY_ATTRIBUTES, -- ) -> io::Result { -- let h = CreateNamedPipeW( -- self.name.as_ptr(), -- self.dwOpenMode, -- self.dwPipeMode, -- self.nMaxInstances, -- self.nOutBufferSize, -- self.nInBufferSize, -- self.nDefaultTimeOut, -- attrs, -- ); -- -- if h == INVALID_HANDLE_VALUE { -- Err(io::Error::last_os_error()) -- } else { -- Ok(NamedPipe(Handle::new(h))) -- } -- } --} -- --#[cfg(test)] --mod tests { -- use std::fs::{File, OpenOptions}; -- use std::io::prelude::*; -- use std::sync::mpsc::channel; -- use std::thread; -- use std::time::Duration; -- -- use rand::{distributions::Alphanumeric, thread_rng, Rng}; -- -- use super::{anonymous, NamedPipe, NamedPipeBuilder}; -- use crate::iocp::CompletionPort; -- use crate::Overlapped; -- -- fn name() -> String { -- let name = thread_rng() -- .sample_iter(Alphanumeric) -- .take(30) -- .map(char::from) -- .collect::(); -- format!(r"\\.\pipe\{}", name) -- } -- -- #[test] -- fn anon() { -- let (mut read, mut write) = t!(anonymous(256)); -- assert_eq!(t!(write.write(&[1, 2, 3])), 3); -- let mut b = [0; 10]; -- assert_eq!(t!(read.read(&mut b)), 3); -- assert_eq!(&b[..3], &[1, 2, 3]); -- } -- -- #[test] -- fn named_not_first() { -- let name = name(); -- let _a = t!(NamedPipe::new(&name)); -- assert!(NamedPipe::new(&name).is_err()); -- -- t!(NamedPipeBuilder::new(&name).first(false).create()); -- } -- -- #[test] -- fn named_connect() { -- let name = name(); -- let a = t!(NamedPipe::new(&name)); -- -- let t = thread::spawn(move || { -- t!(File::open(name)); -- }); -- -- t!(a.connect()); -- t!(a.disconnect()); -- t!(t.join()); -- } -- -- #[test] -- fn named_wait() { -- let name = name(); -- let a = t!(NamedPipe::new(&name)); -- -- let (tx, rx) = channel(); -- let t = thread::spawn(move || { -- t!(NamedPipe::wait(&name, None)); -- t!(File::open(&name)); -- assert!(NamedPipe::wait(&name, Some(Duration::from_millis(1))).is_err()); -- t!(tx.send(())); -- }); -- -- t!(a.connect()); -- t!(rx.recv()); -- t!(a.disconnect()); -- t!(t.join()); -- } -- -- #[test] -- fn named_connect_overlapped() { -- let name = name(); -- let a = t!(NamedPipe::new(&name)); -- -- let t = thread::spawn(move || { -- t!(File::open(name)); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- t!(cp.add_handle(2, &a)); -- -- let over = Overlapped::zero(); -- unsafe { -- t!(a.connect_overlapped(over.raw())); -- } -- -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 0); -- assert_eq!(status.token(), 2); -- assert_eq!(status.overlapped(), over.raw()); -- t!(t.join()); -- } -- -- #[test] -- fn named_read_write() { -- let name = name(); -- let mut a = t!(NamedPipe::new(&name)); -- -- let t = thread::spawn(move || { -- let mut f = t!(OpenOptions::new().read(true).write(true).open(name)); -- t!(f.write_all(&[1, 2, 3])); -- let mut b = [0; 10]; -- assert_eq!(t!(f.read(&mut b)), 3); -- assert_eq!(&b[..3], &[1, 2, 3]); -- }); -- -- t!(a.connect()); -- let mut b = [0; 10]; -- assert_eq!(t!(a.read(&mut b)), 3); -- assert_eq!(&b[..3], &[1, 2, 3]); -- t!(a.write_all(&[1, 2, 3])); -- t!(a.flush()); -- t!(a.disconnect()); -- t!(t.join()); -- } -- -- #[test] -- fn named_read_write_multi() { -- for _ in 0..5 { -- named_read_write() -- } -- } -- -- #[test] -- fn named_read_write_multi_same_thread() { -- let name1 = name(); -- let mut a1 = t!(NamedPipe::new(&name1)); -- let name2 = name(); -- let mut a2 = t!(NamedPipe::new(&name2)); -- -- let t = thread::spawn(move || { -- let mut f = t!(OpenOptions::new().read(true).write(true).open(name1)); -- t!(f.write_all(&[1, 2, 3])); -- let mut b = [0; 10]; -- assert_eq!(t!(f.read(&mut b)), 3); -- assert_eq!(&b[..3], &[1, 2, 3]); -- -- let mut f = t!(OpenOptions::new().read(true).write(true).open(name2)); -- t!(f.write_all(&[1, 2, 3])); -- let mut b = [0; 10]; -- assert_eq!(t!(f.read(&mut b)), 3); -- assert_eq!(&b[..3], &[1, 2, 3]); -- }); -- -- t!(a1.connect()); -- let mut b = [0; 10]; -- assert_eq!(t!(a1.read(&mut b)), 3); -- assert_eq!(&b[..3], &[1, 2, 3]); -- t!(a1.write_all(&[1, 2, 3])); -- t!(a1.flush()); -- t!(a1.disconnect()); -- -- t!(a2.connect()); -- let mut b = [0; 10]; -- assert_eq!(t!(a2.read(&mut b)), 3); -- assert_eq!(&b[..3], &[1, 2, 3]); -- t!(a2.write_all(&[1, 2, 3])); -- t!(a2.flush()); -- t!(a2.disconnect()); -- -- t!(t.join()); -- } -- -- #[test] -- fn named_read_overlapped() { -- let name = name(); -- let a = t!(NamedPipe::new(&name)); -- -- let t = thread::spawn(move || { -- let mut f = t!(File::create(name)); -- t!(f.write_all(&[1, 2, 3])); -- }); -- -- let cp = t!(CompletionPort::new(1)); -- t!(cp.add_handle(3, &a)); -- t!(a.connect()); -- -- let mut b = [0; 10]; -- let over = Overlapped::zero(); -- unsafe { -- t!(a.read_overlapped(&mut b, over.raw())); -- } -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 3); -- assert_eq!(status.token(), 3); -- assert_eq!(status.overlapped(), over.raw()); -- assert_eq!(&b[..3], &[1, 2, 3]); -- -- t!(t.join()); -- } -- -- #[test] -- fn named_write_overlapped() { -- let name = name(); -- let a = t!(NamedPipe::new(&name)); -- -- let t = thread::spawn(move || { -- let mut f = t!(super::connect(name)); -- let mut b = [0; 10]; -- assert_eq!(t!(f.read(&mut b)), 3); -- assert_eq!(&b[..3], &[1, 2, 3]) -- }); -- -- let cp = t!(CompletionPort::new(1)); -- t!(cp.add_handle(3, &a)); -- t!(a.connect()); -- -- let over = Overlapped::zero(); -- unsafe { -- t!(a.write_overlapped(&[1, 2, 3], over.raw())); -- } -- -- let status = t!(cp.get(None)); -- assert_eq!(status.bytes_transferred(), 3); -- assert_eq!(status.token(), 3); -- assert_eq!(status.overlapped(), over.raw()); -- -- t!(t.join()); -- } --} -diff --git a/KubeOS-Rust/vendor/mockall_double/.cargo-checksum.json b/KubeOS-Rust/vendor/mockall_double/.cargo-checksum.json -deleted file mode 100644 -index 83c06db6..00000000 ---- a/KubeOS-Rust/vendor/mockall_double/.cargo-checksum.json -+++ /dev/null -@@ -1 +0,0 @@ --{"files":{"Cargo.toml":"c23ec15a748a1fb64eaaa86d2b9d76c85ff8090cef32b1fe034ad4e1175e037c","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"a6ba0ec436e84b1517c6371beb6db11eab6a8e4a39d895be8584fb2c65303b5a","README.md":"f63b70471e2cf66b5137219cacf4dc836dd5aeaa246d60979ce359b1caf28eb9","src/lib.rs":"4c9f7dc605809220239ee20170945e45c265093b384b81534817363341fbe13a"},"package":"7dffc15b97456ecc84d2bde8c1df79145e154f45225828c4361f676e1b82acd6"} -\ No newline at end of file -diff --git a/KubeOS-Rust/vendor/mockall_double/Cargo.toml b/KubeOS-Rust/vendor/mockall_double/Cargo.toml -deleted file mode 100644 -index 97401aa8..00000000 ---- a/KubeOS-Rust/vendor/mockall_double/Cargo.toml -+++ /dev/null -@@ -1,40 +0,0 @@ --# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO --# --# When uploading crates to the registry Cargo will automatically --# "normalize" Cargo.toml files for maximal compatibility --# with all versions of Cargo and also rewrite `path` dependencies --# to registry (e.g., crates.io) dependencies. --# --# If you are reading this file be aware that the original Cargo.toml --# will likely look very different (and much more reasonable). --# See Cargo.toml.orig for the original contents. -- --[package] --edition = "2018" --name = "mockall_double" --version = "0.2.1" --authors = ["Alan Somers "] --description = "Test double adapter for Mockall\n" --documentation = "https://docs.rs/mockall_double" --keywords = ["mock", "mocking", "testing"] --categories = ["development-tools::testing"] --license = "MIT/Apache-2.0" --repository = "https://github.com/asomers/mockall" -- --[lib] --proc-macro = true --[dependencies.cfg-if] --version = "1.0" -- --[dependencies.proc-macro2] --version = "1.0" -- --[dependencies.quote] --version = "1.0" -- --[dependencies.syn] --version = "1.0.15" --features = ["full"] -- --[features] --nightly = ["proc-macro2/nightly"] -diff --git a/KubeOS-Rust/vendor/mockall_double/LICENSE-APACHE b/KubeOS-Rust/vendor/mockall_double/LICENSE-APACHE -deleted file mode 100644 -index 16fe87b0..00000000 ---- a/KubeOS-Rust/vendor/mockall_double/LICENSE-APACHE -+++ /dev/null -@@ -1,201 +0,0 @@ -- Apache License -- Version 2.0, January 2004 -- http://www.apache.org/licenses/ -- --TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION -- --1. Definitions. -- -- "License" shall mean the terms and conditions for use, reproduction, -- and distribution as defined by Sections 1 through 9 of this document. -- -- "Licensor" shall mean the copyright owner or entity authorized by -- the copyright owner that is granting the License. -- -- "Legal Entity" shall mean the union of the acting entity and all -- other entities that control, are controlled by, or are under common -- control with that entity. For the purposes of this definition, -- "control" means (i) the power, direct or indirect, to cause the -- direction or management of such entity, whether by contract or -- otherwise, or (ii) ownership of fifty percent (50%) or more of the -- outstanding shares, or (iii) beneficial ownership of such entity. -- -- "You" (or "Your") shall mean an individual or Legal Entity -- exercising permissions granted by this License. -- -- "Source" form shall mean the preferred form for making modifications, -- including but not limited to software source code, documentation -- source, and configuration files. -- -- "Object" form shall mean any form resulting from mechanical -- transformation or translation of a Source form, including but -- not limited to compiled object code, generated documentation, -- and conversions to other media types. -- -- "Work" shall mean the work of authorship, whether in Source or -- Object form, made available under the License, as indicated by a -- copyright notice that is included in or attached to the work -- (an example is provided in the Appendix below). -- -- "Derivative Works" shall mean any work, whether in Source or Object -- form, that is based on (or derived from) the Work and for which the -- editorial revisions, annotations, elaborations, or other modifications -- represent, as a whole, an original work of authorship. For the purposes -- of this License, Derivative Works shall not include works that remain -- separable from, or merely link (or bind by name) to the interfaces of, -- the Work and Derivative Works thereof. -- -- "Contribution" shall mean any work of authorship, including -- the original version of the Work and any modifications or additions -- to that Work or Derivative Works thereof, that is intentionally -- submitted to Licensor for inclusion in the Work by the copyright owner -- or by an individual or Legal Entity authorized to submit on behalf of -- the copyright owner. For the purposes of this definition, "submitted" -- means any form of electronic, verbal, or written communication sent -- to the Licensor or its representatives, including but not limited to -- communication on electronic mailing lists, source code control systems, -- and issue tracking systems that are managed by, or on behalf of, the -- Licensor for the purpose of discussing and improving the Work, but -- excluding communication that is conspicuously marked or otherwise -- designated in writing by the copyright owner as "Not a Contribution." -- -- "Contributor" shall mean Licensor and any individual or Legal Entity -- on behalf of whom a Contribution has been received by Licensor and -- subsequently incorporated within the Work. -- --2. Grant of Copyright License. Subject to the terms and conditions of -- this License, each Contributor hereby grants to You a perpetual, -- worldwide, non-exclusive, no-charge, royalty-free, irrevocable -- copyright license to reproduce, prepare Derivative Works of, -- publicly display, publicly perform, sublicense, and distribute the -- Work and such Derivative Works in Source or Object form. -- --3. Grant of Patent License. Subject to the terms and conditions of -- this License, each Contributor hereby grants to You a perpetual, -- worldwide, non-exclusive, no-charge, royalty-free, irrevocable -- (except as stated in this section) patent license to make, have made, -- use, offer to sell, sell, import, and otherwise transfer the Work, -- where such license applies only to those patent claims licensable -- by such Contributor that are necessarily infringed by their -- Contribution(s) alone or by combination of their Contribution(s) -- with the Work to which such Contribution(s) was submitted. If You -- institute patent litigation against any entity (including a -- cross-claim or counterclaim in a lawsuit) alleging that the Work -- or a Contribution incorporated within the Work constitutes direct -- or contributory patent infringement, then any patent licenses -- granted to You under this License for that Work shall terminate -- as of the date such litigation is filed. -- --4. Redistribution. You may reproduce and distribute copies of the -- Work or Derivative Works thereof in any medium, with or without -- modifications, and in Source or Object form, provided that You -- meet the following conditions: -- -- (a) You must give any other recipients of the Work or -- Derivative Works a copy of this License; and -- -- (b) You must cause any modified files to carry prominent notices -- stating that You changed the files; and -- -- (c) You must retain, in the Source form of any Derivative Works -- that You distribute, all copyright, patent, trademark, and -- attribution notices from the Source form of the Work, -- excluding those notices that do not pertain to any part of -- the Derivative Works; and -- -- (d) If the Work includes a "NOTICE" text file as part of its -- distribution, then any Derivative Works that You distribute must -- include a readable copy of the attribution notices contained -- within such NOTICE file, excluding those notices that do not -- pertain to any part of the Derivative Works, in at least one -- of the following places: within a NOTICE text file distributed -- as part of the Derivative Works; within the Source form or -- documentation, if provided along with the Derivative Works; or, -- within a display generated by the Derivative Works, if and -- wherever such third-party notices normally appear. The contents -- of the NOTICE file are for informational purposes only and -- do not modify the License. You may add Your own attribution -- notices within Derivative Works that You distribute, alongside -- or as an addendum to the NOTICE text from the Work, provided -- that such additional attribution notices cannot be construed -- as modifying the License. -- -- You may add Your own copyright statement to Your modifications and -- may provide additional or different license terms and conditions -- for use, reproduction, or distribution of Your modifications, or -- for any such Derivative Works as a whole, provided Your use, -- reproduction, and distribution of the Work otherwise complies with -- the conditions stated in this License. -- --5. Submission of Contributions. Unless You explicitly state otherwise, -- any Contribution intentionally submitted for inclusion in the Work -- by You to the Licensor shall be under the terms and conditions of -- this License, without any additional terms or conditions. -- Notwithstanding the above, nothing herein shall supersede or modify -- the terms of any separate license agreement you may have executed -- with Licensor regarding such Contributions. -- --6. Trademarks. This License does not grant permission to use the trade -- names, trademarks, service marks, or product names of the Licensor, -- except as required for reasonable and customary use in describing the -- origin of the Work and reproducing the content of the NOTICE file. -- --7. Disclaimer of Warranty. Unless required by applicable law or -- agreed to in writing, Licensor provides the Work (and each -- Contributor provides its Contributions) on an "AS IS" BASIS, -- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -- implied, including, without limitation, any warranties or conditions -- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A -- PARTICULAR PURPOSE. You are solely responsible for determining the -- appropriateness of using or redistributing the Work and assume any -- risks associated with Your exercise of permissions under this License. -- --8. Limitation of Liability. In no event and under no legal theory, -- whether in tort (including negligence), contract, or otherwise, -- unless required by applicable law (such as deliberate and grossly -- negligent acts) or agreed to in writing, shall any Contributor be -- liable to You for damages, including any direct, indirect, special, -- incidental, or consequential damages of any character arising as a -- result of this License or out of the use or inability to use the -- Work (including but not limited to damages for loss of goodwill, -- work stoppage, computer failure or malfunction, or any and all -- other commercial damages or losses), even if such Contributor -- has been advised of the possibility of such damages. -- --9. Accepting Warranty or Additional Liability. While redistributing -- the Work or Derivative Works thereof, You may choose to offer, -- and charge a fee for, acceptance of support, warranty, indemnity, -- or other liability obligations and/or rights consistent with this -- License. However, in accepting such obligations, You may act only -- on Your own behalf and on Your sole responsibility, not on behalf -- of any other Contributor, and only if You agree to indemnify, -- defend, and hold each Contributor harmless for any liability -- incurred by, or claims asserted against, such Contributor by reason -- of your accepting any such warranty or additional liability. -- --END OF TERMS AND CONDITIONS -- --APPENDIX: How to apply the Apache License to your work. -- -- To apply the Apache License to your work, attach the following -- boilerplate notice, with the fields enclosed by brackets "[]" -- replaced with your own identifying information. (Don't include -- the brackets!) The text should be enclosed in the appropriate -- comment syntax for the file format. We also recommend that a -- file or class name and description of purpose be included on the -- same "printed page" as the copyright notice for easier -- identification within third-party archives. -- --Copyright [yyyy] [name of copyright owner] -- --Licensed under the Apache License, Version 2.0 (the "License"); --you may not use this file except in compliance with the License. --You may obtain a copy of the License at -- -- http://www.apache.org/licenses/LICENSE-2.0 -- --Unless required by applicable law or agreed to in writing, software --distributed under the License is distributed on an "AS IS" BASIS, --WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. --See the License for the specific language governing permissions and --limitations under the License. -diff --git a/KubeOS-Rust/vendor/mockall_double/LICENSE-MIT b/KubeOS-Rust/vendor/mockall_double/LICENSE-MIT -deleted file mode 100644 -index 39df3da6..00000000 ---- a/KubeOS-Rust/vendor/mockall_double/LICENSE-MIT -+++ /dev/null -@@ -1,25 +0,0 @@ --Copyright (c) 2019 Alan Somers -- --Permission is hereby granted, free of charge, to any --person obtaining a copy of this software and associated --documentation files (the "Software"), to deal in the --Software without restriction, including without --limitation the rights to use, copy, modify, merge, --publish, distribute, sublicense, and/or sell copies of --the Software, and to permit persons to whom the Software --is furnished to do so, subject to the following --conditions: -- --The above copyright notice and this permission notice --shall be included in all copies or substantial portions --of the Software. -- --THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF --ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED --TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A --PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT --SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY --CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION --OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR --IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER --DEALINGS IN THE SOFTWARE. -diff --git a/KubeOS-Rust/vendor/mockall_double/README.md b/KubeOS-Rust/vendor/mockall_double/README.md -deleted file mode 100644 -index 0a3b98d1..00000000 ---- a/KubeOS-Rust/vendor/mockall_double/README.md -+++ /dev/null -@@ -1,88 +0,0 @@ --# mockall_double -- --A double test adapter that works well with Mockall. -- --[![Build Status](https://api.cirrus-ci.com/github/asomers/mockall.svg)](https://cirrus-ci.com/github/asomers/mockall) --[![Crates.io](https://img.shields.io/crates/v/mockall_double.svg)](https://crates.io/crates/mockall_double) --[![Documentation](https://docs.rs/mockall_double/badge.svg)](https://docs.rs/mockall_double) -- --## Overview -- --Mockall can easily create a mock version of a struct. But how does one --convince the code under test to use the mock struct instead of the real one? --In Rust, it's necessary to replace the real struct at compile time. That's --very easy to do with a few `#[cfg(test)]` statements. But mockall_double makes --it even easier. -- --## Usage -- --Typically mockall is only used by unit tests, so it can be a dev-dependency. --But mockall_double must be a full dependency. To use it this way, add this to --your `Cargo.toml`: -- --```toml --[dependencies] --mockall_double = "0.1.0" -- --[dev-dependencies] --mockall = "0.8.0" --``` -- --Then use it like this: -- --```rust --use mockall_double::double; -- --mod mockable { -- #[cfg(test)] -- use mockall::automock; -- -- pub struct Foo {} -- #[cfg_attr(test, automock)] -- impl Foo { -- pub fn foo(&self, x: u32) -> u32 { -- // ... -- 0 -- } -- } --} -- --#[double] --use mockable::Foo; -- --fn bar(f: Foo) -> u32 { -- f.foo(42) --} -- --#[cfg(test)] --mod tests { -- use super::*; -- -- #[test] -- fn bar_test() { -- let mut mock = Foo::new(); -- mock.expect_foo() -- .returning(|x| x + 1); -- assert_eq!(43, bar(mock)); -- } --} --``` -- --See the [API docs](https://docs.rs/mockall_double) for more information. -- --# Minimum Supported Rust Version (MSRV) -- --Mockall_double is tested with the same MSRV as Mockall itself. Currently, that's Rust 1.42.0. mockall_double's MSRV will not be changed in the future without bumping the major or minor version. -- --# License -- --`mockall_double` is primarily distributed under the terms of both the MIT --license and the Apache License (Version 2.0). -- --See LICENSE-APACHE, and LICENSE-MIT for details -- --# Acknowledgements -- --mockall_double is inspired by Jason Grlicky's --[double](https://crates.io/crates/double) crate, but tweaked to work better --with Mockall's naming conventions. -diff --git a/KubeOS-Rust/vendor/mockall_double/src/lib.rs b/KubeOS-Rust/vendor/mockall_double/src/lib.rs -deleted file mode 100644 -index 94abb99b..00000000 ---- a/KubeOS-Rust/vendor/mockall_double/src/lib.rs -+++ /dev/null -@@ -1,301 +0,0 @@ --// vim: tw=80 --//! Test double adapter for use with Mockall --//! --//! This crate provides [`#[double]`](macro@double), which can swap in Mock --//! objects for real objects while in test mode. It's intended to be used in --//! tandem with the [`mockall`](https://docs.rs/mockall/latest/mockall) crate. --//! However, it is defined in its own crate so that the bulk of Mockall can --//! remain a dev-dependency, instead of a regular dependency. -- --#![cfg_attr(feature = "nightly", feature(proc_macro_diagnostic))] --#![cfg_attr(test, deny(warnings))] --extern crate proc_macro; -- --use cfg_if::cfg_if; --use proc_macro2::{Span, TokenStream}; --use quote::{format_ident, quote}; --use syn::{ -- *, -- spanned::Spanned --}; -- --cfg_if! { -- // proc-macro2's Span::unstable method requires the nightly feature, and it -- // doesn't work in test mode. -- // https://github.com/alexcrichton/proc-macro2/issues/159 -- if #[cfg(all(feature = "nightly", not(test)))] { -- fn compile_error(span: Span, msg: &'static str) { -- span.unstable() -- .error(msg) -- .emit(); -- } -- } else { -- fn compile_error(_span: Span, msg: &str) { -- panic!("{}. More information may be available when mockall_double is built with the \"nightly\" feature.", msg); -- } -- } --} -- --fn do_double(_attrs: TokenStream, input: TokenStream) -> TokenStream { -- let mut use_stmt: ItemUse = match parse2(input.clone()) { -- Ok(u) => u, -- Err(e) => return e.to_compile_error() -- }; -- mock_itemuse(&mut use_stmt); -- quote!( -- #[cfg(not(test))] -- #input -- #[cfg(test)] -- #use_stmt -- ) --} -- --/// Import a mock type in test mode, or a real type otherwise. --/// --/// In a regular build, this macro is a no-op. But when `#[cfg(test)]`, it --/// substitutes "MockXXX" for any imported "XXX". This makes it easy to to use --/// mock objects, especially structs, in your unit tests. --/// --/// This macro uses the same naming convention as --/// [`mockall`](https://docs.rs/mockall/latest/mockall), but doesn't strictly --/// require it. It can work with hand-built Mock objects, or any other crate --/// using the same naming convention. --/// --/// This is the most common way to use `#[double]`. In order to replace a type, --/// it must come from a separate module. So to mock type `Foo`, place it into a --/// submodule, along with its mock counterpart. Then simply import `Foo` with --/// `#[double]` like this: --/// ```no_run --/// # use mockall_double::double; --/// mod foo { --/// pub(super) struct Foo { --/// // ... --/// } --/// #[cfg(test)] --/// pub(super) struct MockFoo { --/// // ... --/// } --/// } --/// #[double] --/// use foo::Foo; --/// ``` --/// That will expand to the following: --/// ```no_run --/// # use mockall_double::double; --/// # mod foo { pub struct Foo {} } --/// #[cfg(not(test))] --/// use foo::Foo; --/// #[cfg(test)] --/// use foo::MockFoo as Foo; --/// ``` --/// `#[double]` can handle deeply nested paths, --/// ```no_run --/// # use mockall_double::double; --/// # mod foo { pub mod bar { pub struct Baz{} } } --/// #[double] --/// use foo::bar::Baz; --/// ``` --/// grouped imports, --/// ```no_run --/// # mod foo { pub mod bar { pub struct Baz{} pub struct Bean {} } } --/// # use mockall_double::double; --/// #[double] --/// use foo::bar::{ --/// Baz, --/// Bean --/// }; --/// ``` --/// and renamed imports, too. With renamed imports, it isn't even necessary to --/// declare a submodule. --/// ```no_run --/// # use mockall_double::double; --/// # struct Foo {} --/// #[double] --/// use Foo as Bar; --/// ``` --/// Finally, `#[double]` can also import entire mocked modules, not just --/// structures. In this case the naming convention is different. It will --/// replace "xxx" with "mock_xxx". For example: --/// ```no_run --/// # use mockall_double::double; --/// mod foo { --/// pub mod inner { --/// // ... --/// } --/// pub mod mock_inner { --/// // ... --/// } --/// } --/// #[double] --/// use foo::inner; --/// ``` --/// will expand to: --/// ```no_run --/// # use mockall_double::double; --/// # mod foo { pub mod inner { } pub mod mock_inner { } } --/// #[cfg(not(test))] --/// use foo::inner; --/// #[cfg(test)] --/// use foo::mock_inner as inner; --/// ``` --/// --#[proc_macro_attribute] --pub fn double(attrs: proc_macro::TokenStream, input: proc_macro::TokenStream) -- -> proc_macro::TokenStream --{ -- do_double(attrs.into(), input.into()).into() --} -- --fn mock_itemuse(orig: &mut ItemUse) { -- if let UseTree::Name(un) = &orig.tree { -- compile_error(un.span(), -- "Cannot double types in the current module. Use a submodule (use foo::Foo) or a rename (use Foo as Bar)"); -- } else { -- mock_usetree(&mut orig.tree) -- } --} -- --fn mock_ident(i: &Ident) -> Ident { -- let is_type = format!("{}", i) -- .chars() -- .next() -- .expect("zero-length ident?") -- .is_uppercase(); -- if is_type { -- // probably a Type -- format_ident!("Mock{}", i) -- } else { -- // probably a module -- format_ident!("mock_{}", i) -- } --} -- --fn mock_usetree(mut orig: &mut UseTree) { -- match &mut orig { -- UseTree::Glob(star) => { -- compile_error(star.span(), -- "Cannot double glob imports. Import by fully qualified name instead."); -- }, -- UseTree::Group(ug) => { -- for ut in ug.items.iter_mut() { -- mock_usetree(ut); -- } -- }, -- UseTree::Name(un) => { -- *orig = UseTree::Rename(UseRename { -- ident: mock_ident(&un.ident), -- as_token: ::default(), -- rename: un.ident.clone() -- }); -- }, -- UseTree::Path(up) => { -- mock_usetree(up.tree.as_mut()); -- }, -- UseTree::Rename(ur) => { -- ur.ident = mock_ident(&ur.ident) -- }, -- } --} -- --#[cfg(test)] --mod t { -- use super::*; -- --mod double { -- use super::*; -- use std::str::FromStr; -- -- fn cmp(attrs: &str, code: &str, expected: &str) { -- let attrs_ts = TokenStream::from_str(attrs).unwrap(); -- let code_ts = TokenStream::from_str(code).unwrap(); -- let output = do_double(attrs_ts, code_ts); -- let output = output.to_string(); -- // Round-trip expected through proc_macro2 so whitespace will be -- // identically formatted -- let expected = TokenStream::from_str(expected) -- .unwrap() -- .to_string(); -- assert_eq!(output, expected); -- } -- -- #[test] -- #[should_panic(expected = "Cannot double glob")] -- fn glob() { -- let code = r#"use foo::*;"#; -- cmp("", code, ""); -- } -- -- #[test] -- fn group() { -- let code = r#" -- use foo::bar::{ -- Baz, -- Bean -- }; -- "#; -- let expected = r#" -- #[cfg(not(test))] -- use foo::bar::{ -- Baz, -- Bean -- }; -- #[cfg(test)] -- use foo::bar::{ -- MockBaz as Baz, -- MockBean as Bean -- }; -- "#; -- cmp("", code, expected); -- } -- -- #[test] -- fn module() { -- let code = r#"use foo::bar;"#; -- let expected = r#" -- #[cfg(not(test))] -- use foo::bar; -- #[cfg(test)] -- use foo::mock_bar as bar; -- "#; -- cmp("", code, expected); -- } -- -- #[test] -- #[should_panic(expected = "Cannot double types in the current module")] -- fn name() { -- let code = r#"use Foo;"#; -- cmp("", code, ""); -- } -- -- #[test] -- fn path() { -- let code = r#"use foo::bar::Baz;"#; -- let expected = r#" -- #[cfg(not(test))] -- use foo::bar::Baz; -- #[cfg(test)] -- use foo::bar::MockBaz as Baz; -- "#; -- cmp("", code, expected); -- } -- -- #[test] -- fn rename() { -- let code = r#"use Foo as Bar;"#; -- let expected = r#" -- #[cfg(not(test))] -- use Foo as Bar; -- #[cfg(test)] -- use MockFoo as Bar; -- "#; -- cmp("", code, expected); -- } -- -- #[test] -- fn not_use_stmt() { -- let code = r#"struct Foo{}"#; -- cmp("", code, "compile_error!{\"expected `use`\"}"); -- } --} --} -- -diff --git a/KubeOS-Rust/vendor/ntapi/.cargo-checksum.json b/KubeOS-Rust/vendor/ntapi/.cargo-checksum.json -deleted file mode 100644 -index 8a9d4be0..00000000 ---- a/KubeOS-Rust/vendor/ntapi/.cargo-checksum.json -+++ /dev/null -@@ -1 +0,0 @@ --{"files":{"Cargo.toml":"766a317c4703d827a8405fca763dcc4aab451c7424b666bfccd39caad3341c85","LICENSE-APACHE":"cf90d659de5c1e6418267ab8043b756e65508ee5d8d50b29eb2d2fe444c2c3eb","LICENSE-MIT":"11a7964ccc0dd115d16720ab1d826c5d03e52838748ffaba3d21bae8bcacd82a","README.md":"3be48f39b5fea8f1091aeef02338ef2c0ca7321750ec043bee9ab3c7ac990e54","build.rs":"13a274ea4cb1886872626b8a98269e9bf2e1f93cb1068fc8c797e421746cac7e","src/lib.rs":"5bd23124340783c9d7ba365b85dd7b78efe7345ccfa6a734ecb4a13604f423c9","src/macros.rs":"b0a852ebea2e1aed3e7d70eeadc8356778b064d2eca6e796598e9ab37ac54175","src/ntapi_base.rs":"b2edefaf68709c32f7fb4377ea21457afd3c7546ba59596f9f25bbaeb220f4d4","src/ntdbg.rs":"f891d4b26ef9d6c68ca098ab70bb4b1dd4d7e1d05e0f65c32bc6cb1151528f91","src/ntexapi.rs":"9dc7765b30daddc21068b7ca7a2c07f96b97e2f80f81ef631f8cc8b979a4c8c9","src/ntgdi.rs":"9fa6610566d77e95294432957f8cb8564cef3bb09d2d8d0adcf23047fa3a5221","src/ntioapi.rs":"577f3c3d83a95a965fff62efbdaa01769e9b3cf713f0d296a948f34cdfddcedc","src/ntkeapi.rs":"1ede6613c94303e6087e30e64ee1f1623eada9d088ce50992904e1812b263923","src/ntldr.rs":"c9be16003da83f82599a419995fbf4f15e047f24166f700dd4b08c0e58adb5a8","src/ntlpcapi.rs":"da5070b1c1adad34091aedd01d2b888daa4dc9446fdcd69668565e6eeb2db11f","src/ntmisc.rs":"4904e383065828b86013ebd3b85d45b384b522899954ac89c561963061acc962","src/ntmmapi.rs":"3a371e9edb7df91d1242f9dae92bf6d295c9b6c3ca65846c8d1ebbba55bdf7ee","src/ntnls.rs":"ef90b985da124d2f4c4b8cb0addab766a0928843b4afa4bce40b3a9fcddaf163","src/ntobapi.rs":"3071d8bc73e40d92d769e4093744820c0a5e116ecf4a94676ca3cdc008adfd8e","src/ntpebteb.rs":"94a9fbc1b3c48fa368f1b602fa205d41d3201e4d8c638c0898402eb3ebb5b72a","src/ntpfapi.rs":"37270db61f2562cd5481302c2a5a64be186b8c7126eacfe12b6c66e9bec4bf61","src/ntpnpapi.rs":"cfcaa3dd6110f25a48c51c011bb8369e83e3817e142afb412e40d6e4b868a036","src/ntpoapi.rs":"a535206a89cd42f81e3b931e5802f8b3343fd35387e9f3fedd9b042a78853f34","src/ntpsapi.rs":"5f4b3d176bbbbe6aee3d38a905990911732dbf08569c1fe4e273b38e46d63d49","src/ntregapi.rs":"a6f5a830b48e88fd0a4824036fffda2d2d80d1cad07baf37607121142f2c4777","src/ntrtl.rs":"9ac601ec4425cde859e7fda902a77fe2ff6612fb13c28168e83fe528ec78d64a","src/ntsam.rs":"dc59cfa944c27cf02b782fdbf110de4757ca6ae77806820a64a17742670242b4","src/ntseapi.rs":"c87688e028aa05513e361bb72288ef3af2f3dfe8e923745a84409d8fdeee57fd","src/ntsmss.rs":"6ac1f029b56a2a8856569c3acbedd7c560d2ccfac030aa2f2178f52d9312cdc5","src/nttmapi.rs":"7092c8b35aae642572c333b0fef1fe4a32f5a9c563249b585766317051670db5","src/nttp.rs":"47be534d36af7d6a715c87ef646824162bd3eb47f86a85ed8357c987c1a4fcdd","src/ntwow64.rs":"725baf7b32d24c0800abf730b58335e682332b821636ca699c40e80ba7148f94","src/ntxcapi.rs":"54fcadd43a0e146ade8ebdd750b09872d0e8f7a1295a9646910529048d5f6dca","src/ntzwapi.rs":"012932586fdbcac8eff57d90ce640e10d20e150dc7702100d1ea46f6f261f868","src/string.rs":"ac0e73f37384e03f14d9dc47fcfb3620a4157e122481f30c82b16fb21ab86a40","src/subprocesstag.rs":"4c85e44c91521cb20e5c6624b0cf4b27ca6ac7c3e560854ad34e0e66fb809971","src/winapi_local.rs":"2003099deec5e7039e5d2dd0aa6a43120816f67e94f4d9909c7f6689b62747e4","src/winapi_local/um.rs":"48859dfb53520bdd569c052ac26d06de2d16c57403ffbe4febbc1e1f25847f45","src/winapi_local/um/winioctl.rs":"00020fcda499ce558edfa4d684f5b4e198cbcfa5b3b8e9b62a122c0aca46514f","src/winapi_local/um/winnt.rs":"fc1a3ba99e305ec752528a00ceb02457fe73f4a7875370fe2ffaaaa5336ebfbf","src/winsta.rs":"c5a28c5c55f08745b2b100a5a374af821cf173b053eb8ee54ae19a85455d3fac"},"package":"c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f"} -\ No newline at end of file -diff --git a/KubeOS-Rust/vendor/ntapi/Cargo.toml b/KubeOS-Rust/vendor/ntapi/Cargo.toml -deleted file mode 100644 -index 35516ff8..00000000 ---- a/KubeOS-Rust/vendor/ntapi/Cargo.toml -+++ /dev/null -@@ -1,40 +0,0 @@ --# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO --# --# When uploading crates to the registry Cargo will automatically --# "normalize" Cargo.toml files for maximal compatibility --# with all versions of Cargo and also rewrite `path` dependencies --# to registry (e.g., crates.io) dependencies. --# --# If you are reading this file be aware that the original Cargo.toml --# will likely look very different (and much more reasonable). --# See Cargo.toml.orig for the original contents. -- --[package] --edition = "2018" --name = "ntapi" --version = "0.3.7" --authors = ["MSxDOS "] --include = ["src/**/*", "Cargo.toml", "build.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"] --description = "FFI bindings for Native API" --documentation = "https://docs.rs/ntapi/*/x86_64-pc-windows-msvc/ntapi/" --readme = "README.md" --keywords = ["windows", "ffi", "ntapi", "native", "win32"] --categories = ["external-ffi-bindings", "no-std", "os::windows-apis"] --license = "Apache-2.0 OR MIT" --repository = "https://github.com/MSxDOS/ntapi" --[package.metadata.docs.rs] --default-target = "x86_64-pc-windows-msvc" --features = ["beta"] --targets = ["aarch64-pc-windows-msvc", "i686-pc-windows-msvc", "x86_64-pc-windows-msvc"] --[dependencies.winapi] --version = "0.3.9" --features = ["cfg", "evntrace", "in6addr", "inaddr", "minwinbase", "ntsecapi", "windef", "winioctl"] -- --[features] --beta = [] --default = ["user"] --func-types = [] --impl-default = ["winapi/impl-default"] --kernel = [] --nightly = ["beta"] --user = [] -diff --git a/KubeOS-Rust/vendor/ntapi/LICENSE-APACHE b/KubeOS-Rust/vendor/ntapi/LICENSE-APACHE -deleted file mode 100644 -index e72929ee..00000000 ---- a/KubeOS-Rust/vendor/ntapi/LICENSE-APACHE -+++ /dev/null -@@ -1,202 +0,0 @@ -- Apache License -- Version 2.0, January 2004 -- http://www.apache.org/licenses/ -- -- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION -- -- 1. Definitions. -- -- "License" shall mean the terms and conditions for use, reproduction, -- and distribution as defined by Sections 1 through 9 of this document. -- -- "Licensor" shall mean the copyright owner or entity authorized by -- the copyright owner that is granting the License. -- -- "Legal Entity" shall mean the union of the acting entity and all -- other entities that control, are controlled by, or are under common -- control with that entity. For the purposes of this definition, -- "control" means (i) the power, direct or indirect, to cause the -- direction or management of such entity, whether by contract or -- otherwise, or (ii) ownership of fifty percent (50%) or more of the -- outstanding shares, or (iii) beneficial ownership of such entity. -- -- "You" (or "Your") shall mean an individual or Legal Entity -- exercising permissions granted by this License. -- -- "Source" form shall mean the preferred form for making modifications, -- including but not limited to software source code, documentation -- source, and configuration files. -- -- "Object" form shall mean any form resulting from mechanical -- transformation or translation of a Source form, including but -- not limited to compiled object code, generated documentation, -- and conversions to other media types. -- -- "Work" shall mean the work of authorship, whether in Source or -- Object form, made available under the License, as indicated by a -- copyright notice that is included in or attached to the work -- (an example is provided in the Appendix below). -- -- "Derivative Works" shall mean any work, whether in Source or Object -- form, that is based on (or derived from) the Work and for which the -- editorial revisions, annotations, elaborations, or other modifications -- represent, as a whole, an original work of authorship. For the purposes -- of this License, Derivative Works shall not include works that remain -- separable from, or merely link (or bind by name) to the interfaces of, -- the Work and Derivative Works thereof. -- -- "Contribution" shall mean any work of authorship, including -- the original version of the Work and any modifications or additions -- to that Work or Derivative Works thereof, that is intentionally -- submitted to Licensor for inclusion in the Work by the copyright owner -- or by an individual or Legal Entity authorized to submit on behalf of -- the copyright owner. For the purposes of this definition, "submitted" -- means any form of electronic, verbal, or written communication sent -- to the Licensor or its representatives, including but not limited to -- communication on electronic mailing lists, source code control systems, -- and issue tracking systems that are managed by, or on behalf of, the -- Licensor for the purpose of discussing and improving the Work, but -- excluding communication that is conspicuously marked or otherwise -- designated in writing by the copyright owner as "Not a Contribution." -- -- "Contributor" shall mean Licensor and any individual or Legal Entity -- on behalf of whom a Contribution has been received by Licensor and -- subsequently incorporated within the Work. -- -- 2. Grant of Copyright License. Subject to the terms and conditions of -- this License, each Contributor hereby grants to You a perpetual, -- worldwide, non-exclusive, no-charge, royalty-free, irrevocable -- copyright license to reproduce, prepare Derivative Works of, -- publicly display, publicly perform, sublicense, and distribute the -- Work and such Derivative Works in Source or Object form. -- -- 3. Grant of Patent License. Subject to the terms and conditions of -- this License, each Contributor hereby grants to You a perpetual, -- worldwide, non-exclusive, no-charge, royalty-free, irrevocable -- (except as stated in this section) patent license to make, have made, -- use, offer to sell, sell, import, and otherwise transfer the Work, -- where such license applies only to those patent claims licensable -- by such Contributor that are necessarily infringed by their -- Contribution(s) alone or by combination of their Contribution(s) -- with the Work to which such Contribution(s) was submitted. If You -- institute patent litigation against any entity (including a -- cross-claim or counterclaim in a lawsuit) alleging that the Work -- or a Contribution incorporated within the Work constitutes direct -- or contributory patent infringement, then any patent licenses -- granted to You under this License for that Work shall terminate -- as of the date such litigation is filed. -- -- 4. Redistribution. You may reproduce and distribute copies of the -- Work or Derivative Works thereof in any medium, with or without -- modifications, and in Source or Object form, provided that You -- meet the following conditions: -- -- (a) You must give any other recipients of the Work or -- Derivative Works a copy of this License; and -- -- (b) You must cause any modified files to carry prominent notices -- stating that You changed the files; and -- -- (c) You must retain, in the Source form of any Derivative Works -- that You distribute, all copyright, patent, trademark, and -- attribution notices from the Source form of the Work, -- excluding those notices that do not pertain to any part of -- the Derivative Works; and -- -- (d) If the Work includes a "NOTICE" text file as part of its -- distribution, then any Derivative Works that You distribute must -- include a readable copy of the attribution notices contained -- within such NOTICE file, excluding those notices that do not -- pertain to any part of the Derivative Works, in at least one -- of the following places: within a NOTICE text file distributed -- as part of the Derivative Works; within the Source form or -- documentation, if provided along with the Derivative Works; or, -- within a display generated by the Derivative Works, if and -- wherever such third-party notices normally appear. The contents -- of the NOTICE file are for informational purposes only and -- do not modify the License. You may add Your own attribution -- notices within Derivative Works that You distribute, alongside -- or as an addendum to the NOTICE text from the Work, provided -- that such additional attribution notices cannot be construed -- as modifying the License. -- -- You may add Your own copyright statement to Your modifications and -- may provide additional or different license terms and conditions -- for use, reproduction, or distribution of Your modifications, or -- for any such Derivative Works as a whole, provided Your use, -- reproduction, and distribution of the Work otherwise complies with -- the conditions stated in this License. -- -- 5. Submission of Contributions. Unless You explicitly state otherwise, -- any Contribution intentionally submitted for inclusion in the Work -- by You to the Licensor shall be under the terms and conditions of -- this License, without any additional terms or conditions. -- Notwithstanding the above, nothing herein shall supersede or modify -- the terms of any separate license agreement you may have executed -- with Licensor regarding such Contributions. -- -- 6. Trademarks. This License does not grant permission to use the trade -- names, trademarks, service marks, or product names of the Licensor, -- except as required for reasonable and customary use in describing the -- origin of the Work and reproducing the content of the NOTICE file. -- -- 7. Disclaimer of Warranty. Unless required by applicable law or -- agreed to in writing, Licensor provides the Work (and each -- Contributor provides its Contributions) on an "AS IS" BASIS, -- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -- implied, including, without limitation, any warranties or conditions -- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A -- PARTICULAR PURPOSE. You are solely responsible for determining the -- appropriateness of using or redistributing the Work and assume any -- risks associated with Your exercise of permissions under this License. -- -- 8. Limitation of Liability. In no event and under no legal theory, -- whether in tort (including negligence), contract, or otherwise, -- unless required by applicable law (such as deliberate and grossly -- negligent acts) or agreed to in writing, shall any Contributor be -- liable to You for damages, including any direct, indirect, special, -- incidental, or consequential damages of any character arising as a -- result of this License or out of the use or inability to use the -- Work (including but not limited to damages for loss of goodwill, -- work stoppage, computer failure or malfunction, or any and all -- other commercial damages or losses), even if such Contributor -- has been advised of the possibility of such damages. -- -- 9. Accepting Warranty or Additional Liability. While redistributing -- the Work or Derivative Works thereof, You may choose to offer, -- and charge a fee for, acceptance of support, warranty, indemnity, -- or other liability obligations and/or rights consistent with this -- License. However, in accepting such obligations, You may act only -- on Your own behalf and on Your sole responsibility, not on behalf -- of any other Contributor, and only if You agree to indemnify, -- defend, and hold each Contributor harmless for any liability -- incurred by, or claims asserted against, such Contributor by reason -- of your accepting any such warranty or additional liability. -- -- END OF TERMS AND CONDITIONS -- -- APPENDIX: How to apply the Apache License to your work. -- -- To apply the Apache License to your work, attach the following -- boilerplate notice, with the fields enclosed by brackets "[]" -- replaced with your own identifying information. (Don't include -- the brackets!) The text should be enclosed in the appropriate -- comment syntax for the file format. We also recommend that a -- file or class name and description of purpose be included on the -- same "printed page" as the copyright notice for easier -- identification within third-party archives. -- -- Copyright [yyyy] [name of copyright owner] -- -- Licensed under the Apache License, Version 2.0 (the "License"); -- you may not use this file except in compliance with the License. -- You may obtain a copy of the License at -- -- http://www.apache.org/licenses/LICENSE-2.0 -- -- Unless required by applicable law or agreed to in writing, software -- distributed under the License is distributed on an "AS IS" BASIS, -- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -- See the License for the specific language governing permissions and -- limitations under the License. -- -\ No newline at end of file -diff --git a/KubeOS-Rust/vendor/ntapi/LICENSE-MIT b/KubeOS-Rust/vendor/ntapi/LICENSE-MIT -deleted file mode 100644 -index 0235c6ac..00000000 ---- a/KubeOS-Rust/vendor/ntapi/LICENSE-MIT -+++ /dev/null -@@ -1,17 +0,0 @@ --Permission is hereby granted, free of charge, to any person obtaining a copy --of this software and associated documentation files (the "Software"),to deal --in the Software without restriction, including without limitation the rights --to use, copy, modify, merge, publish, distribute, sublicense, and/or sell --copies of the Software, and to permit persons to whom the Software is --furnished to do so, subject to the following conditions: -- --The above copyright notice and this permission notice shall be included in all --copies or substantial portions of the Software. -- --THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR --IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, --FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL --THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER --LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, --OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE --SOFTWARE. -diff --git a/KubeOS-Rust/vendor/ntapi/README.md b/KubeOS-Rust/vendor/ntapi/README.md -deleted file mode 100644 -index d438de3e..00000000 ---- a/KubeOS-Rust/vendor/ntapi/README.md -+++ /dev/null -@@ -1,17 +0,0 @@ --# ntapi [![AppVeyor][appveyor_badge]][appveyor_link] [![Crates.io][crates_badge]][crates_link] [![Documentation][docs_badge]][docs_link] [![Lines of Code][loc_badge]][loc_link] [![Unsafe][unsafe_badge]][unsafe_link] -- --Rust FFI bindings for Native API. Mostly based on Process Hacker [phnt](https://github.com/processhacker/processhacker/tree/master/phnt) headers as the most complete source of bindings to be found. The comments there also contain useful information on how to use specific things. -- --### Minimum supported Rust --Always the latest stable. Some [features][docs_link] require a beta compiler. -- --[appveyor_link]: https://ci.appveyor.com/project/MSxDOS/ntapi --[appveyor_badge]: https://ci.appveyor.com/api/projects/status/i1fcmm0c5b7c6b6u/branch/master?svg=true --[crates_link]: https://crates.io/crates/ntapi --[crates_badge]: https://img.shields.io/crates/v/ntapi.svg --[docs_link]: https://docs.rs/ntapi/*/x86_64-pc-windows-msvc/ntapi/ --[docs_badge]: https://docs.rs/ntapi/badge.svg --[loc_link]: https://github.com/Aaronepower/tokei --[loc_badge]: https://tokei.rs/b1/github/MSxDOS/ntapi --[unsafe_link]: https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html --[unsafe_badge]: https://img.shields.io/badge/unsafe-%E2%9C%94-C901DD.svg -diff --git a/KubeOS-Rust/vendor/ntapi/build.rs b/KubeOS-Rust/vendor/ntapi/build.rs -deleted file mode 100644 -index bbd46f59..00000000 ---- a/KubeOS-Rust/vendor/ntapi/build.rs -+++ /dev/null -@@ -1,15 +0,0 @@ --use std::env::var; -- --fn main() { -- #[cfg(feature = "user")] { -- if var("TARGET").map( -- |t| t == "x86_64-pc-windows-gnu" || t == "i686-pc-windows-gnu" -- ).unwrap_or(false) { -- if var("WINAPI_NO_BUNDLED_LIBRARIES").is_ok() { -- println!("cargo:rustc-link-lib=ntdll"); -- } else { -- println!("cargo:rustc-link-lib=winapi_ntdll"); -- } -- } -- } --} -diff --git a/KubeOS-Rust/vendor/ntapi/src/lib.rs b/KubeOS-Rust/vendor/ntapi/src/lib.rs -deleted file mode 100644 -index 6b06b6c5..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/lib.rs -+++ /dev/null -@@ -1,70 +0,0 @@ --//! # Features --//! **`func-types`** -- Generate [types][fn_ptr] for external functions.
--//! **`impl-default`** -- Implement [`Default`] for structs and unions.
--//! **`user`** *(default)* -- Link to `ntdll`.
--//! **`kernel`** -- Link to `ntoskrnl` on MSVC targets.
--//! **`beta`** -- Unlock unstable features that require a beta compiler: --//! - [`NtCurrentTeb`] --//! - [`__readfsdword`] --//! - [`__readgsqword`] --//! - [`_bittest64`] --//! - [`NtCurrentPeb`] --//! - [`NtCurrentProcessId`] --//! - [`NtCurrentThreadId`] --//! - [`RtlProcessHeap`] --//! - [`RtlCheckBit`] implementation using [`_bittest64`] on x86_64. --//! --//! [`NtCurrentTeb`]: winapi_local/um/winnt/fn.NtCurrentTeb.html --//! [`__readfsdword`]: winapi_local/um/winnt/fn.__readfsdword.html --//! [`__readgsqword`]: winapi_local/um/winnt/fn.__readgsqword.html --//! [`_bittest64`]: winapi_local/um/winnt/fn._bittest64.html --//! [`NtCurrentPeb`]: ntpsapi/fn.NtCurrentPeb.html --//! [`NtCurrentProcessId`]: ntpsapi/fn.NtCurrentProcessId.html --//! [`NtCurrentThreadId`]: ntpsapi/fn.NtCurrentThreadId.html --//! [`RtlProcessHeap`]: ntrtl/fn.RtlProcessHeap.html --//! [`RtlCheckBit`]: ntrtl/fn.RtlCheckBit.html --//! [fn_ptr]: https://doc.rust-lang.org/reference/types.html#function-pointer-types --//! [`Default`]: https://doc.rust-lang.org/std/default/trait.Default.html#tymethod.default --#![cfg(all(windows, any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64")))] --#![no_std] --#![deny(unused, unused_qualifications)] --#![warn(unused_attributes)] --#![allow(bad_style, deprecated, overflowing_literals, unused_macros, clippy::cast_lossless, clippy::cast_ptr_alignment, clippy::len_without_is_empty, clippy::trivially_copy_pass_by_ref, clippy::unreadable_literal)] --#[doc(hidden)] --pub extern crate core as _core; --#[macro_use] --#[doc(hidden)] --pub extern crate winapi; --#[macro_use] --mod macros; --pub mod ntapi_base; --pub mod ntdbg; --pub mod ntexapi; --pub mod ntgdi; --pub mod ntioapi; --pub mod ntkeapi; --pub mod ntldr; --pub mod ntlpcapi; --pub mod ntmisc; --pub mod ntmmapi; --pub mod ntnls; --pub mod ntobapi; --pub mod ntpebteb; --pub mod ntpfapi; --pub mod ntpnpapi; --pub mod ntpoapi; --pub mod ntpsapi; --pub mod ntregapi; --pub mod ntrtl; --pub mod ntsam; --pub mod ntseapi; --pub mod ntsmss; --pub mod nttmapi; --pub mod nttp; --pub mod ntwow64; --pub mod ntxcapi; --pub mod ntzwapi; --pub mod string; --pub mod subprocesstag; --pub mod winapi_local; --pub mod winsta; -diff --git a/KubeOS-Rust/vendor/ntapi/src/macros.rs b/KubeOS-Rust/vendor/ntapi/src/macros.rs -deleted file mode 100644 -index 92cdd967..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/macros.rs -+++ /dev/null -@@ -1,112 +0,0 @@ --#[macro_export] --macro_rules! EXTERN { -- (extern $c:tt {$( -- fn $n:ident ($( $p:tt $(: $t:ty)?),* $(,)?) $(-> $r:ty)?; -- )+}) => { -- #[cfg_attr(all(target_env = "msvc", feature = "user"), link(name = "ntdll"))] -- #[cfg_attr(all(target_env = "msvc", feature = "kernel"), link(name = "ntoskrnl"))] -- extern $c {$( -- pub fn $n( -- $($p $(: $t)?),* -- ) $(-> $r)?; -- )+} -- $( -- #[cfg(feature = "func-types")] -- pub type $n = unsafe extern $c fn($($p $(: $t)?),*) $(-> $r)?; -- )+ -- }; -- (extern $c:tt {$( -- static mut $n:ident : $t:ty; -- )+}) => { -- #[cfg_attr(all(target_env = "msvc", feature = "user"), link(name = "ntdll"))] -- extern $c {$( -- pub static mut $n: $t; -- )+} -- }; --} --#[macro_export] --#[doc(hidden)] --macro_rules! FIELD_OFFSET { -- ($_type:ty, $field:ident$(.$cfields:ident)*) => { -- unsafe { -- union Transmuter { -- p: *const T, -- r: &'static T, -- i: usize, -- } -- #[allow(unaligned_references)] -- Transmuter { -- r: &(&Transmuter { -- p: $crate::_core::ptr::null::<$_type>() -- }.r).$field$(.$cfields)* -- }.i -- } -- }; --} --macro_rules! BITFIELD { -- ($base:ident $field:ident: $fieldtype:ty [ -- $($thing:ident $set_thing:ident[$r:expr],)+ -- ]) => { -- impl $base {$( -- #[inline] -- pub const fn $thing(&self) -> $fieldtype { -- const SIZE: usize = $crate::_core::mem::size_of::<$fieldtype>() * 8; -- self.$field << (SIZE - $r.end) >> (SIZE - $r.end + $r.start) -- } -- #[inline] -- pub fn $set_thing(&mut self, val: $fieldtype) { -- const MASK: $fieldtype = ((1 << ($r.end - $r.start)) - 1) << $r.start; -- self.$field &= !MASK; -- self.$field |= (val << $r.start) & MASK; -- } -- )+} -- }; -- (unsafe $base:ident $field:ident: $fieldtype:ty [ -- $($thing:ident $set_thing:ident[$r:expr],)+ -- ]) => { -- impl $base {$( -- #[inline] -- pub unsafe fn $thing(&self) -> $fieldtype { -- const SIZE: usize = $crate::_core::mem::size_of::<$fieldtype>() * 8; -- self.$field << (SIZE - $r.end) >> (SIZE - $r.end + $r.start) -- } -- #[inline] -- pub unsafe fn $set_thing(&mut self, val: $fieldtype) { -- const MASK: $fieldtype = ((1 << ($r.end - $r.start)) - 1) << $r.start; -- self.$field &= !MASK; -- self.$field |= (val << $r.start) & MASK; -- } -- )+} -- }; --} --macro_rules! UNION { -- ($(#[$attrs:meta])* union $name:ident { -- $($variant:ident: $ftype:ty,)+ -- }) => ( -- #[repr(C)] $(#[$attrs])* -- pub union $name { -- $(pub $variant: $ftype,)+ -- } -- impl Copy for $name {} -- impl Clone for $name { -- #[inline] -- fn clone(&self) -> $name { *self } -- } -- #[cfg(feature = "impl-default")] -- impl Default for $name { -- #[inline] -- fn default() -> $name { unsafe { $crate::_core::mem::zeroed() } } -- } -- ); --} --macro_rules! FN { -- (stdcall $func:ident($($p:ident: $t:ty,)*) -> $ret:ty) => ( -- pub type $func = Option $ret>; -- ); -- (cdecl $func:ident($($p:ident: $t:ty,)*) -> $ret:ty) => ( -- pub type $func = Option $ret>; -- ); --} --macro_rules! IFDEF { -- ($($thing:item)*) => ($($thing)*) --} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntapi_base.rs b/KubeOS-Rust/vendor/ntapi/src/ntapi_base.rs -deleted file mode 100644 -index aa341af0..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntapi_base.rs -+++ /dev/null -@@ -1,40 +0,0 @@ --use winapi::shared::ntdef::{HANDLE, LONG, NTSTATUS, ULONG, ULONGLONG, USHORT}; --use winapi::shared::ntstatus::FACILITY_NTWIN32; --pub type KPRIORITY = LONG; --pub type RTL_ATOM = USHORT; --pub type PRTL_ATOM = *mut RTL_ATOM; --pub const NT_FACILITY_MASK: ULONG = 0xfff; --pub const NT_FACILITY_SHIFT: ULONG = 16; --#[inline] --pub const fn NT_FACILITY(Status: NTSTATUS) -> ULONG { -- (Status as u32) >> NT_FACILITY_SHIFT & NT_FACILITY_MASK --} --#[inline] --pub const fn NT_NTWIN32(Status: NTSTATUS) -> bool { -- NT_FACILITY(Status) == FACILITY_NTWIN32 as u32 --} --#[inline] --pub const fn WIN32_FROM_NTSTATUS(Status: NTSTATUS) -> ULONG { -- (Status as u32) & 0xffff --} --STRUCT!{struct CLIENT_ID { -- UniqueProcess: HANDLE, -- UniqueThread: HANDLE, --}} --pub type PCLIENT_ID = *mut CLIENT_ID; --STRUCT!{struct CLIENT_ID32 { -- UniqueProcess: ULONG, -- UniqueThread: ULONG, --}} --pub type PCLIENT_ID32 = *mut CLIENT_ID32; --STRUCT!{struct CLIENT_ID64 { -- UniqueProcess: ULONGLONG, -- UniqueThread: ULONGLONG, --}} --pub type PCLIENT_ID64 = *mut CLIENT_ID64; --STRUCT!{struct KSYSTEM_TIME { -- LowPart: ULONG, -- High1Time: LONG, -- High2Time: LONG, --}} --pub type PKSYSTEM_TIME = *mut KSYSTEM_TIME; -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntdbg.rs b/KubeOS-Rust/vendor/ntapi/src/ntdbg.rs -deleted file mode 100644 -index 991e8f9d..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntdbg.rs -+++ /dev/null -@@ -1,239 +0,0 @@ --use crate::ntapi_base::{CLIENT_ID, PCLIENT_ID}; --use winapi::shared::evntprov::EVENT_FILTER_DESCRIPTOR; --use winapi::shared::guiddef::LPCGUID; --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, NTSTATUS, PCCH, PCH, PCSTR, PHANDLE, PLARGE_INTEGER, POBJECT_ATTRIBUTES, -- PULONG, PVOID, UCHAR, ULONG, ULONGLONG, --}; --use winapi::um::minwinbase::LPDEBUG_EVENT; --use winapi::um::winnt::{ACCESS_MASK, EXCEPTION_RECORD, STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE}; --use winapi::vc::vadefs::va_list; --EXTERN!{extern "system" { -- fn DbgUserBreakPoint(); -- fn DbgBreakPoint(); -- fn DbgBreakPointWithStatus( -- Status: ULONG, -- ); --}} --pub const DBG_STATUS_CONTROL_C: u32 = 1; --pub const DBG_STATUS_SYSRQ: u32 = 2; --pub const DBG_STATUS_BUGCHECK_FIRST: u32 = 3; --pub const DBG_STATUS_BUGCHECK_SECOND: u32 = 4; --pub const DBG_STATUS_FATAL: u32 = 5; --pub const DBG_STATUS_DEBUG_CONTROL: u32 = 6; --pub const DBG_STATUS_WORKER: u32 = 7; --EXTERN!{extern "C" { -- fn DbgPrint( -- Format: PCSTR, -- ... -- ) -> ULONG; -- fn DbgPrintEx( -- ComponentId: ULONG, -- Level: ULONG, -- Format: PCSTR, -- ... -- ) -> ULONG; --}} --EXTERN!{extern "system" { -- fn vDbgPrintEx( -- ComponentId: ULONG, -- Level: ULONG, -- Format: PCCH, -- arglist: va_list, -- ) -> ULONG; -- fn vDbgPrintExWithPrefix( -- Prefix: PCH, -- ComponentId: ULONG, -- Level: ULONG, -- Format: PCCH, -- arglist: va_list, -- ) -> ULONG; -- fn DbgQueryDebugFilterState( -- ComponentId: ULONG, -- Level: ULONG, -- ) -> NTSTATUS; -- fn DbgSetDebugFilterState( -- ComponentId: ULONG, -- Level: ULONG, -- State: BOOLEAN, -- ) -> NTSTATUS; -- fn DbgPrompt( -- Prompt: PCCH, -- Response: PCH, -- Length: ULONG, -- ) -> ULONG; --}} --STRUCT!{struct DBGKM_EXCEPTION { -- ExceptionRecord: EXCEPTION_RECORD, -- FirstChance: ULONG, --}} --pub type PDBGKM_EXCEPTION = *mut DBGKM_EXCEPTION; --STRUCT!{struct DBGKM_CREATE_THREAD { -- SubSystemKey: ULONG, -- StartAddress: PVOID, --}} --pub type PDBGKM_CREATE_THREAD = *mut DBGKM_CREATE_THREAD; --STRUCT!{struct DBGKM_CREATE_PROCESS { -- SubSystemKey: ULONG, -- FileHandle: HANDLE, -- BaseOfImage: PVOID, -- DebugInfoFileOffset: ULONG, -- DebugInfoSize: ULONG, -- InitialThread: DBGKM_CREATE_THREAD, --}} --pub type PDBGKM_CREATE_PROCESS = *mut DBGKM_CREATE_PROCESS; --STRUCT!{struct DBGKM_EXIT_THREAD { -- ExitStatus: NTSTATUS, --}} --pub type PDBGKM_EXIT_THREAD = *mut DBGKM_EXIT_THREAD; --STRUCT!{struct DBGKM_EXIT_PROCESS { -- ExitStatus: NTSTATUS, --}} --pub type PDBGKM_EXIT_PROCESS = *mut DBGKM_EXIT_PROCESS; --STRUCT!{struct DBGKM_LOAD_DLL { -- FileHandle: HANDLE, -- BaseOfDll: PVOID, -- DebugInfoFileOffset: ULONG, -- DebugInfoSize: ULONG, -- NamePointer: PVOID, --}} --pub type PDBGKM_LOAD_DLL = *mut DBGKM_LOAD_DLL; --STRUCT!{struct DBGKM_UNLOAD_DLL { -- BaseAddress: PVOID, --}} --pub type PDBGKM_UNLOAD_DLL = *mut DBGKM_UNLOAD_DLL; --ENUM!{enum DBG_STATE { -- DbgIdle = 0, -- DbgReplyPending = 1, -- DbgCreateThreadStateChange = 2, -- DbgCreateProcessStateChange = 3, -- DbgExitThreadStateChange = 4, -- DbgExitProcessStateChange = 5, -- DbgExceptionStateChange = 6, -- DbgBreakpointStateChange = 7, -- DbgSingleStepStateChange = 8, -- DbgLoadDllStateChange = 9, -- DbgUnloadDllStateChange = 10, --}} --pub type PDBG_STATE = *mut DBG_STATE; --STRUCT!{struct DBGUI_CREATE_THREAD { -- HandleToThread: HANDLE, -- NewThread: DBGKM_CREATE_THREAD, --}} --pub type PDBGUI_CREATE_THREAD = *mut DBGUI_CREATE_THREAD; --STRUCT!{struct DBGUI_CREATE_PROCESS { -- HandleToProcess: HANDLE, -- HandleToThread: HANDLE, -- NewProcess: DBGKM_CREATE_PROCESS, --}} --UNION!{union DBGUI_WAIT_STATE_CHANGE_StateInfo { -- Exception: DBGKM_EXCEPTION, -- CreateThread: DBGUI_CREATE_THREAD, -- CreateProcessInfo: DBGUI_CREATE_PROCESS, -- ExitThread: DBGKM_EXIT_THREAD, -- ExitProcess: DBGKM_EXIT_PROCESS, -- LoadDll: DBGKM_LOAD_DLL, -- UnloadDll: DBGKM_UNLOAD_DLL, --}} --pub type PDBGUI_CREATE_PROCESS = *mut DBGUI_CREATE_PROCESS; --STRUCT!{struct DBGUI_WAIT_STATE_CHANGE { -- NewState: DBG_STATE, -- AppClientId: CLIENT_ID, -- StateInfo: DBGUI_WAIT_STATE_CHANGE_StateInfo, --}} --pub type PDBGUI_WAIT_STATE_CHANGE = *mut DBGUI_WAIT_STATE_CHANGE; --pub const DEBUG_READ_EVENT: ULONG = 0x0001; --pub const DEBUG_PROCESS_ASSIGN: ULONG = 0x0002; --pub const DEBUG_SET_INFORMATION: ULONG = 0x0004; --pub const DEBUG_QUERY_INFORMATION: ULONG = 0x0008; --pub const DEBUG_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | DEBUG_READ_EVENT -- | DEBUG_PROCESS_ASSIGN | DEBUG_SET_INFORMATION | DEBUG_QUERY_INFORMATION; --pub const DEBUG_KILL_ON_CLOSE: u32 = 0x1; --ENUM!{enum DEBUGOBJECTINFOCLASS { -- DebugObjectUnusedInformation = 0, -- DebugObjectKillProcessOnExitInformation = 1, -- MaxDebugObjectInfoClass = 2, --}} --pub type PDEBUGOBJECTINFOCLASS = *mut DEBUGOBJECTINFOCLASS; --EXTERN!{extern "system" { -- fn NtCreateDebugObject( -- DebugObjectHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtDebugActiveProcess( -- ProcessHandle: HANDLE, -- DebugObjectHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtDebugContinue( -- DebugObjectHandle: HANDLE, -- ClientId: PCLIENT_ID, -- ContinueStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn NtRemoveProcessDebug( -- ProcessHandle: HANDLE, -- DebugObjectHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtSetInformationDebugObject( -- DebugObjectHandle: HANDLE, -- DebugObjectInformationClass: DEBUGOBJECTINFOCLASS, -- DebugInformation: PVOID, -- DebugInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtWaitForDebugEvent( -- DebugObjectHandle: HANDLE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- WaitStateChange: PVOID, -- ) -> NTSTATUS; -- fn DbgUiConnectToDbg() -> NTSTATUS; -- fn DbgUiGetThreadDebugObject() -> HANDLE; -- fn DbgUiSetThreadDebugObject( -- DebugObject: HANDLE, -- ); -- fn DbgUiWaitStateChange( -- StateChange: PDBGUI_WAIT_STATE_CHANGE, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn DbgUiContinue( -- AppClientId: PCLIENT_ID, -- ContinueStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn DbgUiStopDebugging( -- Process: HANDLE, -- ) -> NTSTATUS; -- fn DbgUiDebugActiveProcess( -- Process: HANDLE, -- ) -> NTSTATUS; -- fn DbgUiRemoteBreakin( -- Context: PVOID, -- ); -- fn DbgUiIssueRemoteBreakin( -- Process: HANDLE, -- ) -> NTSTATUS; -- fn DbgUiConvertStateChangeStructure( -- StateChange: PDBGUI_WAIT_STATE_CHANGE, -- DebugEvent: LPDEBUG_EVENT, -- ) -> NTSTATUS; --}} --FN!{stdcall PENABLECALLBACK( -- SourceId: LPCGUID, -- IsEnabled: ULONG, -- Level: UCHAR, -- MatchAnyKeyword: ULONGLONG, -- MatchAllKeyword: ULONGLONG, -- FilterData: *mut EVENT_FILTER_DESCRIPTOR, -- CallbackContext: PVOID, --) -> ()} --pub type REGHANDLE = ULONGLONG; --pub type PREGHANDLE = *mut ULONGLONG; --EXTERN!{extern "system" { -- fn EtwEventRegister( -- ProviderId: LPCGUID, -- EnableCallback: PENABLECALLBACK, -- CallbackContext: PVOID, -- RegHandle: PREGHANDLE, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntexapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntexapi.rs -deleted file mode 100644 -index 5fa47c91..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntexapi.rs -+++ /dev/null -@@ -1,2998 +0,0 @@ --use core::mem::uninitialized; --use core::ptr::read_volatile; --#[cfg(target_arch = "x86")] --use core::sync::atomic::spin_loop_hint; --use crate::ntapi_base::{CLIENT_ID, KPRIORITY, KSYSTEM_TIME, PRTL_ATOM, RTL_ATOM}; --use crate::ntioapi::{BUS_DATA_TYPE, FILE_IO_COMPLETION_INFORMATION, INTERFACE_TYPE}; --use crate::ntkeapi::{KPROFILE_SOURCE, KTHREAD_STATE, KWAIT_REASON}; --use crate::ntldr::RTL_PROCESS_MODULE_INFORMATION_EX; --use crate::ntpebteb::PTEB; --use crate::ntpoapi::COUNTED_REASON_CONTEXT; --use winapi::shared::basetsd::{KAFFINITY, PULONG64, PULONG_PTR, SIZE_T, ULONG64, ULONG_PTR}; --use winapi::shared::evntrace::PROFILE_SOURCE_INFO; --use winapi::shared::guiddef::{GUID, LPGUID}; --use winapi::shared::ntdef::{ -- BOOLEAN, CCHAR, EVENT_TYPE, HANDLE, LANGID, LARGE_INTEGER, LCID, LOGICAL, LONG, LONGLONG, -- NTSTATUS, NT_PRODUCT_TYPE, PBOOLEAN, PCHAR, PCWNF_STATE_NAME, PGROUP_AFFINITY, PHANDLE, -- PHYSICAL_ADDRESS, PLARGE_INTEGER, PLCID, PLONG, PLUID, POBJECT_ATTRIBUTES, PUCHAR, -- PULARGE_INTEGER, PULONG, PUNICODE_STRING, PUSHORT, PVOID, PWNF_STATE_NAME, PWSTR, TIMER_TYPE, -- UCHAR, ULARGE_INTEGER, ULONG, ULONGLONG, UNICODE_STRING, USHORT, VOID, WCHAR, WNF_STATE_NAME, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, ANYSIZE_ARRAY, FIRMWARE_TYPE, GENERIC_MAPPING, PSECURITY_DESCRIPTOR, -- STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE, XSTATE_CONFIGURATION, --}; --use crate::winapi_local::um::winnt::UInt32x32To64; --EXTERN!{extern "system" { -- fn NtDelayExecution( -- Alertable: BOOLEAN, -- DelayInterval: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtQuerySystemEnvironmentValue( -- VariableName: PUNICODE_STRING, -- VariableValue: PWSTR, -- ValueLength: USHORT, -- ReturnLength: PUSHORT, -- ) -> NTSTATUS; -- fn NtSetSystemEnvironmentValue( -- VariableName: PUNICODE_STRING, -- VariableValue: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn NtQuerySystemEnvironmentValueEx( -- VariableName: PUNICODE_STRING, -- VendorGuid: LPGUID, -- Value: PVOID, -- ValueLength: PULONG, -- Attributes: PULONG, -- ) -> NTSTATUS; -- fn NtSetSystemEnvironmentValueEx( -- VariableName: PUNICODE_STRING, -- VendorGuid: LPGUID, -- Value: PVOID, -- ValueLength: ULONG, -- Attributes: ULONG, -- ) -> NTSTATUS; -- fn NtEnumerateSystemEnvironmentValuesEx( -- InformationClass: ULONG, -- Buffer: PVOID, -- BufferLength: PULONG, -- ) -> NTSTATUS; --}} --STRUCT!{struct BOOT_ENTRY { -- Version: ULONG, -- Length: ULONG, -- Id: ULONG, -- Attributes: ULONG, -- FriendlyNameOffset: ULONG, -- BootFilePathOffset: ULONG, -- OsOptionsLength: ULONG, -- OsOptions: [UCHAR; 1], --}} --pub type PBOOT_ENTRY = *mut BOOT_ENTRY; --STRUCT!{struct BOOT_ENTRY_LIST { -- NextEntryOffset: ULONG, -- BootEntry: BOOT_ENTRY, --}} --pub type PBOOT_ENTRY_LIST = *mut BOOT_ENTRY_LIST; --STRUCT!{struct BOOT_OPTIONS { -- Version: ULONG, -- Length: ULONG, -- Timeout: ULONG, -- CurrentBootEntryId: ULONG, -- NextBootEntryId: ULONG, -- HeadlessRedirection: [WCHAR; 1], --}} --pub type PBOOT_OPTIONS = *mut BOOT_OPTIONS; --STRUCT!{struct FILE_PATH { -- Version: ULONG, -- Length: ULONG, -- Type: ULONG, -- FilePath: [UCHAR; 1], --}} --pub type PFILE_PATH = *mut FILE_PATH; --STRUCT!{struct EFI_DRIVER_ENTRY { -- Version: ULONG, -- Length: ULONG, -- Id: ULONG, -- FriendlyNameOffset: ULONG, -- DriverFilePathOffset: ULONG, --}} --pub type PEFI_DRIVER_ENTRY = *mut EFI_DRIVER_ENTRY; --STRUCT!{struct EFI_DRIVER_ENTRY_LIST { -- NextEntryOffset: ULONG, -- DriverEntry: EFI_DRIVER_ENTRY, --}} --pub type PEFI_DRIVER_ENTRY_LIST = *mut EFI_DRIVER_ENTRY_LIST; --EXTERN!{extern "system" { -- fn NtAddBootEntry( -- BootEntry: PBOOT_ENTRY, -- Id: PULONG, -- ) -> NTSTATUS; -- fn NtDeleteBootEntry( -- Id: ULONG, -- ) -> NTSTATUS; -- fn NtModifyBootEntry( -- BootEntry: PBOOT_ENTRY, -- ) -> NTSTATUS; -- fn NtEnumerateBootEntries( -- Buffer: PVOID, -- BufferLength: PULONG, -- ) -> NTSTATUS; -- fn NtQueryBootEntryOrder( -- Ids: PULONG, -- Count: PULONG, -- ) -> NTSTATUS; -- fn NtSetBootEntryOrder( -- Ids: PULONG, -- Count: ULONG, -- ) -> NTSTATUS; -- fn NtQueryBootOptions( -- BootOptions: PBOOT_OPTIONS, -- BootOptionsLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetBootOptions( -- BootOptions: PBOOT_OPTIONS, -- FieldsToChange: ULONG, -- ) -> NTSTATUS; -- fn NtTranslateFilePath( -- InputFilePath: PFILE_PATH, -- OutputType: ULONG, -- OutputFilePath: PFILE_PATH, -- OutputFilePathLength: PULONG, -- ) -> NTSTATUS; -- fn NtAddDriverEntry( -- DriverEntry: PEFI_DRIVER_ENTRY, -- Id: PULONG, -- ) -> NTSTATUS; -- fn NtDeleteDriverEntry( -- Id: ULONG, -- ) -> NTSTATUS; -- fn NtModifyDriverEntry( -- DriverEntry: PEFI_DRIVER_ENTRY, -- ) -> NTSTATUS; -- fn NtEnumerateDriverEntries( -- Buffer: PVOID, -- BufferLength: PULONG, -- ) -> NTSTATUS; -- fn NtQueryDriverEntryOrder( -- Ids: PULONG, -- Count: PULONG, -- ) -> NTSTATUS; -- fn NtSetDriverEntryOrder( -- Ids: PULONG, -- Count: ULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum FILTER_BOOT_OPTION_OPERATION { -- FilterBootOptionOperationOpenSystemStore = 0, -- FilterBootOptionOperationSetElement = 1, -- FilterBootOptionOperationDeleteElement = 2, -- FilterBootOptionOperationMax = 3, --}} --EXTERN!{extern "system" { -- fn NtFilterBootOption( -- FilterOperation: FILTER_BOOT_OPTION_OPERATION, -- ObjectType: ULONG, -- ElementType: ULONG, -- Data: PVOID, -- DataSize: ULONG, -- ) -> NTSTATUS; --}} --pub const EVENT_QUERY_STATE: u32 = 0x0001; --ENUM!{enum EVENT_INFORMATION_CLASS { -- EventBasicInformation = 0, --}} --STRUCT!{struct EVENT_BASIC_INFORMATION { -- EventType: EVENT_TYPE, -- EventState: LONG, --}} --pub type PEVENT_BASIC_INFORMATION = *mut EVENT_BASIC_INFORMATION; --EXTERN!{extern "system" { -- fn NtCreateEvent( -- EventHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- EventType: EVENT_TYPE, -- InitialState: BOOLEAN, -- ) -> NTSTATUS; -- fn NtOpenEvent( -- EventHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtSetEvent( -- EventHandle: HANDLE, -- PreviousState: PLONG, -- ) -> NTSTATUS; -- fn NtSetEventBoostPriority( -- EventHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtClearEvent( -- EventHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtResetEvent( -- EventHandle: HANDLE, -- PreviousState: PLONG, -- ) -> NTSTATUS; -- fn NtPulseEvent( -- EventHandle: HANDLE, -- PreviousState: PLONG, -- ) -> NTSTATUS; -- fn NtQueryEvent( -- EventHandle: HANDLE, -- EventInformationClass: EVENT_INFORMATION_CLASS, -- EventInformation: PVOID, -- EventInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} --pub const EVENT_PAIR_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE; --EXTERN!{extern "system" { -- fn NtCreateEventPair( -- EventPairHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtOpenEventPair( -- EventPairHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtSetLowEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtSetHighEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtWaitLowEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtWaitHighEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtSetLowWaitHighEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtSetHighWaitLowEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; --}} --ENUM!{enum MUTANT_INFORMATION_CLASS { -- MutantBasicInformation = 0, -- MutantOwnerInformation = 1, --}} --STRUCT!{struct MUTANT_BASIC_INFORMATION { -- CurrentCount: LONG, -- OwnedByCaller: BOOLEAN, -- AbandonedState: BOOLEAN, --}} --pub type PMUTANT_BASIC_INFORMATION = *mut MUTANT_BASIC_INFORMATION; --STRUCT!{struct MUTANT_OWNER_INFORMATION { -- ClientId: CLIENT_ID, --}} --pub type PMUTANT_OWNER_INFORMATION = *mut MUTANT_OWNER_INFORMATION; --EXTERN!{extern "system" { -- fn NtCreateMutant( -- MutantHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- InitialOwner: BOOLEAN, -- ) -> NTSTATUS; -- fn NtOpenMutant( -- MutantHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtReleaseMutant( -- MutantHandle: HANDLE, -- PreviousCount: PLONG, -- ) -> NTSTATUS; -- fn NtQueryMutant( -- MutantHandle: HANDLE, -- MutantInformationClass: MUTANT_INFORMATION_CLASS, -- MutantInformation: PVOID, -- MutantInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} --pub const SEMAPHORE_QUERY_STATE: u32 = 0x0001; --ENUM!{enum SEMAPHORE_INFORMATION_CLASS { -- SemaphoreBasicInformation = 0, --}} --STRUCT!{struct SEMAPHORE_BASIC_INFORMATION { -- CurrentCount: LONG, -- MaximumCount: LONG, --}} --pub type PSEMAPHORE_BASIC_INFORMATION = *mut SEMAPHORE_BASIC_INFORMATION; --EXTERN!{extern "system" { -- fn NtCreateSemaphore( -- SemaphoreHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- InitialCount: LONG, -- MaximumCount: LONG, -- ) -> NTSTATUS; -- fn NtOpenSemaphore( -- SemaphoreHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtReleaseSemaphore( -- SemaphoreHandle: HANDLE, -- ReleaseCount: LONG, -- PreviousCount: PLONG, -- ) -> NTSTATUS; -- fn NtQuerySemaphore( -- SemaphoreHandle: HANDLE, -- SemaphoreInformationClass: SEMAPHORE_INFORMATION_CLASS, -- SemaphoreInformation: PVOID, -- SemaphoreInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum TIMER_INFORMATION_CLASS { -- TimerBasicInformation = 0, --}} --STRUCT!{struct TIMER_BASIC_INFORMATION { -- RemainingTime: LARGE_INTEGER, -- TimerState: BOOLEAN, --}} --pub type PTIMER_BASIC_INFORMATION = *mut TIMER_BASIC_INFORMATION; --FN!{stdcall PTIMER_APC_ROUTINE( -- TimerContext: PVOID, -- TimerLowValue: ULONG, -- TimerHighValue: LONG, --) -> ()} --ENUM!{enum TIMER_SET_INFORMATION_CLASS { -- TimerSetCoalescableTimer = 0, -- MaxTimerInfoClass = 1, --}} --STRUCT!{struct TIMER_SET_COALESCABLE_TIMER_INFO { -- DueTime: LARGE_INTEGER, -- TimerApcRoutine: PTIMER_APC_ROUTINE, -- TimerContext: PVOID, -- WakeContext: *mut COUNTED_REASON_CONTEXT, -- Period: ULONG, -- TolerableDelay: ULONG, -- PreviousState: PBOOLEAN, --}} --pub type PTIMER_SET_COALESCABLE_TIMER_INFO = *mut TIMER_SET_COALESCABLE_TIMER_INFO; --EXTERN!{extern "system" { -- fn NtCreateTimer( -- TimerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TimerType: TIMER_TYPE, -- ) -> NTSTATUS; -- fn NtOpenTimer( -- TimerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtSetTimer( -- TimerHandle: HANDLE, -- DueTime: PLARGE_INTEGER, -- TimerApcRoutine: PTIMER_APC_ROUTINE, -- TimerContext: PVOID, -- ResumeTimer: BOOLEAN, -- Period: LONG, -- PreviousState: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtSetTimerEx( -- TimerHandle: HANDLE, -- TimerSetInformationClass: TIMER_SET_INFORMATION_CLASS, -- TimerSetInformation: PVOID, -- TimerSetInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtCancelTimer( -- TimerHandle: HANDLE, -- CurrentState: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtQueryTimer( -- TimerHandle: HANDLE, -- TimerInformationClass: TIMER_INFORMATION_CLASS, -- TimerInformation: PVOID, -- TimerInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtCreateIRTimer( -- TimerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ) -> NTSTATUS; -- fn NtSetIRTimer( -- TimerHandle: HANDLE, -- DueTime: PLARGE_INTEGER, -- ) -> NTSTATUS; --}} --STRUCT!{struct T2_SET_PARAMETERS { -- Version: ULONG, -- Reserved: ULONG, -- NoWakeTolerance: LONGLONG, --}} --pub type PT2_SET_PARAMETERS = *mut T2_SET_PARAMETERS; --pub type PT2_CANCEL_PARAMETERS = PVOID; --EXTERN!{extern "system" { -- fn NtCreateTimer2( -- TimerHandle: PHANDLE, -- Reserved1: PVOID, -- Reserved2: PVOID, -- Attributes: ULONG, -- DesiredAccess: ACCESS_MASK, -- ) -> NTSTATUS; -- fn NtSetTimer2( -- TimerHandle: HANDLE, -- DueTime: PLARGE_INTEGER, -- Period: PLARGE_INTEGER, -- Parameters: PT2_SET_PARAMETERS, -- ) -> NTSTATUS; -- fn NtCancelTimer2( -- TimerHandle: HANDLE, -- Parameters: PT2_CANCEL_PARAMETERS, -- ) -> NTSTATUS; --}} --pub const PROFILE_CONTROL: u32 = 0x0001; --pub const PROFILE_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | PROFILE_CONTROL; --EXTERN!{extern "system" { -- fn NtCreateProfile( -- ProfileHandle: PHANDLE, -- Process: HANDLE, -- ProfileBase: PVOID, -- ProfileSize: SIZE_T, -- BucketSize: ULONG, -- Buffer: PULONG, -- BufferSize: ULONG, -- ProfileSource: KPROFILE_SOURCE, -- Affinity: KAFFINITY, -- ) -> NTSTATUS; -- fn NtCreateProfileEx( -- ProfileHandle: PHANDLE, -- Process: HANDLE, -- ProfileBase: PVOID, -- ProfileSize: SIZE_T, -- BucketSize: ULONG, -- Buffer: PULONG, -- BufferSize: ULONG, -- ProfileSource: KPROFILE_SOURCE, -- GroupCount: USHORT, -- GroupAffinity: PGROUP_AFFINITY, -- ) -> NTSTATUS; -- fn NtStartProfile( -- ProfileHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtStopProfile( -- ProfileHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtQueryIntervalProfile( -- ProfileSource: KPROFILE_SOURCE, -- Interval: PULONG, -- ) -> NTSTATUS; -- fn NtSetIntervalProfile( -- Interval: ULONG, -- Source: KPROFILE_SOURCE, -- ) -> NTSTATUS; --}} --pub const KEYEDEVENT_WAIT: ULONG = 0x0001; --pub const KEYEDEVENT_WAKE: ULONG = 0x0002; --pub const KEYEDEVENT_ALL_ACCESS: ACCESS_MASK = -- STANDARD_RIGHTS_REQUIRED | KEYEDEVENT_WAIT | KEYEDEVENT_WAKE; --EXTERN!{extern "system" { -- fn NtCreateKeyedEvent( -- KeyedEventHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtOpenKeyedEvent( -- KeyedEventHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtReleaseKeyedEvent( -- KeyedEventHandle: HANDLE, -- KeyValue: PVOID, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtWaitForKeyedEvent( -- KeyedEventHandle: HANDLE, -- KeyValue: PVOID, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtUmsThreadYield( -- SchedulerParam: PVOID, -- ) -> NTSTATUS; --}} --ENUM!{enum WNF_STATE_NAME_LIFETIME { -- WnfWellKnownStateName = 0, -- WnfPermanentStateName = 1, -- WnfPersistentStateName = 2, -- WnfTemporaryStateName = 3, --}} --ENUM!{enum WNF_STATE_NAME_INFORMATION { -- WnfInfoStateNameExist = 0, -- WnfInfoSubscribersPresent = 1, -- WnfInfoIsQuiescent = 2, --}} --ENUM!{enum WNF_DATA_SCOPE { -- WnfDataScopeSystem = 0, -- WnfDataScopeSession = 1, -- WnfDataScopeUser = 2, -- WnfDataScopeProcess = 3, -- WnfDataScopeMachine = 4, --}} --STRUCT!{struct WNF_TYPE_ID { -- TypeId: GUID, --}} --pub type PWNF_TYPE_ID = *mut WNF_TYPE_ID; --pub type PCWNF_TYPE_ID = *const WNF_TYPE_ID; --pub type PWNF_CHANGE_STAMP = *mut ULONG; --pub type WNF_CHANGE_STAMP = ULONG; --STRUCT!{struct WNF_DELIVERY_DESCRIPTOR { -- SubscriptionId: ULONGLONG, -- StateName: WNF_STATE_NAME, -- ChangeStamp: WNF_CHANGE_STAMP, -- StateDataSize: ULONG, -- EventMask: ULONG, -- TypeId: WNF_TYPE_ID, -- StateDataOffset: ULONG, --}} --pub type PWNF_DELIVERY_DESCRIPTOR = *mut WNF_DELIVERY_DESCRIPTOR; --EXTERN!{extern "system" { -- fn NtCreateWnfStateName( -- StateName: PWNF_STATE_NAME, -- NameLifetime: WNF_STATE_NAME_LIFETIME, -- DataScope: WNF_DATA_SCOPE, -- PersistData: BOOLEAN, -- TypeId: PCWNF_TYPE_ID, -- MaximumStateSize: ULONG, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ) -> NTSTATUS; -- fn NtDeleteWnfStateName( -- StateName: PCWNF_STATE_NAME, -- ) -> NTSTATUS; -- fn NtUpdateWnfStateData( -- StateName: PCWNF_STATE_NAME, -- Buffer: *const VOID, -- Length: ULONG, -- TypeId: PCWNF_TYPE_ID, -- ExplicitScope: *const VOID, -- MatchingChangeStamp: WNF_CHANGE_STAMP, -- CheckStamp: LOGICAL, -- ) -> NTSTATUS; -- fn NtDeleteWnfStateData( -- StateName: PCWNF_STATE_NAME, -- ExplicitScope: *const VOID, -- ) -> NTSTATUS; -- fn NtQueryWnfStateData( -- StateName: PCWNF_STATE_NAME, -- TypeId: PCWNF_TYPE_ID, -- ExplicitScope: *const VOID, -- ChangeStamp: PWNF_CHANGE_STAMP, -- Buffer: PVOID, -- BufferSize: PULONG, -- ) -> NTSTATUS; -- fn NtQueryWnfStateNameInformation( -- StateName: PCWNF_STATE_NAME, -- NameInfoClass: WNF_STATE_NAME_INFORMATION, -- ExplicitScope: *const VOID, -- InfoBuffer: PVOID, -- InfoBufferSize: ULONG, -- ) -> NTSTATUS; -- fn NtSubscribeWnfStateChange( -- StateName: PCWNF_STATE_NAME, -- ChangeStamp: WNF_CHANGE_STAMP, -- EventMask: ULONG, -- SubscriptionId: PULONG64, -- ) -> NTSTATUS; -- fn NtUnsubscribeWnfStateChange( -- StateName: PCWNF_STATE_NAME, -- ) -> NTSTATUS; -- fn NtGetCompleteWnfStateSubscription( -- OldDescriptorStateName: PWNF_STATE_NAME, -- OldSubscriptionId: *mut ULONG64, -- OldDescriptorEventMask: ULONG, -- OldDescriptorStatus: ULONG, -- NewDeliveryDescriptor: PWNF_DELIVERY_DESCRIPTOR, -- DescriptorSize: ULONG, -- ) -> NTSTATUS; -- fn NtSetWnfProcessNotificationEvent( -- NotificationEvent: HANDLE, -- ) -> NTSTATUS; --}} --pub const WORKER_FACTORY_RELEASE_WORKER: u32 = 0x0001; --pub const WORKER_FACTORY_WAIT: u32 = 0x0002; --pub const WORKER_FACTORY_SET_INFORMATION: u32 = 0x0004; --pub const WORKER_FACTORY_QUERY_INFORMATION: u32 = 0x0008; --pub const WORKER_FACTORY_READY_WORKER: u32 = 0x0010; --pub const WORKER_FACTORY_SHUTDOWN: u32 = 0x0020; --pub const WORKER_FACTORY_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED -- | WORKER_FACTORY_RELEASE_WORKER | WORKER_FACTORY_WAIT | WORKER_FACTORY_SET_INFORMATION -- | WORKER_FACTORY_QUERY_INFORMATION | WORKER_FACTORY_READY_WORKER | WORKER_FACTORY_SHUTDOWN; --ENUM!{enum WORKERFACTORYINFOCLASS { -- WorkerFactoryTimeout = 0, -- WorkerFactoryRetryTimeout = 1, -- WorkerFactoryIdleTimeout = 2, -- WorkerFactoryBindingCount = 3, -- WorkerFactoryThreadMinimum = 4, -- WorkerFactoryThreadMaximum = 5, -- WorkerFactoryPaused = 6, -- WorkerFactoryBasicInformation = 7, -- WorkerFactoryAdjustThreadGoal = 8, -- WorkerFactoryCallbackType = 9, -- WorkerFactoryStackInformation = 10, -- WorkerFactoryThreadBasePriority = 11, -- WorkerFactoryTimeoutWaiters = 12, -- WorkerFactoryFlags = 13, -- WorkerFactoryThreadSoftMaximum = 14, -- MaxWorkerFactoryInfoClass = 15, --}} --pub type PWORKERFACTORYINFOCLASS = *mut WORKERFACTORYINFOCLASS; --STRUCT!{struct WORKER_FACTORY_BASIC_INFORMATION { -- Timeout: LARGE_INTEGER, -- RetryTimeout: LARGE_INTEGER, -- IdleTimeout: LARGE_INTEGER, -- Paused: BOOLEAN, -- TimerSet: BOOLEAN, -- QueuedToExWorker: BOOLEAN, -- MayCreate: BOOLEAN, -- CreateInProgress: BOOLEAN, -- InsertedIntoQueue: BOOLEAN, -- Shutdown: BOOLEAN, -- BindingCount: ULONG, -- ThreadMinimum: ULONG, -- ThreadMaximum: ULONG, -- PendingWorkerCount: ULONG, -- WaitingWorkerCount: ULONG, -- TotalWorkerCount: ULONG, -- ReleaseCount: ULONG, -- InfiniteWaitGoal: LONGLONG, -- StartRoutine: PVOID, -- StartParameter: PVOID, -- ProcessId: HANDLE, -- StackReserve: SIZE_T, -- StackCommit: SIZE_T, -- LastThreadCreationStatus: NTSTATUS, --}} --pub type PWORKER_FACTORY_BASIC_INFORMATION = *mut WORKER_FACTORY_BASIC_INFORMATION; --EXTERN!{extern "system" { -- fn NtCreateWorkerFactory( -- WorkerFactoryHandleReturn: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- CompletionPortHandle: HANDLE, -- WorkerProcessHandle: HANDLE, -- StartRoutine: PVOID, -- StartParameter: PVOID, -- MaxThreadCount: ULONG, -- StackReserve: SIZE_T, -- StackCommit: SIZE_T, -- ) -> NTSTATUS; -- fn NtQueryInformationWorkerFactory( -- WorkerFactoryHandle: HANDLE, -- WorkerFactoryInformationClass: WORKERFACTORYINFOCLASS, -- WorkerFactoryInformation: PVOID, -- WorkerFactoryInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationWorkerFactory( -- WorkerFactoryHandle: HANDLE, -- WorkerFactoryInformationClass: WORKERFACTORYINFOCLASS, -- WorkerFactoryInformation: PVOID, -- WorkerFactoryInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtShutdownWorkerFactory( -- WorkerFactoryHandle: HANDLE, -- PendingWorkerCount: *mut LONG, -- ) -> NTSTATUS; -- fn NtReleaseWorkerFactoryWorker( -- WorkerFactoryHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtWorkerFactoryWorkerReady( -- WorkerFactoryHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtWaitForWorkViaWorkerFactory( -- WorkerFactoryHandle: HANDLE, -- MiniPacket: *mut FILE_IO_COMPLETION_INFORMATION, -- ) -> NTSTATUS; -- fn NtQuerySystemTime( -- SystemTime: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtSetSystemTime( -- SystemTime: PLARGE_INTEGER, -- PreviousTime: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtQueryTimerResolution( -- MaximumTime: PULONG, -- MinimumTime: PULONG, -- CurrentTime: PULONG, -- ) -> NTSTATUS; -- fn NtSetTimerResolution( -- DesiredTime: ULONG, -- SetResolution: BOOLEAN, -- ActualTime: PULONG, -- ) -> NTSTATUS; -- fn NtQueryPerformanceCounter( -- PerformanceCounter: PLARGE_INTEGER, -- PerformanceFrequency: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtAllocateLocallyUniqueId( -- Luid: PLUID, -- ) -> NTSTATUS; -- fn NtSetUuidSeed( -- Seed: PCHAR, -- ) -> NTSTATUS; -- fn NtAllocateUuids( -- Time: PULARGE_INTEGER, -- Range: PULONG, -- Sequence: PULONG, -- Seed: PCHAR, -- ) -> NTSTATUS; --}} --ENUM!{enum SYSTEM_INFORMATION_CLASS { -- SystemBasicInformation = 0, -- SystemProcessorInformation = 1, -- SystemPerformanceInformation = 2, -- SystemTimeOfDayInformation = 3, -- SystemPathInformation = 4, -- SystemProcessInformation = 5, -- SystemCallCountInformation = 6, -- SystemDeviceInformation = 7, -- SystemProcessorPerformanceInformation = 8, -- SystemFlagsInformation = 9, -- SystemCallTimeInformation = 10, -- SystemModuleInformation = 11, -- SystemLocksInformation = 12, -- SystemStackTraceInformation = 13, -- SystemPagedPoolInformation = 14, -- SystemNonPagedPoolInformation = 15, -- SystemHandleInformation = 16, -- SystemObjectInformation = 17, -- SystemPageFileInformation = 18, -- SystemVdmInstemulInformation = 19, -- SystemVdmBopInformation = 20, -- SystemFileCacheInformation = 21, -- SystemPoolTagInformation = 22, -- SystemInterruptInformation = 23, -- SystemDpcBehaviorInformation = 24, -- SystemFullMemoryInformation = 25, -- SystemLoadGdiDriverInformation = 26, -- SystemUnloadGdiDriverInformation = 27, -- SystemTimeAdjustmentInformation = 28, -- SystemSummaryMemoryInformation = 29, -- SystemMirrorMemoryInformation = 30, -- SystemPerformanceTraceInformation = 31, -- SystemObsolete0 = 32, -- SystemExceptionInformation = 33, -- SystemCrashDumpStateInformation = 34, -- SystemKernelDebuggerInformation = 35, -- SystemContextSwitchInformation = 36, -- SystemRegistryQuotaInformation = 37, -- SystemExtendServiceTableInformation = 38, -- SystemPrioritySeperation = 39, -- SystemVerifierAddDriverInformation = 40, -- SystemVerifierRemoveDriverInformation = 41, -- SystemProcessorIdleInformation = 42, -- SystemLegacyDriverInformation = 43, -- SystemCurrentTimeZoneInformation = 44, -- SystemLookasideInformation = 45, -- SystemTimeSlipNotification = 46, -- SystemSessionCreate = 47, -- SystemSessionDetach = 48, -- SystemSessionInformation = 49, -- SystemRangeStartInformation = 50, -- SystemVerifierInformation = 51, -- SystemVerifierThunkExtend = 52, -- SystemSessionProcessInformation = 53, -- SystemLoadGdiDriverInSystemSpace = 54, -- SystemNumaProcessorMap = 55, -- SystemPrefetcherInformation = 56, -- SystemExtendedProcessInformation = 57, -- SystemRecommendedSharedDataAlignment = 58, -- SystemComPlusPackage = 59, -- SystemNumaAvailableMemory = 60, -- SystemProcessorPowerInformation = 61, -- SystemEmulationBasicInformation = 62, -- SystemEmulationProcessorInformation = 63, -- SystemExtendedHandleInformation = 64, -- SystemLostDelayedWriteInformation = 65, -- SystemBigPoolInformation = 66, -- SystemSessionPoolTagInformation = 67, -- SystemSessionMappedViewInformation = 68, -- SystemHotpatchInformation = 69, -- SystemObjectSecurityMode = 70, -- SystemWatchdogTimerHandler = 71, -- SystemWatchdogTimerInformation = 72, -- SystemLogicalProcessorInformation = 73, -- SystemWow64SharedInformationObsolete = 74, -- SystemRegisterFirmwareTableInformationHandler = 75, -- SystemFirmwareTableInformation = 76, -- SystemModuleInformationEx = 77, -- SystemVerifierTriageInformation = 78, -- SystemSuperfetchInformation = 79, -- SystemMemoryListInformation = 80, -- SystemFileCacheInformationEx = 81, -- SystemThreadPriorityClientIdInformation = 82, -- SystemProcessorIdleCycleTimeInformation = 83, -- SystemVerifierCancellationInformation = 84, -- SystemProcessorPowerInformationEx = 85, -- SystemRefTraceInformation = 86, -- SystemSpecialPoolInformation = 87, -- SystemProcessIdInformation = 88, -- SystemErrorPortInformation = 89, -- SystemBootEnvironmentInformation = 90, -- SystemHypervisorInformation = 91, -- SystemVerifierInformationEx = 92, -- SystemTimeZoneInformation = 93, -- SystemImageFileExecutionOptionsInformation = 94, -- SystemCoverageInformation = 95, -- SystemPrefetchPatchInformation = 96, -- SystemVerifierFaultsInformation = 97, -- SystemSystemPartitionInformation = 98, -- SystemSystemDiskInformation = 99, -- SystemProcessorPerformanceDistribution = 100, -- SystemNumaProximityNodeInformation = 101, -- SystemDynamicTimeZoneInformation = 102, -- SystemCodeIntegrityInformation = 103, -- SystemProcessorMicrocodeUpdateInformation = 104, -- SystemProcessorBrandString = 105, -- SystemVirtualAddressInformation = 106, -- SystemLogicalProcessorAndGroupInformation = 107, -- SystemProcessorCycleTimeInformation = 108, -- SystemStoreInformation = 109, -- SystemRegistryAppendString = 110, -- SystemAitSamplingValue = 111, -- SystemVhdBootInformation = 112, -- SystemCpuQuotaInformation = 113, -- SystemNativeBasicInformation = 114, -- SystemSpare1 = 115, -- SystemLowPriorityIoInformation = 116, -- SystemTpmBootEntropyInformation = 117, -- SystemVerifierCountersInformation = 118, -- SystemPagedPoolInformationEx = 119, -- SystemSystemPtesInformationEx = 120, -- SystemNodeDistanceInformation = 121, -- SystemAcpiAuditInformation = 122, -- SystemBasicPerformanceInformation = 123, -- SystemQueryPerformanceCounterInformation = 124, -- SystemSessionBigPoolInformation = 125, -- SystemBootGraphicsInformation = 126, -- SystemScrubPhysicalMemoryInformation = 127, -- SystemBadPageInformation = 128, -- SystemProcessorProfileControlArea = 129, -- SystemCombinePhysicalMemoryInformation = 130, -- SystemEntropyInterruptTimingCallback = 131, -- SystemConsoleInformation = 132, -- SystemPlatformBinaryInformation = 133, -- SystemThrottleNotificationInformation = 134, -- SystemHypervisorProcessorCountInformation = 135, -- SystemDeviceDataInformation = 136, -- SystemDeviceDataEnumerationInformation = 137, -- SystemMemoryTopologyInformation = 138, -- SystemMemoryChannelInformation = 139, -- SystemBootLogoInformation = 140, -- SystemProcessorPerformanceInformationEx = 141, -- SystemSpare0 = 142, -- SystemSecureBootPolicyInformation = 143, -- SystemPageFileInformationEx = 144, -- SystemSecureBootInformation = 145, -- SystemEntropyInterruptTimingRawInformation = 146, -- SystemPortableWorkspaceEfiLauncherInformation = 147, -- SystemFullProcessInformation = 148, -- SystemKernelDebuggerInformationEx = 149, -- SystemBootMetadataInformation = 150, -- SystemSoftRebootInformation = 151, -- SystemElamCertificateInformation = 152, -- SystemOfflineDumpConfigInformation = 153, -- SystemProcessorFeaturesInformation = 154, -- SystemRegistryReconciliationInformation = 155, -- SystemEdidInformation = 156, -- SystemManufacturingInformation = 157, -- SystemEnergyEstimationConfigInformation = 158, -- SystemHypervisorDetailInformation = 159, -- SystemProcessorCycleStatsInformation = 160, -- SystemVmGenerationCountInformation = 161, -- SystemTrustedPlatformModuleInformation = 162, -- SystemKernelDebuggerFlags = 163, -- SystemCodeIntegrityPolicyInformation = 164, -- SystemIsolatedUserModeInformation = 165, -- SystemHardwareSecurityTestInterfaceResultsInformation = 166, -- SystemSingleModuleInformation = 167, -- SystemAllowedCpuSetsInformation = 168, -- SystemVsmProtectionInformation = 169, -- SystemInterruptCpuSetsInformation = 170, -- SystemSecureBootPolicyFullInformation = 171, -- SystemCodeIntegrityPolicyFullInformation = 172, -- SystemAffinitizedInterruptProcessorInformation = 173, -- SystemRootSiloInformation = 174, -- SystemCpuSetInformation = 175, -- SystemCpuSetTagInformation = 176, -- SystemWin32WerStartCallout = 177, -- SystemSecureKernelProfileInformation = 178, -- SystemCodeIntegrityPlatformManifestInformation = 179, -- SystemInterruptSteeringInformation = 180, -- SystemSupportedProcessorArchitectures = 181, -- SystemMemoryUsageInformation = 182, -- SystemCodeIntegrityCertificateInformation = 183, -- SystemPhysicalMemoryInformation = 184, -- SystemControlFlowTransition = 185, -- SystemKernelDebuggingAllowed = 186, -- SystemActivityModerationExeState = 187, -- SystemActivityModerationUserSettings = 188, -- SystemCodeIntegrityPoliciesFullInformation = 189, -- SystemCodeIntegrityUnlockInformation = 190, -- SystemIntegrityQuotaInformation = 191, -- SystemFlushInformation = 192, -- SystemProcessorIdleMaskInformation = 193, -- SystemSecureDumpEncryptionInformation = 194, -- SystemWriteConstraintInformation = 195, -- SystemKernelVaShadowInformation = 196, -- SystemHypervisorSharedPageInformation = 197, -- SystemFirmwareBootPerformanceInformation = 198, -- SystemCodeIntegrityVerificationInformation = 199, -- SystemFirmwarePartitionInformation = 200, -- SystemSpeculationControlInformation = 201, -- SystemDmaGuardPolicyInformation = 202, -- SystemEnclaveLaunchControlInformation = 203, -- SystemWorkloadAllowedCpuSetsInformation = 204, -- SystemCodeIntegrityUnlockModeInformation = 205, -- SystemLeapSecondInformation = 206, -- SystemFlags2Information = 207, -- MaxSystemInfoClass = 208, --}} --STRUCT!{struct SYSTEM_BASIC_INFORMATION { -- Reserved: ULONG, -- TimerResolution: ULONG, -- PageSize: ULONG, -- NumberOfPhysicalPages: ULONG, -- LowestPhysicalPageNumber: ULONG, -- HighestPhysicalPageNumber: ULONG, -- AllocationGranularity: ULONG, -- MinimumUserModeAddress: ULONG_PTR, -- MaximumUserModeAddress: ULONG_PTR, -- ActiveProcessorsAffinityMask: ULONG_PTR, -- NumberOfProcessors: CCHAR, --}} --pub type PSYSTEM_BASIC_INFORMATION = *mut SYSTEM_BASIC_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_INFORMATION { -- ProcessorArchitecture: USHORT, -- ProcessorLevel: USHORT, -- ProcessorRevision: USHORT, -- MaximumProcessors: USHORT, -- ProcessorFeatureBits: ULONG, --}} --pub type PSYSTEM_PROCESSOR_INFORMATION = *mut SYSTEM_PROCESSOR_INFORMATION; --STRUCT!{struct SYSTEM_PERFORMANCE_INFORMATION { -- IdleProcessTime: LARGE_INTEGER, -- IoReadTransferCount: LARGE_INTEGER, -- IoWriteTransferCount: LARGE_INTEGER, -- IoOtherTransferCount: LARGE_INTEGER, -- IoReadOperationCount: ULONG, -- IoWriteOperationCount: ULONG, -- IoOtherOperationCount: ULONG, -- AvailablePages: ULONG, -- CommittedPages: ULONG, -- CommitLimit: ULONG, -- PeakCommitment: ULONG, -- PageFaultCount: ULONG, -- CopyOnWriteCount: ULONG, -- TransitionCount: ULONG, -- CacheTransitionCount: ULONG, -- DemandZeroCount: ULONG, -- PageReadCount: ULONG, -- PageReadIoCount: ULONG, -- CacheReadCount: ULONG, -- CacheIoCount: ULONG, -- DirtyPagesWriteCount: ULONG, -- DirtyWriteIoCount: ULONG, -- MappedPagesWriteCount: ULONG, -- MappedWriteIoCount: ULONG, -- PagedPoolPages: ULONG, -- NonPagedPoolPages: ULONG, -- PagedPoolAllocs: ULONG, -- PagedPoolFrees: ULONG, -- NonPagedPoolAllocs: ULONG, -- NonPagedPoolFrees: ULONG, -- FreeSystemPtes: ULONG, -- ResidentSystemCodePage: ULONG, -- TotalSystemDriverPages: ULONG, -- TotalSystemCodePages: ULONG, -- NonPagedPoolLookasideHits: ULONG, -- PagedPoolLookasideHits: ULONG, -- AvailablePagedPoolPages: ULONG, -- ResidentSystemCachePage: ULONG, -- ResidentPagedPoolPage: ULONG, -- ResidentSystemDriverPage: ULONG, -- CcFastReadNoWait: ULONG, -- CcFastReadWait: ULONG, -- CcFastReadResourceMiss: ULONG, -- CcFastReadNotPossible: ULONG, -- CcFastMdlReadNoWait: ULONG, -- CcFastMdlReadWait: ULONG, -- CcFastMdlReadResourceMiss: ULONG, -- CcFastMdlReadNotPossible: ULONG, -- CcMapDataNoWait: ULONG, -- CcMapDataWait: ULONG, -- CcMapDataNoWaitMiss: ULONG, -- CcMapDataWaitMiss: ULONG, -- CcPinMappedDataCount: ULONG, -- CcPinReadNoWait: ULONG, -- CcPinReadWait: ULONG, -- CcPinReadNoWaitMiss: ULONG, -- CcPinReadWaitMiss: ULONG, -- CcCopyReadNoWait: ULONG, -- CcCopyReadWait: ULONG, -- CcCopyReadNoWaitMiss: ULONG, -- CcCopyReadWaitMiss: ULONG, -- CcMdlReadNoWait: ULONG, -- CcMdlReadWait: ULONG, -- CcMdlReadNoWaitMiss: ULONG, -- CcMdlReadWaitMiss: ULONG, -- CcReadAheadIos: ULONG, -- CcLazyWriteIos: ULONG, -- CcLazyWritePages: ULONG, -- CcDataFlushes: ULONG, -- CcDataPages: ULONG, -- ContextSwitches: ULONG, -- FirstLevelTbFills: ULONG, -- SecondLevelTbFills: ULONG, -- SystemCalls: ULONG, -- CcTotalDirtyPages: ULONGLONG, -- CcDirtyPageThreshold: ULONGLONG, -- ResidentAvailablePages: LONGLONG, -- SharedCommittedPages: ULONGLONG, --}} --pub type PSYSTEM_PERFORMANCE_INFORMATION = *mut SYSTEM_PERFORMANCE_INFORMATION; --STRUCT!{struct SYSTEM_TIMEOFDAY_INFORMATION { -- BootTime: LARGE_INTEGER, -- CurrentTime: LARGE_INTEGER, -- TimeZoneBias: LARGE_INTEGER, -- TimeZoneId: ULONG, -- Reserved: ULONG, -- BootTimeBias: ULONGLONG, -- SleepTimeBias: ULONGLONG, --}} --pub type PSYSTEM_TIMEOFDAY_INFORMATION = *mut SYSTEM_TIMEOFDAY_INFORMATION; --STRUCT!{struct SYSTEM_THREAD_INFORMATION { -- KernelTime: LARGE_INTEGER, -- UserTime: LARGE_INTEGER, -- CreateTime: LARGE_INTEGER, -- WaitTime: ULONG, -- StartAddress: PVOID, -- ClientId: CLIENT_ID, -- Priority: KPRIORITY, -- BasePriority: LONG, -- ContextSwitches: ULONG, -- ThreadState: KTHREAD_STATE, -- WaitReason: KWAIT_REASON, --}} --pub type PSYSTEM_THREAD_INFORMATION = *mut SYSTEM_THREAD_INFORMATION; --STRUCT!{struct SYSTEM_EXTENDED_THREAD_INFORMATION { -- ThreadInfo: SYSTEM_THREAD_INFORMATION, -- StackBase: PVOID, -- StackLimit: PVOID, -- Win32StartAddress: PVOID, -- TebBase: PTEB, -- Reserved2: ULONG_PTR, -- Reserved3: ULONG_PTR, -- Reserved4: ULONG_PTR, --}} --pub type PSYSTEM_EXTENDED_THREAD_INFORMATION = *mut SYSTEM_EXTENDED_THREAD_INFORMATION; --STRUCT!{struct SYSTEM_PROCESS_INFORMATION { -- NextEntryOffset: ULONG, -- NumberOfThreads: ULONG, -- WorkingSetPrivateSize: LARGE_INTEGER, -- HardFaultCount: ULONG, -- NumberOfThreadsHighWatermark: ULONG, -- CycleTime: ULONGLONG, -- CreateTime: LARGE_INTEGER, -- UserTime: LARGE_INTEGER, -- KernelTime: LARGE_INTEGER, -- ImageName: UNICODE_STRING, -- BasePriority: KPRIORITY, -- UniqueProcessId: HANDLE, -- InheritedFromUniqueProcessId: HANDLE, -- HandleCount: ULONG, -- SessionId: ULONG, -- UniqueProcessKey: ULONG_PTR, -- PeakVirtualSize: SIZE_T, -- VirtualSize: SIZE_T, -- PageFaultCount: ULONG, -- PeakWorkingSetSize: SIZE_T, -- WorkingSetSize: SIZE_T, -- QuotaPeakPagedPoolUsage: SIZE_T, -- QuotaPagedPoolUsage: SIZE_T, -- QuotaPeakNonPagedPoolUsage: SIZE_T, -- QuotaNonPagedPoolUsage: SIZE_T, -- PagefileUsage: SIZE_T, -- PeakPagefileUsage: SIZE_T, -- PrivatePageCount: SIZE_T, -- ReadOperationCount: LARGE_INTEGER, -- WriteOperationCount: LARGE_INTEGER, -- OtherOperationCount: LARGE_INTEGER, -- ReadTransferCount: LARGE_INTEGER, -- WriteTransferCount: LARGE_INTEGER, -- OtherTransferCount: LARGE_INTEGER, -- Threads: [SYSTEM_THREAD_INFORMATION; 1], --}} --pub type PSYSTEM_PROCESS_INFORMATION = *mut SYSTEM_PROCESS_INFORMATION; --STRUCT!{struct SYSTEM_CALL_COUNT_INFORMATION { -- Length: ULONG, -- NumberOfTables: ULONG, --}} --pub type PSYSTEM_CALL_COUNT_INFORMATION = *mut SYSTEM_CALL_COUNT_INFORMATION; --STRUCT!{struct SYSTEM_DEVICE_INFORMATION { -- NumberOfDisks: ULONG, -- NumberOfFloppies: ULONG, -- NumberOfCdRoms: ULONG, -- NumberOfTapes: ULONG, -- NumberOfSerialPorts: ULONG, -- NumberOfParallelPorts: ULONG, --}} --pub type PSYSTEM_DEVICE_INFORMATION = *mut SYSTEM_DEVICE_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION { -- IdleTime: LARGE_INTEGER, -- KernelTime: LARGE_INTEGER, -- UserTime: LARGE_INTEGER, -- DpcTime: LARGE_INTEGER, -- InterruptTime: LARGE_INTEGER, -- InterruptCount: ULONG, --}} --pub type PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = *mut SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION; --STRUCT!{struct SYSTEM_FLAGS_INFORMATION { -- Flags: ULONG, --}} --pub type PSYSTEM_FLAGS_INFORMATION = *mut SYSTEM_FLAGS_INFORMATION; --STRUCT!{struct SYSTEM_CALL_TIME_INFORMATION { -- Length: ULONG, -- TotalCalls: ULONG, -- TimeOfCalls: [LARGE_INTEGER; 1], --}} --pub type PSYSTEM_CALL_TIME_INFORMATION = *mut SYSTEM_CALL_TIME_INFORMATION; --STRUCT!{struct RTL_PROCESS_LOCK_INFORMATION { -- Address: PVOID, -- Type: USHORT, -- CreatorBackTraceIndex: USHORT, -- OwningThread: HANDLE, -- LockCount: LONG, -- ContentionCount: ULONG, -- EntryCount: ULONG, -- RecursionCount: LONG, -- NumberOfWaitingShared: ULONG, -- NumberOfWaitingExclusive: ULONG, --}} --pub type PRTL_PROCESS_LOCK_INFORMATION = *mut RTL_PROCESS_LOCK_INFORMATION; --STRUCT!{struct RTL_PROCESS_LOCKS { -- NumberOfLocks: ULONG, -- Locks: [RTL_PROCESS_LOCK_INFORMATION; 1], --}} --pub type PRTL_PROCESS_LOCKS = *mut RTL_PROCESS_LOCKS; --STRUCT!{struct RTL_PROCESS_BACKTRACE_INFORMATION { -- SymbolicBackTrace: PCHAR, -- TraceCount: ULONG, -- Index: USHORT, -- Depth: USHORT, -- BackTrace: [PVOID; 32], --}} --pub type PRTL_PROCESS_BACKTRACE_INFORMATION = *mut RTL_PROCESS_BACKTRACE_INFORMATION; --STRUCT!{struct RTL_PROCESS_BACKTRACES { -- CommittedMemory: ULONG, -- ReservedMemory: ULONG, -- NumberOfBackTraceLookups: ULONG, -- NumberOfBackTraces: ULONG, -- BackTraces: [RTL_PROCESS_BACKTRACE_INFORMATION; 1], --}} --pub type PRTL_PROCESS_BACKTRACES = *mut RTL_PROCESS_BACKTRACES; --STRUCT!{struct SYSTEM_HANDLE_TABLE_ENTRY_INFO { -- UniqueProcessId: USHORT, -- CreatorBackTraceIndex: USHORT, -- ObjectTypeIndex: UCHAR, -- HandleAttributes: UCHAR, -- HandleValue: USHORT, -- Object: PVOID, -- GrantedAccess: ULONG, --}} --pub type PSYSTEM_HANDLE_TABLE_ENTRY_INFO = *mut SYSTEM_HANDLE_TABLE_ENTRY_INFO; --STRUCT!{struct SYSTEM_HANDLE_INFORMATION { -- NumberOfHandles: ULONG, -- Handles: [SYSTEM_HANDLE_TABLE_ENTRY_INFO; 1], --}} --pub type PSYSTEM_HANDLE_INFORMATION = *mut SYSTEM_HANDLE_INFORMATION; --STRUCT!{struct SYSTEM_OBJECTTYPE_INFORMATION { -- NextEntryOffset: ULONG, -- NumberOfObjects: ULONG, -- NumberOfHandles: ULONG, -- TypeIndex: ULONG, -- InvalidAttributes: ULONG, -- GenericMapping: GENERIC_MAPPING, -- ValidAccessMask: ULONG, -- PoolType: ULONG, -- SecurityRequired: BOOLEAN, -- WaitableObject: BOOLEAN, -- TypeName: UNICODE_STRING, --}} --pub type PSYSTEM_OBJECTTYPE_INFORMATION = *mut SYSTEM_OBJECTTYPE_INFORMATION; --STRUCT!{struct SYSTEM_OBJECT_INFORMATION { -- NextEntryOffset: ULONG, -- Object: PVOID, -- CreatorUniqueProcess: HANDLE, -- CreatorBackTraceIndex: USHORT, -- Flags: USHORT, -- PointerCount: LONG, -- HandleCount: LONG, -- PagedPoolCharge: ULONG, -- NonPagedPoolCharge: ULONG, -- ExclusiveProcessId: HANDLE, -- SecurityDescriptor: PVOID, -- NameInfo: UNICODE_STRING, --}} --pub type PSYSTEM_OBJECT_INFORMATION = *mut SYSTEM_OBJECT_INFORMATION; --STRUCT!{struct SYSTEM_PAGEFILE_INFORMATION { -- NextEntryOffset: ULONG, -- TotalSize: ULONG, -- TotalInUse: ULONG, -- PeakUsage: ULONG, -- PageFileName: UNICODE_STRING, --}} --pub type PSYSTEM_PAGEFILE_INFORMATION = *mut SYSTEM_PAGEFILE_INFORMATION; --pub const MM_WORKING_SET_MAX_HARD_ENABLE: ULONG = 0x1; --pub const MM_WORKING_SET_MAX_HARD_DISABLE: ULONG = 0x2; --pub const MM_WORKING_SET_MIN_HARD_ENABLE: ULONG = 0x4; --pub const MM_WORKING_SET_MIN_HARD_DISABLE: ULONG = 0x8; --STRUCT!{struct SYSTEM_FILECACHE_INFORMATION { -- CurrentSize: SIZE_T, -- PeakSize: SIZE_T, -- PageFaultCount: ULONG, -- MinimumWorkingSet: SIZE_T, -- MaximumWorkingSet: SIZE_T, -- CurrentSizeIncludingTransitionInPages: SIZE_T, -- PeakSizeIncludingTransitionInPages: SIZE_T, -- TransitionRePurposeCount: ULONG, -- Flags: ULONG, --}} --pub type PSYSTEM_FILECACHE_INFORMATION = *mut SYSTEM_FILECACHE_INFORMATION; --STRUCT!{struct SYSTEM_BASIC_WORKING_SET_INFORMATION { -- CurrentSize: SIZE_T, -- PeakSize: SIZE_T, -- PageFaultCount: ULONG, --}} --pub type PSYSTEM_BASIC_WORKING_SET_INFORMATION = *mut SYSTEM_BASIC_WORKING_SET_INFORMATION; --UNION!{union SYSTEM_POOLTAG_u { -- Tag: [UCHAR; 4], -- TagUlong: ULONG, --}} --STRUCT!{struct SYSTEM_POOLTAG { -- u: SYSTEM_POOLTAG_u, -- PagedAllocs: ULONG, -- PagedFrees: ULONG, -- PagedUsed: SIZE_T, -- NonPagedAllocs: ULONG, -- NonPagedFrees: ULONG, -- NonPagedUsed: SIZE_T, --}} --pub type PSYSTEM_POOLTAG = *mut SYSTEM_POOLTAG; --STRUCT!{struct SYSTEM_POOLTAG_INFORMATION { -- Count: ULONG, -- TagInfo: [SYSTEM_POOLTAG; 1], --}} --pub type PSYSTEM_POOLTAG_INFORMATION = *mut SYSTEM_POOLTAG_INFORMATION; --STRUCT!{struct SYSTEM_INTERRUPT_INFORMATION { -- ContextSwitches: ULONG, -- DpcCount: ULONG, -- DpcRate: ULONG, -- TimeIncrement: ULONG, -- DpcBypassCount: ULONG, -- ApcBypassCount: ULONG, --}} --pub type PSYSTEM_INTERRUPT_INFORMATION = *mut SYSTEM_INTERRUPT_INFORMATION; --STRUCT!{struct SYSTEM_DPC_BEHAVIOR_INFORMATION { -- Spare: ULONG, -- DpcQueueDepth: ULONG, -- MinimumDpcRate: ULONG, -- AdjustDpcThreshold: ULONG, -- IdealDpcRate: ULONG, --}} --pub type PSYSTEM_DPC_BEHAVIOR_INFORMATION = *mut SYSTEM_DPC_BEHAVIOR_INFORMATION; --STRUCT!{struct SYSTEM_QUERY_TIME_ADJUST_INFORMATION { -- TimeAdjustment: ULONG, -- TimeIncrement: ULONG, -- Enable: BOOLEAN, --}} --pub type PSYSTEM_QUERY_TIME_ADJUST_INFORMATION = *mut SYSTEM_QUERY_TIME_ADJUST_INFORMATION; --STRUCT!{struct SYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE { -- TimeAdjustment: ULONGLONG, -- TimeIncrement: ULONGLONG, -- Enable: BOOLEAN, --}} --pub type PSYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE = -- *mut SYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE; --STRUCT!{struct SYSTEM_SET_TIME_ADJUST_INFORMATION { -- TimeAdjustment: ULONG, -- Enable: BOOLEAN, --}} --pub type PSYSTEM_SET_TIME_ADJUST_INFORMATION = *mut SYSTEM_SET_TIME_ADJUST_INFORMATION; --STRUCT!{struct SYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE { -- TimeAdjustment: ULONGLONG, -- Enable: BOOLEAN, --}} --pub type PSYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE = -- *mut SYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE; --ENUM!{enum EVENT_TRACE_INFORMATION_CLASS { -- EventTraceKernelVersionInformation = 0, -- EventTraceGroupMaskInformation = 1, -- EventTracePerformanceInformation = 2, -- EventTraceTimeProfileInformation = 3, -- EventTraceSessionSecurityInformation = 4, -- EventTraceSpinlockInformation = 5, -- EventTraceStackTracingInformation = 6, -- EventTraceExecutiveResourceInformation = 7, -- EventTraceHeapTracingInformation = 8, -- EventTraceHeapSummaryTracingInformation = 9, -- EventTracePoolTagFilterInformation = 10, -- EventTracePebsTracingInformation = 11, -- EventTraceProfileConfigInformation = 12, -- EventTraceProfileSourceListInformation = 13, -- EventTraceProfileEventListInformation = 14, -- EventTraceProfileCounterListInformation = 15, -- EventTraceStackCachingInformation = 16, -- EventTraceObjectTypeFilterInformation = 17, -- EventTraceSoftRestartInformation = 18, -- EventTraceLastBranchConfigurationInformation = 19, -- EventTraceLastBranchEventListInformation = 20, -- EventTraceProfileSourceAddInformation = 21, -- EventTraceProfileSourceRemoveInformation = 22, -- EventTraceProcessorTraceConfigurationInformation = 23, -- EventTraceProcessorTraceEventListInformation = 24, -- EventTraceCoverageSamplerInformation = 25, -- MaxEventTraceInfoClass = 26, --}} --STRUCT!{struct EVENT_TRACE_VERSION_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- EventTraceKernelVersion: ULONG, --}} --pub type PEVENT_TRACE_VERSION_INFORMATION = *mut EVENT_TRACE_VERSION_INFORMATION; --STRUCT!{struct PERFINFO_GROUPMASK { -- Masks: [ULONG; 8], --}} --pub type PPERFINFO_GROUPMASK = *mut PERFINFO_GROUPMASK; --STRUCT!{struct EVENT_TRACE_GROUPMASK_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- TraceHandle: HANDLE, -- EventTraceGroupMasks: PERFINFO_GROUPMASK, --}} --pub type PEVENT_TRACE_GROUPMASK_INFORMATION = *mut EVENT_TRACE_GROUPMASK_INFORMATION; --STRUCT!{struct EVENT_TRACE_PERFORMANCE_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- LogfileBytesWritten: LARGE_INTEGER, --}} --pub type PEVENT_TRACE_PERFORMANCE_INFORMATION = *mut EVENT_TRACE_PERFORMANCE_INFORMATION; --STRUCT!{struct EVENT_TRACE_TIME_PROFILE_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- ProfileInterval: ULONG, --}} --pub type PEVENT_TRACE_TIME_PROFILE_INFORMATION = *mut EVENT_TRACE_TIME_PROFILE_INFORMATION; --STRUCT!{struct EVENT_TRACE_SESSION_SECURITY_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- SecurityInformation: ULONG, -- TraceHandle: HANDLE, -- SecurityDescriptor: [UCHAR; 1], --}} --pub type PEVENT_TRACE_SESSION_SECURITY_INFORMATION = *mut EVENT_TRACE_SESSION_SECURITY_INFORMATION; --STRUCT!{struct EVENT_TRACE_SPINLOCK_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- SpinLockSpinThreshold: ULONG, -- SpinLockAcquireSampleRate: ULONG, -- SpinLockContentionSampleRate: ULONG, -- SpinLockHoldThreshold: ULONG, --}} --pub type PEVENT_TRACE_SPINLOCK_INFORMATION = *mut EVENT_TRACE_SPINLOCK_INFORMATION; --STRUCT!{struct EVENT_TRACE_SYSTEM_EVENT_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- TraceHandle: HANDLE, -- HookId: [ULONG; 1], --}} --pub type PEVENT_TRACE_SYSTEM_EVENT_INFORMATION = *mut EVENT_TRACE_SYSTEM_EVENT_INFORMATION; --STRUCT!{struct EVENT_TRACE_EXECUTIVE_RESOURCE_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- ReleaseSamplingRate: ULONG, -- ContentionSamplingRate: ULONG, -- NumberOfExcessiveTimeouts: ULONG, --}} --pub type PEVENT_TRACE_EXECUTIVE_RESOURCE_INFORMATION = -- *mut EVENT_TRACE_EXECUTIVE_RESOURCE_INFORMATION; --STRUCT!{struct EVENT_TRACE_HEAP_TRACING_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- ProcessId: ULONG, --}} --pub type PEVENT_TRACE_HEAP_TRACING_INFORMATION = *mut EVENT_TRACE_HEAP_TRACING_INFORMATION; --STRUCT!{struct EVENT_TRACE_TAG_FILTER_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- TraceHandle: HANDLE, -- Filter: [ULONG; 1], --}} --pub type PEVENT_TRACE_TAG_FILTER_INFORMATION = *mut EVENT_TRACE_TAG_FILTER_INFORMATION; --STRUCT!{struct EVENT_TRACE_PROFILE_COUNTER_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- TraceHandle: HANDLE, -- ProfileSource: [ULONG; 1], --}} --pub type PEVENT_TRACE_PROFILE_COUNTER_INFORMATION = *mut EVENT_TRACE_PROFILE_COUNTER_INFORMATION; --STRUCT!{struct EVENT_TRACE_PROFILE_LIST_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- Spare: ULONG, -- Profile: [*mut PROFILE_SOURCE_INFO; 1], --}} --pub type PEVENT_TRACE_PROFILE_LIST_INFORMATION = *mut EVENT_TRACE_PROFILE_LIST_INFORMATION; --STRUCT!{struct EVENT_TRACE_STACK_CACHING_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- TraceHandle: HANDLE, -- Enabled: BOOLEAN, -- Reserved: [UCHAR; 3], -- CacheSize: ULONG, -- BucketCount: ULONG, --}} --pub type PEVENT_TRACE_STACK_CACHING_INFORMATION = *mut EVENT_TRACE_STACK_CACHING_INFORMATION; --STRUCT!{struct EVENT_TRACE_SOFT_RESTART_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- TraceHandle: HANDLE, -- PersistTraceBuffers: BOOLEAN, -- FileName: [WCHAR; 1], --}} --pub type PEVENT_TRACE_SOFT_RESTART_INFORMATION = *mut EVENT_TRACE_SOFT_RESTART_INFORMATION; --STRUCT!{struct EVENT_TRACE_PROFILE_ADD_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- PerfEvtEventSelect: BOOLEAN, -- PerfEvtUnitSelect: BOOLEAN, -- PerfEvtType: ULONG, -- CpuInfoHierarchy: [ULONG; 3], -- InitialInterval: ULONG, -- AllowsHalt: BOOLEAN, -- Persist: BOOLEAN, -- ProfileSourceDescription: [WCHAR; 1], --}} --pub type PEVENT_TRACE_PROFILE_ADD_INFORMATION = *mut EVENT_TRACE_PROFILE_ADD_INFORMATION; --STRUCT!{struct EVENT_TRACE_PROFILE_REMOVE_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- ProfileSource: KPROFILE_SOURCE, -- CpuInfoHierarchy: [ULONG; 3], --}} --pub type PEVENT_TRACE_PROFILE_REMOVE_INFORMATION = *mut EVENT_TRACE_PROFILE_REMOVE_INFORMATION; --STRUCT!{struct EVENT_TRACE_COVERAGE_SAMPLER_INFORMATION { -- EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, -- CoverageSamplerInformationClass: BOOLEAN, -- MajorVersion: UCHAR, -- MinorVersion: UCHAR, -- Reserved: UCHAR, -- SamplerHandle: HANDLE, --}} --pub type PEVENT_TRACE_COVERAGE_SAMPLER_INFORMATION = *mut EVENT_TRACE_COVERAGE_SAMPLER_INFORMATION; --STRUCT!{struct SYSTEM_EXCEPTION_INFORMATION { -- AlignmentFixupCount: ULONG, -- ExceptionDispatchCount: ULONG, -- FloatingEmulationCount: ULONG, -- ByteWordEmulationCount: ULONG, --}} --pub type PSYSTEM_EXCEPTION_INFORMATION = *mut SYSTEM_EXCEPTION_INFORMATION; --STRUCT!{struct SYSTEM_KERNEL_DEBUGGER_INFORMATION { -- KernelDebuggerEnabled: BOOLEAN, -- KernelDebuggerNotPresent: BOOLEAN, --}} --pub type PSYSTEM_KERNEL_DEBUGGER_INFORMATION = *mut SYSTEM_KERNEL_DEBUGGER_INFORMATION; --STRUCT!{struct SYSTEM_CONTEXT_SWITCH_INFORMATION { -- ContextSwitches: ULONG, -- FindAny: ULONG, -- FindLast: ULONG, -- FindIdeal: ULONG, -- IdleAny: ULONG, -- IdleCurrent: ULONG, -- IdleLast: ULONG, -- IdleIdeal: ULONG, -- PreemptAny: ULONG, -- PreemptCurrent: ULONG, -- PreemptLast: ULONG, -- SwitchToIdle: ULONG, --}} --pub type PSYSTEM_CONTEXT_SWITCH_INFORMATION = *mut SYSTEM_CONTEXT_SWITCH_INFORMATION; --STRUCT!{struct SYSTEM_REGISTRY_QUOTA_INFORMATION { -- RegistryQuotaAllowed: ULONG, -- RegistryQuotaUsed: ULONG, -- PagedPoolSize: SIZE_T, --}} --pub type PSYSTEM_REGISTRY_QUOTA_INFORMATION = *mut SYSTEM_REGISTRY_QUOTA_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_IDLE_INFORMATION { -- IdleTime: ULONGLONG, -- C1Time: ULONGLONG, -- C2Time: ULONGLONG, -- C3Time: ULONGLONG, -- C1Transitions: ULONG, -- C2Transitions: ULONG, -- C3Transitions: ULONG, -- Padding: ULONG, --}} --pub type PSYSTEM_PROCESSOR_IDLE_INFORMATION = *mut SYSTEM_PROCESSOR_IDLE_INFORMATION; --STRUCT!{struct SYSTEM_LEGACY_DRIVER_INFORMATION { -- VetoType: ULONG, -- VetoList: UNICODE_STRING, --}} --pub type PSYSTEM_LEGACY_DRIVER_INFORMATION = *mut SYSTEM_LEGACY_DRIVER_INFORMATION; --STRUCT!{struct SYSTEM_LOOKASIDE_INFORMATION { -- CurrentDepth: USHORT, -- MaximumDepth: USHORT, -- TotalAllocates: ULONG, -- AllocateMisses: ULONG, -- TotalFrees: ULONG, -- FreeMisses: ULONG, -- Type: ULONG, -- Tag: ULONG, -- Size: ULONG, --}} --pub type PSYSTEM_LOOKASIDE_INFORMATION = *mut SYSTEM_LOOKASIDE_INFORMATION; --STRUCT!{struct SYSTEM_RANGE_START_INFORMATION { -- SystemRangeStart: PVOID, --}} --pub type PSYSTEM_RANGE_START_INFORMATION = *mut SYSTEM_RANGE_START_INFORMATION; --STRUCT!{struct SYSTEM_VERIFIER_INFORMATION { -- NextEntryOffset: ULONG, -- Level: ULONG, -- DriverName: UNICODE_STRING, -- RaiseIrqls: ULONG, -- AcquireSpinLocks: ULONG, -- SynchronizeExecutions: ULONG, -- AllocationsAttempted: ULONG, -- AllocationsSucceeded: ULONG, -- AllocationsSucceededSpecialPool: ULONG, -- AllocationsWithNoTag: ULONG, -- TrimRequests: ULONG, -- Trims: ULONG, -- AllocationsFailed: ULONG, -- AllocationsFailedDeliberately: ULONG, -- Loads: ULONG, -- Unloads: ULONG, -- UnTrackedPool: ULONG, -- CurrentPagedPoolAllocations: ULONG, -- CurrentNonPagedPoolAllocations: ULONG, -- PeakPagedPoolAllocations: ULONG, -- PeakNonPagedPoolAllocations: ULONG, -- PagedPoolUsageInBytes: SIZE_T, -- NonPagedPoolUsageInBytes: SIZE_T, -- PeakPagedPoolUsageInBytes: SIZE_T, -- PeakNonPagedPoolUsageInBytes: SIZE_T, --}} --pub type PSYSTEM_VERIFIER_INFORMATION = *mut SYSTEM_VERIFIER_INFORMATION; --STRUCT!{struct SYSTEM_SESSION_PROCESS_INFORMATION { -- SessionId: ULONG, -- SizeOfBuf: ULONG, -- Buffer: PVOID, --}} --pub type PSYSTEM_SESSION_PROCESS_INFORMATION = *mut SYSTEM_SESSION_PROCESS_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_POWER_INFORMATION { -- CurrentFrequency: UCHAR, -- ThermalLimitFrequency: UCHAR, -- ConstantThrottleFrequency: UCHAR, -- DegradedThrottleFrequency: UCHAR, -- LastBusyFrequency: UCHAR, -- LastC3Frequency: UCHAR, -- LastAdjustedBusyFrequency: UCHAR, -- ProcessorMinThrottle: UCHAR, -- ProcessorMaxThrottle: UCHAR, -- NumberOfFrequencies: ULONG, -- PromotionCount: ULONG, -- DemotionCount: ULONG, -- ErrorCount: ULONG, -- RetryCount: ULONG, -- CurrentFrequencyTime: ULONGLONG, -- CurrentProcessorTime: ULONGLONG, -- CurrentProcessorIdleTime: ULONGLONG, -- LastProcessorTime: ULONGLONG, -- LastProcessorIdleTime: ULONGLONG, -- Energy: ULONGLONG, --}} --pub type PSYSTEM_PROCESSOR_POWER_INFORMATION = *mut SYSTEM_PROCESSOR_POWER_INFORMATION; --STRUCT!{struct SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX { -- Object: PVOID, -- UniqueProcessId: ULONG_PTR, -- HandleValue: ULONG_PTR, -- GrantedAccess: ULONG, -- CreatorBackTraceIndex: USHORT, -- ObjectTypeIndex: USHORT, -- HandleAttributes: ULONG, -- Reserved: ULONG, --}} --pub type PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX = *mut SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX; --STRUCT!{struct SYSTEM_HANDLE_INFORMATION_EX { -- NumberOfHandles: ULONG_PTR, -- Reserved: ULONG_PTR, -- Handles: [SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX; 1], --}} --pub type PSYSTEM_HANDLE_INFORMATION_EX = *mut SYSTEM_HANDLE_INFORMATION_EX; --UNION!{union SYSTEM_BIGPOOL_ENTRY_u1 { -- VirtualAddress: PVOID, -- Bitfields: ULONG_PTR, --}} --UNION!{union SYSTEM_BIGPOOL_ENTRY_u2 { -- Tag: [UCHAR; 4], -- TagUlong: ULONG, --}} --BITFIELD!{unsafe SYSTEM_BIGPOOL_ENTRY_u1 Bitfields: ULONG_PTR [ -- NonPaged set_NonPaged[0..1], --]} --STRUCT!{struct SYSTEM_BIGPOOL_ENTRY { -- u1: SYSTEM_BIGPOOL_ENTRY_u1, -- SizeInBytes: SIZE_T, -- u2: SYSTEM_BIGPOOL_ENTRY_u2, --}} --pub type PSYSTEM_BIGPOOL_ENTRY = *mut SYSTEM_BIGPOOL_ENTRY; --STRUCT!{struct SYSTEM_BIGPOOL_INFORMATION { -- Count: ULONG, -- AllocatedInfo: [SYSTEM_BIGPOOL_ENTRY; 1], --}} --pub type PSYSTEM_BIGPOOL_INFORMATION = *mut SYSTEM_BIGPOOL_INFORMATION; --UNION!{union SYSTEM_POOL_ENTRY_u { -- Tag: [UCHAR; 4], -- TagUlong: ULONG, -- ProcessChargedQuota: PVOID, --}} --STRUCT!{struct SYSTEM_POOL_ENTRY { -- Allocated: BOOLEAN, -- Spare0: BOOLEAN, -- AllocatorBackTraceIndex: USHORT, -- Size: ULONG, -- u: SYSTEM_POOL_ENTRY_u, --}} --pub type PSYSTEM_POOL_ENTRY = *mut SYSTEM_POOL_ENTRY; --STRUCT!{struct SYSTEM_POOL_INFORMATION { -- TotalSize: SIZE_T, -- FirstEntry: PVOID, -- EntryOverhead: USHORT, -- PoolTagPresent: BOOLEAN, -- Spare0: BOOLEAN, -- NumberOfEntries: ULONG, -- Entries: [SYSTEM_POOL_ENTRY; 1], --}} --pub type PSYSTEM_POOL_INFORMATION = *mut SYSTEM_POOL_INFORMATION; --STRUCT!{struct SYSTEM_SESSION_POOLTAG_INFORMATION { -- NextEntryOffset: SIZE_T, -- SessionId: ULONG, -- Count: ULONG, -- TagInfo: [SYSTEM_POOLTAG; 1], --}} --pub type PSYSTEM_SESSION_POOLTAG_INFORMATION = *mut SYSTEM_SESSION_POOLTAG_INFORMATION; --STRUCT!{struct SYSTEM_SESSION_MAPPED_VIEW_INFORMATION { -- NextEntryOffset: SIZE_T, -- SessionId: ULONG, -- ViewFailures: ULONG, -- NumberOfBytesAvailable: SIZE_T, -- NumberOfBytesAvailableContiguous: SIZE_T, --}} --pub type PSYSTEM_SESSION_MAPPED_VIEW_INFORMATION = *mut SYSTEM_SESSION_MAPPED_VIEW_INFORMATION; --ENUM!{enum SYSTEM_FIRMWARE_TABLE_ACTION { -- SystemFirmwareTableEnumerate = 0, -- SystemFirmwareTableGet = 1, -- SystemFirmwareTableMax = 2, --}} --STRUCT!{struct SYSTEM_FIRMWARE_TABLE_INFORMATION { -- ProviderSignature: ULONG, -- Action: SYSTEM_FIRMWARE_TABLE_ACTION, -- TableID: ULONG, -- TableBufferLength: ULONG, -- TableBuffer: [UCHAR; 1], --}} --pub type PSYSTEM_FIRMWARE_TABLE_INFORMATION = *mut SYSTEM_FIRMWARE_TABLE_INFORMATION; --STRUCT!{struct SYSTEM_MEMORY_LIST_INFORMATION { -- ZeroPageCount: ULONG_PTR, -- FreePageCount: ULONG_PTR, -- ModifiedPageCount: ULONG_PTR, -- ModifiedNoWritePageCount: ULONG_PTR, -- BadPageCount: ULONG_PTR, -- PageCountByPriority: [ULONG_PTR; 8], -- RepurposedPagesByPriority: [ULONG_PTR; 8], -- ModifiedPageCountPageFile: ULONG_PTR, --}} --pub type PSYSTEM_MEMORY_LIST_INFORMATION = *mut SYSTEM_MEMORY_LIST_INFORMATION; --ENUM!{enum SYSTEM_MEMORY_LIST_COMMAND { -- MemoryCaptureAccessedBits = 0, -- MemoryCaptureAndResetAccessedBits = 1, -- MemoryEmptyWorkingSets = 2, -- MemoryFlushModifiedList = 3, -- MemoryPurgeStandbyList = 4, -- MemoryPurgeLowPriorityStandbyList = 5, -- MemoryCommandMax = 6, --}} --STRUCT!{struct SYSTEM_THREAD_CID_PRIORITY_INFORMATION { -- ClientId: CLIENT_ID, -- Priority: KPRIORITY, --}} --pub type PSYSTEM_THREAD_CID_PRIORITY_INFORMATION = *mut SYSTEM_THREAD_CID_PRIORITY_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION { -- CycleTime: ULONGLONG, --}} --pub type PSYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION = -- *mut SYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION; --STRUCT!{struct SYSTEM_REF_TRACE_INFORMATION { -- TraceEnable: BOOLEAN, -- TracePermanent: BOOLEAN, -- TraceProcessName: UNICODE_STRING, -- TracePoolTags: UNICODE_STRING, --}} --pub type PSYSTEM_REF_TRACE_INFORMATION = *mut SYSTEM_REF_TRACE_INFORMATION; --STRUCT!{struct SYSTEM_PROCESS_ID_INFORMATION { -- ProcessId: HANDLE, -- ImageName: UNICODE_STRING, --}} --pub type PSYSTEM_PROCESS_ID_INFORMATION = *mut SYSTEM_PROCESS_ID_INFORMATION; --STRUCT!{struct SYSTEM_BOOT_ENVIRONMENT_INFORMATION { -- BootIdentifier: GUID, -- FirmwareType: FIRMWARE_TYPE, -- BootFlags: ULONGLONG, --}} --BITFIELD!{SYSTEM_BOOT_ENVIRONMENT_INFORMATION BootFlags: ULONGLONG [ -- DbgMenuOsSelection set_DbgMenuOsSelection[0..1], -- DbgHiberBoot set_DbgHiberBoot[1..2], -- DbgSoftBoot set_DbgSoftBoot[2..3], -- DbgMeasuredLaunch set_DbgMeasuredLaunch[3..4], --]} --pub type PSYSTEM_BOOT_ENVIRONMENT_INFORMATION = *mut SYSTEM_BOOT_ENVIRONMENT_INFORMATION; --STRUCT!{struct SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION { -- FlagsToEnable: ULONG, -- FlagsToDisable: ULONG, --}} --pub type PSYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION = -- *mut SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION; --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --STRUCT!{struct SYSTEM_VERIFIER_INFORMATION_EX { -- VerifyMode: ULONG, -- OptionChanges: ULONG, -- PreviousBucketName: UNICODE_STRING, -- IrpCancelTimeoutMsec: ULONG, -- VerifierExtensionEnabled: ULONG, -- Reserved: [ULONG; 1], --}} --#[cfg(target_arch = "x86")] --STRUCT!{struct SYSTEM_VERIFIER_INFORMATION_EX { -- VerifyMode: ULONG, -- OptionChanges: ULONG, -- PreviousBucketName: UNICODE_STRING, -- IrpCancelTimeoutMsec: ULONG, -- VerifierExtensionEnabled: ULONG, -- Reserved: [ULONG; 3], --}} --pub type PSYSTEM_VERIFIER_INFORMATION_EX = *mut SYSTEM_VERIFIER_INFORMATION_EX; --STRUCT!{struct SYSTEM_SYSTEM_PARTITION_INFORMATION { -- SystemPartition: UNICODE_STRING, --}} --pub type PSYSTEM_SYSTEM_PARTITION_INFORMATION = *mut SYSTEM_SYSTEM_PARTITION_INFORMATION; --STRUCT!{struct SYSTEM_SYSTEM_DISK_INFORMATION { -- SystemDisk: UNICODE_STRING, --}} --pub type PSYSTEM_SYSTEM_DISK_INFORMATION = *mut SYSTEM_SYSTEM_DISK_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT { -- Hits: ULONGLONG, -- PercentFrequency: UCHAR, --}} --pub type PSYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT = *mut SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT; --STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT_WIN8 { -- Hits: ULONG, -- PercentFrequency: UCHAR, --}} --pub type PSYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT_WIN8 = -- *mut SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT_WIN8; --STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_STATE_DISTRIBUTION { -- ProcessorNumber: ULONG, -- StateCount: ULONG, -- States: [SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT; 1], --}} --pub type PSYSTEM_PROCESSOR_PERFORMANCE_STATE_DISTRIBUTION = -- *mut SYSTEM_PROCESSOR_PERFORMANCE_STATE_DISTRIBUTION; --STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION { -- ProcessorCount: ULONG, -- Offsets: [ULONG; 1], --}} --pub type PSYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION = -- *mut SYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION; --STRUCT!{struct SYSTEM_CODEINTEGRITY_INFORMATION { -- Length: ULONG, -- CodeIntegrityOptions: ULONG, --}} --pub type PSYSTEM_CODEINTEGRITY_INFORMATION = *mut SYSTEM_CODEINTEGRITY_INFORMATION; --ENUM!{enum SYSTEM_VA_TYPE { -- SystemVaTypeAll = 0, -- SystemVaTypeNonPagedPool = 1, -- SystemVaTypePagedPool = 2, -- SystemVaTypeSystemCache = 3, -- SystemVaTypeSystemPtes = 4, -- SystemVaTypeSessionSpace = 5, -- SystemVaTypeMax = 6, --}} --pub type PSYSTEM_VA_TYPE = *mut SYSTEM_VA_TYPE; --STRUCT!{struct SYSTEM_VA_LIST_INFORMATION { -- VirtualSize: SIZE_T, -- VirtualPeak: SIZE_T, -- VirtualLimit: SIZE_T, -- AllocationFailures: SIZE_T, --}} --pub type PSYSTEM_VA_LIST_INFORMATION = *mut SYSTEM_VA_LIST_INFORMATION; --STRUCT!{struct SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS { -- KeyHandle: HANDLE, -- ValueNamePointer: PUNICODE_STRING, -- RequiredLengthPointer: PULONG, -- Buffer: PUCHAR, -- BufferLength: ULONG, -- Type: ULONG, -- AppendBuffer: PUCHAR, -- AppendBufferLength: ULONG, -- CreateIfDoesntExist: BOOLEAN, -- TruncateExistingValue: BOOLEAN, --}} --pub type PSYSTEM_REGISTRY_APPEND_STRING_PARAMETERS = *mut SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS; --STRUCT!{struct SYSTEM_VHD_BOOT_INFORMATION { -- OsDiskIsVhd: BOOLEAN, -- OsVhdFilePathOffset: ULONG, -- OsVhdParentVolume: [WCHAR; ANYSIZE_ARRAY], --}} --pub type PSYSTEM_VHD_BOOT_INFORMATION = *mut SYSTEM_VHD_BOOT_INFORMATION; --STRUCT!{struct SYSTEM_LOW_PRIORITY_IO_INFORMATION { -- LowPriReadOperations: ULONG, -- LowPriWriteOperations: ULONG, -- KernelBumpedToNormalOperations: ULONG, -- LowPriPagingReadOperations: ULONG, -- KernelPagingReadsBumpedToNormal: ULONG, -- LowPriPagingWriteOperations: ULONG, -- KernelPagingWritesBumpedToNormal: ULONG, -- BoostedIrpCount: ULONG, -- BoostedPagingIrpCount: ULONG, -- BlanketBoostCount: ULONG, --}} --pub type PSYSTEM_LOW_PRIORITY_IO_INFORMATION = *mut SYSTEM_LOW_PRIORITY_IO_INFORMATION; --ENUM!{enum TPM_BOOT_ENTROPY_RESULT_CODE { -- TpmBootEntropyStructureUninitialized = 0, -- TpmBootEntropyDisabledByPolicy = 1, -- TpmBootEntropyNoTpmFound = 2, -- TpmBootEntropyTpmError = 3, -- TpmBootEntropySuccess = 4, --}} --STRUCT!{struct TPM_BOOT_ENTROPY_NT_RESULT { -- Policy: ULONGLONG, -- ResultCode: TPM_BOOT_ENTROPY_RESULT_CODE, -- ResultStatus: NTSTATUS, -- Time: ULONGLONG, -- EntropyLength: ULONG, -- EntropyData: [UCHAR; 40], --}} --pub type PTPM_BOOT_ENTROPY_NT_RESULT = *mut TPM_BOOT_ENTROPY_NT_RESULT; --STRUCT!{struct SYSTEM_VERIFIER_COUNTERS_INFORMATION { -- Legacy: SYSTEM_VERIFIER_INFORMATION, -- RaiseIrqls: ULONG, -- AcquireSpinLocks: ULONG, -- SynchronizeExecutions: ULONG, -- AllocationsWithNoTag: ULONG, -- AllocationsFailed: ULONG, -- AllocationsFailedDeliberately: ULONG, -- LockedBytes: SIZE_T, -- PeakLockedBytes: SIZE_T, -- MappedLockedBytes: SIZE_T, -- PeakMappedLockedBytes: SIZE_T, -- MappedIoSpaceBytes: SIZE_T, -- PeakMappedIoSpaceBytes: SIZE_T, -- PagesForMdlBytes: SIZE_T, -- PeakPagesForMdlBytes: SIZE_T, -- ContiguousMemoryBytes: SIZE_T, -- PeakContiguousMemoryBytes: SIZE_T, -- ExecutePoolTypes: ULONG, -- ExecutePageProtections: ULONG, -- ExecutePageMappings: ULONG, -- ExecuteWriteSections: ULONG, -- SectionAlignmentFailures: ULONG, -- UnsupportedRelocs: ULONG, -- IATInExecutableSection: ULONG, --}} --pub type PSYSTEM_VERIFIER_COUNTERS_INFORMATION = *mut SYSTEM_VERIFIER_COUNTERS_INFORMATION; --STRUCT!{struct SYSTEM_ACPI_AUDIT_INFORMATION { -- RsdpCount: ULONG, -- Bitfields: ULONG, --}} --BITFIELD!{SYSTEM_ACPI_AUDIT_INFORMATION Bitfields: ULONG [ -- SameRsdt set_SameRsdt[0..1], -- SlicPresent set_SlicPresent[1..2], -- SlicDifferent set_SlicDifferent[2..3], --]} --pub type PSYSTEM_ACPI_AUDIT_INFORMATION = *mut SYSTEM_ACPI_AUDIT_INFORMATION; --STRUCT!{struct SYSTEM_BASIC_PERFORMANCE_INFORMATION { -- AvailablePages: SIZE_T, -- CommittedPages: SIZE_T, -- CommitLimit: SIZE_T, -- PeakCommitment: SIZE_T, --}} --pub type PSYSTEM_BASIC_PERFORMANCE_INFORMATION = *mut SYSTEM_BASIC_PERFORMANCE_INFORMATION; --STRUCT!{struct QUERY_PERFORMANCE_COUNTER_FLAGS { -- ul: ULONG, --}} --BITFIELD!{QUERY_PERFORMANCE_COUNTER_FLAGS ul: ULONG [ -- KernelTransition set_KernelTransition[0..1], -- Reserved set_Reserved[1..32], --]} --STRUCT!{struct SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION { -- Version: ULONG, -- Flags: QUERY_PERFORMANCE_COUNTER_FLAGS, -- ValidFlags: QUERY_PERFORMANCE_COUNTER_FLAGS, --}} --pub type PSYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION = -- *mut SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION; --ENUM!{enum SYSTEM_PIXEL_FORMAT { -- SystemPixelFormatUnknown = 0, -- SystemPixelFormatR8G8B8 = 1, -- SystemPixelFormatR8G8B8X8 = 2, -- SystemPixelFormatB8G8R8 = 3, -- SystemPixelFormatB8G8R8X8 = 4, --}} --STRUCT!{struct SYSTEM_BOOT_GRAPHICS_INFORMATION { -- FrameBuffer: LARGE_INTEGER, -- Width: ULONG, -- Height: ULONG, -- PixelStride: ULONG, -- Flags: ULONG, -- Format: SYSTEM_PIXEL_FORMAT, -- DisplayRotation: ULONG, --}} --pub type PSYSTEM_BOOT_GRAPHICS_INFORMATION = *mut SYSTEM_BOOT_GRAPHICS_INFORMATION; --STRUCT!{struct MEMORY_SCRUB_INFORMATION { -- Handle: HANDLE, -- PagesScrubbed: ULONG, --}} --pub type PMEMORY_SCRUB_INFORMATION = *mut MEMORY_SCRUB_INFORMATION; --STRUCT!{struct PEBS_DS_SAVE_AREA { -- BtsBufferBase: ULONGLONG, -- BtsIndex: ULONGLONG, -- BtsAbsoluteMaximum: ULONGLONG, -- BtsInterruptThreshold: ULONGLONG, -- PebsBufferBase: ULONGLONG, -- PebsIndex: ULONGLONG, -- PebsAbsoluteMaximum: ULONGLONG, -- PebsInterruptThreshold: ULONGLONG, -- PebsCounterReset0: ULONGLONG, -- PebsCounterReset1: ULONGLONG, -- PebsCounterReset2: ULONGLONG, -- PebsCounterReset3: ULONGLONG, --}} --pub type PPEBS_DS_SAVE_AREA = *mut PEBS_DS_SAVE_AREA; --STRUCT!{struct PROCESSOR_PROFILE_CONTROL_AREA { -- PebsDsSaveArea: PEBS_DS_SAVE_AREA, --}} --pub type PPROCESSOR_PROFILE_CONTROL_AREA = *mut PROCESSOR_PROFILE_CONTROL_AREA; --STRUCT!{struct SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA { -- ProcessorProfileControlArea: PROCESSOR_PROFILE_CONTROL_AREA, -- Allocate: BOOLEAN, --}} --pub type PSYSTEM_PROCESSOR_PROFILE_CONTROL_AREA = *mut SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA; --STRUCT!{struct MEMORY_COMBINE_INFORMATION { -- Handle: HANDLE, -- PagesCombined: ULONG_PTR, --}} --pub type PMEMORY_COMBINE_INFORMATION = *mut MEMORY_COMBINE_INFORMATION; --pub const MEMORY_COMBINE_FLAGS_COMMON_PAGES_ONLY: ULONG = 0x4; --STRUCT!{struct MEMORY_COMBINE_INFORMATION_EX { -- Handle: HANDLE, -- PagesCombined: ULONG_PTR, -- Flags: ULONG, --}} --pub type PMEMORY_COMBINE_INFORMATION_EX = *mut MEMORY_COMBINE_INFORMATION_EX; --STRUCT!{struct MEMORY_COMBINE_INFORMATION_EX2 { -- Handle: HANDLE, -- PagesCombined: ULONG_PTR, -- Flags: ULONG, -- ProcessHandle: HANDLE, --}} --pub type PMEMORY_COMBINE_INFORMATION_EX2 = *mut MEMORY_COMBINE_INFORMATION_EX2; --STRUCT!{struct SYSTEM_CONSOLE_INFORMATION { -- Bitfields: ULONG, --}} --BITFIELD!{SYSTEM_CONSOLE_INFORMATION Bitfields: ULONG [ -- DriverLoaded set_DriverLoaded[0..1], -- Spare set_Spare[1..32], --]} --pub type PSYSTEM_CONSOLE_INFORMATION = *mut SYSTEM_CONSOLE_INFORMATION; --STRUCT!{struct SYSTEM_PLATFORM_BINARY_INFORMATION { -- PhysicalAddress: ULONG64, -- HandoffBuffer: PVOID, -- CommandLineBuffer: PVOID, -- HandoffBufferSize: ULONG, -- CommandLineBufferSize: ULONG, --}} --pub type PSYSTEM_PLATFORM_BINARY_INFORMATION = *mut SYSTEM_PLATFORM_BINARY_INFORMATION; --STRUCT!{struct SYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION { -- NumberOfLogicalProcessors: ULONG, -- NumberOfCores: ULONG, --}} --pub type PSYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION = -- *mut SYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION; --STRUCT!{struct SYSTEM_DEVICE_DATA_INFORMATION { -- DeviceId: UNICODE_STRING, -- DataName: UNICODE_STRING, -- DataType: ULONG, -- DataBufferLength: ULONG, -- DataBuffer: PVOID, --}} --pub type PSYSTEM_DEVICE_DATA_INFORMATION = *mut SYSTEM_DEVICE_DATA_INFORMATION; --STRUCT!{struct PHYSICAL_CHANNEL_RUN { -- NodeNumber: ULONG, -- ChannelNumber: ULONG, -- BasePage: ULONGLONG, -- PageCount: ULONGLONG, -- Flags: ULONG, --}} --pub type PPHYSICAL_CHANNEL_RUN = *mut PHYSICAL_CHANNEL_RUN; --STRUCT!{struct SYSTEM_MEMORY_TOPOLOGY_INFORMATION { -- NumberOfRuns: ULONGLONG, -- NumberOfNodes: ULONG, -- NumberOfChannels: ULONG, -- Run: [PHYSICAL_CHANNEL_RUN; 1], --}} --pub type PSYSTEM_MEMORY_TOPOLOGY_INFORMATION = *mut SYSTEM_MEMORY_TOPOLOGY_INFORMATION; --STRUCT!{struct SYSTEM_MEMORY_CHANNEL_INFORMATION { -- ChannelNumber: ULONG, -- ChannelHeatIndex: ULONG, -- TotalPageCount: ULONGLONG, -- ZeroPageCount: ULONGLONG, -- FreePageCount: ULONGLONG, -- StandbyPageCount: ULONGLONG, --}} --pub type PSYSTEM_MEMORY_CHANNEL_INFORMATION = *mut SYSTEM_MEMORY_CHANNEL_INFORMATION; --STRUCT!{struct SYSTEM_BOOT_LOGO_INFORMATION { -- Flags: ULONG, -- BitmapOffset: ULONG, --}} --pub type PSYSTEM_BOOT_LOGO_INFORMATION = *mut SYSTEM_BOOT_LOGO_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX { -- IdleTime: LARGE_INTEGER, -- KernelTime: LARGE_INTEGER, -- UserTime: LARGE_INTEGER, -- DpcTime: LARGE_INTEGER, -- InterruptTime: LARGE_INTEGER, -- InterruptCount: ULONG, -- Spare0: ULONG, -- AvailableTime: LARGE_INTEGER, -- Spare1: LARGE_INTEGER, -- Spare2: LARGE_INTEGER, --}} --pub type PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX = -- *mut SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX; --STRUCT!{struct SYSTEM_SECUREBOOT_POLICY_INFORMATION { -- PolicyPublisher: GUID, -- PolicyVersion: ULONG, -- PolicyOptions: ULONG, --}} --pub type PSYSTEM_SECUREBOOT_POLICY_INFORMATION = *mut SYSTEM_SECUREBOOT_POLICY_INFORMATION; --STRUCT!{struct SYSTEM_PAGEFILE_INFORMATION_EX { -- Info: SYSTEM_PAGEFILE_INFORMATION, -- MinimumSize: ULONG, -- MaximumSize: ULONG, --}} --pub type PSYSTEM_PAGEFILE_INFORMATION_EX = *mut SYSTEM_PAGEFILE_INFORMATION_EX; --STRUCT!{struct SYSTEM_SECUREBOOT_INFORMATION { -- SecureBootEnabled: BOOLEAN, -- SecureBootCapable: BOOLEAN, --}} --pub type PSYSTEM_SECUREBOOT_INFORMATION = *mut SYSTEM_SECUREBOOT_INFORMATION; --STRUCT!{struct PROCESS_DISK_COUNTERS { -- BytesRead: ULONGLONG, -- BytesWritten: ULONGLONG, -- ReadOperationCount: ULONGLONG, -- WriteOperationCount: ULONGLONG, -- FlushOperationCount: ULONGLONG, --}} --pub type PPROCESS_DISK_COUNTERS = *mut PROCESS_DISK_COUNTERS; --UNION!{union ENERGY_STATE_DURATION_u { -- Value: ULONGLONG, -- LastChangeTime: ULONG, --}} --UNION!{union ENERGY_STATE_DURATION { -- u: ENERGY_STATE_DURATION_u, -- BitFields: ULONG, --}} --pub type PENERGY_STATE_DURATION = *mut ENERGY_STATE_DURATION; --BITFIELD!{unsafe ENERGY_STATE_DURATION BitFields: ULONG [ -- Duration set_Duration[0..31], -- IsInState set_IsInState[31..32], --]} --STRUCT!{struct PROCESS_ENERGY_VALUES { -- Cycles: [[ULONGLONG; 4]; 2], -- DiskEnergy: ULONGLONG, -- NetworkTailEnergy: ULONGLONG, -- MBBTailEnergy: ULONGLONG, -- NetworkTxRxBytes: ULONGLONG, -- MBBTxRxBytes: ULONGLONG, -- ForegroundDuration: ENERGY_STATE_DURATION, -- DesktopVisibleDuration: ENERGY_STATE_DURATION, -- PSMForegroundDuration: ENERGY_STATE_DURATION, -- CompositionRendered: ULONG, -- CompositionDirtyGenerated: ULONG, -- CompositionDirtyPropagated: ULONG, -- Reserved1: ULONG, -- AttributedCycles: [[ULONGLONG; 2]; 4], -- WorkOnBehalfCycles: [[ULONGLONG; 2]; 4], --}} --pub type PPROCESS_ENERGY_VALUES = *mut PROCESS_ENERGY_VALUES; --STRUCT!{struct TIMELINE_BITMAP { -- Value: ULONGLONG, -- EndTime: ULONG, -- Bitmap: ULONG, --}} --pub type PTIMELINE_BITMAP = *mut TIMELINE_BITMAP; --STRUCT!{struct PROCESS_ENERGY_VALUES_EXTENSION_Timelines { -- CpuTimeline: TIMELINE_BITMAP, -- DiskTimeline: TIMELINE_BITMAP, -- NetworkTimeline: TIMELINE_BITMAP, -- MBBTimeline: TIMELINE_BITMAP, -- ForegroundTimeline: TIMELINE_BITMAP, -- DesktopVisibleTimeline: TIMELINE_BITMAP, -- CompositionRenderedTimeline: TIMELINE_BITMAP, -- CompositionDirtyGeneratedTimeline: TIMELINE_BITMAP, -- CompositionDirtyPropagatedTimeline: TIMELINE_BITMAP, -- InputTimeline: TIMELINE_BITMAP, -- AudioInTimeline: TIMELINE_BITMAP, -- AudioOutTimeline: TIMELINE_BITMAP, -- DisplayRequiredTimeline: TIMELINE_BITMAP, -- KeyboardInputTimeline: TIMELINE_BITMAP, --}} --STRUCT!{struct PROCESS_ENERGY_VALUES_EXTENSION_Durations { -- InputDuration: ENERGY_STATE_DURATION, -- AudioInDuration: ENERGY_STATE_DURATION, -- AudioOutDuration: ENERGY_STATE_DURATION, -- DisplayRequiredDuration: ENERGY_STATE_DURATION, -- PSMBackgroundDuration: ENERGY_STATE_DURATION, --}} --STRUCT!{struct PROCESS_ENERGY_VALUES_EXTENSION { -- Timelines: PROCESS_ENERGY_VALUES_EXTENSION_Timelines, -- Durations: PROCESS_ENERGY_VALUES_EXTENSION_Durations, -- KeyboardInput: ULONG, -- MouseInput: ULONG, --}} --pub type PPROCESS_ENERGY_VALUES_EXTENSION = *mut PROCESS_ENERGY_VALUES_EXTENSION; --STRUCT!{struct PROCESS_EXTENDED_ENERGY_VALUES { -- Base: PROCESS_ENERGY_VALUES, -- Extension: PROCESS_ENERGY_VALUES_EXTENSION, --}} --pub type PPROCESS_EXTENDED_ENERGY_VALUES = *mut PROCESS_EXTENDED_ENERGY_VALUES; --ENUM!{enum SYSTEM_PROCESS_CLASSIFICATION { -- SystemProcessClassificationNormal = 0, -- SystemProcessClassificationSystem = 1, -- SystemProcessClassificationSecureSystem = 2, -- SystemProcessClassificationMemCompression = 3, -- SystemProcessClassificationRegistry = 4, -- SystemProcessClassificationMaximum = 5, --}} --STRUCT!{struct SYSTEM_PROCESS_INFORMATION_EXTENSION { -- DiskCounters: PROCESS_DISK_COUNTERS, -- ContextSwitches: ULONGLONG, -- Flags: ULONG, -- UserSidOffset: ULONG, -- PackageFullNameOffset: ULONG, -- EnergyValues: PROCESS_ENERGY_VALUES, -- AppIdOffset: ULONG, -- SharedCommitCharge: SIZE_T, -- JobObjectId: ULONG, -- SpareUlong: ULONG, -- ProcessSequenceNumber: ULONGLONG, --}} --BITFIELD!{SYSTEM_PROCESS_INFORMATION_EXTENSION Flags: ULONG [ -- HasStrongId set_HasStrongId[0..1], -- Classification set_Classification[1..5], -- BackgroundActivityModerated set_BackgroundActivityModerated[5..6], -- Spare set_Spare[6..32], --]} --pub type PSYSTEM_PROCESS_INFORMATION_EXTENSION = *mut SYSTEM_PROCESS_INFORMATION_EXTENSION; --STRUCT!{struct SYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION { -- EfiLauncherEnabled: BOOLEAN, --}} --pub type PSYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION = -- *mut SYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION; --STRUCT!{struct SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX { -- DebuggerAllowed: BOOLEAN, -- DebuggerEnabled: BOOLEAN, -- DebuggerPresent: BOOLEAN, --}} --pub type PSYSTEM_KERNEL_DEBUGGER_INFORMATION_EX = *mut SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX; --STRUCT!{struct SYSTEM_ELAM_CERTIFICATE_INFORMATION { -- ElamDriverFile: HANDLE, --}} --pub type PSYSTEM_ELAM_CERTIFICATE_INFORMATION = *mut SYSTEM_ELAM_CERTIFICATE_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_FEATURES_INFORMATION { -- ProcessorFeatureBits: ULONGLONG, -- Reserved: [ULONGLONG; 3], --}} --pub type PSYSTEM_PROCESSOR_FEATURES_INFORMATION = *mut SYSTEM_PROCESSOR_FEATURES_INFORMATION; --STRUCT!{struct SYSTEM_MANUFACTURING_INFORMATION { -- Options: ULONG, -- ProfileName: UNICODE_STRING, --}} --pub type PSYSTEM_MANUFACTURING_INFORMATION = *mut SYSTEM_MANUFACTURING_INFORMATION; --STRUCT!{struct SYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION { -- Enabled: BOOLEAN, --}} --pub type PSYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION = -- *mut SYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION; --STRUCT!{struct HV_DETAILS { -- Data: [ULONG; 4], --}} --pub type PHV_DETAILS = *mut HV_DETAILS; --STRUCT!{struct SYSTEM_HYPERVISOR_DETAIL_INFORMATION { -- HvVendorAndMaxFunction: HV_DETAILS, -- HypervisorInterface: HV_DETAILS, -- HypervisorVersion: HV_DETAILS, -- HvFeatures: HV_DETAILS, -- HwFeatures: HV_DETAILS, -- EnlightenmentInfo: HV_DETAILS, -- ImplementationLimits: HV_DETAILS, --}} --pub type PSYSTEM_HYPERVISOR_DETAIL_INFORMATION = *mut SYSTEM_HYPERVISOR_DETAIL_INFORMATION; --STRUCT!{struct SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION { -- Cycles: [[ULONGLONG; 4]; 2], --}} --pub type PSYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION = *mut SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION; --STRUCT!{struct SYSTEM_TPM_INFORMATION { -- Flags: ULONG, --}} --pub type PSYSTEM_TPM_INFORMATION = *mut SYSTEM_TPM_INFORMATION; --STRUCT!{struct SYSTEM_VSM_PROTECTION_INFORMATION { -- DmaProtectionsAvailable: BOOLEAN, -- DmaProtectionsInUse: BOOLEAN, -- HardwareMbecAvailable: BOOLEAN, --}} --pub type PSYSTEM_VSM_PROTECTION_INFORMATION = *mut SYSTEM_VSM_PROTECTION_INFORMATION; --STRUCT!{struct SYSTEM_CODEINTEGRITYPOLICY_INFORMATION { -- Options: ULONG, -- HVCIOptions: ULONG, -- Version: ULONGLONG, -- PolicyGuid: GUID, --}} --pub type PSYSTEM_CODEINTEGRITYPOLICY_INFORMATION = *mut SYSTEM_CODEINTEGRITYPOLICY_INFORMATION; --STRUCT!{struct SYSTEM_ISOLATED_USER_MODE_INFORMATION { -- Bitfields1: BOOLEAN, -- Bitfields2: BOOLEAN, -- Spare0: [BOOLEAN; 6], -- Spare1: ULONGLONG, --}} --BITFIELD!{SYSTEM_ISOLATED_USER_MODE_INFORMATION Bitfields1: BOOLEAN [ -- SecureKernelRunning set_SecureKernelRunning[0..1], -- HvciEnabled set_HvciEnabled[1..2], -- HvciStrictMode set_HvciStrictMode[2..3], -- DebugEnabled set_DebugEnabled[3..4], -- FirmwarePageProtection set_FirmwarePageProtection[4..5], -- EncryptionKeyAvailable set_EncryptionKeyAvailable[5..6], -- SpareFlags set_SpareFlags[6..7], -- TrustletRunning set_TrustletRunning[7..8], --]} --BITFIELD!{SYSTEM_ISOLATED_USER_MODE_INFORMATION Bitfields2: BOOLEAN [ -- SpareFlags2 set_SpareFlags2[0..1], --]} --pub type PSYSTEM_ISOLATED_USER_MODE_INFORMATION = *mut SYSTEM_ISOLATED_USER_MODE_INFORMATION; --STRUCT!{struct SYSTEM_SINGLE_MODULE_INFORMATION { -- TargetModuleAddress: PVOID, -- ExInfo: RTL_PROCESS_MODULE_INFORMATION_EX, --}} --pub type PSYSTEM_SINGLE_MODULE_INFORMATION = *mut SYSTEM_SINGLE_MODULE_INFORMATION; --STRUCT!{struct SYSTEM_INTERRUPT_CPU_SET_INFORMATION { -- Gsiv: ULONG, -- Group: USHORT, -- CpuSets: ULONGLONG, --}} --pub type PSYSTEM_INTERRUPT_CPU_SET_INFORMATION = *mut SYSTEM_INTERRUPT_CPU_SET_INFORMATION; --STRUCT!{struct SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION { -- PolicyInformation: SYSTEM_SECUREBOOT_POLICY_INFORMATION, -- PolicySize: ULONG, -- Policy: [UCHAR; 1], --}} --pub type PSYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION = -- *mut SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION; --STRUCT!{struct SYSTEM_ROOT_SILO_INFORMATION { -- NumberOfSilos: ULONG, -- SiloIdList: [ULONG; 1], --}} --pub type PSYSTEM_ROOT_SILO_INFORMATION = *mut SYSTEM_ROOT_SILO_INFORMATION; --STRUCT!{struct SYSTEM_CPU_SET_TAG_INFORMATION { -- Tag: ULONGLONG, -- CpuSets: [ULONGLONG; 1], --}} --pub type PSYSTEM_CPU_SET_TAG_INFORMATION = *mut SYSTEM_CPU_SET_TAG_INFORMATION; --STRUCT!{struct SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION { -- ExtentCount: ULONG, -- ValidStructureSize: ULONG, -- NextExtentIndex: ULONG, -- ExtentRestart: ULONG, -- CycleCount: ULONG, -- TimeoutCount: ULONG, -- CycleTime: ULONGLONG, -- CycleTimeMax: ULONGLONG, -- ExtentTime: ULONGLONG, -- ExtentTimeIndex: ULONG, -- ExtentTimeMaxIndex: ULONG, -- ExtentTimeMax: ULONGLONG, -- HyperFlushTimeMax: ULONGLONG, -- TranslateVaTimeMax: ULONGLONG, -- DebugExemptionCount: ULONGLONG, -- TbHitCount: ULONGLONG, -- TbMissCount: ULONGLONG, -- VinaPendingYield: ULONGLONG, -- HashCycles: ULONGLONG, -- HistogramOffset: ULONG, -- HistogramBuckets: ULONG, -- HistogramShift: ULONG, -- Reserved1: ULONG, -- PageNotPresentCount: ULONGLONG, --}} --pub type PSYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION = -- *mut SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION; --STRUCT!{struct SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION { -- PlatformManifestSize: ULONG, -- PlatformManifest: [UCHAR; 1], --}} --pub type PSYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION = -- *mut SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION; --STRUCT!{struct SYSTEM_MEMORY_USAGE_INFORMATION { -- TotalPhysicalBytes: ULONGLONG, -- AvailableBytes: ULONGLONG, -- ResidentAvailableBytes: LONGLONG, -- CommittedBytes: ULONGLONG, -- SharedCommittedBytes: ULONGLONG, -- CommitLimitBytes: ULONGLONG, -- PeakCommitmentBytes: ULONGLONG, --}} --pub type PSYSTEM_MEMORY_USAGE_INFORMATION = *mut SYSTEM_MEMORY_USAGE_INFORMATION; --STRUCT!{struct SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION { -- ImageFile: HANDLE, -- Type: ULONG, --}} --pub type PSYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION = -- *mut SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION; --STRUCT!{struct SYSTEM_PHYSICAL_MEMORY_INFORMATION { -- TotalPhysicalBytes: ULONGLONG, -- LowestPhysicalAddress: ULONGLONG, -- HighestPhysicalAddress: ULONGLONG, --}} --pub type PSYSTEM_PHYSICAL_MEMORY_INFORMATION = *mut SYSTEM_PHYSICAL_MEMORY_INFORMATION; --ENUM!{enum SYSTEM_ACTIVITY_MODERATION_STATE { -- SystemActivityModerationStateSystemManaged = 0, -- SystemActivityModerationStateUserManagedAllowThrottling = 1, -- SystemActivityModerationStateUserManagedDisableThrottling = 2, -- MaxSystemActivityModerationState = 3, --}} --ENUM!{enum SYSTEM_ACTIVITY_MODERATION_APP_TYPE { -- SystemActivityModerationAppTypeClassic = 0, -- SystemActivityModerationAppTypePackaged = 1, -- MaxSystemActivityModerationAppType = 2, --}} --STRUCT!{struct SYSTEM_ACTIVITY_MODERATION_INFO { -- Identifier: UNICODE_STRING, -- ModerationState: SYSTEM_ACTIVITY_MODERATION_STATE, -- AppType: SYSTEM_ACTIVITY_MODERATION_APP_TYPE, --}} --pub type PSYSTEM_ACTIVITY_MODERATION_INFO = *mut SYSTEM_ACTIVITY_MODERATION_INFO; --STRUCT!{struct SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS { -- UserKeyHandle: HANDLE, --}} --pub type PSYSTEM_ACTIVITY_MODERATION_USER_SETTINGS = *mut SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS; --STRUCT!{struct SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION { -- Flags: ULONG, -- UnlockId: [UCHAR; 32], --}} --BITFIELD!{SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION Flags: ULONG [ -- Locked set_Locked[0..1], -- Unlockable set_Unlockable[1..2], -- UnlockApplied set_UnlockApplied[2..3], -- UnlockIdValid set_UnlockIdValid[3..4], -- Reserved set_Reserved[4..32], --]} --pub type PSYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION = *mut SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION; --STRUCT!{struct SYSTEM_FLUSH_INFORMATION { -- SupportedFlushMethods: ULONG, -- ProcessorCacheFlushSize: ULONG, -- SystemFlushCapabilities: ULONGLONG, -- Reserved: [ULONGLONG; 2], --}} --pub type PSYSTEM_FLUSH_INFORMATION = *mut SYSTEM_FLUSH_INFORMATION; --STRUCT!{struct SYSTEM_WRITE_CONSTRAINT_INFORMATION { -- WriteConstraintPolicy: ULONG, -- Reserved: ULONG, --}} --pub type PSYSTEM_WRITE_CONSTRAINT_INFORMATION = *mut SYSTEM_WRITE_CONSTRAINT_INFORMATION; --STRUCT!{struct SYSTEM_KERNEL_VA_SHADOW_INFORMATION { -- Flags: ULONG, --}} --BITFIELD!{SYSTEM_KERNEL_VA_SHADOW_INFORMATION Flags: ULONG [ -- KvaShadowEnabled set_KvaShadowEnabled[0..1], -- KvaShadowUserGlobal set_KvaShadowUserGlobal[1..2], -- KvaShadowPcid set_KvaShadowPcid[2..3], -- KvaShadowInvpcid set_KvaShadowInvpcid[3..4], -- KvaShadowRequired set_KvaShadowRequired[4..5], -- KvaShadowRequiredAvailable set_KvaShadowRequiredAvailable[5..6], -- InvalidPteBit set_InvalidPteBit[6..12], -- L1DataCacheFlushSupported set_L1DataCacheFlushSupported[12..13], -- L1TerminalFaultMitigationPresent set_L1TerminalFaultMitigationPresent[13..14], -- Reserved set_Reserved[14..32], --]} --pub type PSYSTEM_KERNEL_VA_SHADOW_INFORMATION = *mut SYSTEM_KERNEL_VA_SHADOW_INFORMATION; --STRUCT!{struct SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION { -- FileHandle: HANDLE, -- ImageSize: ULONG, -- Image: PVOID, --}} --pub type PSYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION = -- *mut SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION; --STRUCT!{struct SYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION { -- HypervisorSharedUserVa: PVOID, --}} --pub type PSYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION = -- *mut SYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION; --STRUCT!{struct SYSTEM_SPECULATION_CONTROL_INFORMATION { -- Flags: ULONG, --}} --BITFIELD!{SYSTEM_SPECULATION_CONTROL_INFORMATION Flags: ULONG [ -- BpbEnabled set_BpbEnabled[0..1], -- BpbDisabledSystemPolicy set_BpbDisabledSystemPolicy[1..2], -- BpbDisabledNoHardwareSupport set_BpbDisabledNoHardwareSupport[2..3], -- SpecCtrlEnumerated set_SpecCtrlEnumerated[3..4], -- SpecCmdEnumerated set_SpecCmdEnumerated[4..5], -- IbrsPresent set_IbrsPresent[5..6], -- StibpPresent set_StibpPresent[6..7], -- SmepPresent set_SmepPresent[7..8], -- SpeculativeStoreBypassDisableAvailable set_SpeculativeStoreBypassDisableAvailable[8..9], -- SpeculativeStoreBypassDisableSupported set_SpeculativeStoreBypassDisableSupported[9..10], -- SpeculativeStoreBypassDisabledSystemWide set_SpeculativeStoreBypassDisabledSystemWide[10..11], -- SpeculativeStoreBypassDisabledKernel set_SpeculativeStoreBypassDisabledKernel[11..12], -- SpeculativeStoreBypassDisableRequired set_SpeculativeStoreBypassDisableRequired[12..13], -- BpbDisabledKernelToUser set_BpbDisabledKernelToUser[13..14], -- SpecCtrlRetpolineEnabled set_SpecCtrlRetpolineEnabled[14..15], -- SpecCtrlImportOptimizationEnabled set_SpecCtrlImportOptimizationEnabled[15..16], -- Reserved set_Reserved[16..32], --]} --pub type PSYSTEM_SPECULATION_CONTROL_INFORMATION = *mut SYSTEM_SPECULATION_CONTROL_INFORMATION; --STRUCT!{struct SYSTEM_DMA_GUARD_POLICY_INFORMATION { -- DmaGuardPolicyEnabled: BOOLEAN, --}} --pub type PSYSTEM_DMA_GUARD_POLICY_INFORMATION = *mut SYSTEM_DMA_GUARD_POLICY_INFORMATION; --STRUCT!{struct SYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION { -- EnclaveLaunchSigner: [UCHAR; 32], --}} --pub type PSYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION = -- *mut SYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION; --STRUCT!{struct SYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION { -- WorkloadClass: ULONGLONG, -- CpuSets: [ULONGLONG; 1], --}} --pub type PSYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION = -- *mut SYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION; --EXTERN!{extern "system" { -- fn NtQuerySystemInformation( -- SystemInformationClass: SYSTEM_INFORMATION_CLASS, -- SystemInformation: PVOID, -- SystemInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtQuerySystemInformationEx( -- SystemInformationClass: SYSTEM_INFORMATION_CLASS, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- SystemInformation: PVOID, -- SystemInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetSystemInformation( -- SystemInformationClass: SYSTEM_INFORMATION_CLASS, -- SystemInformation: PVOID, -- SystemInformationLength: ULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum SYSDBG_COMMAND { -- SysDbgQueryModuleInformation = 0, -- SysDbgQueryTraceInformation = 1, -- SysDbgSetTracepoint = 2, -- SysDbgSetSpecialCall = 3, -- SysDbgClearSpecialCalls = 4, -- SysDbgQuerySpecialCalls = 5, -- SysDbgBreakPoint = 6, -- SysDbgQueryVersion = 7, -- SysDbgReadVirtual = 8, -- SysDbgWriteVirtual = 9, -- SysDbgReadPhysical = 10, -- SysDbgWritePhysical = 11, -- SysDbgReadControlSpace = 12, -- SysDbgWriteControlSpace = 13, -- SysDbgReadIoSpace = 14, -- SysDbgWriteIoSpace = 15, -- SysDbgReadMsr = 16, -- SysDbgWriteMsr = 17, -- SysDbgReadBusData = 18, -- SysDbgWriteBusData = 19, -- SysDbgCheckLowMemory = 20, -- SysDbgEnableKernelDebugger = 21, -- SysDbgDisableKernelDebugger = 22, -- SysDbgGetAutoKdEnable = 23, -- SysDbgSetAutoKdEnable = 24, -- SysDbgGetPrintBufferSize = 25, -- SysDbgSetPrintBufferSize = 26, -- SysDbgGetKdUmExceptionEnable = 27, -- SysDbgSetKdUmExceptionEnable = 28, -- SysDbgGetTriageDump = 29, -- SysDbgGetKdBlockEnable = 30, -- SysDbgSetKdBlockEnable = 31, -- SysDbgRegisterForUmBreakInfo = 32, -- SysDbgGetUmBreakPid = 33, -- SysDbgClearUmBreakPid = 34, -- SysDbgGetUmAttachPid = 35, -- SysDbgClearUmAttachPid = 36, -- SysDbgGetLiveKernelDump = 37, --}} --pub type PSYSDBG_COMMAND = *mut SYSDBG_COMMAND; --STRUCT!{struct SYSDBG_VIRTUAL { -- Address: PVOID, -- Buffer: PVOID, -- Request: ULONG, --}} --pub type PSYSDBG_VIRTUAL = *mut SYSDBG_VIRTUAL; --STRUCT!{struct SYSDBG_PHYSICAL { -- Address: PHYSICAL_ADDRESS, -- Buffer: PVOID, -- Request: ULONG, --}} --pub type PSYSDBG_PHYSICAL = *mut SYSDBG_PHYSICAL; --STRUCT!{struct SYSDBG_CONTROL_SPACE { -- Address: ULONG64, -- Buffer: PVOID, -- Request: ULONG, -- Processor: ULONG, --}} --pub type PSYSDBG_CONTROL_SPACE = *mut SYSDBG_CONTROL_SPACE; --STRUCT!{struct SYSDBG_IO_SPACE { -- Address: ULONG64, -- Buffer: PVOID, -- Request: ULONG, -- InterfaceType: INTERFACE_TYPE, -- BusNumber: ULONG, -- AddressSpace: ULONG, --}} --pub type PSYSDBG_IO_SPACE = *mut SYSDBG_IO_SPACE; --STRUCT!{struct SYSDBG_MSR { -- Msr: ULONG, -- Data: ULONG64, --}} --pub type PSYSDBG_MSR = *mut SYSDBG_MSR; --STRUCT!{struct SYSDBG_BUS_DATA { -- Address: ULONG, -- Buffer: PVOID, -- Request: ULONG, -- BusDataType: BUS_DATA_TYPE, -- BusNumber: ULONG, -- SlotNumber: ULONG, --}} --pub type PSYSDBG_BUS_DATA = *mut SYSDBG_BUS_DATA; --STRUCT!{struct SYSDBG_TRIAGE_DUMP { -- Flags: ULONG, -- BugCheckCode: ULONG, -- BugCheckParam1: ULONG_PTR, -- BugCheckParam2: ULONG_PTR, -- BugCheckParam3: ULONG_PTR, -- BugCheckParam4: ULONG_PTR, -- ProcessHandles: ULONG, -- ThreadHandles: ULONG, -- Handles: PHANDLE, --}} --pub type PSYSDBG_TRIAGE_DUMP = *mut SYSDBG_TRIAGE_DUMP; --STRUCT!{struct SYSDBG_LIVEDUMP_CONTROL_FLAGS { -- AsUlong: ULONG, --}} --BITFIELD!{SYSDBG_LIVEDUMP_CONTROL_FLAGS AsUlong: ULONG [ -- UseDumpStorageStack set_UseDumpStorageStack[0..1], -- CompressMemoryPagesData set_CompressMemoryPagesData[1..2], -- IncludeUserSpaceMemoryPages set_IncludeUserSpaceMemoryPages[2..3], -- AbortIfMemoryPressure set_AbortIfMemoryPressure[3..4], -- Reserved set_Reserved[4..32], --]} --pub type PSYSDBG_LIVEDUMP_CONTROL_FLAGS = *mut SYSDBG_LIVEDUMP_CONTROL_FLAGS; --STRUCT!{struct SYSDBG_LIVEDUMP_CONTROL_ADDPAGES { -- AsUlong: ULONG, --}} --BITFIELD!{SYSDBG_LIVEDUMP_CONTROL_ADDPAGES AsUlong: ULONG [ -- HypervisorPages set_HypervisorPages[0..1], -- Reserved set_Reserved[1..32], --]} --pub type PSYSDBG_LIVEDUMP_CONTROL_ADDPAGES = *mut SYSDBG_LIVEDUMP_CONTROL_ADDPAGES; --pub const SYSDBG_LIVEDUMP_CONTROL_VERSION: ULONG = 1; --STRUCT!{struct SYSDBG_LIVEDUMP_CONTROL { -- Version: ULONG, -- BugCheckCode: ULONG, -- BugCheckParam1: ULONG_PTR, -- BugCheckParam2: ULONG_PTR, -- BugCheckParam3: ULONG_PTR, -- BugCheckParam4: ULONG_PTR, -- DumpFileHandle: HANDLE, -- CancelEventHandle: HANDLE, -- Flags: SYSDBG_LIVEDUMP_CONTROL_FLAGS, -- AddPagesControl: SYSDBG_LIVEDUMP_CONTROL_ADDPAGES, --}} --pub type PSYSDBG_LIVEDUMP_CONTROL = *mut SYSDBG_LIVEDUMP_CONTROL; --EXTERN!{extern "system" { -- fn NtSystemDebugControl( -- Command: SYSDBG_COMMAND, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- OutputBuffer: PVOID, -- OutputBufferLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum HARDERROR_RESPONSE_OPTION { -- OptionAbortRetryIgnore = 0, -- OptionOk = 1, -- OptionOkCancel = 2, -- OptionRetryCancel = 3, -- OptionYesNo = 4, -- OptionYesNoCancel = 5, -- OptionShutdownSystem = 6, -- OptionOkNoWait = 7, -- OptionCancelTryContinue = 8, --}} --ENUM!{enum HARDERROR_RESPONSE { -- ResponseReturnToCaller = 0, -- ResponseNotHandled = 1, -- ResponseAbort = 2, -- ResponseCancel = 3, -- ResponseIgnore = 4, -- ResponseNo = 5, -- ResponseOk = 6, -- ResponseRetry = 7, -- ResponseYes = 8, -- ResponseTryAgain = 9, -- ResponseContinue = 10, --}} --pub const HARDERROR_OVERRIDE_ERRORMODE: ULONG = 0x10000000; --EXTERN!{extern "system" { -- fn NtRaiseHardError( -- ErrorStatus: NTSTATUS, -- NumberOfParameters: ULONG, -- UnicodeStringParameterMask: ULONG, -- Parameters: PULONG_PTR, -- ValidResponseOptions: ULONG, -- Response: PULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum ALTERNATIVE_ARCHITECTURE_TYPE { -- StandardDesign = 0, -- NEC98x86 = 1, -- EndAlternatives = 2, --}} --pub const PROCESSOR_FEATURE_MAX: usize = 64; --pub const MAX_WOW64_SHARED_ENTRIES: u32 = 16; --pub const NX_SUPPORT_POLICY_ALWAYSOFF: u32 = 0; --pub const NX_SUPPORT_POLICY_ALWAYSON: u32 = 1; --pub const NX_SUPPORT_POLICY_OPTIN: u32 = 2; --pub const NX_SUPPORT_POLICY_OPTOUT: u32 = 3; --UNION!{union KUSER_SHARED_DATA_u { -- TickCount: KSYSTEM_TIME, -- TickCountQuad: ULONG64, -- ReservedTickCountOverlay: [ULONG; 3], --}} --STRUCT!{#[repr(packed(4))] struct KUSER_SHARED_DATA { -- TickCountLowDeprecated: ULONG, -- TickCountMultiplier: ULONG, -- InterruptTime: KSYSTEM_TIME, -- SystemTime: KSYSTEM_TIME, -- TimeZoneBias: KSYSTEM_TIME, -- ImageNumberLow: USHORT, -- ImageNumberHigh: USHORT, -- NtSystemRoot: [WCHAR; 260], -- MaxStackTraceDepth: ULONG, -- CryptoExponent: ULONG, -- TimeZoneId: ULONG, -- LargePageMinimum: ULONG, -- AitSamplingValue: ULONG, -- AppCompatFlag: ULONG, -- RNGSeedVersion: ULONGLONG, -- GlobalValidationRunlevel: ULONG, -- TimeZoneBiasStamp: LONG, -- NtBuildNumber: ULONG, -- NtProductType: NT_PRODUCT_TYPE, -- ProductTypeIsValid: BOOLEAN, -- Reserved0: [UCHAR; 1], -- NativeProcessorArchitecture: USHORT, -- NtMajorVersion: ULONG, -- NtMinorVersion: ULONG, -- ProcessorFeatures: [BOOLEAN; PROCESSOR_FEATURE_MAX], -- Reserved1: ULONG, -- Reserved3: ULONG, -- TimeSlip: ULONG, -- AlternativeArchitecture: ALTERNATIVE_ARCHITECTURE_TYPE, -- BootId: ULONG, -- SystemExpirationDate: LARGE_INTEGER, -- SuiteMask: ULONG, -- KdDebuggerEnabled: BOOLEAN, -- MitigationPolicies: UCHAR, -- Reserved6: [UCHAR; 2], -- ActiveConsoleId: ULONG, -- DismountCount: ULONG, -- ComPlusPackage: ULONG, -- LastSystemRITEventTickCount: ULONG, -- NumberOfPhysicalPages: ULONG, -- SafeBootMode: BOOLEAN, -- VirtualizationFlags: UCHAR, -- Reserved12: [UCHAR; 2], -- SharedDataFlags: ULONG, -- DataFlagsPad: [ULONG; 1], -- TestRetInstruction: ULONGLONG, -- QpcFrequency: LONGLONG, -- SystemCall: ULONG, -- SystemCallPad0: ULONG, -- SystemCallPad: [ULONGLONG; 2], -- u: KUSER_SHARED_DATA_u, -- //TickCountPad: [ULONG; 1], -- Cookie: ULONG, -- CookiePad: [ULONG; 1], -- ConsoleSessionForegroundProcessId: LONGLONG, -- TimeUpdateLock: ULONGLONG, -- BaselineSystemTimeQpc: ULONGLONG, -- BaselineInterruptTimeQpc: ULONGLONG, -- QpcSystemTimeIncrement: ULONGLONG, -- QpcInterruptTimeIncrement: ULONGLONG, -- QpcSystemTimeIncrementShift: UCHAR, -- QpcInterruptTimeIncrementShift: UCHAR, -- UnparkedProcessorCount: USHORT, -- EnclaveFeatureMask: [ULONG; 4], -- TelemetryCoverageRound: ULONG, -- UserModeGlobalLogger: [USHORT; 16], -- ImageFileExecutionOptions: ULONG, -- LangGenerationCount: ULONG, -- Reserved4: ULONGLONG, -- InterruptTimeBias: ULONG64, -- QpcBias: ULONG64, -- ActiveProcessorCount: ULONG, -- ActiveGroupCount: UCHAR, -- Reserved9: UCHAR, -- QpcData: UCHAR, -- TimeZoneBiasEffectiveStart: LARGE_INTEGER, -- TimeZoneBiasEffectiveEnd: LARGE_INTEGER, -- XState: XSTATE_CONFIGURATION, --}} --BITFIELD!{KUSER_SHARED_DATA MitigationPolicies: UCHAR [ -- NXSupportPolicy set_NXSupportPolicy[0..2], -- SEHValidationPolicy set_SEHValidationPolicy[2..4], -- CurDirDevicesSkippedForDlls set_CurDirDevicesSkippedForDlls[4..6], -- Reserved set_Reserved[6..8], --]} --BITFIELD!{KUSER_SHARED_DATA SharedDataFlags: ULONG [ -- DbgErrorPortPresent set_DbgErrorPortPresent[0..1], -- DbgElevationEnabled set_DbgElevationEnabled[1..2], -- DbgVirtEnabled set_DbgVirtEnabled[2..3], -- DbgInstallerDetectEnabled set_DbgInstallerDetectEnabled[3..4], -- DbgLkgEnabled set_DbgLkgEnabled[4..5], -- DbgDynProcessorEnabled set_DbgDynProcessorEnabled[5..6], -- DbgConsoleBrokerEnabled set_DbgConsoleBrokerEnabled[6..7], -- DbgSecureBootEnabled set_DbgSecureBootEnabled[7..8], -- DbgMultiSessionSku set_DbgMultiSessionSku[8..9], -- DbgMultiUsersInSessionSku set_DbgMultiUsersInSessionSku[9..10], -- DbgStateSeparationEnabled set_DbgStateSeparationEnabled[10..11], -- SpareBits set_SpareBits[11..32], --]} --BITFIELD!{KUSER_SHARED_DATA QpcData: UCHAR [ -- QpcBypassEnabled set_QpcBypassEnabled[0..1], -- QpcShift set_QpcShift[1..2], --]} --pub type PKUSER_SHARED_DATA = *mut KUSER_SHARED_DATA; --pub const USER_SHARED_DATA: *const KUSER_SHARED_DATA = 0x7ffe0000 as *const _; --#[inline] --pub unsafe fn NtGetTickCount64() -> ULONGLONG { -- let mut tick_count: ULARGE_INTEGER = uninitialized(); -- #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] { -- *tick_count.QuadPart_mut() = read_volatile(&(*USER_SHARED_DATA).u.TickCountQuad); -- } -- #[cfg(target_arch = "x86")] { -- loop { -- tick_count.s_mut().HighPart = -- read_volatile(&(*USER_SHARED_DATA).u.TickCount.High1Time) as u32; -- tick_count.s_mut().LowPart = read_volatile(&(*USER_SHARED_DATA).u.TickCount.LowPart); -- if tick_count.s().HighPart == read_volatile(&(*USER_SHARED_DATA).u.TickCount.High2Time) -- as u32 -- { -- break; -- } -- spin_loop_hint(); -- } -- } -- (UInt32x32To64(tick_count.s().LowPart, (*USER_SHARED_DATA).TickCountMultiplier) >> 24) -- + (UInt32x32To64( -- tick_count.s().HighPart as u32, -- (*USER_SHARED_DATA).TickCountMultiplier, -- ) << 8) --} --#[inline] --pub unsafe fn NtGetTickCount() -> ULONG { -- #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] { -- ((read_volatile(&(*USER_SHARED_DATA).u.TickCountQuad) -- * (*USER_SHARED_DATA).TickCountMultiplier as u64) >> 24) as u32 -- } -- #[cfg(target_arch = "x86")] { -- let mut tick_count: ULARGE_INTEGER = uninitialized(); -- loop { -- tick_count.s_mut().HighPart = read_volatile(&(*USER_SHARED_DATA).u.TickCount.High1Time) -- as u32; -- tick_count.s_mut().LowPart = read_volatile(&(*USER_SHARED_DATA).u.TickCount.LowPart); -- if tick_count.s().HighPart == read_volatile(&(*USER_SHARED_DATA).u.TickCount.High2Time) -- as u32 -- { -- break; -- } -- spin_loop_hint(); -- } -- ((UInt32x32To64(tick_count.s().LowPart, (*USER_SHARED_DATA).TickCountMultiplier) >> 24) -- + UInt32x32To64( -- (tick_count.s().HighPart as u32) << 8, -- (*USER_SHARED_DATA).TickCountMultiplier, -- )) as u32 -- } --} --EXTERN!{extern "system" { -- fn NtQueryDefaultLocale( -- UserProfile: BOOLEAN, -- DefaultLocaleId: PLCID, -- ) -> NTSTATUS; -- fn NtSetDefaultLocale( -- UserProfile: BOOLEAN, -- DefaultLocaleId: LCID, -- ) -> NTSTATUS; -- fn NtQueryInstallUILanguage( -- InstallUILanguageId: *mut LANGID, -- ) -> NTSTATUS; -- fn NtFlushInstallUILanguage( -- InstallUILanguage: LANGID, -- SetComittedFlag: ULONG, -- ) -> NTSTATUS; -- fn NtQueryDefaultUILanguage( -- DefaultUILanguageId: *mut LANGID, -- ) -> NTSTATUS; -- fn NtSetDefaultUILanguage( -- DefaultUILanguageId: LANGID, -- ) -> NTSTATUS; -- fn NtIsUILanguageComitted() -> NTSTATUS; -- fn NtInitializeNlsFiles( -- BaseAddress: *mut PVOID, -- DefaultLocaleId: PLCID, -- DefaultCasingTableSize: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtGetNlsSectionPtr( -- SectionType: ULONG, -- SectionData: ULONG, -- ContextData: PVOID, -- SectionPointer: *mut PVOID, -- SectionSize: PULONG, -- ) -> NTSTATUS; -- fn NtMapCMFModule( -- What: ULONG, -- Index: ULONG, -- CacheIndexOut: PULONG, -- CacheFlagsOut: PULONG, -- ViewSizeOut: PULONG, -- BaseAddress: *mut PVOID, -- ) -> NTSTATUS; -- fn NtGetMUIRegistryInfo( -- Flags: ULONG, -- DataSize: PULONG, -- Data: PVOID, -- ) -> NTSTATUS; -- fn NtAddAtom( -- AtomName: PWSTR, -- Length: ULONG, -- Atom: PRTL_ATOM, -- ) -> NTSTATUS; --}} --pub const ATOM_FLAG_GLOBAL: ULONG = 0x2; --EXTERN!{extern "system" { -- fn NtAddAtomEx( -- AtomName: PWSTR, -- Length: ULONG, -- Atom: PRTL_ATOM, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtFindAtom( -- AtomName: PWSTR, -- Length: ULONG, -- Atom: PRTL_ATOM, -- ) -> NTSTATUS; -- fn NtDeleteAtom( -- Atom: RTL_ATOM, -- ) -> NTSTATUS; --}} --ENUM!{enum ATOM_INFORMATION_CLASS { -- AtomBasicInformation = 0, -- AtomTableInformation = 1, --}} --STRUCT!{struct ATOM_BASIC_INFORMATION { -- UsageCount: USHORT, -- Flags: USHORT, -- NameLength: USHORT, -- Name: [WCHAR; 1], --}} --pub type PATOM_BASIC_INFORMATION = *mut ATOM_BASIC_INFORMATION; --STRUCT!{struct ATOM_TABLE_INFORMATION { -- NumberOfAtoms: ULONG, -- Atoms: [RTL_ATOM; 1], --}} --pub type PATOM_TABLE_INFORMATION = *mut ATOM_TABLE_INFORMATION; --EXTERN!{extern "system" { -- fn NtQueryInformationAtom( -- Atom: RTL_ATOM, -- AtomInformationClass: ATOM_INFORMATION_CLASS, -- AtomInformation: PVOID, -- AtomInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} --pub const FLG_STOP_ON_EXCEPTION: u32 = 0x00000001; --pub const FLG_SHOW_LDR_SNAPS: u32 = 0x00000002; --pub const FLG_DEBUG_INITIAL_COMMAND: u32 = 0x00000004; --pub const FLG_STOP_ON_HUNG_GUI: u32 = 0x00000008; --pub const FLG_HEAP_ENABLE_TAIL_CHECK: u32 = 0x00000010; --pub const FLG_HEAP_ENABLE_FREE_CHECK: u32 = 0x00000020; --pub const FLG_HEAP_VALIDATE_PARAMETERS: u32 = 0x00000040; --pub const FLG_HEAP_VALIDATE_ALL: u32 = 0x00000080; --pub const FLG_APPLICATION_VERIFIER: u32 = 0x00000100; --pub const FLG_POOL_ENABLE_TAGGING: u32 = 0x00000400; --pub const FLG_HEAP_ENABLE_TAGGING: u32 = 0x00000800; --pub const FLG_USER_STACK_TRACE_DB: u32 = 0x00001000; --pub const FLG_KERNEL_STACK_TRACE_DB: u32 = 0x00002000; --pub const FLG_MAINTAIN_OBJECT_TYPELIST: u32 = 0x00004000; --pub const FLG_HEAP_ENABLE_TAG_BY_DLL: u32 = 0x00008000; --pub const FLG_DISABLE_STACK_EXTENSION: u32 = 0x00010000; --pub const FLG_ENABLE_CSRDEBUG: u32 = 0x00020000; --pub const FLG_ENABLE_KDEBUG_SYMBOL_LOAD: u32 = 0x00040000; --pub const FLG_DISABLE_PAGE_KERNEL_STACKS: u32 = 0x00080000; --pub const FLG_ENABLE_SYSTEM_CRIT_BREAKS: u32 = 0x00100000; --pub const FLG_HEAP_DISABLE_COALESCING: u32 = 0x00200000; --pub const FLG_ENABLE_CLOSE_EXCEPTIONS: u32 = 0x00400000; --pub const FLG_ENABLE_EXCEPTION_LOGGING: u32 = 0x00800000; --pub const FLG_ENABLE_HANDLE_TYPE_TAGGING: u32 = 0x01000000; --pub const FLG_HEAP_PAGE_ALLOCS: u32 = 0x02000000; --pub const FLG_DEBUG_INITIAL_COMMAND_EX: u32 = 0x04000000; --pub const FLG_DISABLE_DBGPRINT: u32 = 0x08000000; --pub const FLG_CRITSEC_EVENT_CREATION: u32 = 0x10000000; --pub const FLG_LDR_TOP_DOWN: u32 = 0x20000000; --pub const FLG_ENABLE_HANDLE_EXCEPTIONS: u32 = 0x40000000; --pub const FLG_DISABLE_PROTDLLS: u32 = 0x80000000; --pub const FLG_VALID_BITS: u32 = 0xfffffdff; --pub const FLG_USERMODE_VALID_BITS: u32 = FLG_STOP_ON_EXCEPTION | FLG_SHOW_LDR_SNAPS -- | FLG_HEAP_ENABLE_TAIL_CHECK | FLG_HEAP_ENABLE_FREE_CHECK | FLG_HEAP_VALIDATE_PARAMETERS -- | FLG_HEAP_VALIDATE_ALL | FLG_APPLICATION_VERIFIER | FLG_HEAP_ENABLE_TAGGING -- | FLG_USER_STACK_TRACE_DB | FLG_HEAP_ENABLE_TAG_BY_DLL | FLG_DISABLE_STACK_EXTENSION -- | FLG_ENABLE_SYSTEM_CRIT_BREAKS | FLG_HEAP_DISABLE_COALESCING | FLG_DISABLE_PROTDLLS -- | FLG_HEAP_PAGE_ALLOCS | FLG_CRITSEC_EVENT_CREATION | FLG_LDR_TOP_DOWN; --pub const FLG_BOOTONLY_VALID_BITS: u32 = FLG_KERNEL_STACK_TRACE_DB | FLG_MAINTAIN_OBJECT_TYPELIST -- | FLG_ENABLE_CSRDEBUG | FLG_DEBUG_INITIAL_COMMAND | FLG_DEBUG_INITIAL_COMMAND_EX -- | FLG_DISABLE_PAGE_KERNEL_STACKS; --pub const FLG_KERNELMODE_VALID_BITS: u32 = FLG_STOP_ON_EXCEPTION | FLG_SHOW_LDR_SNAPS -- | FLG_STOP_ON_HUNG_GUI | FLG_POOL_ENABLE_TAGGING | FLG_ENABLE_KDEBUG_SYMBOL_LOAD -- | FLG_ENABLE_CLOSE_EXCEPTIONS | FLG_ENABLE_EXCEPTION_LOGGING | FLG_ENABLE_HANDLE_TYPE_TAGGING -- | FLG_DISABLE_DBGPRINT | FLG_ENABLE_HANDLE_EXCEPTIONS; --EXTERN!{extern "system" { -- fn NtQueryLicenseValue( -- ValueName: PUNICODE_STRING, -- Type: PULONG, -- Data: PVOID, -- DataSize: ULONG, -- ResultDataSize: PULONG, -- ) -> NTSTATUS; -- fn NtSetDefaultHardErrorPort( -- DefaultHardErrorPort: HANDLE, -- ) -> NTSTATUS; --}} --ENUM!{enum SHUTDOWN_ACTION { -- ShutdownNoReboot = 0, -- ShutdownReboot = 1, -- ShutdownPowerOff = 2, --}} --EXTERN!{extern "system" { -- fn NtShutdownSystem( -- Action: SHUTDOWN_ACTION, -- ) -> NTSTATUS; -- fn NtDisplayString( -- String: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn NtDrawText( -- Text: PUNICODE_STRING, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntgdi.rs b/KubeOS-Rust/vendor/ntapi/src/ntgdi.rs -deleted file mode 100644 -index ac6e387d..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntgdi.rs -+++ /dev/null -@@ -1,123 +0,0 @@ --use winapi::shared::ntdef::{PVOID, UCHAR, ULONG, USHORT}; --pub const GDI_MAX_HANDLE_COUNT: usize = 0x4000; --pub const GDI_HANDLE_INDEX_SHIFT: ULONG = 0; --pub const GDI_HANDLE_INDEX_BITS: ULONG = 16; --pub const GDI_HANDLE_INDEX_MASK: ULONG = 0xffff; --pub const GDI_HANDLE_TYPE_SHIFT: ULONG = 16; --pub const GDI_HANDLE_TYPE_BITS: ULONG = 5; --pub const GDI_HANDLE_TYPE_MASK: ULONG = 0x1f; --pub const GDI_HANDLE_ALTTYPE_SHIFT: ULONG = 21; --pub const GDI_HANDLE_ALTTYPE_BITS: ULONG = 2; --pub const GDI_HANDLE_ALTTYPE_MASK: ULONG = 0x3; --pub const GDI_HANDLE_STOCK_SHIFT: ULONG = 23; --pub const GDI_HANDLE_STOCK_BITS: ULONG = 1; --pub const GDI_HANDLE_STOCK_MASK: ULONG = 0x1; --pub const GDI_HANDLE_UNIQUE_SHIFT: ULONG = 24; --pub const GDI_HANDLE_UNIQUE_BITS: ULONG = 8; --pub const GDI_HANDLE_UNIQUE_MASK: ULONG = 0xff; --#[inline] --pub const fn GDI_HANDLE_INDEX(Handle: ULONG) -> ULONG { -- Handle & GDI_HANDLE_INDEX_MASK --} --#[inline] --pub const fn GDI_HANDLE_TYPE(Handle: ULONG) -> ULONG { -- Handle >> GDI_HANDLE_TYPE_SHIFT & GDI_HANDLE_TYPE_MASK --} --#[inline] --pub const fn GDI_HANDLE_ALTTYPE(Handle: ULONG) -> ULONG { -- Handle >> GDI_HANDLE_ALTTYPE_SHIFT & GDI_HANDLE_ALTTYPE_MASK --} --#[inline] --pub const fn GDI_HANDLE_STOCK(Handle: ULONG) -> ULONG { -- Handle >> GDI_HANDLE_STOCK_SHIFT & GDI_HANDLE_STOCK_MASK --} --#[inline] --pub const fn GDI_MAKE_HANDLE(Index: ULONG, Unique: ULONG) -> ULONG { -- Unique << GDI_HANDLE_INDEX_BITS | Index --} --pub const GDI_DEF_TYPE: ULONG = 0; --pub const GDI_DC_TYPE: ULONG = 1; --pub const GDI_DD_DIRECTDRAW_TYPE: ULONG = 2; --pub const GDI_DD_SURFACE_TYPE: ULONG = 3; --pub const GDI_RGN_TYPE: ULONG = 4; --pub const GDI_SURF_TYPE: ULONG = 5; --pub const GDI_CLIENTOBJ_TYPE: ULONG = 6; --pub const GDI_PATH_TYPE: ULONG = 7; --pub const GDI_PAL_TYPE: ULONG = 8; --pub const GDI_ICMLCS_TYPE: ULONG = 9; --pub const GDI_LFONT_TYPE: ULONG = 10; --pub const GDI_RFONT_TYPE: ULONG = 11; --pub const GDI_PFE_TYPE: ULONG = 12; --pub const GDI_PFT_TYPE: ULONG = 13; --pub const GDI_ICMCXF_TYPE: ULONG = 14; --pub const GDI_ICMDLL_TYPE: ULONG = 15; --pub const GDI_BRUSH_TYPE: ULONG = 16; --pub const GDI_PFF_TYPE: ULONG = 17; --pub const GDI_CACHE_TYPE: ULONG = 18; --pub const GDI_SPACE_TYPE: ULONG = 19; --pub const GDI_DBRUSH_TYPE: ULONG = 20; --pub const GDI_META_TYPE: ULONG = 21; --pub const GDI_EFSTATE_TYPE: ULONG = 22; --pub const GDI_BMFD_TYPE: ULONG = 23; --pub const GDI_VTFD_TYPE: ULONG = 24; --pub const GDI_TTFD_TYPE: ULONG = 25; --pub const GDI_RC_TYPE: ULONG = 26; --pub const GDI_TEMP_TYPE: ULONG = 27; --pub const GDI_DRVOBJ_TYPE: ULONG = 28; --pub const GDI_DCIOBJ_TYPE: ULONG = 29; --pub const GDI_SPOOL_TYPE: ULONG = 30; --#[inline] --pub const fn GDI_CLIENT_TYPE_FROM_HANDLE(Handle: ULONG) -> ULONG { -- Handle & (GDI_HANDLE_ALTTYPE_MASK << GDI_HANDLE_ALTTYPE_SHIFT | GDI_HANDLE_TYPE_MASK -- << GDI_HANDLE_TYPE_SHIFT) --} --#[inline] --pub const fn GDI_CLIENT_TYPE_FROM_UNIQUE(Unique: ULONG) -> ULONG { -- GDI_CLIENT_TYPE_FROM_HANDLE(Unique << 16) --} --pub const GDI_ALTTYPE_1: ULONG = 1 << GDI_HANDLE_ALTTYPE_SHIFT; --pub const GDI_ALTTYPE_2: ULONG = 2 << GDI_HANDLE_ALTTYPE_SHIFT; --pub const GDI_ALTTYPE_3: ULONG = 3 << GDI_HANDLE_ALTTYPE_SHIFT; --pub const GDI_CLIENT_BITMAP_TYPE: ULONG = GDI_SURF_TYPE << GDI_HANDLE_TYPE_SHIFT; --pub const GDI_CLIENT_BRUSH_TYPE: ULONG = GDI_BRUSH_TYPE << GDI_HANDLE_TYPE_SHIFT; --pub const GDI_CLIENT_CLIENTOBJ_TYPE: ULONG = GDI_CLIENTOBJ_TYPE << GDI_HANDLE_TYPE_SHIFT; --pub const GDI_CLIENT_DC_TYPE: ULONG = GDI_DC_TYPE << GDI_HANDLE_TYPE_SHIFT; --pub const GDI_CLIENT_FONT_TYPE: ULONG = GDI_LFONT_TYPE << GDI_HANDLE_TYPE_SHIFT; --pub const GDI_CLIENT_PALETTE_TYPE: ULONG = GDI_PAL_TYPE << GDI_HANDLE_TYPE_SHIFT; --pub const GDI_CLIENT_REGION_TYPE: ULONG = GDI_RGN_TYPE << GDI_HANDLE_TYPE_SHIFT; --pub const GDI_CLIENT_ALTDC_TYPE: ULONG = GDI_CLIENT_DC_TYPE | GDI_ALTTYPE_1; --pub const GDI_CLIENT_DIBSECTION_TYPE: ULONG = GDI_CLIENT_BITMAP_TYPE | GDI_ALTTYPE_1; --pub const GDI_CLIENT_EXTPEN_TYPE: ULONG = GDI_CLIENT_BRUSH_TYPE | GDI_ALTTYPE_2; --pub const GDI_CLIENT_METADC16_TYPE: ULONG = GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_3; --pub const GDI_CLIENT_METAFILE_TYPE: ULONG = GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_2; --pub const GDI_CLIENT_METAFILE16_TYPE: ULONG = GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_1; --pub const GDI_CLIENT_PEN_TYPE: ULONG = GDI_CLIENT_BRUSH_TYPE | GDI_ALTTYPE_1; --UNION!{union GDI_HANDLE_ENTRY_u { -- Object: PVOID, -- NextFree: PVOID, --}} --STRUCT!{struct GDI_HANDLE_ENTRY_Owner_s { -- ProcessId: USHORT, -- Bitfields: USHORT, --}} --BITFIELD!{GDI_HANDLE_ENTRY_Owner_s Bitfields: USHORT [ -- Lock set_Lock[0..1], -- Count set_Count[1..16], --]} --UNION!{union GDI_HANDLE_ENTRY_Owner { -- s: GDI_HANDLE_ENTRY_Owner_s, -- Value: ULONG, --}} --STRUCT!{struct GDI_HANDLE_ENTRY { -- u: GDI_HANDLE_ENTRY_u, -- Owner: GDI_HANDLE_ENTRY_Owner, -- Unique: USHORT, -- Type: UCHAR, -- Flags: UCHAR, -- UserPointer: PVOID, --}} --pub type PGDI_HANDLE_ENTRY = *mut GDI_HANDLE_ENTRY; --STRUCT!{struct GDI_SHARED_MEMORY { -- Handles: [GDI_HANDLE_ENTRY; GDI_MAX_HANDLE_COUNT], --}} --pub type PGDI_SHARED_MEMORY = *mut GDI_SHARED_MEMORY; -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntioapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntioapi.rs -deleted file mode 100644 -index 48c416b2..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntioapi.rs -+++ /dev/null -@@ -1,1464 +0,0 @@ --use crate::string::UTF16Const; --use crate::winapi_local::um::winioctl::CTL_CODE; --use winapi::shared::basetsd::ULONG_PTR; --use winapi::shared::guiddef::GUID; --use winapi::shared::minwindef::DWORD; --use winapi::shared::ntdef::{ -- BOOLEAN, CCHAR, CHAR, HANDLE, LARGE_INTEGER, LONG, LONGLONG, NTSTATUS, PBOOLEAN, PHANDLE, -- PLARGE_INTEGER, POBJECT_ATTRIBUTES, PUCHAR, PULONG, PUNICODE_STRING, PVOID, UCHAR, ULONG, -- ULONGLONG, USHORT, WCHAR, --}; --use winapi::um::winioctl::{ -- FILE_ANY_ACCESS, FILE_DEVICE_MAILSLOT, FILE_DEVICE_NAMED_PIPE, METHOD_BUFFERED, METHOD_NEITHER, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, FILE_ID_128, FILE_READ_DATA, FILE_WRITE_DATA, PFILE_SEGMENT_ELEMENT, PSID, SID, --}; --pub const FILE_SUPERSEDE: ULONG = 0x00000000; --pub const FILE_OPEN: ULONG = 0x00000001; --pub const FILE_CREATE: ULONG = 0x00000002; --pub const FILE_OPEN_IF: ULONG = 0x00000003; --pub const FILE_OVERWRITE: ULONG = 0x00000004; --pub const FILE_OVERWRITE_IF: ULONG = 0x00000005; --pub const FILE_MAXIMUM_DISPOSITION: ULONG = 0x00000005; --pub const FILE_DIRECTORY_FILE: ULONG = 0x00000001; --pub const FILE_WRITE_THROUGH: ULONG = 0x00000002; --pub const FILE_SEQUENTIAL_ONLY: ULONG = 0x00000004; --pub const FILE_NO_INTERMEDIATE_BUFFERING: ULONG = 0x00000008; --pub const FILE_SYNCHRONOUS_IO_ALERT: ULONG = 0x00000010; --pub const FILE_SYNCHRONOUS_IO_NONALERT: ULONG = 0x00000020; --pub const FILE_NON_DIRECTORY_FILE: ULONG = 0x00000040; --pub const FILE_CREATE_TREE_CONNECTION: ULONG = 0x00000080; --pub const FILE_COMPLETE_IF_OPLOCKED: ULONG = 0x00000100; --pub const FILE_NO_EA_KNOWLEDGE: ULONG = 0x00000200; --pub const FILE_OPEN_FOR_RECOVERY: ULONG = 0x00000400; --pub const FILE_RANDOM_ACCESS: ULONG = 0x00000800; --pub const FILE_DELETE_ON_CLOSE: ULONG = 0x00001000; --pub const FILE_OPEN_BY_FILE_ID: ULONG = 0x00002000; --pub const FILE_OPEN_FOR_BACKUP_INTENT: ULONG = 0x00004000; --pub const FILE_NO_COMPRESSION: ULONG = 0x00008000; --pub const FILE_OPEN_REQUIRING_OPLOCK: ULONG = 0x00010000; --pub const FILE_DISALLOW_EXCLUSIVE: ULONG = 0x00020000; --pub const FILE_SESSION_AWARE: ULONG = 0x00040000; --pub const FILE_RESERVE_OPFILTER: ULONG = 0x00100000; --pub const FILE_OPEN_REPARSE_POINT: ULONG = 0x00200000; --pub const FILE_OPEN_NO_RECALL: ULONG = 0x00400000; --pub const FILE_OPEN_FOR_FREE_SPACE_QUERY: ULONG = 0x00800000; --pub const FILE_COPY_STRUCTURED_STORAGE: ULONG = 0x00000041; --pub const FILE_STRUCTURED_STORAGE: ULONG = 0x00000441; --pub const FILE_SUPERSEDED: ULONG = 0x00000000; --pub const FILE_OPENED: ULONG = 0x00000001; --pub const FILE_CREATED: ULONG = 0x00000002; --pub const FILE_OVERWRITTEN: ULONG = 0x00000003; --pub const FILE_EXISTS: ULONG = 0x00000004; --pub const FILE_DOES_NOT_EXIST: ULONG = 0x00000005; --pub const FILE_WRITE_TO_END_OF_FILE: ULONG = 0xffffffff; --pub const FILE_USE_FILE_POINTER_POSITION: ULONG = 0xfffffffe; --pub const FILE_BYTE_ALIGNMENT: ULONG = 0x00000000; --pub const FILE_WORD_ALIGNMENT: ULONG = 0x00000001; --pub const FILE_LONG_ALIGNMENT: ULONG = 0x00000003; --pub const FILE_QUAD_ALIGNMENT: ULONG = 0x00000007; --pub const FILE_OCTA_ALIGNMENT: ULONG = 0x0000000f; --pub const FILE_32_BYTE_ALIGNMENT: ULONG = 0x0000001f; --pub const FILE_64_BYTE_ALIGNMENT: ULONG = 0x0000003f; --pub const FILE_128_BYTE_ALIGNMENT: ULONG = 0x0000007f; --pub const FILE_256_BYTE_ALIGNMENT: ULONG = 0x000000ff; --pub const FILE_512_BYTE_ALIGNMENT: ULONG = 0x000001ff; --pub const MAXIMUM_FILENAME_LENGTH: u32 = 256; --pub const FILE_NEED_EA: ULONG = 0x00000080; --pub const FILE_EA_TYPE_BINARY: ULONG = 0xfffe; --pub const FILE_EA_TYPE_ASCII: ULONG = 0xfffd; --pub const FILE_EA_TYPE_BITMAP: ULONG = 0xfffb; --pub const FILE_EA_TYPE_METAFILE: ULONG = 0xfffa; --pub const FILE_EA_TYPE_ICON: ULONG = 0xfff9; --pub const FILE_EA_TYPE_EA: ULONG = 0xffee; --pub const FILE_EA_TYPE_MVMT: ULONG = 0xffdf; --pub const FILE_EA_TYPE_MVST: ULONG = 0xffde; --pub const FILE_EA_TYPE_ASN1: ULONG = 0xffdd; --pub const FILE_EA_TYPE_FAMILY_IDS: ULONG = 0xff01; --pub const FILE_REMOVABLE_MEDIA: ULONG = 0x00000001; --pub const FILE_READ_ONLY_DEVICE: ULONG = 0x00000002; --pub const FILE_FLOPPY_DISKETTE: ULONG = 0x00000004; --pub const FILE_WRITE_ONCE_MEDIA: ULONG = 0x00000008; --pub const FILE_REMOTE_DEVICE: ULONG = 0x00000010; --pub const FILE_DEVICE_IS_MOUNTED: ULONG = 0x00000020; --pub const FILE_VIRTUAL_VOLUME: ULONG = 0x00000040; --pub const FILE_AUTOGENERATED_DEVICE_NAME: ULONG = 0x00000080; --pub const FILE_DEVICE_SECURE_OPEN: ULONG = 0x00000100; --pub const FILE_CHARACTERISTIC_PNP_DEVICE: ULONG = 0x00000800; --pub const FILE_CHARACTERISTIC_TS_DEVICE: ULONG = 0x00001000; --pub const FILE_CHARACTERISTIC_WEBDAV_DEVICE: ULONG = 0x00002000; --pub const FILE_CHARACTERISTIC_CSV: ULONG = 0x00010000; --pub const FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL: ULONG = 0x00020000; --pub const FILE_PORTABLE_DEVICE: ULONG = 0x00040000; --pub const FILE_PIPE_BYTE_STREAM_TYPE: ULONG = 0x00000000; --pub const FILE_PIPE_MESSAGE_TYPE: ULONG = 0x00000001; --pub const FILE_PIPE_ACCEPT_REMOTE_CLIENTS: ULONG = 0x00000000; --pub const FILE_PIPE_REJECT_REMOTE_CLIENTS: ULONG = 0x00000002; --pub const FILE_PIPE_TYPE_VALID_MASK: ULONG = 0x00000003; --pub const FILE_PIPE_QUEUE_OPERATION: ULONG = 0x00000000; --pub const FILE_PIPE_COMPLETE_OPERATION: ULONG = 0x00000001; --pub const FILE_PIPE_BYTE_STREAM_MODE: ULONG = 0x00000000; --pub const FILE_PIPE_MESSAGE_MODE: ULONG = 0x00000001; --pub const FILE_PIPE_INBOUND: ULONG = 0x00000000; --pub const FILE_PIPE_OUTBOUND: ULONG = 0x00000001; --pub const FILE_PIPE_FULL_DUPLEX: ULONG = 0x00000002; --pub const FILE_PIPE_DISCONNECTED_STATE: ULONG = 0x00000001; --pub const FILE_PIPE_LISTENING_STATE: ULONG = 0x00000002; --pub const FILE_PIPE_CONNECTED_STATE: ULONG = 0x00000003; --pub const FILE_PIPE_CLOSING_STATE: ULONG = 0x00000004; --pub const FILE_PIPE_CLIENT_END: ULONG = 0x00000000; --pub const FILE_PIPE_SERVER_END: ULONG = 0x00000001; --pub const MAILSLOT_SIZE_AUTO: u32 = 0; --UNION!{union IO_STATUS_BLOCK_u { -- Status: NTSTATUS, -- Pointer: PVOID, --}} --STRUCT!{struct IO_STATUS_BLOCK { -- u: IO_STATUS_BLOCK_u, -- Information: ULONG_PTR, --}} --pub type PIO_STATUS_BLOCK = *mut IO_STATUS_BLOCK; --FN!{stdcall PIO_APC_ROUTINE( -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Reserved: ULONG, --) -> ()} --STRUCT!{struct FILE_IO_COMPLETION_INFORMATION { -- KeyContext: PVOID, -- ApcContext: PVOID, -- IoStatusBlock: IO_STATUS_BLOCK, --}} --pub type PFILE_IO_COMPLETION_INFORMATION = *mut FILE_IO_COMPLETION_INFORMATION; --ENUM!{enum FILE_INFORMATION_CLASS { -- FileDirectoryInformation = 1, -- FileFullDirectoryInformation = 2, -- FileBothDirectoryInformation = 3, -- FileBasicInformation = 4, -- FileStandardInformation = 5, -- FileInternalInformation = 6, -- FileEaInformation = 7, -- FileAccessInformation = 8, -- FileNameInformation = 9, -- FileRenameInformation = 10, -- FileLinkInformation = 11, -- FileNamesInformation = 12, -- FileDispositionInformation = 13, -- FilePositionInformation = 14, -- FileFullEaInformation = 15, -- FileModeInformation = 16, -- FileAlignmentInformation = 17, -- FileAllInformation = 18, -- FileAllocationInformation = 19, -- FileEndOfFileInformation = 20, -- FileAlternateNameInformation = 21, -- FileStreamInformation = 22, -- FilePipeInformation = 23, -- FilePipeLocalInformation = 24, -- FilePipeRemoteInformation = 25, -- FileMailslotQueryInformation = 26, -- FileMailslotSetInformation = 27, -- FileCompressionInformation = 28, -- FileObjectIdInformation = 29, -- FileCompletionInformation = 30, -- FileMoveClusterInformation = 31, -- FileQuotaInformation = 32, -- FileReparsePointInformation = 33, -- FileNetworkOpenInformation = 34, -- FileAttributeTagInformation = 35, -- FileTrackingInformation = 36, -- FileIdBothDirectoryInformation = 37, -- FileIdFullDirectoryInformation = 38, -- FileValidDataLengthInformation = 39, -- FileShortNameInformation = 40, -- FileIoCompletionNotificationInformation = 41, -- FileIoStatusBlockRangeInformation = 42, -- FileIoPriorityHintInformation = 43, -- FileSfioReserveInformation = 44, -- FileSfioVolumeInformation = 45, -- FileHardLinkInformation = 46, -- FileProcessIdsUsingFileInformation = 47, -- FileNormalizedNameInformation = 48, -- FileNetworkPhysicalNameInformation = 49, -- FileIdGlobalTxDirectoryInformation = 50, -- FileIsRemoteDeviceInformation = 51, -- FileUnusedInformation = 52, -- FileNumaNodeInformation = 53, -- FileStandardLinkInformation = 54, -- FileRemoteProtocolInformation = 55, -- FileRenameInformationBypassAccessCheck = 56, -- FileLinkInformationBypassAccessCheck = 57, -- FileVolumeNameInformation = 58, -- FileIdInformation = 59, -- FileIdExtdDirectoryInformation = 60, -- FileReplaceCompletionInformation = 61, -- FileHardLinkFullIdInformation = 62, -- FileIdExtdBothDirectoryInformation = 63, -- FileDispositionInformationEx = 64, -- FileRenameInformationEx = 65, -- FileRenameInformationExBypassAccessCheck = 66, -- FileDesiredStorageClassInformation = 67, -- FileStatInformation = 68, -- FileMemoryPartitionInformation = 69, -- FileStatLxInformation = 70, -- FileCaseSensitiveInformation = 71, -- FileLinkInformationEx = 72, -- FileLinkInformationExBypassAccessCheck = 73, -- FileStorageReserveIdInformation = 74, -- FileCaseSensitiveInformationForceAccessCheck = 75, -- FileMaximumInformation = 76, --}} --pub type PFILE_INFORMATION_CLASS = *mut FILE_INFORMATION_CLASS; --STRUCT!{struct FILE_BASIC_INFORMATION { -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- FileAttributes: ULONG, --}} --pub type PFILE_BASIC_INFORMATION = *mut FILE_BASIC_INFORMATION; --STRUCT!{struct FILE_STANDARD_INFORMATION { -- AllocationSize: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- NumberOfLinks: ULONG, -- DeletePending: BOOLEAN, -- Directory: BOOLEAN, --}} --pub type PFILE_STANDARD_INFORMATION = *mut FILE_STANDARD_INFORMATION; --STRUCT!{struct FILE_STANDARD_INFORMATION_EX { -- AllocationSize: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- NumberOfLinks: ULONG, -- DeletePending: BOOLEAN, -- Directory: BOOLEAN, -- AlternateStream: BOOLEAN, -- MetadataAttribute: BOOLEAN, --}} --pub type PFILE_STANDARD_INFORMATION_EX = *mut FILE_STANDARD_INFORMATION_EX; --STRUCT!{struct FILE_INTERNAL_INFORMATION { -- IndexNumber: LARGE_INTEGER, --}} --pub type PFILE_INTERNAL_INFORMATION = *mut FILE_INTERNAL_INFORMATION; --STRUCT!{struct FILE_EA_INFORMATION { -- EaSize: ULONG, --}} --pub type PFILE_EA_INFORMATION = *mut FILE_EA_INFORMATION; --STRUCT!{struct FILE_ACCESS_INFORMATION { -- AccessFlags: ACCESS_MASK, --}} --pub type PFILE_ACCESS_INFORMATION = *mut FILE_ACCESS_INFORMATION; --STRUCT!{struct FILE_POSITION_INFORMATION { -- CurrentByteOffset: LARGE_INTEGER, --}} --pub type PFILE_POSITION_INFORMATION = *mut FILE_POSITION_INFORMATION; --STRUCT!{struct FILE_MODE_INFORMATION { -- Mode: ULONG, --}} --pub type PFILE_MODE_INFORMATION = *mut FILE_MODE_INFORMATION; --STRUCT!{struct FILE_ALIGNMENT_INFORMATION { -- AlignmentRequirement: ULONG, --}} --pub type PFILE_ALIGNMENT_INFORMATION = *mut FILE_ALIGNMENT_INFORMATION; --STRUCT!{struct FILE_NAME_INFORMATION { -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_NAME_INFORMATION = *mut FILE_NAME_INFORMATION; --STRUCT!{struct FILE_ALL_INFORMATION { -- BasicInformation: FILE_BASIC_INFORMATION, -- StandardInformation: FILE_STANDARD_INFORMATION, -- InternalInformation: FILE_INTERNAL_INFORMATION, -- EaInformation: FILE_EA_INFORMATION, -- AccessInformation: FILE_ACCESS_INFORMATION, -- PositionInformation: FILE_POSITION_INFORMATION, -- ModeInformation: FILE_MODE_INFORMATION, -- AlignmentInformation: FILE_ALIGNMENT_INFORMATION, -- NameInformation: FILE_NAME_INFORMATION, --}} --pub type PFILE_ALL_INFORMATION = *mut FILE_ALL_INFORMATION; --STRUCT!{struct FILE_NETWORK_OPEN_INFORMATION { -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- FileAttributes: ULONG, --}} --pub type PFILE_NETWORK_OPEN_INFORMATION = *mut FILE_NETWORK_OPEN_INFORMATION; --STRUCT!{struct FILE_ATTRIBUTE_TAG_INFORMATION { -- FileAttributes: ULONG, -- ReparseTag: ULONG, --}} --pub type PFILE_ATTRIBUTE_TAG_INFORMATION = *mut FILE_ATTRIBUTE_TAG_INFORMATION; --STRUCT!{struct FILE_ALLOCATION_INFORMATION { -- AllocationSize: LARGE_INTEGER, --}} --pub type PFILE_ALLOCATION_INFORMATION = *mut FILE_ALLOCATION_INFORMATION; --STRUCT!{struct FILE_COMPRESSION_INFORMATION { -- CompressedFileSize: LARGE_INTEGER, -- CompressionFormat: USHORT, -- CompressionUnitShift: UCHAR, -- ChunkShift: UCHAR, -- ClusterShift: UCHAR, -- Reserved: [UCHAR; 3], --}} --pub type PFILE_COMPRESSION_INFORMATION = *mut FILE_COMPRESSION_INFORMATION; --STRUCT!{struct FILE_DISPOSITION_INFORMATION { -- DeleteFileA: BOOLEAN, --}} --pub type PFILE_DISPOSITION_INFORMATION = *mut FILE_DISPOSITION_INFORMATION; --STRUCT!{struct FILE_END_OF_FILE_INFORMATION { -- EndOfFile: LARGE_INTEGER, --}} --pub type PFILE_END_OF_FILE_INFORMATION = *mut FILE_END_OF_FILE_INFORMATION; --STRUCT!{struct FILE_VALID_DATA_LENGTH_INFORMATION { -- ValidDataLength: LARGE_INTEGER, --}} --pub type PFILE_VALID_DATA_LENGTH_INFORMATION = *mut FILE_VALID_DATA_LENGTH_INFORMATION; --STRUCT!{struct FILE_LINK_INFORMATION { -- ReplaceIfExists: BOOLEAN, -- RootDirectory: HANDLE, -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_LINK_INFORMATION = *mut FILE_LINK_INFORMATION; --STRUCT!{struct FILE_MOVE_CLUSTER_INFORMATION { -- ClusterCount: ULONG, -- RootDirectory: HANDLE, -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_MOVE_CLUSTER_INFORMATION = *mut FILE_MOVE_CLUSTER_INFORMATION; --STRUCT!{struct FILE_RENAME_INFORMATION { -- ReplaceIfExists: BOOLEAN, -- RootDirectory: HANDLE, -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_RENAME_INFORMATION = *mut FILE_RENAME_INFORMATION; --STRUCT!{struct FILE_STREAM_INFORMATION { -- NextEntryOffset: ULONG, -- StreamNameLength: ULONG, -- StreamSize: LARGE_INTEGER, -- StreamAllocationSize: LARGE_INTEGER, -- StreamName: [WCHAR; 1], --}} --pub type PFILE_STREAM_INFORMATION = *mut FILE_STREAM_INFORMATION; --STRUCT!{struct FILE_TRACKING_INFORMATION { -- DestinationFile: HANDLE, -- ObjectInformationLength: ULONG, -- ObjectInformation: [CHAR; 1], --}} --pub type PFILE_TRACKING_INFORMATION = *mut FILE_TRACKING_INFORMATION; --STRUCT!{struct FILE_COMPLETION_INFORMATION { -- Port: HANDLE, -- Key: PVOID, --}} --pub type PFILE_COMPLETION_INFORMATION = *mut FILE_COMPLETION_INFORMATION; --STRUCT!{struct FILE_PIPE_INFORMATION { -- ReadMode: ULONG, -- CompletionMode: ULONG, --}} --pub type PFILE_PIPE_INFORMATION = *mut FILE_PIPE_INFORMATION; --STRUCT!{struct FILE_PIPE_LOCAL_INFORMATION { -- NamedPipeType: ULONG, -- NamedPipeConfiguration: ULONG, -- MaximumInstances: ULONG, -- CurrentInstances: ULONG, -- InboundQuota: ULONG, -- ReadDataAvailable: ULONG, -- OutboundQuota: ULONG, -- WriteQuotaAvailable: ULONG, -- NamedPipeState: ULONG, -- NamedPipeEnd: ULONG, --}} --pub type PFILE_PIPE_LOCAL_INFORMATION = *mut FILE_PIPE_LOCAL_INFORMATION; --STRUCT!{struct FILE_PIPE_REMOTE_INFORMATION { -- CollectDataTime: LARGE_INTEGER, -- MaximumCollectionCount: ULONG, --}} --pub type PFILE_PIPE_REMOTE_INFORMATION = *mut FILE_PIPE_REMOTE_INFORMATION; --STRUCT!{struct FILE_MAILSLOT_QUERY_INFORMATION { -- MaximumMessageSize: ULONG, -- MailslotQuota: ULONG, -- NextMessageSize: ULONG, -- MessagesAvailable: ULONG, -- ReadTimeout: LARGE_INTEGER, --}} --pub type PFILE_MAILSLOT_QUERY_INFORMATION = *mut FILE_MAILSLOT_QUERY_INFORMATION; --STRUCT!{struct FILE_MAILSLOT_SET_INFORMATION { -- ReadTimeout: PLARGE_INTEGER, --}} --pub type PFILE_MAILSLOT_SET_INFORMATION = *mut FILE_MAILSLOT_SET_INFORMATION; --STRUCT!{struct FILE_REPARSE_POINT_INFORMATION { -- FileReference: LONGLONG, -- Tag: ULONG, --}} --pub type PFILE_REPARSE_POINT_INFORMATION = *mut FILE_REPARSE_POINT_INFORMATION; --STRUCT!{struct FILE_LINK_ENTRY_INFORMATION { -- NextEntryOffset: ULONG, -- ParentFileId: LONGLONG, -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_LINK_ENTRY_INFORMATION = *mut FILE_LINK_ENTRY_INFORMATION; --STRUCT!{struct FILE_LINKS_INFORMATION { -- BytesNeeded: ULONG, -- EntriesReturned: ULONG, -- Entry: FILE_LINK_ENTRY_INFORMATION, --}} --pub type PFILE_LINKS_INFORMATION = *mut FILE_LINKS_INFORMATION; --STRUCT!{struct FILE_NETWORK_PHYSICAL_NAME_INFORMATION { -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_NETWORK_PHYSICAL_NAME_INFORMATION = *mut FILE_NETWORK_PHYSICAL_NAME_INFORMATION; --STRUCT!{struct FILE_STANDARD_LINK_INFORMATION { -- NumberOfAccessibleLinks: ULONG, -- TotalNumberOfLinks: ULONG, -- DeletePending: BOOLEAN, -- Directory: BOOLEAN, --}} --pub type PFILE_STANDARD_LINK_INFORMATION = *mut FILE_STANDARD_LINK_INFORMATION; --STRUCT!{struct FILE_SFIO_RESERVE_INFORMATION { -- RequestsPerPeriod: ULONG, -- Period: ULONG, -- RetryFailures: BOOLEAN, -- Discardable: BOOLEAN, -- RequestSize: ULONG, -- NumOutstandingRequests: ULONG, --}} --pub type PFILE_SFIO_RESERVE_INFORMATION = *mut FILE_SFIO_RESERVE_INFORMATION; --STRUCT!{struct FILE_SFIO_VOLUME_INFORMATION { -- MaximumRequestsPerPeriod: ULONG, -- MinimumPeriod: ULONG, -- MinimumTransferSize: ULONG, --}} --pub type PFILE_SFIO_VOLUME_INFORMATION = *mut FILE_SFIO_VOLUME_INFORMATION; --ENUM!{enum IO_PRIORITY_HINT { -- IoPriorityVeryLow = 0, -- IoPriorityLow = 1, -- IoPriorityNormal = 2, -- IoPriorityHigh = 3, -- IoPriorityCritical = 4, -- MaxIoPriorityTypes = 5, --}} --STRUCT!{struct FILE_IO_PRIORITY_HINT_INFORMATION { -- PriorityHint: IO_PRIORITY_HINT, --}} --pub type PFILE_IO_PRIORITY_HINT_INFORMATION = *mut FILE_IO_PRIORITY_HINT_INFORMATION; --STRUCT!{struct FILE_IO_PRIORITY_HINT_INFORMATION_EX { -- PriorityHint: IO_PRIORITY_HINT, -- BoostOutstanding: BOOLEAN, --}} --pub type PFILE_IO_PRIORITY_HINT_INFORMATION_EX = *mut FILE_IO_PRIORITY_HINT_INFORMATION_EX; --pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS: u32 = 0x1; --pub const FILE_SKIP_SET_EVENT_ON_HANDLE: u32 = 0x2; --pub const FILE_SKIP_SET_USER_EVENT_ON_FAST_IO: u32 = 0x4; --STRUCT!{struct FILE_IO_COMPLETION_NOTIFICATION_INFORMATION { -- Flags: ULONG, --}} --pub type PFILE_IO_COMPLETION_NOTIFICATION_INFORMATION = -- *mut FILE_IO_COMPLETION_NOTIFICATION_INFORMATION; --STRUCT!{struct FILE_PROCESS_IDS_USING_FILE_INFORMATION { -- NumberOfProcessIdsInList: ULONG, -- ProcessIdList: [ULONG_PTR; 1], --}} --pub type PFILE_PROCESS_IDS_USING_FILE_INFORMATION = *mut FILE_PROCESS_IDS_USING_FILE_INFORMATION; --STRUCT!{struct FILE_IS_REMOTE_DEVICE_INFORMATION { -- IsRemote: BOOLEAN, --}} --pub type PFILE_IS_REMOTE_DEVICE_INFORMATION = *mut FILE_IS_REMOTE_DEVICE_INFORMATION; --STRUCT!{struct FILE_NUMA_NODE_INFORMATION { -- NodeNumber: USHORT, --}} --pub type PFILE_NUMA_NODE_INFORMATION = *mut FILE_NUMA_NODE_INFORMATION; --STRUCT!{struct FILE_IOSTATUSBLOCK_RANGE_INFORMATION { -- IoStatusBlockRange: PUCHAR, -- Length: ULONG, --}} --pub type PFILE_IOSTATUSBLOCK_RANGE_INFORMATION = *mut FILE_IOSTATUSBLOCK_RANGE_INFORMATION; --STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION_GenericReserved { -- Reserved: [ULONG; 8], --}} --STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Server { -- Capabilities: ULONG, --}} --STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Share { -- Capabilities: ULONG, -- CachingFlags: ULONG, --}} --STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2 { -- Server: FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Server, -- Share: FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Share, --}} --UNION!{union FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific { -- Smb2: FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2, -- Reserved: [ULONG; 16], --}} --STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION { -- StructureVersion: USHORT, -- StructureSize: USHORT, -- Protocol: ULONG, -- ProtocolMajorVersion: USHORT, -- ProtocolMinorVersion: USHORT, -- ProtocolRevision: USHORT, -- Reserved: USHORT, -- Flags: ULONG, -- GenericReserved: FILE_REMOTE_PROTOCOL_INFORMATION_GenericReserved, -- ProtocolSpecific: FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific, --}} --pub type PFILE_REMOTE_PROTOCOL_INFORMATION = *mut FILE_REMOTE_PROTOCOL_INFORMATION; --pub const CHECKSUM_ENFORCEMENT_OFF: u32 = 0x00000001; --STRUCT!{struct FILE_INTEGRITY_STREAM_INFORMATION { -- ChecksumAlgorithm: USHORT, -- ChecksumChunkShift: UCHAR, -- ClusterShift: UCHAR, -- Flags: ULONG, --}} --pub type PFILE_INTEGRITY_STREAM_INFORMATION = *mut FILE_INTEGRITY_STREAM_INFORMATION; --STRUCT!{struct FILE_VOLUME_NAME_INFORMATION { -- DeviceNameLength: ULONG, -- DeviceName: [WCHAR; 1], --}} --pub type PFILE_VOLUME_NAME_INFORMATION = *mut FILE_VOLUME_NAME_INFORMATION; --STRUCT!{struct FILE_ID_INFORMATION { -- VolumeSerialNumber: ULONGLONG, -- FileId: FILE_ID_128, --}} --pub type PFILE_ID_INFORMATION = *mut FILE_ID_INFORMATION; --STRUCT!{struct FILE_ID_EXTD_DIR_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- FileAttributes: ULONG, -- FileNameLength: ULONG, -- EaSize: ULONG, -- ReparsePointTag: ULONG, -- FileId: FILE_ID_128, -- FileName: [WCHAR; 1], --}} --pub type PFILE_ID_EXTD_DIR_INFORMATION = *mut FILE_ID_EXTD_DIR_INFORMATION; --STRUCT!{struct FILE_LINK_ENTRY_FULL_ID_INFORMATION { -- NextEntryOffset: ULONG, -- ParentFileId: FILE_ID_128, -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_LINK_ENTRY_FULL_ID_INFORMATION = *mut FILE_LINK_ENTRY_FULL_ID_INFORMATION; --STRUCT!{struct FILE_ID_EXTD_BOTH_DIR_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- FileAttributes: ULONG, -- FileNameLength: ULONG, -- EaSize: ULONG, -- ReparsePointTag: ULONG, -- FileId: FILE_ID_128, -- ShortNameLength: CCHAR, -- ShortName: [WCHAR; 12], -- FileName: [WCHAR; 1], --}} --pub type PFILE_ID_EXTD_BOTH_DIR_INFORMATION = *mut FILE_ID_EXTD_BOTH_DIR_INFORMATION; --STRUCT!{struct FILE_STAT_INFORMATION { -- FileId: LARGE_INTEGER, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- FileAttributes: ULONG, -- ReparseTag: ULONG, -- NumberOfLinks: ULONG, -- EffectiveAccess: ULONG, --}} --pub type PFILE_STAT_INFORMATION = *mut FILE_STAT_INFORMATION; --STRUCT!{struct FILE_MEMORY_PARTITION_INFORMATION_Flags_s { -- NoCrossPartitionAccess: UCHAR, -- Spare: [UCHAR; 3], --}} --UNION!{union FILE_MEMORY_PARTITION_INFORMATION_Flags { -- s: FILE_MEMORY_PARTITION_INFORMATION_Flags_s, -- AllFlags: ULONG, --}} --STRUCT!{struct FILE_MEMORY_PARTITION_INFORMATION { -- OwnerPartitionHandle: HANDLE, -- Flags: FILE_MEMORY_PARTITION_INFORMATION_Flags, --}} --pub type PFILE_MEMORY_PARTITION_INFORMATION = *mut FILE_MEMORY_PARTITION_INFORMATION; --STRUCT!{struct FILE_STAT_LX_INFORMATION { -- FileId: LARGE_INTEGER, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- FileAttributes: ULONG, -- ReparseTag: ULONG, -- NumberOfLinks: ULONG, -- EffectiveAccess: ULONG, -- LxFlags: ULONG, -- LxUid: ULONG, -- LxGid: ULONG, -- LxMode: ULONG, -- LxDeviceIdMajor: ULONG, -- LxDeviceIdMinor: ULONG, --}} --pub type PFILE_STAT_LX_INFORMATION = *mut FILE_STAT_LX_INFORMATION; --STRUCT!{struct FILE_CASE_SENSITIVE_INFORMATION { -- Flags: ULONG, --}} --pub type PFILE_CASE_SENSITIVE_INFORMATION = *mut FILE_CASE_SENSITIVE_INFORMATION; --STRUCT!{struct FILE_DIRECTORY_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- FileAttributes: ULONG, -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_DIRECTORY_INFORMATION = *mut FILE_DIRECTORY_INFORMATION; --STRUCT!{struct FILE_FULL_DIR_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- FileAttributes: ULONG, -- FileNameLength: ULONG, -- EaSize: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_FULL_DIR_INFORMATION = *mut FILE_FULL_DIR_INFORMATION; --STRUCT!{struct FILE_ID_FULL_DIR_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- FileAttributes: ULONG, -- FileNameLength: ULONG, -- EaSize: ULONG, -- FileId: LARGE_INTEGER, -- FileName: [WCHAR; 1], --}} --pub type PFILE_ID_FULL_DIR_INFORMATION = *mut FILE_ID_FULL_DIR_INFORMATION; --STRUCT!{struct FILE_BOTH_DIR_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- FileAttributes: ULONG, -- FileNameLength: ULONG, -- EaSize: ULONG, -- ShortNameLength: CCHAR, -- ShortName: [WCHAR; 12], -- FileName: [WCHAR; 1], --}} --pub type PFILE_BOTH_DIR_INFORMATION = *mut FILE_BOTH_DIR_INFORMATION; --STRUCT!{struct FILE_ID_BOTH_DIR_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- FileAttributes: ULONG, -- FileNameLength: ULONG, -- EaSize: ULONG, -- ShortNameLength: CCHAR, -- ShortName: [WCHAR; 12], -- FileId: LARGE_INTEGER, -- FileName: [WCHAR; 1], --}} --pub type PFILE_ID_BOTH_DIR_INFORMATION = *mut FILE_ID_BOTH_DIR_INFORMATION; --STRUCT!{struct FILE_NAMES_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- FileNameLength: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_NAMES_INFORMATION = *mut FILE_NAMES_INFORMATION; --STRUCT!{struct FILE_ID_GLOBAL_TX_DIR_INFORMATION { -- NextEntryOffset: ULONG, -- FileIndex: ULONG, -- CreationTime: LARGE_INTEGER, -- LastAccessTime: LARGE_INTEGER, -- LastWriteTime: LARGE_INTEGER, -- ChangeTime: LARGE_INTEGER, -- EndOfFile: LARGE_INTEGER, -- AllocationSize: LARGE_INTEGER, -- FileAttributes: ULONG, -- FileNameLength: ULONG, -- FileId: LARGE_INTEGER, -- LockingTransactionId: GUID, -- TxInfoFlags: ULONG, -- FileName: [WCHAR; 1], --}} --pub type PFILE_ID_GLOBAL_TX_DIR_INFORMATION = *mut FILE_ID_GLOBAL_TX_DIR_INFORMATION; --pub const FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_WRITELOCKED: u32 = 0x00000001; --pub const FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_VISIBLE_TO_TX: u32 = 0x00000002; --pub const FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_VISIBLE_OUTSIDE_TX: u32 = 0x00000004; --STRUCT!{struct FILE_OBJECTID_INFORMATION_u_s { -- BirthVolumeId: [UCHAR; 16], -- BirthObjectId: [UCHAR; 16], -- DomainId: [UCHAR; 16], --}} --UNION!{union FILE_OBJECTID_INFORMATION_u { -- s: FILE_OBJECTID_INFORMATION_u_s, -- ExtendedInfo: [UCHAR; 48], --}} --STRUCT!{struct FILE_OBJECTID_INFORMATION { -- FileReference: LONGLONG, -- ObjectId: [UCHAR; 16], -- u: FILE_OBJECTID_INFORMATION_u, --}} --pub type PFILE_OBJECTID_INFORMATION = *mut FILE_OBJECTID_INFORMATION; --STRUCT!{struct FILE_FULL_EA_INFORMATION { -- NextEntryOffset: ULONG, -- Flags: UCHAR, -- EaNameLength: UCHAR, -- EaValueLength: USHORT, -- EaName: [CHAR; 1], --}} --pub type PFILE_FULL_EA_INFORMATION = *mut FILE_FULL_EA_INFORMATION; --STRUCT!{struct FILE_GET_EA_INFORMATION { -- NextEntryOffset: ULONG, -- EaNameLength: UCHAR, -- EaName: [CHAR; 1], --}} --pub type PFILE_GET_EA_INFORMATION = *mut FILE_GET_EA_INFORMATION; --STRUCT!{struct FILE_GET_QUOTA_INFORMATION { -- NextEntryOffset: ULONG, -- SidLength: ULONG, -- Sid: SID, --}} --pub type PFILE_GET_QUOTA_INFORMATION = *mut FILE_GET_QUOTA_INFORMATION; --STRUCT!{struct FILE_QUOTA_INFORMATION { -- NextEntryOffset: ULONG, -- SidLength: ULONG, -- ChangeTime: LARGE_INTEGER, -- QuotaUsed: LARGE_INTEGER, -- QuotaThreshold: LARGE_INTEGER, -- QuotaLimit: LARGE_INTEGER, -- Sid: SID, --}} --pub type PFILE_QUOTA_INFORMATION = *mut FILE_QUOTA_INFORMATION; --ENUM!{enum FS_INFORMATION_CLASS { -- FileFsVolumeInformation = 1, -- FileFsLabelInformation = 2, -- FileFsSizeInformation = 3, -- FileFsDeviceInformation = 4, -- FileFsAttributeInformation = 5, -- FileFsControlInformation = 6, -- FileFsFullSizeInformation = 7, -- FileFsObjectIdInformation = 8, -- FileFsDriverPathInformation = 9, -- FileFsVolumeFlagsInformation = 10, -- FileFsSectorSizeInformation = 11, -- FileFsDataCopyInformation = 12, -- FileFsMetadataSizeInformation = 13, -- FileFsFullSizeInformationEx = 14, -- FileFsMaximumInformation = 15, --}} --pub type PFS_INFORMATION_CLASS = *mut FS_INFORMATION_CLASS; --STRUCT!{struct FILE_FS_LABEL_INFORMATION { -- VolumeLabelLength: ULONG, -- VolumeLabel: [WCHAR; 1], --}} --pub type PFILE_FS_LABEL_INFORMATION = *mut FILE_FS_LABEL_INFORMATION; --STRUCT!{struct FILE_FS_VOLUME_INFORMATION { -- VolumeCreationTime: LARGE_INTEGER, -- VolumeSerialNumber: ULONG, -- VolumeLabelLength: ULONG, -- SupportsObjects: BOOLEAN, -- VolumeLabel: [WCHAR; 1], --}} --pub type PFILE_FS_VOLUME_INFORMATION = *mut FILE_FS_VOLUME_INFORMATION; --STRUCT!{struct FILE_FS_SIZE_INFORMATION { -- TotalAllocationUnits: LARGE_INTEGER, -- AvailableAllocationUnits: LARGE_INTEGER, -- SectorsPerAllocationUnit: ULONG, -- BytesPerSector: ULONG, --}} --pub type PFILE_FS_SIZE_INFORMATION = *mut FILE_FS_SIZE_INFORMATION; --STRUCT!{struct FILE_FS_CONTROL_INFORMATION { -- FreeSpaceStartFiltering: LARGE_INTEGER, -- FreeSpaceThreshold: LARGE_INTEGER, -- FreeSpaceStopFiltering: LARGE_INTEGER, -- DefaultQuotaThreshold: LARGE_INTEGER, -- DefaultQuotaLimit: LARGE_INTEGER, -- FileSystemControlFlags: ULONG, --}} --pub type PFILE_FS_CONTROL_INFORMATION = *mut FILE_FS_CONTROL_INFORMATION; --STRUCT!{struct FILE_FS_FULL_SIZE_INFORMATION { -- TotalAllocationUnits: LARGE_INTEGER, -- CallerAvailableAllocationUnits: LARGE_INTEGER, -- ActualAvailableAllocationUnits: LARGE_INTEGER, -- SectorsPerAllocationUnit: ULONG, -- BytesPerSector: ULONG, --}} --pub type PFILE_FS_FULL_SIZE_INFORMATION = *mut FILE_FS_FULL_SIZE_INFORMATION; --STRUCT!{struct FILE_FS_OBJECTID_INFORMATION { -- ObjectId: [UCHAR; 16], -- ExtendedInfo: [UCHAR; 48], --}} --pub type PFILE_FS_OBJECTID_INFORMATION = *mut FILE_FS_OBJECTID_INFORMATION; --STRUCT!{struct FILE_FS_DEVICE_INFORMATION { -- DeviceType: DWORD, -- Characteristics: ULONG, --}} --pub type PFILE_FS_DEVICE_INFORMATION = *mut FILE_FS_DEVICE_INFORMATION; --STRUCT!{struct FILE_FS_ATTRIBUTE_INFORMATION { -- FileSystemAttributes: ULONG, -- MaximumComponentNameLength: LONG, -- FileSystemNameLength: ULONG, -- FileSystemName: [WCHAR; 1], --}} --pub type PFILE_FS_ATTRIBUTE_INFORMATION = *mut FILE_FS_ATTRIBUTE_INFORMATION; --STRUCT!{struct FILE_FS_DRIVER_PATH_INFORMATION { -- DriverInPath: BOOLEAN, -- DriverNameLength: ULONG, -- DriverName: [WCHAR; 1], --}} --pub type PFILE_FS_DRIVER_PATH_INFORMATION = *mut FILE_FS_DRIVER_PATH_INFORMATION; --STRUCT!{struct FILE_FS_VOLUME_FLAGS_INFORMATION { -- Flags: ULONG, --}} --pub type PFILE_FS_VOLUME_FLAGS_INFORMATION = *mut FILE_FS_VOLUME_FLAGS_INFORMATION; --pub const SSINFO_FLAGS_ALIGNED_DEVICE: u32 = 0x00000001; --pub const SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE: u32 = 0x00000002; --pub const SSINFO_OFFSET_UNKNOWN: u32 = 0xffffffff; --STRUCT!{struct FILE_FS_SECTOR_SIZE_INFORMATION { -- LogicalBytesPerSector: ULONG, -- PhysicalBytesPerSectorForAtomicity: ULONG, -- PhysicalBytesPerSectorForPerformance: ULONG, -- FileSystemEffectivePhysicalBytesPerSectorForAtomicity: ULONG, -- Flags: ULONG, -- ByteOffsetForSectorAlignment: ULONG, -- ByteOffsetForPartitionAlignment: ULONG, --}} --pub type PFILE_FS_SECTOR_SIZE_INFORMATION = *mut FILE_FS_SECTOR_SIZE_INFORMATION; --STRUCT!{struct FILE_FS_DATA_COPY_INFORMATION { -- NumberOfCopies: ULONG, --}} --pub type PFILE_FS_DATA_COPY_INFORMATION = *mut FILE_FS_DATA_COPY_INFORMATION; --STRUCT!{struct FILE_FS_METADATA_SIZE_INFORMATION { -- TotalMetadataAllocationUnits: LARGE_INTEGER, -- SectorsPerAllocationUnit: ULONG, -- BytesPerSector: ULONG, --}} --pub type PFILE_FS_METADATA_SIZE_INFORMATION = *mut FILE_FS_METADATA_SIZE_INFORMATION; --STRUCT!{struct FILE_FS_FULL_SIZE_INFORMATION_EX { -- ActualTotalAllocationUnits: ULONGLONG, -- ActualAvailableAllocationUnits: ULONGLONG, -- ActualPoolUnavailableAllocationUnits: ULONGLONG, -- CallerTotalAllocationUnits: ULONGLONG, -- CallerAvailableAllocationUnits: ULONGLONG, -- CallerPoolUnavailableAllocationUnits: ULONGLONG, -- UsedAllocationUnits: ULONGLONG, -- TotalReservedAllocationUnits: ULONGLONG, -- VolumeStorageReserveAllocationUnits: ULONGLONG, -- AvailableCommittedAllocationUnits: ULONGLONG, -- PoolAvailableAllocationUnits: ULONGLONG, -- SectorsPerAllocationUnit: ULONG, -- BytesPerSector: ULONG, --}} --pub type PFILE_FS_FULL_SIZE_INFORMATION_EX = *mut FILE_FS_FULL_SIZE_INFORMATION_EX; --EXTERN!{extern "system" { -- fn NtCreateFile( -- FileHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- AllocationSize: PLARGE_INTEGER, -- FileAttributes: ULONG, -- ShareAccess: ULONG, -- CreateDisposition: ULONG, -- CreateOptions: ULONG, -- EaBuffer: PVOID, -- EaLength: ULONG, -- ) -> NTSTATUS; -- fn NtCreateNamedPipeFile( -- FileHandle: PHANDLE, -- DesiredAccess: ULONG, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ShareAccess: ULONG, -- CreateDisposition: ULONG, -- CreateOptions: ULONG, -- NamedPipeType: ULONG, -- ReadMode: ULONG, -- CompletionMode: ULONG, -- MaximumInstances: ULONG, -- InboundQuota: ULONG, -- OutboundQuota: ULONG, -- DefaultTimeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtCreateMailslotFile( -- FileHandle: PHANDLE, -- DesiredAccess: ULONG, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- CreateOptions: ULONG, -- MailslotQuota: ULONG, -- MaximumMessageSize: ULONG, -- ReadTimeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtOpenFile( -- FileHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ShareAccess: ULONG, -- OpenOptions: ULONG, -- ) -> NTSTATUS; -- fn NtDeleteFile( -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtFlushBuffersFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn NtFlushBuffersFileEx( -- FileHandle: HANDLE, -- Flags: ULONG, -- Parameters: PVOID, -- ParametersSize: ULONG, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn NtQueryInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FileInformation: PVOID, -- Length: ULONG, -- FileInformationClass: FILE_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn NtQueryInformationByName( -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FileInformation: PVOID, -- Length: ULONG, -- FileInformationClass: FILE_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn NtSetInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FileInformation: PVOID, -- Length: ULONG, -- FileInformationClass: FILE_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn NtQueryDirectoryFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FileInformation: PVOID, -- Length: ULONG, -- FileInformationClass: FILE_INFORMATION_CLASS, -- ReturnSingleEntry: BOOLEAN, -- FileName: PUNICODE_STRING, -- RestartScan: BOOLEAN, -- ) -> NTSTATUS; -- fn NtQueryEaFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ReturnSingleEntry: BOOLEAN, -- EaList: PVOID, -- EaListLength: ULONG, -- EaIndex: PULONG, -- RestartScan: BOOLEAN, -- ) -> NTSTATUS; -- fn NtSetEaFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ) -> NTSTATUS; -- fn NtQueryQuotaInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ReturnSingleEntry: BOOLEAN, -- SidList: PVOID, -- SidListLength: ULONG, -- StartSid: PSID, -- RestartScan: BOOLEAN, -- ) -> NTSTATUS; -- fn NtSetQuotaInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ) -> NTSTATUS; -- fn NtQueryVolumeInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FsInformation: PVOID, -- Length: ULONG, -- FsInformationClass: FS_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn NtSetVolumeInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FsInformation: PVOID, -- Length: ULONG, -- FsInformationClass: FS_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn NtCancelIoFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn NtCancelIoFileEx( -- FileHandle: HANDLE, -- IoRequestToCancel: PIO_STATUS_BLOCK, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn NtCancelSynchronousIoFile( -- ThreadHandle: HANDLE, -- IoRequestToCancel: PIO_STATUS_BLOCK, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn NtDeviceIoControlFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- IoControlCode: ULONG, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- OutputBuffer: PVOID, -- OutputBufferLength: ULONG, -- ) -> NTSTATUS; -- fn NtFsControlFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FsControlCode: ULONG, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- OutputBuffer: PVOID, -- OutputBufferLength: ULONG, -- ) -> NTSTATUS; -- fn NtReadFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ByteOffset: PLARGE_INTEGER, -- Key: PULONG, -- ) -> NTSTATUS; -- fn NtWriteFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ByteOffset: PLARGE_INTEGER, -- Key: PULONG, -- ) -> NTSTATUS; -- fn NtReadFileScatter( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- SegmentArray: PFILE_SEGMENT_ELEMENT, -- Length: ULONG, -- ByteOffset: PLARGE_INTEGER, -- Key: PULONG, -- ) -> NTSTATUS; -- fn NtWriteFileGather( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- SegmentArray: PFILE_SEGMENT_ELEMENT, -- Length: ULONG, -- ByteOffset: PLARGE_INTEGER, -- Key: PULONG, -- ) -> NTSTATUS; -- fn NtLockFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ByteOffset: PLARGE_INTEGER, -- Length: PLARGE_INTEGER, -- Key: ULONG, -- FailImmediately: BOOLEAN, -- ExclusiveLock: BOOLEAN, -- ) -> NTSTATUS; -- fn NtUnlockFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ByteOffset: PLARGE_INTEGER, -- Length: PLARGE_INTEGER, -- Key: ULONG, -- ) -> NTSTATUS; -- fn NtQueryAttributesFile( -- ObjectAttributes: POBJECT_ATTRIBUTES, -- FileInformation: PFILE_BASIC_INFORMATION, -- ) -> NTSTATUS; -- fn NtQueryFullAttributesFile( -- ObjectAttributes: POBJECT_ATTRIBUTES, -- FileInformation: PFILE_NETWORK_OPEN_INFORMATION, -- ) -> NTSTATUS; -- fn NtNotifyChangeDirectoryFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- CompletionFilter: ULONG, -- WatchTree: BOOLEAN, -- ) -> NTSTATUS; -- fn NtLoadDriver( -- DriverServiceName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn NtUnloadDriver( -- DriverServiceName: PUNICODE_STRING, -- ) -> NTSTATUS; --}} --pub const IO_COMPLETION_QUERY_STATE: u32 = 0x0001; --ENUM!{enum IO_COMPLETION_INFORMATION_CLASS { -- IoCompletionBasicInformation = 0, --}} --STRUCT!{struct IO_COMPLETION_BASIC_INFORMATION { -- Depth: LONG, --}} --pub type PIO_COMPLETION_BASIC_INFORMATION = *mut IO_COMPLETION_BASIC_INFORMATION; --EXTERN!{extern "system" { -- fn NtCreateIoCompletion( -- IoCompletionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Count: ULONG, -- ) -> NTSTATUS; -- fn NtOpenIoCompletion( -- IoCompletionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtQueryIoCompletion( -- IoCompletionHandle: HANDLE, -- IoCompletionInformationClass: IO_COMPLETION_INFORMATION_CLASS, -- IoCompletionInformation: PVOID, -- IoCompletionInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetIoCompletion( -- IoCompletionHandle: HANDLE, -- KeyContext: PVOID, -- ApcContext: PVOID, -- IoStatus: NTSTATUS, -- IoStatusInformation: ULONG_PTR, -- ) -> NTSTATUS; -- fn NtSetIoCompletionEx( -- IoCompletionHandle: HANDLE, -- IoCompletionPacketHandle: HANDLE, -- KeyContext: PVOID, -- ApcContext: PVOID, -- IoStatus: NTSTATUS, -- IoStatusInformation: ULONG_PTR, -- ) -> NTSTATUS; -- fn NtRemoveIoCompletion( -- IoCompletionHandle: HANDLE, -- KeyContext: *mut PVOID, -- ApcContext: *mut PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtRemoveIoCompletionEx( -- IoCompletionHandle: HANDLE, -- IoCompletionInformation: PFILE_IO_COMPLETION_INFORMATION, -- Count: ULONG, -- NumEntriesRemoved: PULONG, -- Timeout: PLARGE_INTEGER, -- Alertable: BOOLEAN, -- ) -> NTSTATUS; -- fn NtCreateWaitCompletionPacket( -- WaitCompletionPacketHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtAssociateWaitCompletionPacket( -- WaitCompletionPacketHandle: HANDLE, -- IoCompletionHandle: HANDLE, -- TargetObjectHandle: HANDLE, -- KeyContext: PVOID, -- ApcContext: PVOID, -- IoStatus: NTSTATUS, -- IoStatusInformation: ULONG_PTR, -- AlreadySignaled: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtCancelWaitCompletionPacket( -- WaitCompletionPacketHandle: HANDLE, -- RemoveSignaledPacket: BOOLEAN, -- ) -> NTSTATUS; --}} --ENUM!{enum IO_SESSION_EVENT { -- IoSessionEventIgnore = 0, -- IoSessionEventCreated = 1, -- IoSessionEventTerminated = 2, -- IoSessionEventConnected = 3, -- IoSessionEventDisconnected = 4, -- IoSessionEventLogon = 5, -- IoSessionEventLogoff = 6, -- IoSessionEventMax = 7, --}} --ENUM!{enum IO_SESSION_STATE { -- IoSessionStateCreated = 0, -- IoSessionStateInitialized = 1, -- IoSessionStateConnected = 2, -- IoSessionStateDisconnected = 3, -- IoSessionStateDisconnectedLoggedOn = 4, -- IoSessionStateLoggedOn = 5, -- IoSessionStateLoggedOff = 6, -- IoSessionStateTerminated = 7, -- IoSessionStateMax = 8, --}} --EXTERN!{extern "system" { -- fn NtNotifyChangeSession( -- SessionHandle: HANDLE, -- ChangeSequenceNumber: ULONG, -- ChangeTimeStamp: PLARGE_INTEGER, -- Event: IO_SESSION_EVENT, -- NewState: IO_SESSION_STATE, -- PreviousState: IO_SESSION_STATE, -- Payload: PVOID, -- PayloadSize: ULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum INTERFACE_TYPE { -- InterfaceTypeUndefined = -1i32 as u32, -- Internal = 0, -- Isa = 1, -- Eisa = 2, -- MicroChannel = 3, -- TurboChannel = 4, -- PCIBus = 5, -- VMEBus = 6, -- NuBus = 7, -- PCMCIABus = 8, -- CBus = 9, -- MPIBus = 10, -- MPSABus = 11, -- ProcessorInternal = 12, -- InternalPowerBus = 13, -- PNPISABus = 14, -- PNPBus = 15, -- Vmcs = 16, -- MaximumInterfaceType = 17, --}} --pub type PINTERFACE_TYPE = *mut INTERFACE_TYPE; --ENUM!{enum DMA_WIDTH { -- Width8Bits = 0, -- Width16Bits = 1, -- Width32Bits = 2, -- MaximumDmaWidth = 3, --}} --pub type PDMA_WIDTH = *mut DMA_WIDTH; --ENUM!{enum DMA_SPEED { -- Compatible = 0, -- TypeA = 1, -- TypeB = 2, -- TypeC = 3, -- TypeF = 4, -- MaximumDmaSpeed = 5, --}} --pub type PDMA_SPEED = *mut DMA_SPEED; --ENUM!{enum BUS_DATA_TYPE { -- ConfigurationSpaceUndefined = -1i32 as u32, -- Cmos = 0, -- EisaConfiguration = 1, -- Pos = 2, -- CbusConfiguration = 3, -- PCIConfiguration = 4, -- VMEConfiguration = 5, -- NuBusConfiguration = 6, -- PCMCIAConfiguration = 7, -- MPIConfiguration = 8, -- MPSAConfiguration = 9, -- PNPISAConfiguration = 10, -- SgiInternalConfiguration = 11, -- MaximumBusDataType = 12, --}} --pub type PBUS_DATA_TYPE = *mut BUS_DATA_TYPE; --pub const SYMLINK_FLAG_RELATIVE: u32 = 1; --STRUCT!{struct REPARSE_DATA_BUFFER_u_SymbolicLinkReparseBuffer { -- SubstituteNameOffset: USHORT, -- SubstituteNameLength: USHORT, -- PrintNameOffset: USHORT, -- PrintNameLength: USHORT, -- Flags: ULONG, -- PathBuffer: [WCHAR; 1], --}} --STRUCT!{struct REPARSE_DATA_BUFFER_u_MountPointReparseBuffer { -- SubstituteNameOffset: USHORT, -- SubstituteNameLength: USHORT, -- PrintNameOffset: USHORT, -- PrintNameLength: USHORT, -- PathBuffer: [WCHAR; 1], --}} --STRUCT!{struct REPARSE_DATA_BUFFER_u_GenericReparseBuffer { -- DataBuffer: [UCHAR; 1], --}} --UNION!{union REPARSE_DATA_BUFFER_u { -- SymbolicLinkReparseBuffer: REPARSE_DATA_BUFFER_u_SymbolicLinkReparseBuffer, -- MountPointReparseBuffer: REPARSE_DATA_BUFFER_u_MountPointReparseBuffer, -- GenericReparseBuffer: REPARSE_DATA_BUFFER_u_GenericReparseBuffer, --}} --STRUCT!{struct REPARSE_DATA_BUFFER { -- ReparseTag: ULONG, -- ReparseDataLength: USHORT, -- Reserved: USHORT, -- u: REPARSE_DATA_BUFFER_u, --}} --pub type PREPARSE_DATA_BUFFER = *mut REPARSE_DATA_BUFFER; --/// "\Device\NamedPipe\" --pub const DEVICE_NAMED_PIPE: UTF16Const = UTF16Const(&[ -- 0x005C, 0x0044, 0x0065, 0x0076, 0x0069, 0x0063, 0x0065, 0x005C, 0x004E, 0x0061, 0x006D, 0x0065, -- 0x0064, 0x0050, 0x0069, 0x0070, 0x0065, 0x005C, 0u16, --]); --pub const FSCTL_PIPE_ASSIGN_EVENT: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_DISCONNECT: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 1, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_LISTEN: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_PEEK: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 3, METHOD_BUFFERED, FILE_READ_DATA); --pub const FSTL_PIPE_QUERY_EVENT: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 4, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_TRANSCEIVE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 5, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA); --pub const FSTL_PIPE_WAIT: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 6, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_IMPERSONATE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 7, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_SET_CLIENT_PROCESS: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 8, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_QUERY_CLIENT_PROCESS: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 9, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_GET_PIPE_ATTRIBUTE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 10, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_SET_PIPE_ATTRIBUTE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 11, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_GET_CONNECTION_ATTRIBUTE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 12, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_SET_CONNECTION_ATTRIBUTE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 13, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_GET_HANDLE_ATTRIBUTE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 14, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_SET_HANDLE_ATTRIBUTE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 15, METHOD_BUFFERED, FILE_ANY_ACCESS); --pub const FSTL_PIPE_FLUSH: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 16, METHOD_BUFFERED, FILE_WRITE_DATA); --pub const FSTL_PIPE_INTERNAL_READ: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2045, METHOD_BUFFERED, FILE_READ_DATA); --pub const FSTL_PIPE_INTERNAL_WRITE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2046, METHOD_BUFFERED, FILE_WRITE_DATA); --pub const FSTL_PIPE_INTERNAL_TRANSCEIVE: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2047, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA); --pub const FSTL_PIPE_INTERNAL_READ_OVFLOW: u32 = -- CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2048, METHOD_BUFFERED, FILE_READ_DATA); --pub const FILE_PIPE_READ_DATA: u32 = 0x00000000; --pub const FILE_PIPE_WRITE_SPACE: u32 = 0x00000001; --STRUCT!{struct FILE_PIPE_ASSIGN_EVENT_BUFFER { -- EventHandle: HANDLE, -- KeyValue: ULONG, --}} --pub type PFILE_PIPE_ASSIGN_EVENT_BUFFER = *mut FILE_PIPE_ASSIGN_EVENT_BUFFER; --STRUCT!{struct FILE_PIPE_PEEK_BUFFER { -- NamedPipeState: ULONG, -- ReadDataAvailable: ULONG, -- NumberOfMessages: ULONG, -- MessageLength: ULONG, -- Data: [CHAR; 1], --}} --pub type PFILE_PIPE_PEEK_BUFFER = *mut FILE_PIPE_PEEK_BUFFER; --STRUCT!{struct FILE_PIPE_EVENT_BUFFER { -- NamedPipeState: ULONG, -- EntryType: ULONG, -- ByteCount: ULONG, -- KeyValue: ULONG, -- NumberRequests: ULONG, --}} --pub type PFILE_PIPE_EVENT_BUFFER = *mut FILE_PIPE_EVENT_BUFFER; --STRUCT!{struct FILE_PIPE_WAIT_FOR_BUFFER { -- Timeout: LARGE_INTEGER, -- NameLength: ULONG, -- TimeoutSpecified: BOOLEAN, -- Name: [WCHAR; 1], --}} --pub type PFILE_PIPE_WAIT_FOR_BUFFER = *mut FILE_PIPE_WAIT_FOR_BUFFER; --STRUCT!{struct FILE_PIPE_CLIENT_PROCESS_BUFFER { -- ClientSession: PVOID, -- ClientProcess: PVOID, --}} --pub type PFILE_PIPE_CLIENT_PROCESS_BUFFER = *mut FILE_PIPE_CLIENT_PROCESS_BUFFER; --pub const FILE_PIPE_COMPUTER_NAME_LENGTH: usize = 15; --STRUCT!{struct FILE_PIPE_CLIENT_PROCESS_BUFFER_EX { -- ClientSession: PVOID, -- ClientProcess: PVOID, -- ClientComputerNameLength: USHORT, -- ClientComputerBuffer: [WCHAR; FILE_PIPE_COMPUTER_NAME_LENGTH + 1], --}} --pub type PFILE_PIPE_CLIENT_PROCESS_BUFFER_EX = *mut FILE_PIPE_CLIENT_PROCESS_BUFFER_EX; --pub const MAILSLOT_CLASS_FIRSTCLASS: u32 = 1; --pub const MAILSLOT_CLASS_SECONDCLASS: u32 = 2; --pub const FSCTL_MAILSLOT_PEEK: u32 = -- CTL_CODE(FILE_DEVICE_MAILSLOT, 0, METHOD_NEITHER, FILE_READ_DATA); --STRUCT!{struct FILE_MAILSLOT_PEEK_BUFFER { -- ReadDataAvailable: ULONG, -- NumberOfMessages: ULONG, -- MessageLength: ULONG, --}} --pub type PFILE_MAILSLOT_PEEK_BUFFER = *mut FILE_MAILSLOT_PEEK_BUFFER; -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntkeapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntkeapi.rs -deleted file mode 100644 -index a26f39b3..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntkeapi.rs -+++ /dev/null -@@ -1,121 +0,0 @@ --use winapi::shared::ntdef::{BOOLEAN, NTSTATUS, PVOID, ULONG}; --pub const LOW_PRIORITY: u32 = 0; --pub const LOW_REALTIME_PRIORITY: u32 = 16; --pub const HIGH_PRIORITY: u32 = 31; --pub const MAXIMUM_PRIORITY: u32 = 32; --ENUM!{enum KTHREAD_STATE { -- Initialized = 0, -- Ready = 1, -- Running = 2, -- Standby = 3, -- Terminated = 4, -- Waiting = 5, -- Transition = 6, -- DeferredReady = 7, -- GateWaitObsolete = 8, -- WaitingForProcessInSwap = 9, -- MaximumThreadState = 10, --}} --pub type PKTHREAD_STATE = *mut KTHREAD_STATE; --ENUM!{enum KHETERO_CPU_POLICY { -- KHeteroCpuPolicyAll = 0, -- KHeteroCpuPolicyLarge = 1, -- KHeteroCpuPolicyLargeOrIdle = 2, -- KHeteroCpuPolicySmall = 3, -- KHeteroCpuPolicySmallOrIdle = 4, -- KHeteroCpuPolicyDynamic = 5, -- KHeteroCpuPolicyStaticMax = 6, -- KHeteroCpuPolicyBiasedSmall = 7, -- KHeteroCpuPolicyBiasedLarge = 8, -- KHeteroCpuPolicyDefault = 9, -- KHeteroCpuPolicyMax = 10, --}} --pub type PKHETERO_CPU_POLICY = *mut KHETERO_CPU_POLICY; --ENUM!{enum KWAIT_REASON { -- Executive = 0, -- FreePage = 1, -- PageIn = 2, -- PoolAllocation = 3, -- DelayExecution = 4, -- Suspended = 5, -- UserRequest = 6, -- WrExecutive = 7, -- WrFreePage = 8, -- WrPageIn = 9, -- WrPoolAllocation = 10, -- WrDelayExecution = 11, -- WrSuspended = 12, -- WrUserRequest = 13, -- WrEventPair = 14, -- WrQueue = 15, -- WrLpcReceive = 16, -- WrLpcReply = 17, -- WrVirtualMemory = 18, -- WrPageOut = 19, -- WrRendezvous = 20, -- WrKeyedEvent = 21, -- WrTerminated = 22, -- WrProcessInSwap = 23, -- WrCpuRateControl = 24, -- WrCalloutStack = 25, -- WrKernel = 26, -- WrResource = 27, -- WrPushLock = 28, -- WrMutex = 29, -- WrQuantumEnd = 30, -- WrDispatchInt = 31, -- WrPreempted = 32, -- WrYieldExecution = 33, -- WrFastMutex = 34, -- WrGuardedMutex = 35, -- WrRundown = 36, -- WrAlertByThreadId = 37, -- WrDeferredPreempt = 38, -- MaximumWaitReason = 39, --}} --pub type PKWAIT_REASON = *mut KWAIT_REASON; --ENUM!{enum KPROFILE_SOURCE { -- ProfileTime = 0, -- ProfileAlignmentFixup = 1, -- ProfileTotalIssues = 2, -- ProfilePipelineDry = 3, -- ProfileLoadInstructions = 4, -- ProfilePipelineFrozen = 5, -- ProfileBranchInstructions = 6, -- ProfileTotalNonissues = 7, -- ProfileDcacheMisses = 8, -- ProfileIcacheMisses = 9, -- ProfileCacheMisses = 10, -- ProfileBranchMispredictions = 11, -- ProfileStoreInstructions = 12, -- ProfileFpInstructions = 13, -- ProfileIntegerInstructions = 14, -- Profile2Issue = 15, -- Profile3Issue = 16, -- Profile4Issue = 17, -- ProfileSpecialInstructions = 18, -- ProfileTotalCycles = 19, -- ProfileIcacheIssues = 20, -- ProfileDcacheAccesses = 21, -- ProfileMemoryBarrierCycles = 22, -- ProfileLoadLinkedIssues = 23, -- ProfileMaximum = 24, --}} --EXTERN!{extern "system" { -- fn NtCallbackReturn( -- OutputBuffer: PVOID, -- OutputLength: ULONG, -- Status: NTSTATUS, -- ) -> NTSTATUS; -- fn NtFlushProcessWriteBuffers(); -- fn NtQueryDebugFilterState( -- ComponentId: ULONG, -- Level: ULONG, -- ) -> NTSTATUS; -- fn NtSetDebugFilterState( -- ComponentId: ULONG, -- Level: ULONG, -- State: BOOLEAN, -- ) -> NTSTATUS; -- fn NtYieldExecution() -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntldr.rs b/KubeOS-Rust/vendor/ntapi/src/ntldr.rs -deleted file mode 100644 -index 1114dd8e..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntldr.rs -+++ /dev/null -@@ -1,661 +0,0 @@ --use winapi::shared::basetsd::{LONG_PTR, PSIZE_T, SIZE_T, ULONG_PTR}; --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, LARGE_INTEGER, LIST_ENTRY, LONG, LONGLONG, NTSTATUS, PANSI_STRING, PCSTR, -- PCUNICODE_STRING, PCWSTR, PHANDLE, POBJECT_ATTRIBUTES, PSINGLE_LIST_ENTRY, PSTR, PULONG, -- PUNICODE_STRING, PUSHORT, PVOID, PWSTR, RTL_BALANCED_NODE, SINGLE_LIST_ENTRY, UCHAR, ULONG, -- UNICODE_STRING, USHORT, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, ACTIVATION_CONTEXT, IMAGE_RESOURCE_DIRECTORY_ENTRY, PCIMAGE_DELAYLOAD_DESCRIPTOR, -- PIMAGE_BASE_RELOCATION, PIMAGE_IMPORT_DESCRIPTOR, PIMAGE_RESOURCE_DATA_ENTRY, -- PIMAGE_RESOURCE_DIRECTORY, PIMAGE_RESOURCE_DIRECTORY_STRING, PIMAGE_THUNK_DATA, --}; --FN!{stdcall PLDR_INIT_ROUTINE( -- DllHandle: PVOID, -- Reason: ULONG, -- Context: PVOID, --) -> BOOLEAN} --STRUCT!{struct LDR_SERVICE_TAG_RECORD { -- Next: *mut LDR_SERVICE_TAG_RECORD, -- ServiceTag: ULONG, --}} --pub type PLDR_SERVICE_TAG_RECORD = *mut LDR_SERVICE_TAG_RECORD; --STRUCT!{struct LDRP_CSLIST { -- Tail: PSINGLE_LIST_ENTRY, --}} --pub type PLDRP_CSLIST = *mut LDRP_CSLIST; --ENUM!{enum LDR_DDAG_STATE { -- LdrModulesMerged = -5i32 as u32, -- LdrModulesInitError = -4i32 as u32, -- LdrModulesSnapError = -3i32 as u32, -- LdrModulesUnloaded = -2i32 as u32, -- LdrModulesUnloading = -1i32 as u32, -- LdrModulesPlaceHolder = 0, -- LdrModulesMapping = 1, -- LdrModulesMapped = 2, -- LdrModulesWaitingForDependencies = 3, -- LdrModulesSnapping = 4, -- LdrModulesSnapped = 5, -- LdrModulesCondensed = 6, -- LdrModulesReadyToInit = 7, -- LdrModulesInitializing = 8, -- LdrModulesReadyToRun = 9, --}} --UNION!{union LDR_DDAG_NODE_u { -- Dependencies: LDRP_CSLIST, -- RemovalLink: SINGLE_LIST_ENTRY, --}} --STRUCT!{struct LDR_DDAG_NODE { -- Modules: LIST_ENTRY, -- ServiceTagList: PLDR_SERVICE_TAG_RECORD, -- LoadCount: ULONG, -- LoadWhileUnloadingCount: ULONG, -- LowestLink: ULONG, -- u: LDR_DDAG_NODE_u, -- IncomingDependencies: LDRP_CSLIST, -- State: LDR_DDAG_STATE, -- CondenseLink: SINGLE_LIST_ENTRY, -- PreorderNumber: ULONG, --}} --pub type PLDR_DDAG_NODE = *mut LDR_DDAG_NODE; --STRUCT!{struct LDR_DEPENDENCY_RECORD { -- DependencyLink: SINGLE_LIST_ENTRY, -- DependencyNode: PLDR_DDAG_NODE, -- IncomingDependencyLink: SINGLE_LIST_ENTRY, -- IncomingDependencyNode: PLDR_DDAG_NODE, --}} --pub type PLDR_DEPENDENCY_RECORD = *mut LDR_DEPENDENCY_RECORD; --ENUM!{enum LDR_DLL_LOAD_REASON { -- LoadReasonStaticDependency = 0, -- LoadReasonStaticForwarderDependency = 1, -- LoadReasonDynamicForwarderDependency = 2, -- LoadReasonDelayloadDependency = 3, -- LoadReasonDynamicLoad = 4, -- LoadReasonAsImageLoad = 5, -- LoadReasonAsDataLoad = 6, -- LoadReasonEnclavePrimary = 7, -- LoadReasonEnclaveDependency = 8, -- LoadReasonUnknown = -1i32 as u32, --}} --pub type PLDR_DLL_LOAD_REASON = *mut LDR_DLL_LOAD_REASON; --pub const LDRP_PACKAGED_BINARY: ULONG = 0x00000001; --pub const LDRP_STATIC_LINK: ULONG = 0x00000002; --pub const LDRP_IMAGE_DLL: ULONG = 0x00000004; --pub const LDRP_LOAD_IN_PROGRESS: ULONG = 0x00001000; --pub const LDRP_UNLOAD_IN_PROGRESS: ULONG = 0x00002000; --pub const LDRP_ENTRY_PROCESSED: ULONG = 0x00004000; --pub const LDRP_ENTRY_INSERTED: ULONG = 0x00008000; --pub const LDRP_CURRENT_LOAD: ULONG = 0x00010000; --pub const LDRP_FAILED_BUILTIN_LOAD: ULONG = 0x00020000; --pub const LDRP_DONT_CALL_FOR_THREADS: ULONG = 0x00040000; --pub const LDRP_PROCESS_ATTACH_CALLED: ULONG = 0x00080000; --pub const LDRP_DEBUG_SYMBOLS_LOADED: ULONG = 0x00100000; --pub const LDRP_IMAGE_NOT_AT_BASE: ULONG = 0x00200000; --pub const LDRP_COR_IMAGE: ULONG = 0x00400000; --pub const LDRP_DONT_RELOCATE: ULONG = 0x00800000; --pub const LDRP_SYSTEM_MAPPED: ULONG = 0x01000000; --pub const LDRP_IMAGE_VERIFYING: ULONG = 0x02000000; --pub const LDRP_DRIVER_DEPENDENT_DLL: ULONG = 0x04000000; --pub const LDRP_ENTRY_NATIVE: ULONG = 0x08000000; --pub const LDRP_REDIRECTED: ULONG = 0x10000000; --pub const LDRP_NON_PAGED_DEBUG_INFO: ULONG = 0x20000000; --pub const LDRP_MM_LOADED: ULONG = 0x40000000; --pub const LDRP_COMPAT_DATABASE_PROCESSED: ULONG = 0x80000000; --STRUCT!{struct LDRP_LOAD_CONTEXT { -- BaseDllName: UNICODE_STRING, -- somestruct: PVOID, -- Flags: ULONG, -- pstatus: *mut NTSTATUS, -- ParentEntry: *mut LDR_DATA_TABLE_ENTRY, -- Entry: *mut LDR_DATA_TABLE_ENTRY, -- WorkQueueListEntry: LIST_ENTRY, -- ReplacedEntry: *mut LDR_DATA_TABLE_ENTRY, -- pvImports: *mut *mut LDR_DATA_TABLE_ENTRY, -- ImportDllCount: ULONG, -- TaskCount: LONG, -- pvIAT: PVOID, -- SizeOfIAT: ULONG, -- CurrentDll: ULONG, -- piid: PIMAGE_IMPORT_DESCRIPTOR, -- OriginalIATProtect: ULONG, -- GuardCFCheckFunctionPointer: PVOID, -- pGuardCFCheckFunctionPointer: *mut PVOID, --}} --UNION!{union LDR_DATA_TABLE_ENTRY_u1 { -- InInitializationOrderLinks: LIST_ENTRY, -- InProgressLinks: LIST_ENTRY, --}} --UNION!{union LDR_DATA_TABLE_ENTRY_u2 { -- FlagGroup: [UCHAR; 4], -- Flags: ULONG, --}} --STRUCT!{struct LDR_DATA_TABLE_ENTRY { -- InLoadOrderLinks: LIST_ENTRY, -- InMemoryOrderLinks: LIST_ENTRY, -- u1: LDR_DATA_TABLE_ENTRY_u1, -- DllBase: PVOID, -- EntryPoint: PLDR_INIT_ROUTINE, -- SizeOfImage: ULONG, -- FullDllName: UNICODE_STRING, -- BaseDllName: UNICODE_STRING, -- u2: LDR_DATA_TABLE_ENTRY_u2, -- ObsoleteLoadCount: USHORT, -- TlsIndex: USHORT, -- HashLinks: LIST_ENTRY, -- TimeDateStamp: ULONG, -- EntryPointActivationContext: *mut ACTIVATION_CONTEXT, -- Lock: PVOID, -- DdagNode: PLDR_DDAG_NODE, -- NodeModuleLink: LIST_ENTRY, -- LoadContext: *mut LDRP_LOAD_CONTEXT, -- ParentDllBase: PVOID, -- SwitchBackContext: PVOID, -- BaseAddressIndexNode: RTL_BALANCED_NODE, -- MappingInfoIndexNode: RTL_BALANCED_NODE, -- OriginalBase: ULONG_PTR, -- LoadTime: LARGE_INTEGER, -- BaseNameHashValue: ULONG, -- LoadReason: LDR_DLL_LOAD_REASON, -- ImplicitPathOptions: ULONG, -- ReferenceCount: ULONG, -- DependentLoadFlags: ULONG, -- SigningLevel: UCHAR, --}} --BITFIELD!{unsafe LDR_DATA_TABLE_ENTRY_u2 Flags: ULONG [ -- PackagedBinary set_PackagedBinary[0..1], -- MarkedForRemoval set_MarkedForRemoval[1..2], -- ImageDll set_ImageDll[2..3], -- LoadNotificationsSent set_LoadNotificationsSent[3..4], -- TelemetryEntryProcessed set_TelemetryEntryProcessed[4..5], -- ProcessStaticImport set_ProcessStaticImport[5..6], -- InLegacyLists set_InLegacyLists[6..7], -- InIndexes set_InIndexes[7..8], -- ShimDll set_ShimDll[8..9], -- InExceptionTable set_InExceptionTable[9..10], -- ReservedFlags1 set_ReservedFlags1[10..12], -- LoadInProgress set_LoadInProgress[12..13], -- LoadConfigProcessed set_LoadConfigProcessed[13..14], -- EntryProcessed set_EntryProcessed[14..15], -- ProtectDelayLoad set_ProtectDelayLoad[15..16], -- ReservedFlags3 set_ReservedFlags3[16..18], -- DontCallForThreads set_DontCallForThreads[18..19], -- ProcessAttachCalled set_ProcessAttachCalled[19..20], -- ProcessAttachFailed set_ProcessAttachFailed[20..21], -- CorDeferredValidate set_CorDeferredValidate[21..22], -- CorImage set_CorImage[22..23], -- DontRelocate set_DontRelocate[23..24], -- CorILOnly set_CorILOnly[24..25], -- ReservedFlags5 set_ReservedFlags5[25..28], -- Redirected set_Redirected[28..29], -- ReservedFlags6 set_ReservedFlags6[29..31], -- CompatDatabaseProcessed set_CompatDatabaseProcessed[31..32], --]} --pub type PLDR_DATA_TABLE_ENTRY = *mut LDR_DATA_TABLE_ENTRY; --#[inline] --pub const fn LDR_IS_DATAFILE(DllHandle: ULONG_PTR) -> bool { -- DllHandle & 1 != 0 --} --#[inline] --pub const fn LDR_IS_IMAGEMAPPING(DllHandle: ULONG_PTR) -> bool { -- DllHandle & 2 != 0 --} --#[inline] --pub const fn LDR_IS_RESOURCE(DllHandle: ULONG_PTR) -> bool { -- (LDR_IS_IMAGEMAPPING(DllHandle) | LDR_IS_DATAFILE(DllHandle)) as u8 != 0 //fixme --} --EXTERN!{extern "system" { -- fn LdrLoadDll( -- DllPath: PWSTR, -- DllCharacteristics: PULONG, -- DllName: PUNICODE_STRING, -- DllHandle: *mut PVOID, -- ) -> NTSTATUS; -- fn LdrUnloadDll( -- DllHandle: PVOID, -- ) -> NTSTATUS; -- fn LdrGetDllHandle( -- DllPath: PWSTR, -- DllCharacteristics: PULONG, -- DllName: PUNICODE_STRING, -- DllHandle: *mut PVOID, -- ) -> NTSTATUS; --}} --pub const LDR_GET_DLL_HANDLE_EX_UNCHANGED_REFCOUNT: ULONG = 0x00000001; --pub const LDR_GET_DLL_HANDLE_EX_PIN: ULONG = 0x00000002; --EXTERN!{extern "system" { -- fn LdrGetDllHandleEx( -- Flags: ULONG, -- DllPath: PWSTR, -- DllCharacteristics: PULONG, -- DllName: PUNICODE_STRING, -- DllHandle: *mut PVOID, -- ) -> NTSTATUS; -- fn LdrGetDllHandleByMapping( -- BaseAddress: PVOID, -- DllHandle: *mut PVOID, -- ) -> NTSTATUS; -- fn LdrGetDllHandleByName( -- BaseDllName: PUNICODE_STRING, -- FullDllName: PUNICODE_STRING, -- DllHandle: *mut PVOID, -- ) -> NTSTATUS; -- fn LdrGetDllFullName( -- DllHandle: PVOID, -- FullDllName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn LdrGetDllDirectory( -- DllDirectory: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn LdrSetDllDirectory( -- DllDirectory: PUNICODE_STRING, -- ) -> NTSTATUS; --}} --pub const LDR_ADDREF_DLL_PIN: ULONG = 0x00000001; --EXTERN!{extern "system" { -- fn LdrAddRefDll( -- Flags: ULONG, -- DllHandle: PVOID, -- ) -> NTSTATUS; -- fn LdrGetProcedureAddress( -- DllHandle: PVOID, -- ProcedureName: PANSI_STRING, -- ProcedureNumber: ULONG, -- ProcedureAddress: *mut PVOID, -- ) -> NTSTATUS; --}} --pub const LDR_GET_PROCEDURE_ADDRESS_DONT_RECORD_FORWARDER: ULONG = 0x00000001; --EXTERN!{extern "system" { -- fn LdrGetProcedureAddressEx( -- DllHandle: PVOID, -- ProcedureName: PANSI_STRING, -- ProcedureNumber: ULONG, -- ProcedureAddress: *mut PVOID, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn LdrGetKnownDllSectionHandle( -- DllName: PCWSTR, -- KnownDlls32: BOOLEAN, -- Section: PHANDLE, -- ) -> NTSTATUS; -- fn LdrGetProcedureAddressForCaller( -- DllHandle: PVOID, -- ProcedureName: PANSI_STRING, -- ProcedureNumber: ULONG, -- ProcedureAddress: *mut PVOID, -- Flags: ULONG, -- Callback: *mut PVOID, -- ) -> NTSTATUS; --}} --pub const LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS: ULONG = 0x00000001; --pub const LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY: ULONG = 0x00000002; --pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_INVALID: ULONG = 0; --pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED: ULONG = 1; --pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_NOT_ACQUIRED: ULONG = 2; --EXTERN!{extern "system" { -- fn LdrLockLoaderLock( -- Flags: ULONG, -- Disposition: *mut ULONG, -- Cookie: *mut PVOID, -- ) -> NTSTATUS; --}} --pub const LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS: ULONG = 0x00000001; --EXTERN!{extern "system" { -- fn LdrUnlockLoaderLock( -- Flags: ULONG, -- Cookie: PVOID, -- ) -> NTSTATUS; -- fn LdrRelocateImage( -- NewBase: PVOID, -- LoaderName: PSTR, -- Success: NTSTATUS, -- Conflict: NTSTATUS, -- Invalid: NTSTATUS, -- ) -> NTSTATUS; -- fn LdrRelocateImageWithBias( -- NewBase: PVOID, -- Bias: LONGLONG, -- LoaderName: PSTR, -- Success: NTSTATUS, -- Conflict: NTSTATUS, -- Invalid: NTSTATUS, -- ) -> NTSTATUS; -- fn LdrProcessRelocationBlock( -- VA: ULONG_PTR, -- SizeOfBlock: ULONG, -- NextOffset: PUSHORT, -- Diff: LONG_PTR, -- ) -> PIMAGE_BASE_RELOCATION; -- fn LdrVerifyMappedImageMatchesChecksum( -- BaseAddress: PVOID, -- NumberOfBytes: SIZE_T, -- FileLength: ULONG, -- ) -> BOOLEAN; --}} --FN!{stdcall PLDR_IMPORT_MODULE_CALLBACK( -- Parameter: PVOID, -- ModuleName: PSTR, --) -> ()} --EXTERN!{extern "system" { -- fn LdrVerifyImageMatchesChecksum( -- ImageFileHandle: HANDLE, -- ImportCallbackRoutine: PLDR_IMPORT_MODULE_CALLBACK, -- ImportCallbackParameter: PVOID, -- ImageCharacteristics: PUSHORT, -- ) -> NTSTATUS; --}} --STRUCT!{struct LDR_IMPORT_CALLBACK_INFO { -- ImportCallbackRoutine: PLDR_IMPORT_MODULE_CALLBACK, -- ImportCallbackParameter: PVOID, --}} --pub type PLDR_IMPORT_CALLBACK_INFO = *mut LDR_IMPORT_CALLBACK_INFO; --STRUCT!{struct LDR_SECTION_INFO { -- SectionHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjA: POBJECT_ATTRIBUTES, -- SectionPageProtection: ULONG, -- AllocationAttributes: ULONG, --}} --pub type PLDR_SECTION_INFO = *mut LDR_SECTION_INFO; --STRUCT!{struct LDR_VERIFY_IMAGE_INFO { -- Size: ULONG, -- Flags: ULONG, -- CallbackInfo: LDR_IMPORT_CALLBACK_INFO, -- SectionInfo: LDR_SECTION_INFO, -- ImageCharacteristics: USHORT, --}} --pub type PLDR_VERIFY_IMAGE_INFO = *mut LDR_VERIFY_IMAGE_INFO; --EXTERN!{extern "system" { -- fn LdrVerifyImageMatchesChecksumEx( -- ImageFileHandle: HANDLE, -- VerifyInfo: PLDR_VERIFY_IMAGE_INFO, -- ) -> NTSTATUS; -- fn LdrQueryModuleServiceTags( -- DllHandle: PVOID, -- ServiceTagBuffer: PULONG, -- BufferSize: PULONG, -- ) -> NTSTATUS; --}} --pub const LDR_DLL_NOTIFICATION_REASON_LOADED: ULONG = 1; --pub const LDR_DLL_NOTIFICATION_REASON_UNLOADED: ULONG = 2; --STRUCT!{struct LDR_DLL_LOADED_NOTIFICATION_DATA { -- Flags: ULONG, -- FullDllName: PUNICODE_STRING, -- BaseDllName: PUNICODE_STRING, -- DllBase: PVOID, -- SizeOfImage: ULONG, --}} --pub type PLDR_DLL_LOADED_NOTIFICATION_DATA = *mut LDR_DLL_LOADED_NOTIFICATION_DATA; --STRUCT!{struct LDR_DLL_UNLOADED_NOTIFICATION_DATA { -- Flags: ULONG, -- FullDllName: PCUNICODE_STRING, -- BaseDllName: PCUNICODE_STRING, -- DllBase: PVOID, -- SizeOfImage: ULONG, --}} --pub type PLDR_DLL_UNLOADED_NOTIFICATION_DATA = *mut LDR_DLL_UNLOADED_NOTIFICATION_DATA; --UNION!{union LDR_DLL_NOTIFICATION_DATA { -- Loaded: LDR_DLL_LOADED_NOTIFICATION_DATA, -- Unloaded: LDR_DLL_UNLOADED_NOTIFICATION_DATA, --}} --pub type PLDR_DLL_NOTIFICATION_DATA = *mut LDR_DLL_NOTIFICATION_DATA; --FN!{stdcall PLDR_DLL_NOTIFICATION_FUNCTION( -- NotificationReason: ULONG, -- NotificationData: PLDR_DLL_NOTIFICATION_DATA, -- Context: PVOID, --) -> ()} --EXTERN!{extern "system" { -- fn LdrRegisterDllNotification( -- Flags: ULONG, -- NotificationFunction: PLDR_DLL_NOTIFICATION_FUNCTION, -- Context: PVOID, -- Cookie: *mut PVOID, -- ) -> NTSTATUS; -- fn LdrUnregisterDllNotification( -- Cookie: PVOID, -- ) -> NTSTATUS; --}} --STRUCT!{struct PS_MITIGATION_OPTIONS_MAP { -- Map: [ULONG_PTR; 2], --}} --pub type PPS_MITIGATION_OPTIONS_MAP = *mut PS_MITIGATION_OPTIONS_MAP; --STRUCT!{struct PS_MITIGATION_AUDIT_OPTIONS_MAP { -- Map: [ULONG_PTR; 2], --}} --pub type PPS_MITIGATION_AUDIT_OPTIONS_MAP = *mut PS_MITIGATION_AUDIT_OPTIONS_MAP; --STRUCT!{struct PS_SYSTEM_DLL_INIT_BLOCK { -- Size: ULONG, -- SystemDllWowRelocation: ULONG_PTR, -- SystemDllNativeRelocation: ULONG_PTR, -- Wow64SharedInformation: [ULONG_PTR; 16], -- RngData: ULONG, -- Flags: ULONG, -- MitigationOptionsMap: PS_MITIGATION_OPTIONS_MAP, -- CfgBitMap: ULONG_PTR, -- CfgBitMapSize: ULONG_PTR, -- Wow64CfgBitMap: ULONG_PTR, -- Wow64CfgBitMapSize: ULONG_PTR, -- MitigationAuditOptionsMap: PS_MITIGATION_AUDIT_OPTIONS_MAP, --}} --BITFIELD!{PS_SYSTEM_DLL_INIT_BLOCK Flags: ULONG [ -- CfgOverride set_CfgOverride[0..1], -- Reserved set_Reserved[1..32], --]} --pub type PPS_SYSTEM_DLL_INIT_BLOCK = *mut PS_SYSTEM_DLL_INIT_BLOCK; --EXTERN!{extern "system" { -- fn LdrSystemDllInitBlock() -> PPS_SYSTEM_DLL_INIT_BLOCK; -- fn LdrAddLoadAsDataTable( -- Module: PVOID, -- FilePath: PWSTR, -- Size: SIZE_T, -- Handle: HANDLE, -- ) -> NTSTATUS; -- fn LdrRemoveLoadAsDataTable( -- InitModule: PVOID, -- BaseModule: *mut PVOID, -- Size: PSIZE_T, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn LdrGetFileNameFromLoadAsDataTable( -- Module: PVOID, -- pFileNamePrt: *mut PVOID, -- ) -> NTSTATUS; -- fn LdrDisableThreadCalloutsForDll( -- DllImageBase: PVOID, -- ) -> NTSTATUS; -- fn LdrAccessResource( -- DllHandle: PVOID, -- ResourceDataEntry: PIMAGE_RESOURCE_DATA_ENTRY, -- ResourceBuffer: *mut PVOID, -- ResourceLength: *mut ULONG, -- ) -> NTSTATUS; --}} --STRUCT!{struct LDR_RESOURCE_INFO { -- Type: ULONG_PTR, -- Name: ULONG_PTR, -- Language: ULONG_PTR, --}} --pub type PLDR_RESOURCE_INFO = *mut LDR_RESOURCE_INFO; --pub const RESOURCE_TYPE_LEVEL: ULONG = 0; --pub const RESOURCE_NAME_LEVEL: ULONG = 1; --pub const RESOURCE_LANGUAGE_LEVEL: ULONG = 2; --pub const RESOURCE_DATA_LEVEL: ULONG = 3; --EXTERN!{extern "system" { -- fn LdrFindResource_U( -- DllHandle: PVOID, -- ResourceInfo: PLDR_RESOURCE_INFO, -- Level: ULONG, -- ResourceDataEntry: *mut PIMAGE_RESOURCE_DATA_ENTRY, -- ) -> NTSTATUS; -- fn LdrFindResourceDirectory_U( -- DllHandle: PVOID, -- ResourceInfo: PLDR_RESOURCE_INFO, -- Level: ULONG, -- ResourceDirectory: *mut PIMAGE_RESOURCE_DIRECTORY, -- ) -> NTSTATUS; --}} --STRUCT!{struct LDR_ENUM_RESOURCE_ENTRY_Path_s { -- Id: USHORT, -- NameIsPresent: USHORT, --}} --UNION!{union LDR_ENUM_RESOURCE_ENTRY_Path { -- NameOrId: ULONG_PTR, -- Name: PIMAGE_RESOURCE_DIRECTORY_STRING, -- s: LDR_ENUM_RESOURCE_ENTRY_Path_s, --}} --STRUCT!{struct LDR_ENUM_RESOURCE_ENTRY { -- Path: [LDR_ENUM_RESOURCE_ENTRY_Path; 3], -- Data: PVOID, -- Size: ULONG, -- Reserved: ULONG, --}} --pub type PLDR_ENUM_RESOURCE_ENTRY = *mut LDR_ENUM_RESOURCE_ENTRY; --#[inline] --pub unsafe fn NAME_FROM_RESOURCE_ENTRY( -- RootDirectory: PIMAGE_RESOURCE_DIRECTORY, -- Entry: &IMAGE_RESOURCE_DIRECTORY_ENTRY, --) -> usize { -- if Entry.u.s().NameIsString() != 0 { -- return RootDirectory as usize + Entry.u.s().NameOffset() as usize; -- } -- *Entry.u.Id() as usize --} --EXTERN!{extern "system" { -- fn LdrEnumResources( -- DllHandle: PVOID, -- ResourceInfo: PLDR_RESOURCE_INFO, -- Level: ULONG, -- ResourceCount: *mut ULONG, -- Resources: PLDR_ENUM_RESOURCE_ENTRY, -- ) -> NTSTATUS; -- fn LdrFindEntryForAddress( -- DllHandle: PVOID, -- Entry: *mut PLDR_DATA_TABLE_ENTRY, -- ) -> NTSTATUS; --}} --STRUCT!{struct RTL_PROCESS_MODULE_INFORMATION { -- Section: HANDLE, -- MappedBase: PVOID, -- ImageBase: PVOID, -- ImageSize: ULONG, -- Flags: ULONG, -- LoadOrderIndex: USHORT, -- InitOrderIndex: USHORT, -- LoadCount: USHORT, -- OffsetToFileName: USHORT, -- FullPathName: [UCHAR; 256], --}} --pub type PRTL_PROCESS_MODULE_INFORMATION = *mut RTL_PROCESS_MODULE_INFORMATION; --STRUCT!{struct RTL_PROCESS_MODULES { -- NumberOfModules: ULONG, -- Modules: [RTL_PROCESS_MODULE_INFORMATION; 1], --}} --pub type PRTL_PROCESS_MODULES = *mut RTL_PROCESS_MODULES; --STRUCT!{struct RTL_PROCESS_MODULE_INFORMATION_EX { -- NextOffset: USHORT, -- BaseInfo: RTL_PROCESS_MODULE_INFORMATION, -- ImageChecksum: ULONG, -- TimeDateStamp: ULONG, -- DefaultBase: PVOID, --}} --pub type PRTL_PROCESS_MODULE_INFORMATION_EX = *mut RTL_PROCESS_MODULE_INFORMATION_EX; --EXTERN!{extern "system" { -- fn LdrQueryProcessModuleInformation( -- ModuleInformation: PRTL_PROCESS_MODULES, -- Size: ULONG, -- ReturnedSize: PULONG, -- ) -> NTSTATUS; --}} --FN!{stdcall PLDR_ENUM_CALLBACK( -- ModuleInformation: PLDR_DATA_TABLE_ENTRY, -- Parameter: PVOID, -- Stop: *mut BOOLEAN, --) -> ()} --EXTERN!{extern "system" { -- fn LdrEnumerateLoadedModules( -- ReservedFlag: BOOLEAN, -- EnumProc: PLDR_ENUM_CALLBACK, -- Context: PVOID, -- ) -> NTSTATUS; -- fn LdrOpenImageFileOptionsKey( -- SubKey: PUNICODE_STRING, -- Wow64: BOOLEAN, -- NewKeyHandle: PHANDLE, -- ) -> NTSTATUS; -- fn LdrQueryImageFileKeyOption( -- KeyHandle: HANDLE, -- ValueName: PCWSTR, -- Type: ULONG, -- Buffer: PVOID, -- BufferSize: ULONG, -- ReturnedLength: PULONG, -- ) -> NTSTATUS; -- fn LdrQueryImageFileExecutionOptions( -- SubKey: PUNICODE_STRING, -- ValueName: PCWSTR, -- ValueSize: ULONG, -- Buffer: PVOID, -- BufferSize: ULONG, -- ReturnedLength: PULONG, -- ) -> NTSTATUS; -- fn LdrQueryImageFileExecutionOptionsEx( -- SubKey: PUNICODE_STRING, -- ValueName: PCWSTR, -- Type: ULONG, -- Buffer: PVOID, -- BufferSize: ULONG, -- ReturnedLength: PULONG, -- Wow64: BOOLEAN, -- ) -> NTSTATUS; --}} --UNION!{union DELAYLOAD_PROC_DESCRIPTOR_Description { -- Name: PCSTR, -- Ordinal: ULONG, --}} --STRUCT!{struct DELAYLOAD_PROC_DESCRIPTOR { -- ImportDescribedByName: ULONG, -- Description: DELAYLOAD_PROC_DESCRIPTOR_Description, --}} --pub type PDELAYLOAD_PROC_DESCRIPTOR = *mut DELAYLOAD_PROC_DESCRIPTOR; --STRUCT!{struct DELAYLOAD_INFO { -- Size: ULONG, -- DelayloadDescriptor: PCIMAGE_DELAYLOAD_DESCRIPTOR, -- ThunkAddress: PIMAGE_THUNK_DATA, -- TargetDllName: PCSTR, -- TargetApiDescriptor: DELAYLOAD_PROC_DESCRIPTOR, -- TargetModuleBase: PVOID, -- Unused: PVOID, -- LastError: ULONG, --}} --pub type PDELAYLOAD_INFO = *mut DELAYLOAD_INFO; --FN!{stdcall PDELAYLOAD_FAILURE_DLL_CALLBACK( -- NotificationReason: ULONG, -- DelayloadInfo: PDELAYLOAD_INFO, --) -> PVOID} --FN!{stdcall PDELAYLOAD_FAILURE_SYSTEM_ROUTINE( -- DllName: PCSTR, -- ProcName: PCSTR, --) -> PVOID} --EXTERN!{extern "system" { -- fn LdrResolveDelayLoadedAPI( -- ParentModuleBase: PVOID, -- DelayloadDescriptor: PCIMAGE_DELAYLOAD_DESCRIPTOR, -- FailureDllHook: PDELAYLOAD_FAILURE_DLL_CALLBACK, -- FailureSystemHook: PDELAYLOAD_FAILURE_SYSTEM_ROUTINE, -- ThunkAddress: PIMAGE_THUNK_DATA, -- Flags: ULONG, -- ) -> PVOID; -- fn LdrResolveDelayLoadsFromDll( -- ParentBase: PVOID, -- TargetDllName: PCSTR, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn LdrSetDefaultDllDirectories( -- DirectoryFlags: ULONG, -- ) -> NTSTATUS; -- fn LdrShutdownProcess() -> NTSTATUS; -- fn LdrShutdownThread() -> NTSTATUS; -- fn LdrSetImplicitPathOptions( -- ImplicitPathOptions: ULONG, -- ) -> NTSTATUS; -- fn LdrControlFlowGuardEnforced() -> BOOLEAN; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntlpcapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntlpcapi.rs -deleted file mode 100644 -index 012c9056..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntlpcapi.rs -+++ /dev/null -@@ -1,692 +0,0 @@ --use core::mem::size_of; --use crate::ntapi_base::{CLIENT_ID, CLIENT_ID64}; --use winapi::ctypes::c_double; --use winapi::shared::basetsd::{PSIZE_T, SIZE_T, ULONG64, ULONG_PTR}; --use winapi::shared::ntdef::{ -- BOOLEAN, CSHORT, HANDLE, LARGE_INTEGER, NTSTATUS, OBJ_CASE_INSENSITIVE, PHANDLE, -- PLARGE_INTEGER, POBJECT_ATTRIBUTES, PULONG, PUNICODE_STRING, PVOID, ULONG, ULONGLONG, -- UNICODE_STRING, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, PSECURITY_DESCRIPTOR, PSECURITY_QUALITY_OF_SERVICE, PSID, RTL_SRWLOCK, -- SECURITY_QUALITY_OF_SERVICE, STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE, --}; --pub const PORT_CONNECT: u32 = 0x0001; --pub const PORT_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1; --STRUCT!{struct PORT_MESSAGE_u1_s { -- DataLength: CSHORT, -- TotalLength: CSHORT, --}} --STRUCT!{struct PORT_MESSAGE_u2_s { -- Type: CSHORT, -- DataInfoOffset: CSHORT, --}} --UNION!{union PORT_MESSAGE_u1 { -- s: PORT_MESSAGE_u1_s, -- Length: ULONG, --}} --UNION!{union PORT_MESSAGE_u2 { -- s: PORT_MESSAGE_u2_s, -- ZeroInit: ULONG, --}} --UNION!{union PORT_MESSAGE_u3 { -- ClientId: CLIENT_ID, -- DoNotUseThisField: c_double, --}} --UNION!{union PORT_MESSAGE_u4 { -- ClientViewSize: SIZE_T, -- CallbackId: ULONG, --}} --STRUCT!{struct PORT_MESSAGE { -- u1: PORT_MESSAGE_u1, -- u2: PORT_MESSAGE_u2, -- u3: PORT_MESSAGE_u3, -- MessageId: ULONG, -- u4: PORT_MESSAGE_u4, --}} --pub type PPORT_MESSAGE = *mut PORT_MESSAGE; --STRUCT!{struct PORT_DATA_ENTRY { -- Base: PVOID, -- Size: ULONG, --}} --pub type PPORT_DATA_ENTRY = *mut PORT_DATA_ENTRY; --STRUCT!{struct PORT_DATA_INFORMATION { -- CountDataEntries: ULONG, -- DataEntries: [PORT_DATA_ENTRY; 1], --}} --pub type PPORT_DATA_INFORMATION = *mut PORT_DATA_INFORMATION; --pub const LPC_REQUEST: ULONG = 1; --pub const LPC_REPLY: ULONG = 2; --pub const LPC_DATAGRAM: ULONG = 3; --pub const LPC_LOST_REPLY: ULONG = 4; --pub const LPC_PORT_CLOSED: ULONG = 5; --pub const LPC_CLIENT_DIED: ULONG = 6; --pub const LPC_EXCEPTION: ULONG = 7; --pub const LPC_DEBUG_EVENT: ULONG = 8; --pub const LPC_ERROR_EVENT: ULONG = 9; --pub const LPC_CONNECTION_REQUEST: ULONG = 10; --pub const LPC_KERNELMODE_MESSAGE: CSHORT = 0x8000; --pub const LPC_NO_IMPERSONATE: CSHORT = 0x4000; --pub const PORT_VALID_OBJECT_ATTRIBUTES: u32 = OBJ_CASE_INSENSITIVE; --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --pub const PORT_MAXIMUM_MESSAGE_LENGTH: u32 = 512; --#[cfg(target_arch = "x86")] --pub const PORT_MAXIMUM_MESSAGE_LENGTH: u32 = 256; --pub const LPC_MAX_CONNECTION_INFO_SIZE: u32 = 16 * size_of::() as u32; --pub const PORT_TOTAL_MAXIMUM_MESSAGE_LENGTH: u32 = (PORT_MAXIMUM_MESSAGE_LENGTH -- + size_of::() as u32 -- + LPC_MAX_CONNECTION_INFO_SIZE -- + 0xf) & !0xf; --STRUCT!{struct LPC_CLIENT_DIED_MSG { -- PortMsg: PORT_MESSAGE, -- CreateTime: LARGE_INTEGER, --}} --pub type PLPC_CLIENT_DIED_MSG = *mut LPC_CLIENT_DIED_MSG; --STRUCT!{struct PORT_VIEW { -- Length: ULONG, -- SectionHandle: HANDLE, -- SectionOffset: ULONG, -- ViewSize: SIZE_T, -- ViewBase: PVOID, -- ViewRemoteBase: PVOID, --}} --pub type PPORT_VIEW = *mut PORT_VIEW; --STRUCT!{struct REMOTE_PORT_VIEW { -- Length: ULONG, -- ViewSize: SIZE_T, -- ViewBase: PVOID, --}} --pub type PREMOTE_PORT_VIEW = *mut REMOTE_PORT_VIEW; --STRUCT!{struct PORT_MESSAGE64_u1_s { -- DataLength: CSHORT, -- TotalLength: CSHORT, --}} --STRUCT!{struct PORT_MESSAGE64_u2_s { -- Type: CSHORT, -- DataInfoOffset: CSHORT, --}} --UNION!{union PORT_MESSAGE64_u1 { -- s: PORT_MESSAGE64_u1_s, -- Length: ULONG, --}} --UNION!{union PORT_MESSAGE64_u2 { -- s: PORT_MESSAGE64_u2_s, -- ZeroInit: ULONG, --}} --UNION!{union PORT_MESSAGE64_u3 { -- ClientId: CLIENT_ID64, -- DoNotUseThisField: c_double, --}} --UNION!{union PORT_MESSAGE64_u4 { -- ClientViewSize: ULONGLONG, -- CallbackId: ULONG, --}} --STRUCT!{struct PORT_MESSAGE64 { -- u1: PORT_MESSAGE64_u1, -- u2: PORT_MESSAGE64_u2, -- u3: PORT_MESSAGE64_u3, -- MessageId: ULONG, -- u4: PORT_MESSAGE64_u4, --}} --pub type PPORT_MESSAGE64 = *mut PORT_MESSAGE64; --STRUCT!{struct LPC_CLIENT_DIED_MSG64 { -- PortMsg: PORT_MESSAGE64, -- CreateTime: LARGE_INTEGER, --}} --pub type PLPC_CLIENT_DIED_MSG64 = *mut LPC_CLIENT_DIED_MSG64; --STRUCT!{struct PORT_VIEW64 { -- Length: ULONG, -- SectionHandle: ULONGLONG, -- SectionOffset: ULONG, -- ViewSize: ULONGLONG, -- ViewBase: ULONGLONG, -- ViewRemoteBase: ULONGLONG, --}} --pub type PPORT_VIEW64 = *mut PORT_VIEW64; --STRUCT!{struct REMOTE_PORT_VIEW64 { -- Length: ULONG, -- ViewSize: ULONGLONG, -- ViewBase: ULONGLONG, --}} --pub type PREMOTE_PORT_VIEW64 = *mut REMOTE_PORT_VIEW64; --EXTERN!{extern "system" { -- fn NtCreatePort( -- PortHandle: PHANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- MaxConnectionInfoLength: ULONG, -- MaxMessageLength: ULONG, -- MaxPoolUsage: ULONG, -- ) -> NTSTATUS; -- fn NtCreateWaitablePort( -- PortHandle: PHANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- MaxConnectionInfoLength: ULONG, -- MaxMessageLength: ULONG, -- MaxPoolUsage: ULONG, -- ) -> NTSTATUS; -- fn NtConnectPort( -- PortHandle: PHANDLE, -- PortName: PUNICODE_STRING, -- SecurityQos: PSECURITY_QUALITY_OF_SERVICE, -- ClientView: PPORT_VIEW, -- ServerView: PREMOTE_PORT_VIEW, -- MaxMessageLength: PULONG, -- ConnectionInformation: PVOID, -- ConnectionInformationLength: PULONG, -- ) -> NTSTATUS; -- fn NtSecureConnectPort( -- PortHandle: PHANDLE, -- PortName: PUNICODE_STRING, -- SecurityQos: PSECURITY_QUALITY_OF_SERVICE, -- ClientView: PPORT_VIEW, -- RequiredServerSid: PSID, -- ServerView: PREMOTE_PORT_VIEW, -- MaxMessageLength: PULONG, -- ConnectionInformation: PVOID, -- ConnectionInformationLength: PULONG, -- ) -> NTSTATUS; -- fn NtListenPort( -- PortHandle: HANDLE, -- ConnectionRequest: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn NtAcceptConnectPort( -- PortHandle: PHANDLE, -- PortContext: PVOID, -- ConnectionRequest: PPORT_MESSAGE, -- AcceptConnection: BOOLEAN, -- ServerView: PPORT_VIEW, -- ClientView: PREMOTE_PORT_VIEW, -- ) -> NTSTATUS; -- fn NtCompleteConnectPort( -- PortHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtRequestPort( -- PortHandle: HANDLE, -- RequestMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn NtRequestWaitReplyPort( -- PortHandle: HANDLE, -- RequestMessage: PPORT_MESSAGE, -- ReplyMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn NtReplyPort( -- PortHandle: HANDLE, -- ReplyMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn NtReplyWaitReplyPort( -- PortHandle: HANDLE, -- ReplyMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn NtReplyWaitReceivePort( -- PortHandle: HANDLE, -- PortContext: *mut PVOID, -- ReplyMessage: PPORT_MESSAGE, -- ReceiveMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn NtReplyWaitReceivePortEx( -- PortHandle: HANDLE, -- PortContext: *mut PVOID, -- ReplyMessage: PPORT_MESSAGE, -- ReceiveMessage: PPORT_MESSAGE, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtImpersonateClientOfPort( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn NtReadRequestData( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- DataEntryIndex: ULONG, -- Buffer: PVOID, -- BufferSize: SIZE_T, -- NumberOfBytesRead: PSIZE_T, -- ) -> NTSTATUS; -- fn NtWriteRequestData( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- DataEntryIndex: ULONG, -- Buffer: PVOID, -- BufferSize: SIZE_T, -- NumberOfBytesWritten: PSIZE_T, -- ) -> NTSTATUS; --}} --ENUM!{enum PORT_INFORMATION_CLASS { -- PortBasicInformation = 0, -- PortDumpInformation = 1, --}} --EXTERN!{extern "system" { -- fn NtQueryInformationPort( -- PortHandle: HANDLE, -- PortInformationClass: PORT_INFORMATION_CLASS, -- PortInformation: PVOID, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} --pub type PALPC_HANDLE = *mut HANDLE; --pub type ALPC_HANDLE = HANDLE; --pub const ALPC_PORFLG_ALLOW_LPC_REQUESTS: ULONG = 0x20000; --pub const ALPC_PORFLG_WAITABLE_PORT: ULONG = 0x40000; --pub const ALPC_PORFLG_SYSTEM_PROCESS: ULONG = 0x100000; --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --STRUCT!{struct ALPC_PORT_ATTRIBUTES { -- Flags: ULONG, -- SecurityQos: SECURITY_QUALITY_OF_SERVICE, -- MaxMessageLength: SIZE_T, -- MemoryBandwidth: SIZE_T, -- MaxPoolUsage: SIZE_T, -- MaxSectionSize: SIZE_T, -- MaxViewSize: SIZE_T, -- MaxTotalSectionSize: SIZE_T, -- DupObjectTypes: ULONG, -- Reserved: ULONG, --}} --#[cfg(target_arch = "x86")] --STRUCT!{struct ALPC_PORT_ATTRIBUTES { -- Flags: ULONG, -- SecurityQos: SECURITY_QUALITY_OF_SERVICE, -- MaxMessageLength: SIZE_T, -- MemoryBandwidth: SIZE_T, -- MaxPoolUsage: SIZE_T, -- MaxSectionSize: SIZE_T, -- MaxViewSize: SIZE_T, -- MaxTotalSectionSize: SIZE_T, -- DupObjectTypes: ULONG, --}} --pub type PALPC_PORT_ATTRIBUTES = *mut ALPC_PORT_ATTRIBUTES; --pub const ALPC_MESSAGE_SECURITY_ATTRIBUTE: ULONG = 0x80000000; --pub const ALPC_MESSAGE_VIEW_ATTRIBUTE: ULONG = 0x40000000; --pub const ALPC_MESSAGE_CONTEXT_ATTRIBUTE: ULONG = 0x20000000; --pub const ALPC_MESSAGE_HANDLE_ATTRIBUTE: ULONG = 0x10000000; --STRUCT!{struct ALPC_MESSAGE_ATTRIBUTES { -- AllocatedAttributes: ULONG, -- ValidAttributes: ULONG, --}} --pub type PALPC_MESSAGE_ATTRIBUTES = *mut ALPC_MESSAGE_ATTRIBUTES; --STRUCT!{struct ALPC_COMPLETION_LIST_STATE { -- Value: ULONG64, --}} --BITFIELD!{ALPC_COMPLETION_LIST_STATE Value: ULONG64 [ -- Head set_Head[0..24], -- Tail set_Tail[24..48], -- ActiveThreadCount set_ActiveThreadCount[48..64], --]} --pub type PALPC_COMPLETION_LIST_STATE = *mut ALPC_COMPLETION_LIST_STATE; --pub const ALPC_COMPLETION_LIST_BUFFER_GRANULARITY_MASK: ULONG = 0x3f; --STRUCT!{#[repr(align(128))] struct ALPC_COMPLETION_LIST_HEADER { -- StartMagic: ULONG64, -- TotalSize: ULONG, -- ListOffset: ULONG, -- ListSize: ULONG, -- BitmapOffset: ULONG, -- BitmapSize: ULONG, -- DataOffset: ULONG, -- DataSize: ULONG, -- AttributeFlags: ULONG, -- AttributeSize: ULONG, -- __padding0: [u64; 10], -- State: ALPC_COMPLETION_LIST_STATE, -- LastMessageId: ULONG, -- LastCallbackId: ULONG, -- __padding1: [u32; 28], -- PostCount: ULONG, -- __padding2: [u32; 31], -- ReturnCount: ULONG, -- __padding3: [u32; 31], -- LogSequenceNumber: ULONG, -- __padding4: [u64; 15], -- UserLock: RTL_SRWLOCK, -- EndMagic: ULONG64, -- __padding5: [u64; 14], --}} --pub type PALPC_COMPLETION_LIST_HEADER = *mut ALPC_COMPLETION_LIST_HEADER; --STRUCT!{struct ALPC_CONTEXT_ATTR { -- PortContext: PVOID, -- MessageContext: PVOID, -- Sequence: ULONG, -- MessageId: ULONG, -- CallbackId: ULONG, --}} --pub type PALPC_CONTEXT_ATTR = *mut ALPC_CONTEXT_ATTR; --pub const ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS: ULONG = 0x10000; --pub const ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES: ULONG = 0x20000; --pub const ALPC_HANDLEFLG_DUPLICATE_INHERIT: ULONG = 0x80000; --STRUCT!{struct ALPC_HANDLE_ATTR32 { -- Flags: ULONG, -- Reserved0: ULONG, -- SameAccess: ULONG, -- SameAttributes: ULONG, -- Indirect: ULONG, -- Inherit: ULONG, -- Reserved1: ULONG, -- Handle: ULONG, -- ObjectType: ULONG, -- DesiredAccess: ULONG, -- GrantedAccess: ULONG, --}} --pub type PALPC_HANDLE_ATTR32 = *mut ALPC_HANDLE_ATTR32; --STRUCT!{struct ALPC_HANDLE_ATTR { -- Flags: ULONG, -- Reserved0: ULONG, -- SameAccess: ULONG, -- SameAttributes: ULONG, -- Indirect: ULONG, -- Inherit: ULONG, -- Reserved1: ULONG, -- Handle: HANDLE, -- HandleAttrArray: PALPC_HANDLE_ATTR32, -- ObjectType: ULONG, -- HandleCount: ULONG, -- DesiredAccess: ACCESS_MASK, -- GrantedAccess: ACCESS_MASK, --}} --pub type PALPC_HANDLE_ATTR = *mut ALPC_HANDLE_ATTR; --pub const ALPC_SECFLG_CREATE_HANDLE: ULONG = 0x20000; --STRUCT!{struct ALPC_SECURITY_ATTR { -- Flags: ULONG, -- QoS: PSECURITY_QUALITY_OF_SERVICE, -- ContextHandle: ALPC_HANDLE, --}} --pub type PALPC_SECURITY_ATTR = *mut ALPC_SECURITY_ATTR; --pub const ALPC_VIEWFLG_NOT_SECURE: ULONG = 0x40000; --STRUCT!{struct ALPC_DATA_VIEW_ATTR { -- Flags: ULONG, -- SectionHandle: ALPC_HANDLE, -- ViewBase: PVOID, -- ViewSize: SIZE_T, --}} --pub type PALPC_DATA_VIEW_ATTR = *mut ALPC_DATA_VIEW_ATTR; --ENUM!{enum ALPC_PORT_INFORMATION_CLASS { -- AlpcBasicInformation = 0, -- AlpcPortInformation = 1, -- AlpcAssociateCompletionPortInformation = 2, -- AlpcConnectedSIDInformation = 3, -- AlpcServerInformation = 4, -- AlpcMessageZoneInformation = 5, -- AlpcRegisterCompletionListInformation = 6, -- AlpcUnregisterCompletionListInformation = 7, -- AlpcAdjustCompletionListConcurrencyCountInformation = 8, -- AlpcRegisterCallbackInformation = 9, -- AlpcCompletionListRundownInformation = 10, -- AlpcWaitForPortReferences = 11, --}} --STRUCT!{struct ALPC_BASIC_INFORMATION { -- Flags: ULONG, -- SequenceNo: ULONG, -- PortContext: PVOID, --}} --pub type PALPC_BASIC_INFORMATION = *mut ALPC_BASIC_INFORMATION; --STRUCT!{struct ALPC_PORT_ASSOCIATE_COMPLETION_PORT { -- CompletionKey: PVOID, -- CompletionPort: HANDLE, --}} --pub type PALPC_PORT_ASSOCIATE_COMPLETION_PORT = *mut ALPC_PORT_ASSOCIATE_COMPLETION_PORT; --STRUCT!{struct ALPC_SERVER_INFORMATION_Out { -- ThreadBlocked: BOOLEAN, -- ConnectedProcessId: HANDLE, -- ConnectionPortName: UNICODE_STRING, --}} --UNION!{union ALPC_SERVER_INFORMATION { -- ThreadHandle: HANDLE, -- Out: ALPC_SERVER_INFORMATION_Out, --}} --pub type PALPC_SERVER_INFORMATION = *mut ALPC_SERVER_INFORMATION; --STRUCT!{struct ALPC_PORT_MESSAGE_ZONE_INFORMATION { -- Buffer: PVOID, -- Size: ULONG, --}} --pub type PALPC_PORT_MESSAGE_ZONE_INFORMATION = *mut ALPC_PORT_MESSAGE_ZONE_INFORMATION; --STRUCT!{struct ALPC_PORT_COMPLETION_LIST_INFORMATION { -- Buffer: PVOID, -- Size: ULONG, -- ConcurrencyCount: ULONG, -- AttributeFlags: ULONG, --}} --pub type PALPC_PORT_COMPLETION_LIST_INFORMATION = *mut ALPC_PORT_COMPLETION_LIST_INFORMATION; --ENUM!{enum ALPC_MESSAGE_INFORMATION_CLASS { -- AlpcMessageSidInformation = 0, -- AlpcMessageTokenModifiedIdInformation = 1, -- AlpcMessageDirectStatusInformation = 2, -- AlpcMessageHandleInformation = 3, -- MaxAlpcMessageInfoClass = 4, --}} --pub type PALPC_MESSAGE_INFORMATION_CLASS = *mut ALPC_MESSAGE_INFORMATION_CLASS; --STRUCT!{struct ALPC_MESSAGE_HANDLE_INFORMATION { -- Index: ULONG, -- Flags: ULONG, -- Handle: ULONG, -- ObjectType: ULONG, -- GrantedAccess: ACCESS_MASK, --}} --pub type PALPC_MESSAGE_HANDLE_INFORMATION = *mut ALPC_MESSAGE_HANDLE_INFORMATION; --EXTERN!{extern "system" { -- fn NtAlpcCreatePort( -- PortHandle: PHANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PortAttributes: PALPC_PORT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtAlpcDisconnectPort( -- PortHandle: HANDLE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtAlpcQueryInformation( -- PortHandle: HANDLE, -- PortInformationClass: ALPC_PORT_INFORMATION_CLASS, -- PortInformation: PVOID, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtAlpcSetInformation( -- PortHandle: HANDLE, -- PortInformationClass: ALPC_PORT_INFORMATION_CLASS, -- PortInformation: PVOID, -- Length: ULONG, -- ) -> NTSTATUS; -- fn NtAlpcCreatePortSection( -- PortHandle: HANDLE, -- Flags: ULONG, -- SectionHandle: HANDLE, -- SectionSize: SIZE_T, -- AlpcSectionHandle: PALPC_HANDLE, -- ActualSectionSize: PSIZE_T, -- ) -> NTSTATUS; -- fn NtAlpcDeletePortSection( -- PortHandle: HANDLE, -- Flags: ULONG, -- SectionHandle: ALPC_HANDLE, -- ) -> NTSTATUS; -- fn NtAlpcCreateResourceReserve( -- PortHandle: HANDLE, -- Flags: ULONG, -- MessageSize: SIZE_T, -- ResourceId: PALPC_HANDLE, -- ) -> NTSTATUS; -- fn NtAlpcDeleteResourceReserve( -- PortHandle: HANDLE, -- Flags: ULONG, -- ResourceId: ALPC_HANDLE, -- ) -> NTSTATUS; -- fn NtAlpcCreateSectionView( -- PortHandle: HANDLE, -- Flags: ULONG, -- ViewAttributes: PALPC_DATA_VIEW_ATTR, -- ) -> NTSTATUS; -- fn NtAlpcDeleteSectionView( -- PortHandle: HANDLE, -- Flags: ULONG, -- ViewBase: PVOID, -- ) -> NTSTATUS; -- fn NtAlpcCreateSecurityContext( -- PortHandle: HANDLE, -- Flags: ULONG, -- SecurityAttribute: PALPC_SECURITY_ATTR, -- ) -> NTSTATUS; -- fn NtAlpcDeleteSecurityContext( -- PortHandle: HANDLE, -- Flags: ULONG, -- ContextHandle: ALPC_HANDLE, -- ) -> NTSTATUS; -- fn NtAlpcRevokeSecurityContext( -- PortHandle: HANDLE, -- Flags: ULONG, -- ContextHandle: ALPC_HANDLE, -- ) -> NTSTATUS; -- fn NtAlpcQueryInformationMessage( -- PortHandle: HANDLE, -- PortMessage: PPORT_MESSAGE, -- MessageInformationClass: ALPC_MESSAGE_INFORMATION_CLASS, -- MessageInformation: PVOID, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} --pub const ALPC_MSGFLG_REPLY_MESSAGE: ULONG = 0x1; --pub const ALPC_MSGFLG_LPC_MODE: ULONG = 0x2; --pub const ALPC_MSGFLG_RELEASE_MESSAGE: ULONG = 0x10000; --pub const ALPC_MSGFLG_SYNC_REQUEST: ULONG = 0x20000; --pub const ALPC_MSGFLG_WAIT_USER_MODE: ULONG = 0x100000; --pub const ALPC_MSGFLG_WAIT_ALERTABLE: ULONG = 0x200000; --pub const ALPC_MSGFLG_WOW64_CALL: ULONG = 0x80000000; --EXTERN!{extern "system" { -- fn NtAlpcConnectPort( -- PortHandle: PHANDLE, -- PortName: PUNICODE_STRING, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PortAttributes: PALPC_PORT_ATTRIBUTES, -- Flags: ULONG, -- RequiredServerSid: PSID, -- ConnectionMessage: PPORT_MESSAGE, -- BufferLength: PULONG, -- OutMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- InMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtAlpcConnectPortEx( -- PortHandle: PHANDLE, -- ConnectionPortObjectAttributes: POBJECT_ATTRIBUTES, -- ClientPortObjectAttributes: POBJECT_ATTRIBUTES, -- PortAttributes: PALPC_PORT_ATTRIBUTES, -- Flags: ULONG, -- ServerSecurityRequirements: PSECURITY_DESCRIPTOR, -- ConnectionMessage: PPORT_MESSAGE, -- BufferLength: PSIZE_T, -- OutMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- InMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtAlpcAcceptConnectPort( -- PortHandle: PHANDLE, -- ConnectionPortHandle: HANDLE, -- Flags: ULONG, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PortAttributes: PALPC_PORT_ATTRIBUTES, -- PortContext: PVOID, -- ConnectionRequest: PPORT_MESSAGE, -- ConnectionMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- AcceptConnection: BOOLEAN, -- ) -> NTSTATUS; -- fn NtAlpcSendWaitReceivePort( -- PortHandle: HANDLE, -- Flags: ULONG, -- SendMessageA: PPORT_MESSAGE, -- SendMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- ReceiveMessage: PPORT_MESSAGE, -- BufferLength: PSIZE_T, -- ReceiveMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; --}} --pub const ALPC_CANCELFLG_TRY_CANCEL: ULONG = 0x1; --pub const ALPC_CANCELFLG_NO_CONTEXT_CHECK: ULONG = 0x8; --pub const ALPC_CANCELFLGP_FLUSH: ULONG = 0x10000; --EXTERN!{extern "system" { -- fn NtAlpcCancelMessage( -- PortHandle: HANDLE, -- Flags: ULONG, -- MessageContext: PALPC_CONTEXT_ATTR, -- ) -> NTSTATUS; -- fn NtAlpcImpersonateClientOfPort( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- Flags: PVOID, -- ) -> NTSTATUS; -- fn NtAlpcImpersonateClientContainerOfPort( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtAlpcOpenSenderProcess( -- ProcessHandle: PHANDLE, -- PortHandle: HANDLE, -- PortMessage: PPORT_MESSAGE, -- Flags: ULONG, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtAlpcOpenSenderThread( -- ThreadHandle: PHANDLE, -- PortHandle: HANDLE, -- PortMessage: PPORT_MESSAGE, -- Flags: ULONG, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn AlpcMaxAllowedMessageLength() -> ULONG; -- fn AlpcGetHeaderSize( -- Flags: ULONG, -- ) -> ULONG; -- fn AlpcInitializeMessageAttribute( -- AttributeFlags: ULONG, -- Buffer: PALPC_MESSAGE_ATTRIBUTES, -- BufferSize: ULONG, -- RequiredBufferSize: PULONG, -- ) -> NTSTATUS; -- fn AlpcGetMessageAttribute( -- Buffer: PALPC_MESSAGE_ATTRIBUTES, -- AttributeFlag: ULONG, -- ) -> PVOID; -- fn AlpcRegisterCompletionList( -- PortHandle: HANDLE, -- Buffer: PALPC_COMPLETION_LIST_HEADER, -- Size: ULONG, -- ConcurrencyCount: ULONG, -- AttributeFlags: ULONG, -- ) -> NTSTATUS; -- fn AlpcUnregisterCompletionList( -- PortHandle: HANDLE, -- ) -> NTSTATUS; -- fn AlpcRundownCompletionList( -- PortHandle: HANDLE, -- ) -> NTSTATUS; -- fn AlpcAdjustCompletionListConcurrencyCount( -- PortHandle: HANDLE, -- ConcurrencyCount: ULONG, -- ) -> NTSTATUS; -- fn AlpcRegisterCompletionListWorkerThread( -- CompletionList: PVOID, -- ) -> BOOLEAN; -- fn AlpcUnregisterCompletionListWorkerThread( -- CompletionList: PVOID, -- ) -> BOOLEAN; -- fn AlpcGetCompletionListLastMessageInformation( -- CompletionList: PVOID, -- LastMessageId: PULONG, -- LastCallbackId: PULONG, -- ); -- fn AlpcGetOutstandingCompletionListMessageCount( -- CompletionList: PVOID, -- ) -> ULONG; -- fn AlpcGetMessageFromCompletionList( -- CompletionList: PVOID, -- MessageAttributes: *mut PALPC_MESSAGE_ATTRIBUTES, -- ) -> PPORT_MESSAGE; -- fn AlpcFreeCompletionListMessage( -- CompletionList: PVOID, -- Message: PPORT_MESSAGE, -- ); -- fn AlpcGetCompletionListMessageAttributes( -- CompletionList: PVOID, -- Message: PPORT_MESSAGE, -- ) -> PALPC_MESSAGE_ATTRIBUTES; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntmisc.rs b/KubeOS-Rust/vendor/ntapi/src/ntmisc.rs -deleted file mode 100644 -index 7f579999..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntmisc.rs -+++ /dev/null -@@ -1,42 +0,0 @@ --use winapi::shared::ntdef::{HANDLE, NTSTATUS, PULONG, PVOID, ULONG}; --use winapi::um::winnt::STANDARD_RIGHTS_ALL; --pub const FLT_PORT_CONNECT: u32 = 0x0001; --pub const FLT_PORT_ALL_ACCESS: u32 = FLT_PORT_CONNECT | STANDARD_RIGHTS_ALL; --ENUM!{enum VDMSERVICECLASS { -- VdmStartExecution = 0, -- VdmQueueInterrupt = 1, -- VdmDelayInterrupt = 2, -- VdmInitialize = 3, -- VdmFeatures = 4, -- VdmSetInt21Handler = 5, -- VdmQueryDir = 6, -- VdmPrinterDirectIoOpen = 7, -- VdmPrinterDirectIoClose = 8, -- VdmPrinterInitialize = 9, -- VdmSetLdtEntries = 10, -- VdmSetProcessLdtInfo = 11, -- VdmAdlibEmulation = 12, -- VdmPMCliControl = 13, -- VdmQueryVdmProcess = 14, --}} --pub type PVDMSERVICECLASS = *mut VDMSERVICECLASS; --EXTERN!{extern "system" { -- fn NtVdmControl( -- Service: VDMSERVICECLASS, -- ServiceData: PVOID, -- ) -> NTSTATUS; -- fn NtTraceEvent( -- TraceHandle: HANDLE, -- Flags: ULONG, -- FieldSize: ULONG, -- Fields: PVOID, -- ) -> NTSTATUS; -- fn NtTraceControl( -- FunctionCode: ULONG, -- InBuffer: PVOID, -- InBufferLen: ULONG, -- OutBuffer: PVOID, -- OutBufferLen: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntmmapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntmmapi.rs -deleted file mode 100644 -index 7cae677a..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntmmapi.rs -+++ /dev/null -@@ -1,630 +0,0 @@ --use crate::winapi_local::um::winnt::PMEM_EXTENDED_PARAMETER; --use winapi::shared::basetsd::{PSIZE_T, PULONG_PTR, SIZE_T, ULONG_PTR}; --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, LARGE_INTEGER, NTSTATUS, PHANDLE, PLARGE_INTEGER, POBJECT_ATTRIBUTES, PULONG, -- PUNICODE_STRING, PVOID, UCHAR, ULONG, ULONGLONG, UNICODE_STRING, USHORT, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, PCFG_CALL_TARGET_INFO, STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE, --}; --ENUM!{enum MEMORY_INFORMATION_CLASS { -- MemoryBasicInformation = 0, -- MemoryWorkingSetInformation = 1, -- MemoryMappedFilenameInformation = 2, -- MemoryRegionInformation = 3, -- MemoryWorkingSetExInformation = 4, -- MemorySharedCommitInformation = 5, -- MemoryImageInformation = 6, -- MemoryRegionInformationEx = 7, -- MemoryPrivilegedBasicInformation = 8, -- MemoryEnclaveImageInformation = 9, -- MemoryBasicInformationCapped = 10, --}} --STRUCT!{struct MEMORY_WORKING_SET_BLOCK { -- Bitfields: ULONG_PTR, --}} --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --BITFIELD!{MEMORY_WORKING_SET_BLOCK Bitfields: ULONG_PTR [ -- Protection set_Protection[0..5], -- ShareCount set_ShareCount[5..8], -- Shared set_Shared[8..9], -- Node set_Node[9..12], -- VirtualPage set_VirtualPage[12..64], --]} --#[cfg(target_arch = "x86")] --BITFIELD!{MEMORY_WORKING_SET_BLOCK Bitfields: ULONG_PTR [ -- Protection set_Protection[0..5], -- ShareCount set_ShareCount[5..8], -- Shared set_Shared[8..9], -- Node set_Node[9..12], -- VirtualPage set_VirtualPage[12..32], --]} --pub type PMEMORY_WORKING_SET_BLOCK = *mut MEMORY_WORKING_SET_BLOCK; --STRUCT!{struct MEMORY_WORKING_SET_INFORMATION { -- NumberOfEntries: ULONG_PTR, -- WorkingSetInfo: [MEMORY_WORKING_SET_BLOCK; 1], --}} --pub type PMEMORY_WORKING_SET_INFORMATION = *mut MEMORY_WORKING_SET_INFORMATION; --STRUCT!{struct MEMORY_REGION_INFORMATION { -- AllocationBase: PVOID, -- AllocationProtect: ULONG, -- RegionType: ULONG, -- RegionSize: SIZE_T, -- CommitSize: SIZE_T, --}} --BITFIELD!{MEMORY_REGION_INFORMATION RegionType: ULONG [ -- Private set_Private[0..1], -- MappedDataFile set_MappedDataFile[1..2], -- MappedImage set_MappedImage[2..3], -- MappedPageFile set_MappedPageFile[3..4], -- MappedPhysical set_MappedPhysical[4..5], -- DirectMapped set_DirectMapped[5..6], -- SoftwareEnclave set_SoftwareEnclave[6..7], -- PageSize64K set_PageSize64K[7..8], -- PlaceholderReservation set_PlaceholderReservation[8..9], -- Reserved set_Reserved[9..32], --]} --pub type PMEMORY_REGION_INFORMATION = *mut MEMORY_REGION_INFORMATION; --ENUM!{enum MEMORY_WORKING_SET_EX_LOCATION { -- MemoryLocationInvalid = 0, -- MemoryLocationResident = 1, -- MemoryLocationPagefile = 2, -- MemoryLocationReserved = 3, --}} --UNION!{union MEMORY_WORKING_SET_EX_BLOCK_u { -- Bitfields: ULONG_PTR, -- Invalid: ULONG_PTR, --}} --STRUCT!{struct MEMORY_WORKING_SET_EX_BLOCK { -- u: MEMORY_WORKING_SET_EX_BLOCK_u, --}} --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: ULONG_PTR [ -- Valid set_Valid[0..1], -- ShareCount set_ShareCount[1..4], -- Win32Protection set_Win32Protection[4..15], -- Shared set_Shared[15..16], -- Node set_Node[16..22], -- Locked set_Locked[22..23], -- LargePage set_LargePage[23..24], -- Priority set_Priority[24..27], -- Reserved set_Reserved[27..30], -- SharedOriginal set_SharedOriginal[30..31], -- Bad set_Bad[31..32], -- ReservedUlong set_ReservedUlong[32..64], --]} --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: ULONG_PTR [ -- Invalid_Valid set_Invalid_Valid[0..1], -- Invalid_Reserved0 set_Invalid_Reserved0[1..15], -- Invalid_Shared set_Invalid_Shared[15..16], -- Invalid_Reserved1 set_Invalid_Reserved1[16..21], -- Invalid_PageTable set_Invalid_PageTable[21..22], -- Invalid_Location set_Invalid_Location[22..24], -- Invalid_Priority set_Invalid_Priority[24..27], -- Invalid_ModifiedList set_Invalid_ModifiedList[27..28], -- Invalid_Reserved2 set_Invalid_Reserved2[28..30], -- Invalid_SharedOriginal set_Invalid_SharedOriginal[30..31], -- Invalid_Bad set_Invalid_Bad[31..32], -- Invalid_ReservedUlong set_Invalid_ReservedUlong[32..64], --]} --#[cfg(target_arch = "x86")] --BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: ULONG_PTR [ -- Valid set_Valid[0..1], -- ShareCount set_ShareCount[1..4], -- Win32Protection set_Win32Protection[4..15], -- Shared set_Shared[15..16], -- Node set_Node[16..22], -- Locked set_Locked[22..23], -- LargePage set_LargePage[23..24], -- Priority set_Priority[24..27], -- Reserved set_Reserved[27..30], -- SharedOriginal set_SharedOriginal[30..31], -- Bad set_Bad[31..32], --]} --#[cfg(target_arch = "x86")] --BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: ULONG_PTR [ -- Invalid_Valid set_Invalid_Valid[0..1], -- Invalid_Reserved0 set_Invalid_Reserved0[1..15], -- Invalid_Shared set_Invalid_Shared[15..16], -- Invalid_Reserved1 set_Invalid_Reserved1[16..21], -- Invalid_PageTable set_Invalid_PageTable[21..22], -- Invalid_Location set_Invalid_Location[22..24], -- Invalid_Priority set_Invalid_Priority[24..27], -- Invalid_ModifiedList set_Invalid_ModifiedList[27..28], -- Invalid_Reserved2 set_Invalid_Reserved2[28..30], -- Invalid_SharedOriginal set_Invalid_SharedOriginal[30..31], -- Invalid_Bad set_Invalid_Bad[31..32], --]} --pub type PMEMORY_WORKING_SET_EX_BLOCK = *mut MEMORY_WORKING_SET_EX_BLOCK; --STRUCT!{struct MEMORY_WORKING_SET_EX_INFORMATION { -- VirtualAddress: PVOID, -- VirtualAttributes: MEMORY_WORKING_SET_EX_BLOCK, --}} --pub type PMEMORY_WORKING_SET_EX_INFORMATION = *mut MEMORY_WORKING_SET_EX_INFORMATION; --STRUCT!{struct MEMORY_SHARED_COMMIT_INFORMATION { -- CommitSize: SIZE_T, --}} --pub type PMEMORY_SHARED_COMMIT_INFORMATION = *mut MEMORY_SHARED_COMMIT_INFORMATION; --STRUCT!{struct MEMORY_IMAGE_INFORMATION { -- ImageBase: PVOID, -- SizeOfImage: SIZE_T, -- ImageFlags: ULONG, --}} --BITFIELD!{MEMORY_IMAGE_INFORMATION ImageFlags: ULONG [ -- ImagePartialMap set_ImagePartialMap[0..1], -- ImageNotExecutable set_ImageNotExecutable[1..2], -- ImageSigningLevel set_ImageSigningLevel[2..6], -- Reserved set_Reserved[6..32], --]} --pub type PMEMORY_IMAGE_INFORMATION = *mut MEMORY_IMAGE_INFORMATION; --STRUCT!{struct MEMORY_ENCLAVE_IMAGE_INFORMATION { -- ImageInfo: MEMORY_IMAGE_INFORMATION, -- UniqueID: [UCHAR; 32], -- AuthorID: [UCHAR; 32], --}} --pub type PMEMORY_ENCLAVE_IMAGE_INFORMATION = *mut MEMORY_ENCLAVE_IMAGE_INFORMATION; --pub const MMPFNLIST_ZERO: u32 = 0; --pub const MMPFNLIST_FREE: u32 = 1; --pub const MMPFNLIST_STANDBY: u32 = 2; --pub const MMPFNLIST_MODIFIED: u32 = 3; --pub const MMPFNLIST_MODIFIEDNOWRITE: u32 = 4; --pub const MMPFNLIST_BAD: u32 = 5; --pub const MMPFNLIST_ACTIVE: u32 = 6; --pub const MMPFNLIST_TRANSITION: u32 = 7; --pub const MMPFNUSE_PROCESSPRIVATE: u32 = 0; --pub const MMPFNUSE_FILE: u32 = 1; --pub const MMPFNUSE_PAGEFILEMAPPED: u32 = 2; --pub const MMPFNUSE_PAGETABLE: u32 = 3; --pub const MMPFNUSE_PAGEDPOOL: u32 = 4; --pub const MMPFNUSE_NONPAGEDPOOL: u32 = 5; --pub const MMPFNUSE_SYSTEMPTE: u32 = 6; --pub const MMPFNUSE_SESSIONPRIVATE: u32 = 7; --pub const MMPFNUSE_METAFILE: u32 = 8; --pub const MMPFNUSE_AWEPAGE: u32 = 9; --pub const MMPFNUSE_DRIVERLOCKPAGE: u32 = 10; --pub const MMPFNUSE_KERNELSTACK: u32 = 11; --STRUCT!{struct MEMORY_FRAME_INFORMATION { -- Bitfields: ULONGLONG, --}} --BITFIELD!{MEMORY_FRAME_INFORMATION Bitfields: ULONGLONG [ -- UseDescription set_UseDescription[0..4], -- ListDescription set_ListDescription[4..7], -- Reserved0 set_Reserved0[7..8], -- Pinned set_Pinned[8..9], -- DontUse set_DontUse[9..57], -- Priority set_Priority[57..60], -- Reserved set_Reserved[60..64], --]} --STRUCT!{struct FILEOFFSET_INFORMATION { -- Bitfields: ULONGLONG, --}} --BITFIELD!{FILEOFFSET_INFORMATION Bitfields: ULONGLONG [ -- DontUse set_DontUse[0..9], -- Offset set_Offset[9..57], -- Reserved set_Reserved[57..64], --]} --STRUCT!{struct PAGEDIR_INFORMATION { -- Bitfields: ULONGLONG, --}} --BITFIELD!{PAGEDIR_INFORMATION Bitfields: ULONGLONG [ -- DontUse set_DontUse[0..9], -- PageDirectoryBase set_PageDirectoryBase[9..57], -- Reserved set_Reserved[57..64], --]} --STRUCT!{struct UNIQUE_PROCESS_INFORMATION { -- Bitfields: ULONGLONG, --}} --BITFIELD!{UNIQUE_PROCESS_INFORMATION Bitfields: ULONGLONG [ -- DontUse set_DontUse[0..9], -- UniqueProcessKey set_UniqueProcessKey[9..57], -- Reserved set_Reserved[57..64], --]} --pub type PUNIQUE_PROCESS_INFORMATION = *mut UNIQUE_PROCESS_INFORMATION; --UNION!{union MMPFN_IDENTITY_u1 { -- e1: MEMORY_FRAME_INFORMATION, -- e2: FILEOFFSET_INFORMATION, -- e3: PAGEDIR_INFORMATION, -- e4: UNIQUE_PROCESS_INFORMATION, --}} --UNION!{union MMPFN_IDENTITY_u2 { -- e1: ULONG_PTR, -- e2_CombinedPage: ULONG_PTR, -- FileObject: ULONG_PTR, -- UniqueFileObjectKey: ULONG_PTR, -- ProtoPteAddress: ULONG_PTR, -- VirtualAddress: ULONG_PTR, --}} --STRUCT!{struct MMPFN_IDENTITY { -- u1: MMPFN_IDENTITY_u1, -- PageFrameIndex: ULONG_PTR, -- u2: MMPFN_IDENTITY_u2, --}} --BITFIELD!{unsafe MMPFN_IDENTITY_u2 e1: ULONG_PTR [ -- Image set_Image[0..1], -- Mismatch set_Mismatch[1..2], --]} --pub type PMMPFN_IDENTITY = *mut MMPFN_IDENTITY; --STRUCT!{struct MMPFN_MEMSNAP_INFORMATION { -- InitialPageFrameIndex: ULONG_PTR, -- Count: ULONG_PTR, --}} --pub type PMMPFN_MEMSNAP_INFORMATION = *mut MMPFN_MEMSNAP_INFORMATION; --ENUM!{enum SECTION_INFORMATION_CLASS { -- SectionBasicInformation = 0, -- SectionImageInformation = 1, -- SectionRelocationInformation = 2, -- SectionOriginalBaseInformation = 3, -- SectionInternalImageInformation = 4, -- MaxSectionInfoClass = 5, --}} --STRUCT!{struct SECTION_BASIC_INFORMATION { -- BaseAddress: PVOID, -- AllocationAttributes: ULONG, -- MaximumSize: LARGE_INTEGER, --}} --pub type PSECTION_BASIC_INFORMATION = *mut SECTION_BASIC_INFORMATION; --STRUCT!{struct SECTION_IMAGE_INFORMATION_u1_s { -- SubSystemMinorVersion: USHORT, -- SubSystemMajorVersion: USHORT, --}} --UNION!{union SECTION_IMAGE_INFORMATION_u1 { -- s: SECTION_IMAGE_INFORMATION_u1_s, -- SubSystemVersion: ULONG, --}} --STRUCT!{struct SECTION_IMAGE_INFORMATION_u2_s { -- MajorOperatingSystemVersion: USHORT, -- MinorOperatingSystemVersion: USHORT, --}} --UNION!{union SECTION_IMAGE_INFORMATION_u2 { -- s: SECTION_IMAGE_INFORMATION_u2_s, -- OperatingSystemVersion: ULONG, --}} --STRUCT!{struct SECTION_IMAGE_INFORMATION { -- TransferAddress: PVOID, -- ZeroBits: ULONG, -- MaximumStackSize: SIZE_T, -- CommittedStackSize: SIZE_T, -- SubSystemType: ULONG, -- u1: SECTION_IMAGE_INFORMATION_u1, -- u2: SECTION_IMAGE_INFORMATION_u2, -- ImageCharacteristics: USHORT, -- DllCharacteristics: USHORT, -- Machine: USHORT, -- ImageContainsCode: BOOLEAN, -- ImageFlags: UCHAR, -- LoaderFlags: ULONG, -- ImageFileSize: ULONG, -- CheckSum: ULONG, --}} --BITFIELD!{SECTION_IMAGE_INFORMATION ImageFlags: UCHAR [ -- ComPlusNativeReady set_ComPlusNativeReady[0..1], -- ComPlusILOnly set_ComPlusILOnly[1..2], -- ImageDynamicallyRelocated set_ImageDynamicallyRelocated[2..3], -- ImageMappedFlat set_ImageMappedFlat[3..4], -- BaseBelow4gb set_BaseBelow4gb[4..5], -- ComPlusPrefer32bit set_ComPlusPrefer32bit[5..6], -- Reserved set_Reserved[6..8], --]} --pub type PSECTION_IMAGE_INFORMATION = *mut SECTION_IMAGE_INFORMATION; --STRUCT!{struct SECTION_INTERNAL_IMAGE_INFORMATION { -- SectionInformation: SECTION_IMAGE_INFORMATION, -- ExtendedFlags: ULONG, --}} --BITFIELD!{SECTION_INTERNAL_IMAGE_INFORMATION ExtendedFlags: ULONG [ -- ImageExportSuppressionEnabled set_ImageExportSuppressionEnabled[0..1], -- Reserved set_Reserved[1..32], --]} --pub type PSECTION_INTERNAL_IMAGE_INFORMATION = *mut SECTION_INTERNAL_IMAGE_INFORMATION; --ENUM!{enum SECTION_INHERIT { -- ViewShare = 1, -- ViewUnmap = 2, --}} --pub const SEC_BASED: u32 = 0x200000; --pub const SEC_NO_CHANGE: u32 = 0x400000; --pub const SEC_GLOBAL: u32 = 0x20000000; --pub const MEM_EXECUTE_OPTION_DISABLE: u32 = 0x1; --pub const MEM_EXECUTE_OPTION_ENABLE: u32 = 0x2; --pub const MEM_EXECUTE_OPTION_DISABLE_THUNK_EMULATION: u32 = 0x4; --pub const MEM_EXECUTE_OPTION_PERMANENT: u32 = 0x8; --pub const MEM_EXECUTE_OPTION_EXECUTE_DISPATCH_ENABLE: u32 = 0x10; --pub const MEM_EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE: u32 = 0x20; --pub const MEM_EXECUTE_OPTION_VALID_FLAGS: u32 = 0x3f; --EXTERN!{extern "system" { -- fn NtAllocateVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- ZeroBits: ULONG_PTR, -- RegionSize: PSIZE_T, -- AllocationType: ULONG, -- Protect: ULONG, -- ) -> NTSTATUS; -- fn NtFreeVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- RegionSize: PSIZE_T, -- FreeType: ULONG, -- ) -> NTSTATUS; -- fn NtReadVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- Buffer: PVOID, -- BufferSize: SIZE_T, -- NumberOfBytesRead: PSIZE_T, -- ) -> NTSTATUS; -- fn NtWriteVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- Buffer: PVOID, -- BufferSize: SIZE_T, -- NumberOfBytesWritten: PSIZE_T, -- ) -> NTSTATUS; -- fn NtProtectVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- RegionSize: PSIZE_T, -- NewProtect: ULONG, -- OldProtect: PULONG, -- ) -> NTSTATUS; -- fn NtQueryVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- MemoryInformationClass: MEMORY_INFORMATION_CLASS, -- MemoryInformation: PVOID, -- MemoryInformationLength: SIZE_T, -- ReturnLength: PSIZE_T, -- ) -> NTSTATUS; --}} --ENUM!{enum VIRTUAL_MEMORY_INFORMATION_CLASS { -- VmPrefetchInformation = 0, -- VmPagePriorityInformation = 1, -- VmCfgCallTargetInformation = 2, -- VmPageDirtyStateInformation = 3, --}} --STRUCT!{struct MEMORY_RANGE_ENTRY { -- VirtualAddress: PVOID, -- NumberOfBytes: SIZE_T, --}} --pub type PMEMORY_RANGE_ENTRY = *mut MEMORY_RANGE_ENTRY; --STRUCT!{struct CFG_CALL_TARGET_LIST_INFORMATION { -- NumberOfEntries: ULONG, -- Reserved: ULONG, -- NumberOfEntriesProcessed: PULONG, -- CallTargetInfo: PCFG_CALL_TARGET_INFO, -- Section: PVOID, -- FileOffset: ULONGLONG, --}} --pub type PCFG_CALL_TARGET_LIST_INFORMATION = *mut CFG_CALL_TARGET_LIST_INFORMATION; --EXTERN!{extern "system" { -- fn NtSetInformationVirtualMemory( -- ProcessHandle: HANDLE, -- VmInformationClass: VIRTUAL_MEMORY_INFORMATION_CLASS, -- NumberOfEntries: ULONG_PTR, -- VirtualAddresses: PMEMORY_RANGE_ENTRY, -- VmInformation: PVOID, -- VmInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtLockVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- RegionSize: PSIZE_T, -- MapType: ULONG, -- ) -> NTSTATUS; -- fn NtUnlockVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- RegionSize: PSIZE_T, -- MapType: ULONG, -- ) -> NTSTATUS; -- fn NtCreateSection( -- SectionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- MaximumSize: PLARGE_INTEGER, -- SectionPageProtection: ULONG, -- AllocationAttributes: ULONG, -- FileHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtCreateSectionEx( -- SectionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- MaximumSize: PLARGE_INTEGER, -- SectionPageProtection: ULONG, -- AllocationAttributes: ULONG, -- FileHandle: HANDLE, -- ExtendedParameters: PMEM_EXTENDED_PARAMETER, -- ExtendedParameterCount: ULONG, -- ) -> NTSTATUS; -- fn NtOpenSection( -- SectionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtMapViewOfSection( -- SectionHandle: HANDLE, -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- ZeroBits: ULONG_PTR, -- CommitSize: SIZE_T, -- SectionOffset: PLARGE_INTEGER, -- ViewSize: PSIZE_T, -- InheritDisposition: SECTION_INHERIT, -- AllocationType: ULONG, -- Win32Protect: ULONG, -- ) -> NTSTATUS; -- fn NtUnmapViewOfSection( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- ) -> NTSTATUS; -- fn NtUnmapViewOfSectionEx( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtExtendSection( -- SectionHandle: HANDLE, -- NewSectionSize: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtQuerySection( -- SectionHandle: HANDLE, -- SectionInformationClass: SECTION_INFORMATION_CLASS, -- SectionInformation: PVOID, -- SectionInformationLength: SIZE_T, -- ReturnLength: PSIZE_T, -- ) -> NTSTATUS; -- fn NtAreMappedFilesTheSame( -- File1MappedAsAnImage: PVOID, -- File2MappedAsFile: PVOID, -- ) -> NTSTATUS; --}} --pub const MEMORY_PARTITION_QUERY_ACCESS: u32 = 0x0001; --pub const MEMORY_PARTITION_MODIFY_ACCESS: u32 = 0x0002; --pub const MEMORY_PARTITION_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE -- | MEMORY_PARTITION_QUERY_ACCESS | MEMORY_PARTITION_MODIFY_ACCESS; --ENUM!{enum MEMORY_PARTITION_INFORMATION_CLASS { -- SystemMemoryPartitionInformation = 0, -- SystemMemoryPartitionMoveMemory = 1, -- SystemMemoryPartitionAddPagefile = 2, -- SystemMemoryPartitionCombineMemory = 3, -- SystemMemoryPartitionInitialAddMemory = 4, -- SystemMemoryPartitionGetMemoryEvents = 5, -- SystemMemoryPartitionMax = 6, --}} --STRUCT!{struct MEMORY_PARTITION_CONFIGURATION_INFORMATION { -- Flags: ULONG, -- NumaNode: ULONG, -- Channel: ULONG, -- NumberOfNumaNodes: ULONG, -- ResidentAvailablePages: ULONG_PTR, -- CommittedPages: ULONG_PTR, -- CommitLimit: ULONG_PTR, -- PeakCommitment: ULONG_PTR, -- TotalNumberOfPages: ULONG_PTR, -- AvailablePages: ULONG_PTR, -- ZeroPages: ULONG_PTR, -- FreePages: ULONG_PTR, -- StandbyPages: ULONG_PTR, -- StandbyPageCountByPriority: [ULONG_PTR; 8], -- RepurposedPagesByPriority: [ULONG_PTR; 8], -- MaximumCommitLimit: ULONG_PTR, -- DonatedPagesToPartitions: ULONG_PTR, -- PartitionId: ULONG, --}} --pub type PMEMORY_PARTITION_CONFIGURATION_INFORMATION = -- *mut MEMORY_PARTITION_CONFIGURATION_INFORMATION; --STRUCT!{struct MEMORY_PARTITION_TRANSFER_INFORMATION { -- NumberOfPages: ULONG_PTR, -- NumaNode: ULONG, -- Flags: ULONG, --}} --pub type PMEMORY_PARTITION_TRANSFER_INFORMATION = *mut MEMORY_PARTITION_TRANSFER_INFORMATION; --STRUCT!{struct MEMORY_PARTITION_PAGEFILE_INFORMATION { -- PageFileName: UNICODE_STRING, -- MinimumSize: LARGE_INTEGER, -- MaximumSize: LARGE_INTEGER, -- Flags: ULONG, --}} --pub type PMEMORY_PARTITION_PAGEFILE_INFORMATION = *mut MEMORY_PARTITION_PAGEFILE_INFORMATION; --STRUCT!{struct MEMORY_PARTITION_PAGE_COMBINE_INFORMATION { -- StopHandle: HANDLE, -- Flags: ULONG, -- TotalNumberOfPages: ULONG_PTR, --}} --pub type PMEMORY_PARTITION_PAGE_COMBINE_INFORMATION = -- *mut MEMORY_PARTITION_PAGE_COMBINE_INFORMATION; --STRUCT!{struct MEMORY_PARTITION_PAGE_RANGE { -- StartPage: ULONG_PTR, -- NumberOfPages: ULONG_PTR, --}} --pub type PMEMORY_PARTITION_PAGE_RANGE = *mut MEMORY_PARTITION_PAGE_RANGE; --STRUCT!{struct MEMORY_PARTITION_INITIAL_ADD_INFORMATION { -- Flags: ULONG, -- NumberOfRanges: ULONG, -- NumberOfPagesAdded: ULONG_PTR, -- PartitionRanges: [MEMORY_PARTITION_PAGE_RANGE; 1], --}} --pub type PMEMORY_PARTITION_INITIAL_ADD_INFORMATION = *mut MEMORY_PARTITION_INITIAL_ADD_INFORMATION; --STRUCT!{struct MEMORY_PARTITION_MEMORY_EVENTS_INFORMATION { -- Flags: ULONG, -- HandleAttributes: ULONG, -- DesiredAccess: ULONG, -- LowCommitCondition: HANDLE, -- HighCommitCondition: HANDLE, -- MaximumCommitCondition: HANDLE, --}} --BITFIELD!{MEMORY_PARTITION_MEMORY_EVENTS_INFORMATION Flags: ULONG [ -- CommitEvents set_CommitEvents[0..1], -- Spare set_Spare[1..32], --]} --pub type PMEMORY_PARTITION_MEMORY_EVENTS_INFORMATION = -- *mut MEMORY_PARTITION_MEMORY_EVENTS_INFORMATION; --EXTERN!{extern "system" { -- fn NtCreatePartition( -- PartitionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PreferredNode: ULONG, -- ) -> NTSTATUS; -- fn NtOpenPartition( -- PartitionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtManagePartition( -- PartitionInformationClass: MEMORY_PARTITION_INFORMATION_CLASS, -- PartitionInformation: PVOID, -- PartitionInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtMapUserPhysicalPages( -- VirtualAddress: PVOID, -- NumberOfPages: ULONG_PTR, -- UserPfnArray: PULONG_PTR, -- ) -> NTSTATUS; -- fn NtMapUserPhysicalPagesScatter( -- VirtualAddresses: *mut PVOID, -- NumberOfPages: ULONG_PTR, -- UserPfnArray: PULONG_PTR, -- ) -> NTSTATUS; -- fn NtAllocateUserPhysicalPages( -- ProcessHandle: HANDLE, -- NumberOfPages: PULONG_PTR, -- UserPfnArray: PULONG_PTR, -- ) -> NTSTATUS; -- fn NtFreeUserPhysicalPages( -- ProcessHandle: HANDLE, -- NumberOfPages: PULONG_PTR, -- UserPfnArray: PULONG_PTR, -- ) -> NTSTATUS; -- fn NtOpenSession( -- SessionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtGetWriteWatch( -- ProcessHandle: HANDLE, -- Flags: ULONG, -- BaseAddress: PVOID, -- RegionSize: SIZE_T, -- UserAddressArray: *mut PVOID, -- EntriesInUserAddressArray: PULONG_PTR, -- Granularity: PULONG, -- ) -> NTSTATUS; -- fn NtResetWriteWatch( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- RegionSize: SIZE_T, -- ) -> NTSTATUS; -- fn NtCreatePagingFile( -- PageFileName: PUNICODE_STRING, -- MinimumSize: PLARGE_INTEGER, -- MaximumSize: PLARGE_INTEGER, -- Priority: ULONG, -- ) -> NTSTATUS; -- fn NtFlushInstructionCache( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- Length: SIZE_T, -- ) -> NTSTATUS; -- fn NtFlushWriteBuffer() -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntnls.rs b/KubeOS-Rust/vendor/ntapi/src/ntnls.rs -deleted file mode 100644 -index 592a1988..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntnls.rs -+++ /dev/null -@@ -1,29 +0,0 @@ --use winapi::shared::ntdef::{BOOLEAN, PUSHORT, PVOID, UCHAR, USHORT}; --pub const MAXIMUM_LEADBYTES: usize = 12; --STRUCT!{struct CPTABLEINFO { -- CodePage: USHORT, -- MaximumCharacterSize: USHORT, -- DefaultChar: USHORT, -- UniDefaultChar: USHORT, -- TransDefaultChar: USHORT, -- TransUniDefaultChar: USHORT, -- DBCSCodePage: USHORT, -- LeadByte: [UCHAR; MAXIMUM_LEADBYTES], -- MultiByteTable: PUSHORT, -- WideCharTable: PVOID, -- DBCSRanges: PUSHORT, -- DBCSOffsets: PUSHORT, --}} --pub type PCPTABLEINFO = *mut CPTABLEINFO; --STRUCT!{struct NLSTABLEINFO { -- OemTableInfo: CPTABLEINFO, -- AnsiTableInfo: CPTABLEINFO, -- UpperCaseTable: PUSHORT, -- LowerCaseTable: PUSHORT, --}} --pub type PNLSTABLEINFO = *mut NLSTABLEINFO; --EXTERN!{extern "C" { -- static mut NlsAnsiCodePage: USHORT; -- static mut NlsMbCodePageTag: BOOLEAN; -- static mut NlsMbOemCodePageTag: BOOLEAN; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntobapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntobapi.rs -deleted file mode 100644 -index 388ec619..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntobapi.rs -+++ /dev/null -@@ -1,226 +0,0 @@ --use winapi::shared::ntdef::{ -- BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, LONG, NTSTATUS, PHANDLE, PLARGE_INTEGER, -- POBJECT_ATTRIBUTES, PULONG, PUNICODE_STRING, PVOID, UCHAR, ULONG, UNICODE_STRING, WAIT_TYPE, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, GENERIC_MAPPING, PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, -- STANDARD_RIGHTS_REQUIRED, --}; --pub const OBJECT_TYPE_CREATE: u32 = 0x0001; --pub const OBJECT_TYPE_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | 0x1; --pub const DIRECTORY_QUERY: u32 = 0x0001; --pub const DIRECTORY_TRAVERSE: u32 = 0x0002; --pub const DIRECTORY_CREATE_OBJECT: u32 = 0x0004; --pub const DIRECTORY_CREATE_SUBDIRECTORY: u32 = 0x0008; --pub const DIRECTORY_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | 0xf; --pub const SYMBOLIC_LINK_QUERY: u32 = 0x0001; --pub const SYMBOLIC_LINK_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | 0x1; --pub const OBJ_PROTECT_CLOSE: u32 = 0x00000001; --pub const OBJ_INHERIT: u32 = 0x00000002; --pub const OBJ_AUDIT_OBJECT_CLOSE: u32 = 0x00000004; --ENUM!{enum OBJECT_INFORMATION_CLASS { -- ObjectBasicInformation = 0, -- ObjectNameInformation = 1, -- ObjectTypeInformation = 2, -- ObjectTypesInformation = 3, -- ObjectHandleFlagInformation = 4, -- ObjectSessionInformation = 5, -- ObjectSessionObjectInformation = 6, -- MaxObjectInfoClass = 7, --}} --STRUCT!{struct OBJECT_BASIC_INFORMATION { -- Attributes: ULONG, -- GrantedAccess: ACCESS_MASK, -- HandleCount: ULONG, -- PointerCount: ULONG, -- PagedPoolCharge: ULONG, -- NonPagedPoolCharge: ULONG, -- Reserved: [ULONG; 3], -- NameInfoSize: ULONG, -- TypeInfoSize: ULONG, -- SecurityDescriptorSize: ULONG, -- CreationTime: LARGE_INTEGER, --}} --pub type POBJECT_BASIC_INFORMATION = *mut OBJECT_BASIC_INFORMATION; --STRUCT!{struct OBJECT_NAME_INFORMATION { -- Name: UNICODE_STRING, --}} --pub type POBJECT_NAME_INFORMATION = *mut OBJECT_NAME_INFORMATION; --STRUCT!{struct OBJECT_TYPE_INFORMATION { -- TypeName: UNICODE_STRING, -- TotalNumberOfObjects: ULONG, -- TotalNumberOfHandles: ULONG, -- TotalPagedPoolUsage: ULONG, -- TotalNonPagedPoolUsage: ULONG, -- TotalNamePoolUsage: ULONG, -- TotalHandleTableUsage: ULONG, -- HighWaterNumberOfObjects: ULONG, -- HighWaterNumberOfHandles: ULONG, -- HighWaterPagedPoolUsage: ULONG, -- HighWaterNonPagedPoolUsage: ULONG, -- HighWaterNamePoolUsage: ULONG, -- HighWaterHandleTableUsage: ULONG, -- InvalidAttributes: ULONG, -- GenericMapping: GENERIC_MAPPING, -- ValidAccessMask: ULONG, -- SecurityRequired: BOOLEAN, -- MaintainHandleCount: BOOLEAN, -- TypeIndex: UCHAR, -- ReservedByte: CHAR, -- PoolType: ULONG, -- DefaultPagedPoolCharge: ULONG, -- DefaultNonPagedPoolCharge: ULONG, --}} --pub type POBJECT_TYPE_INFORMATION = *mut OBJECT_TYPE_INFORMATION; --STRUCT!{struct OBJECT_TYPES_INFORMATION { -- NumberOfTypes: ULONG, --}} --pub type POBJECT_TYPES_INFORMATION = *mut OBJECT_TYPES_INFORMATION; --STRUCT!{struct OBJECT_HANDLE_FLAG_INFORMATION { -- Inherit: BOOLEAN, -- ProtectFromClose: BOOLEAN, --}} --pub type POBJECT_HANDLE_FLAG_INFORMATION = *mut OBJECT_HANDLE_FLAG_INFORMATION; --EXTERN!{extern "system" { -- fn NtQueryObject( -- Handle: HANDLE, -- ObjectInformationClass: OBJECT_INFORMATION_CLASS, -- ObjectInformation: PVOID, -- ObjectInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationObject( -- Handle: HANDLE, -- ObjectInformationClass: OBJECT_INFORMATION_CLASS, -- ObjectInformation: PVOID, -- ObjectInformationLength: ULONG, -- ) -> NTSTATUS; --}} --pub const DUPLICATE_CLOSE_SOURCE: u32 = 0x00000001; --pub const DUPLICATE_SAME_ACCESS: u32 = 0x00000002; --pub const DUPLICATE_SAME_ATTRIBUTES: u32 = 0x00000004; --EXTERN!{extern "system" { -- fn NtDuplicateObject( -- SourceProcessHandle: HANDLE, -- SourceHandle: HANDLE, -- TargetProcessHandle: HANDLE, -- TargetHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- HandleAttributes: ULONG, -- Options: ULONG, -- ) -> NTSTATUS; -- fn NtMakeTemporaryObject( -- Handle: HANDLE, -- ) -> NTSTATUS; -- fn NtMakePermanentObject( -- Handle: HANDLE, -- ) -> NTSTATUS; -- fn NtSignalAndWaitForSingleObject( -- SignalHandle: HANDLE, -- WaitHandle: HANDLE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtWaitForSingleObject( -- Handle: HANDLE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtWaitForMultipleObjects( -- Count: ULONG, -- Handles: *mut HANDLE, -- WaitType: WAIT_TYPE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtWaitForMultipleObjects32( -- Count: ULONG, -- Handles: *mut LONG, -- WaitType: WAIT_TYPE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtSetSecurityObject( -- Handle: HANDLE, -- SecurityInformation: SECURITY_INFORMATION, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ) -> NTSTATUS; -- fn NtQuerySecurityObject( -- Handle: HANDLE, -- SecurityInformation: SECURITY_INFORMATION, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Length: ULONG, -- LengthNeeded: PULONG, -- ) -> NTSTATUS; -- fn NtClose( -- Handle: HANDLE, -- ) -> NTSTATUS; -- fn NtCompareObjects( -- FirstObjectHandle: HANDLE, -- SecondObjectHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtCreateDirectoryObject( -- DirectoryHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtCreateDirectoryObjectEx( -- DirectoryHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ShadowDirectoryHandle: HANDLE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtOpenDirectoryObject( -- DirectoryHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; --}} --STRUCT!{struct OBJECT_DIRECTORY_INFORMATION { -- Name: UNICODE_STRING, -- TypeName: UNICODE_STRING, --}} --pub type POBJECT_DIRECTORY_INFORMATION = *mut OBJECT_DIRECTORY_INFORMATION; --EXTERN!{extern "system" { -- fn NtQueryDirectoryObject( -- DirectoryHandle: HANDLE, -- Buffer: PVOID, -- Length: ULONG, -- ReturnSingleEntry: BOOLEAN, -- RestartScan: BOOLEAN, -- Context: PULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtCreatePrivateNamespace( -- NamespaceHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- BoundaryDescriptor: PVOID, -- ) -> NTSTATUS; -- fn NtOpenPrivateNamespace( -- NamespaceHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- BoundaryDescriptor: PVOID, -- ) -> NTSTATUS; -- fn NtDeletePrivateNamespace( -- NamespaceHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtCreateSymbolicLinkObject( -- LinkHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- LinkTarget: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn NtOpenSymbolicLinkObject( -- LinkHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtQuerySymbolicLinkObject( -- LinkHandle: HANDLE, -- LinkTarget: PUNICODE_STRING, -- ReturnedLength: PULONG, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntpebteb.rs b/KubeOS-Rust/vendor/ntapi/src/ntpebteb.rs -deleted file mode 100644 -index b5170586..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntpebteb.rs -+++ /dev/null -@@ -1,431 +0,0 @@ --use core::mem::size_of; --use crate::ntapi_base::CLIENT_ID; --use crate::ntpsapi::{GDI_HANDLE_BUFFER, PPEB_LDR_DATA}; --use crate::ntrtl::PRTL_USER_PROCESS_PARAMETERS; --use winapi::shared::basetsd::{SIZE_T, ULONG_PTR}; --use winapi::shared::guiddef::GUID; --use winapi::shared::ntdef::{ -- BOOLEAN, CHAR, HANDLE, LCID, LIST_ENTRY, LONG, NTSTATUS, PROCESSOR_NUMBER, PSTR, PVOID, UCHAR, -- ULARGE_INTEGER, ULONG, ULONGLONG, UNICODE_STRING, USHORT, WCHAR, --}; --use winapi::um::winnt::{ -- ACTIVATION_CONTEXT, FLS_MAXIMUM_AVAILABLE, NT_TIB, PRTL_CRITICAL_SECTION, PSLIST_HEADER, --}; --STRUCT!{struct RTL_ACTIVATION_CONTEXT_STACK_FRAME { -- Previous: PRTL_ACTIVATION_CONTEXT_STACK_FRAME, -- ActivationContext: *mut ACTIVATION_CONTEXT, -- Flags: ULONG, --}} --pub type PRTL_ACTIVATION_CONTEXT_STACK_FRAME = *mut RTL_ACTIVATION_CONTEXT_STACK_FRAME; --STRUCT!{struct ACTIVATION_CONTEXT_STACK { -- ActiveFrame: *mut RTL_ACTIVATION_CONTEXT_STACK_FRAME, -- FrameListCache: LIST_ENTRY, -- Flags: ULONG, -- NextCookieSequenceNumber: ULONG, -- StackId: ULONG, --}} --pub type PACTIVATION_CONTEXT_STACK = *mut ACTIVATION_CONTEXT_STACK; --STRUCT!{struct API_SET_NAMESPACE { -- Version: ULONG, -- Size: ULONG, -- Flags: ULONG, -- Count: ULONG, -- EntryOffset: ULONG, -- HashOffset: ULONG, -- HashFactor: ULONG, --}} --pub type PAPI_SET_NAMESPACE = *mut API_SET_NAMESPACE; --STRUCT!{struct API_SET_HASH_ENTRY { -- Hash: ULONG, -- Index: ULONG, --}} --pub type PAPI_SET_HASH_ENTRY = *mut API_SET_HASH_ENTRY; --STRUCT!{struct API_SET_NAMESPACE_ENTRY { -- Flags: ULONG, -- NameOffset: ULONG, -- NameLength: ULONG, -- HashedLength: ULONG, -- ValueOffset: ULONG, -- ValueCount: ULONG, --}} --pub type PAPI_SET_NAMESPACE_ENTRY = *mut API_SET_NAMESPACE_ENTRY; --STRUCT!{struct API_SET_VALUE_ENTRY { -- Flags: ULONG, -- NameOffset: ULONG, -- NameLength: ULONG, -- ValueOffset: ULONG, -- ValueLength: ULONG, --}} --pub type PAPI_SET_VALUE_ENTRY = *mut API_SET_VALUE_ENTRY; --UNION!{union PEB_u { -- KernelCallbackTable: PVOID, -- UserSharedInfoPtr: PVOID, --}} --#[repr(C)] --pub struct LEAP_SECOND_DATA([u8; 0]); //fixme --STRUCT!{struct PEB { -- InheritedAddressSpace: BOOLEAN, -- ReadImageFileExecOptions: BOOLEAN, -- BeingDebugged: BOOLEAN, -- BitField: BOOLEAN, -- Mutant: HANDLE, -- ImageBaseAddress: PVOID, -- Ldr: PPEB_LDR_DATA, -- ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, -- SubSystemData: PVOID, -- ProcessHeap: PVOID, -- FastPebLock: PRTL_CRITICAL_SECTION, -- IFEOKey: PVOID, -- AtlThunkSListPtr: PSLIST_HEADER, -- CrossProcessFlags: ULONG, -- u: PEB_u, -- SystemReserved: [ULONG; 1], -- AtlThunkSListPtr32: ULONG, -- ApiSetMap: PAPI_SET_NAMESPACE, -- TlsExpansionCounter: ULONG, -- TlsBitmap: PVOID, -- TlsBitmapBits: [ULONG; 2], -- ReadOnlySharedMemoryBase: PVOID, -- SharedData: PVOID, -- ReadOnlyStaticServerData: *mut PVOID, -- AnsiCodePageData: PVOID, -- OemCodePageData: PVOID, -- UnicodeCaseTableData: PVOID, -- NumberOfProcessors: ULONG, -- NtGlobalFlag: ULONG, -- CriticalSectionTimeout: ULARGE_INTEGER, -- HeapSegmentReserve: SIZE_T, -- HeapSegmentCommit: SIZE_T, -- HeapDeCommitTotalFreeThreshold: SIZE_T, -- HeapDeCommitFreeBlockThreshold: SIZE_T, -- NumberOfHeaps: ULONG, -- MaximumNumberOfHeaps: ULONG, -- ProcessHeaps: *mut PVOID, -- GdiSharedHandleTable: PVOID, -- ProcessStarterHelper: PVOID, -- GdiDCAttributeList: ULONG, -- LoaderLock: PRTL_CRITICAL_SECTION, -- OSMajorVersion: ULONG, -- OSMinorVersion: ULONG, -- OSBuildNumber: USHORT, -- OSCSDVersion: USHORT, -- OSPlatformId: ULONG, -- ImageSubsystem: ULONG, -- ImageSubsystemMajorVersion: ULONG, -- ImageSubsystemMinorVersion: ULONG, -- ActiveProcessAffinityMask: ULONG_PTR, -- GdiHandleBuffer: GDI_HANDLE_BUFFER, -- PostProcessInitRoutine: PVOID, -- TlsExpansionBitmap: PVOID, -- TlsExpansionBitmapBits: [ULONG; 32], -- SessionId: ULONG, -- AppCompatFlags: ULARGE_INTEGER, -- AppCompatFlagsUser: ULARGE_INTEGER, -- pShimData: PVOID, -- AppCompatInfo: PVOID, -- CSDVersion: UNICODE_STRING, -- ActivationContextData: PVOID, -- ProcessAssemblyStorageMap: PVOID, -- SystemDefaultActivationContextData: PVOID, -- SystemAssemblyStorageMap: PVOID, -- MinimumStackCommit: SIZE_T, -- FlsCallback: *mut PVOID, -- FlsListHead: LIST_ENTRY, -- FlsBitmap: PVOID, -- FlsBitmapBits: [ULONG; FLS_MAXIMUM_AVAILABLE as usize / (size_of::() * 8)], -- FlsHighIndex: ULONG, -- WerRegistrationData: PVOID, -- WerShipAssertPtr: PVOID, -- pUnused: PVOID, -- pImageHeaderHash: PVOID, -- TracingFlags: ULONG, -- CsrServerReadOnlySharedMemoryBase: ULONGLONG, -- TppWorkerpListLock: PRTL_CRITICAL_SECTION, -- TppWorkerpList: LIST_ENTRY, -- WaitOnAddressHashTable: [PVOID; 128], -- TelemetryCoverageHeader: PVOID, -- CloudFileFlags: ULONG, -- CloudFileDiagFlags: ULONG, -- PlaceholderCompatibilityMode: CHAR, -- PlaceholderCompatibilityModeReserved: [CHAR; 7], -- LeapSecondData: *mut LEAP_SECOND_DATA, -- LeapSecondFlags: ULONG, -- NtGlobalFlag2: ULONG, --}} --BITFIELD!{PEB BitField: BOOLEAN [ -- ImageUsesLargePages set_ImageUsesLargePages[0..1], -- IsProtectedProcess set_IsProtectedProcess[1..2], -- IsImageDynamicallyRelocated set_IsImageDynamicallyRelocated[2..3], -- SkipPatchingUser32Forwarders set_SkipPatchingUser32Forwarders[3..4], -- IsPackagedProcess set_IsPackagedProcess[4..5], -- IsAppContainer set_IsAppContainer[5..6], -- IsProtectedProcessLight set_IsProtectedProcessLight[6..7], -- IsLongPathAwareProcess set_IsLongPathAwareProcess[7..8], --]} --BITFIELD!{PEB CrossProcessFlags: ULONG [ -- ProcessInJob set_ProcessInJob[0..1], -- ProcessInitializing set_ProcessInitializing[1..2], -- ProcessUsingVEH set_ProcessUsingVEH[2..3], -- ProcessUsingVCH set_ProcessUsingVCH[3..4], -- ProcessUsingFTH set_ProcessUsingFTH[4..5], -- ProcessPreviouslyThrottled set_ProcessPreviouslyThrottled[5..6], -- ProcessCurrentlyThrottled set_ProcessCurrentlyThrottled[6..7], -- ProcessImagesHotPatched set_ProcessImagesHotPatched[7..8], -- ReservedBits0 set_ReservedBits0[8..32], --]} --BITFIELD!{PEB TracingFlags: ULONG [ -- HeapTracingEnabled set_HeapTracingEnabled[0..1], -- CritSecTracingEnabled set_CritSecTracingEnabled[1..2], -- LibLoaderTracingEnabled set_LibLoaderTracingEnabled[2..3], -- SpareTracingBits set_SpareTracingBits[3..32], --]} --BITFIELD!{PEB LeapSecondFlags: ULONG [ -- SixtySecondEnabled set_SixtySecondEnabled[0..1], -- Reserved set_Reserved[1..32], --]} --pub type PPEB = *mut PEB; --pub const GDI_BATCH_BUFFER_SIZE: usize = 310; --STRUCT!{struct GDI_TEB_BATCH { -- Offset: ULONG, -- HDC: ULONG_PTR, -- Buffer: [ULONG; GDI_BATCH_BUFFER_SIZE], --}} --pub type PGDI_TEB_BATCH = *mut GDI_TEB_BATCH; --STRUCT!{struct TEB_ACTIVE_FRAME_CONTEXT { -- Flags: ULONG, -- FrameName: PSTR, --}} --pub type PTEB_ACTIVE_FRAME_CONTEXT = *mut TEB_ACTIVE_FRAME_CONTEXT; --STRUCT!{struct TEB_ACTIVE_FRAME { -- Flags: ULONG, -- Previous: *mut TEB_ACTIVE_FRAME, -- Context: PTEB_ACTIVE_FRAME_CONTEXT, --}} --pub type PTEB_ACTIVE_FRAME = *mut TEB_ACTIVE_FRAME; --STRUCT!{struct TEB_u_s { -- ReservedPad0: UCHAR, -- ReservedPad1: UCHAR, -- ReservedPad2: UCHAR, -- IdealProcessor: UCHAR, --}} --UNION!{union TEB_u { -- CurrentIdealProcessor: PROCESSOR_NUMBER, -- IdealProcessorValue: ULONG, -- s: TEB_u_s, --}} --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --STRUCT!{struct TEB { -- NtTib: NT_TIB, -- EnvironmentPointer: PVOID, -- ClientId: CLIENT_ID, -- ActiveRpcHandle: PVOID, -- ThreadLocalStoragePointer: PVOID, -- ProcessEnvironmentBlock: PPEB, -- LastErrorValue: ULONG, -- CountOfOwnedCriticalSections: ULONG, -- CsrClientThread: PVOID, -- Win32ThreadInfo: PVOID, -- User32Reserved: [ULONG; 26], -- UserReserved: [ULONG; 5], -- WOW32Reserved: PVOID, -- CurrentLocale: LCID, -- FpSoftwareStatusRegister: ULONG, -- ReservedForDebuggerInstrumentation: [PVOID; 16], -- SystemReserved1: [PVOID; 30], -- PlaceholderCompatibilityMode: CHAR, -- PlaceholderReserved: [CHAR; 11], -- ProxiedProcessId: ULONG, -- ActivationStack: ACTIVATION_CONTEXT_STACK, -- WorkingOnBehalfTicket: [UCHAR; 8], -- ExceptionCode: NTSTATUS, -- ActivationContextStackPointer: PACTIVATION_CONTEXT_STACK, -- InstrumentationCallbackSp: ULONG_PTR, -- InstrumentationCallbackPreviousPc: ULONG_PTR, -- InstrumentationCallbackPreviousSp: ULONG_PTR, -- TxFsContext: ULONG, -- InstrumentationCallbackDisabled: BOOLEAN, -- GdiTebBatch: GDI_TEB_BATCH, -- RealClientId: CLIENT_ID, -- GdiCachedProcessHandle: HANDLE, -- GdiClientPID: ULONG, -- GdiClientTID: ULONG, -- GdiThreadLocalInfo: PVOID, -- Win32ClientInfo: [ULONG_PTR; 62], -- glDispatchTable: [PVOID; 233], -- glReserved1: [ULONG_PTR; 29], -- glReserved2: PVOID, -- glSectionInfo: PVOID, -- glSection: PVOID, -- glTable: PVOID, -- glCurrentRC: PVOID, -- glContext: PVOID, -- LastStatusValue: NTSTATUS, -- StaticUnicodeString: UNICODE_STRING, -- StaticUnicodeBuffer: [WCHAR; 261], -- DeallocationStack: PVOID, -- TlsSlots: [PVOID; 64], -- TlsLinks: LIST_ENTRY, -- Vdm: PVOID, -- ReservedForNtRpc: PVOID, -- DbgSsReserved: [PVOID; 2], -- HardErrorMode: ULONG, -- Instrumentation: [PVOID; 11], -- ActivityId: GUID, -- SubProcessTag: PVOID, -- PerflibData: PVOID, -- EtwTraceData: PVOID, -- WinSockData: PVOID, -- GdiBatchCount: ULONG, -- u: TEB_u, -- GuaranteedStackBytes: ULONG, -- ReservedForPerf: PVOID, -- ReservedForOle: PVOID, -- WaitingOnLoaderLock: ULONG, -- SavedPriorityState: PVOID, -- ReservedForCodeCoverage: ULONG_PTR, -- ThreadPoolData: PVOID, -- TlsExpansionSlots: *mut PVOID, -- DeallocationBStore: PVOID, -- BStoreLimit: PVOID, -- MuiGeneration: ULONG, -- IsImpersonating: ULONG, -- NlsCache: PVOID, -- pShimData: PVOID, -- HeapVirtualAffinity: USHORT, -- LowFragHeapDataSlot: USHORT, -- CurrentTransactionHandle: HANDLE, -- ActiveFrame: PTEB_ACTIVE_FRAME, -- FlsData: PVOID, -- PreferredLanguages: PVOID, -- UserPrefLanguages: PVOID, -- MergedPrefLanguages: PVOID, -- MuiImpersonation: ULONG, -- CrossTebFlags: USHORT, -- SameTebFlags: USHORT, -- TxnScopeEnterCallback: PVOID, -- TxnScopeExitCallback: PVOID, -- TxnScopeContext: PVOID, -- LockCount: ULONG, -- WowTebOffset: LONG, -- ResourceRetValue: PVOID, -- ReservedForWdf: PVOID, -- ReservedForCrt: ULONGLONG, -- EffectiveContainerId: GUID, --}} --#[cfg(target_arch = "x86")] --STRUCT!{struct TEB { -- NtTib: NT_TIB, -- EnvironmentPointer: PVOID, -- ClientId: CLIENT_ID, -- ActiveRpcHandle: PVOID, -- ThreadLocalStoragePointer: PVOID, -- ProcessEnvironmentBlock: PPEB, -- LastErrorValue: ULONG, -- CountOfOwnedCriticalSections: ULONG, -- CsrClientThread: PVOID, -- Win32ThreadInfo: PVOID, -- User32Reserved: [ULONG; 26], -- UserReserved: [ULONG; 5], -- WOW32Reserved: PVOID, -- CurrentLocale: LCID, -- FpSoftwareStatusRegister: ULONG, -- ReservedForDebuggerInstrumentation: [PVOID; 16], -- SystemReserved1: [PVOID; 26], -- PlaceholderCompatibilityMode: CHAR, -- PlaceholderReserved: [CHAR; 11], -- ProxiedProcessId: ULONG, -- ActivationStack: ACTIVATION_CONTEXT_STACK, -- WorkingOnBehalfTicket: [UCHAR; 8], -- ExceptionCode: NTSTATUS, -- ActivationContextStackPointer: PACTIVATION_CONTEXT_STACK, -- InstrumentationCallbackSp: ULONG_PTR, -- InstrumentationCallbackPreviousPc: ULONG_PTR, -- InstrumentationCallbackPreviousSp: ULONG_PTR, -- InstrumentationCallbackDisabled: BOOLEAN, -- SpareBytes: [UCHAR; 23], -- TxFsContext: ULONG, -- GdiTebBatch: GDI_TEB_BATCH, -- RealClientId: CLIENT_ID, -- GdiCachedProcessHandle: HANDLE, -- GdiClientPID: ULONG, -- GdiClientTID: ULONG, -- GdiThreadLocalInfo: PVOID, -- Win32ClientInfo: [ULONG_PTR; 62], -- glDispatchTable: [PVOID; 233], -- glReserved1: [ULONG_PTR; 29], -- glReserved2: PVOID, -- glSectionInfo: PVOID, -- glSection: PVOID, -- glTable: PVOID, -- glCurrentRC: PVOID, -- glContext: PVOID, -- LastStatusValue: NTSTATUS, -- StaticUnicodeString: UNICODE_STRING, -- StaticUnicodeBuffer: [WCHAR; 261], -- DeallocationStack: PVOID, -- TlsSlots: [PVOID; 64], -- TlsLinks: LIST_ENTRY, -- Vdm: PVOID, -- ReservedForNtRpc: PVOID, -- DbgSsReserved: [PVOID; 2], -- HardErrorMode: ULONG, -- Instrumentation: [PVOID; 9], -- ActivityId: GUID, -- SubProcessTag: PVOID, -- PerflibData: PVOID, -- EtwTraceData: PVOID, -- WinSockData: PVOID, -- GdiBatchCount: ULONG, -- u: TEB_u, -- GuaranteedStackBytes: ULONG, -- ReservedForPerf: PVOID, -- ReservedForOle: PVOID, -- WaitingOnLoaderLock: ULONG, -- SavedPriorityState: PVOID, -- ReservedForCodeCoverage: ULONG_PTR, -- ThreadPoolData: PVOID, -- TlsExpansionSlots: *mut PVOID, -- MuiGeneration: ULONG, -- IsImpersonating: ULONG, -- NlsCache: PVOID, -- pShimData: PVOID, -- HeapVirtualAffinity: USHORT, -- LowFragHeapDataSlot: USHORT, -- CurrentTransactionHandle: HANDLE, -- ActiveFrame: PTEB_ACTIVE_FRAME, -- FlsData: PVOID, -- PreferredLanguages: PVOID, -- UserPrefLanguages: PVOID, -- MergedPrefLanguages: PVOID, -- MuiImpersonation: ULONG, -- CrossTebFlags: USHORT, -- SameTebFlags: USHORT, -- TxnScopeEnterCallback: PVOID, -- TxnScopeExitCallback: PVOID, -- TxnScopeContext: PVOID, -- LockCount: ULONG, -- WowTebOffset: LONG, -- ResourceRetValue: PVOID, -- ReservedForWdf: PVOID, -- ReservedForCrt: ULONGLONG, -- EffectiveContainerId: GUID, --}} --BITFIELD!{TEB SameTebFlags: USHORT [ -- SafeThunkCall set_SafeThunkCall[0..1], -- InDebugPrint set_InDebugPrint[1..2], -- HasFiberData set_HasFiberData[2..3], -- SkipThreadAttach set_SkipThreadAttach[3..4], -- WerInShipAssertCode set_WerInShipAssertCode[4..5], -- RanProcessInit set_RanProcessInit[5..6], -- ClonedThread set_ClonedThread[6..7], -- SuppressDebugMsg set_SuppressDebugMsg[7..8], -- DisableUserStackWalk set_DisableUserStackWalk[8..9], -- RtlExceptionAttached set_RtlExceptionAttached[9..10], -- InitialThread set_InitialThread[10..11], -- SessionAware set_SessionAware[11..12], -- LoadOwner set_LoadOwner[12..13], -- LoaderWorker set_LoaderWorker[13..14], -- SkipLoaderInit set_SkipLoaderInit[14..15], -- SpareSameTebBits set_SpareSameTebBits[15..16], --]} --pub type PTEB = *mut TEB; -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntpfapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntpfapi.rs -deleted file mode 100644 -index d6323611..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntpfapi.rs -+++ /dev/null -@@ -1,219 +0,0 @@ --use crate::ntexapi::SYSTEM_MEMORY_LIST_INFORMATION; --use crate::ntmmapi::MMPFN_IDENTITY; --use winapi::shared::basetsd::{SIZE_T, ULONG_PTR}; --use winapi::shared::ntdef::{CHAR, LONGLONG, PVOID, ULONG, ULONGLONG, WCHAR}; --ENUM!{enum PF_BOOT_PHASE_ID { -- PfKernelInitPhase = 0, -- PfBootDriverInitPhase = 90, -- PfSystemDriverInitPhase = 120, -- PfSessionManagerInitPhase = 150, -- PfSMRegistryInitPhase = 180, -- PfVideoInitPhase = 210, -- PfPostVideoInitPhase = 240, -- PfBootAcceptedRegistryInitPhase = 270, -- PfUserShellReadyPhase = 300, -- PfMaxBootPhaseId = 900, --}} --ENUM!{enum PF_ENABLE_STATUS { -- PfSvNotSpecified = 0, -- PfSvEnabled = 1, -- PfSvDisabled = 2, -- PfSvMaxEnableStatus = 3, --}} --STRUCT!{struct PF_TRACE_LIMITS { -- MaxNumPages: ULONG, -- MaxNumSections: ULONG, -- TimerPeriod: LONGLONG, --}} --pub type PPF_TRACE_LIMITS = *mut PF_TRACE_LIMITS; --STRUCT!{struct PF_SYSTEM_PREFETCH_PARAMETERS { -- EnableStatus: [PF_ENABLE_STATUS; 2], -- TraceLimits: [PF_TRACE_LIMITS; 2], -- MaxNumActiveTraces: ULONG, -- MaxNumSavedTraces: ULONG, -- RootDirPath: [WCHAR; 32], -- HostingApplicationList: [WCHAR; 128], --}} --pub type PPF_SYSTEM_PREFETCH_PARAMETERS = *mut PF_SYSTEM_PREFETCH_PARAMETERS; --pub const PF_BOOT_CONTROL_VERSION: u32 = 1; --STRUCT!{struct PF_BOOT_CONTROL { -- Version: ULONG, -- DisableBootPrefetching: ULONG, --}} --pub type PPF_BOOT_CONTROL = *mut PF_BOOT_CONTROL; --ENUM!{enum PREFETCHER_INFORMATION_CLASS { -- PrefetcherRetrieveTrace = 1, -- PrefetcherSystemParameters = 2, -- PrefetcherBootPhase = 3, -- PrefetcherRetrieveBootLoaderTrace = 4, -- PrefetcherBootControl = 5, --}} --pub const PREFETCHER_INFORMATION_VERSION: ULONG = 23; --pub const PREFETCHER_INFORMATION_MAGIC: ULONG = 0x6b756843; --STRUCT!{struct PREFETCHER_INFORMATION { -- Version: ULONG, -- Magic: ULONG, -- PrefetcherInformationClass: PREFETCHER_INFORMATION_CLASS, -- PrefetcherInformation: PVOID, -- PrefetcherInformationLength: ULONG, --}} --pub type PPREFETCHER_INFORMATION = *mut PREFETCHER_INFORMATION; --STRUCT!{struct PF_SYSTEM_SUPERFETCH_PARAMETERS { -- EnabledComponents: ULONG, -- BootID: ULONG, -- SavedSectInfoTracesMax: ULONG, -- SavedPageAccessTracesMax: ULONG, -- ScenarioPrefetchTimeoutStandby: ULONG, -- ScenarioPrefetchTimeoutHibernate: ULONG, --}} --pub type PPF_SYSTEM_SUPERFETCH_PARAMETERS = *mut PF_SYSTEM_SUPERFETCH_PARAMETERS; --pub const PF_PFN_PRIO_REQUEST_VERSION: u32 = 1; --pub const PF_PFN_PRIO_REQUEST_QUERY_MEMORY_LIST: u32 = 0x1; --pub const PF_PFN_PRIO_REQUEST_VALID_FLAGS: u32 = 0x1; --STRUCT!{struct PF_PFN_PRIO_REQUEST { -- Version: ULONG, -- RequestFlags: ULONG, -- PfnCount: ULONG_PTR, -- MemInfo: SYSTEM_MEMORY_LIST_INFORMATION, -- PageData: [MMPFN_IDENTITY; 256], --}} --pub type PPF_PFN_PRIO_REQUEST = *mut PF_PFN_PRIO_REQUEST; --ENUM!{enum PFS_PRIVATE_PAGE_SOURCE_TYPE { -- PfsPrivateSourceKernel = 0, -- PfsPrivateSourceSession = 1, -- PfsPrivateSourceProcess = 2, -- PfsPrivateSourceMax = 3, --}} --UNION!{union PFS_PRIVATE_PAGE_SOURCE_u { -- SessionId: ULONG, -- ProcessId: ULONG, --}} --STRUCT!{struct PFS_PRIVATE_PAGE_SOURCE { -- Type: PFS_PRIVATE_PAGE_SOURCE_TYPE, -- u: PFS_PRIVATE_PAGE_SOURCE_u, -- ImagePathHash: ULONG, -- UniqueProcessHash: ULONG_PTR, --}} --UNION!{union PF_PRIVSOURCE_INFO_u { -- WsSwapPages: ULONG_PTR, -- SessionPagedPoolPages: ULONG_PTR, -- StoreSizePages: ULONG_PTR, --}} --pub type PPFS_PRIVATE_PAGE_SOURCE = *mut PFS_PRIVATE_PAGE_SOURCE; --STRUCT!{struct PF_PRIVSOURCE_INFO { -- DbInfo: PFS_PRIVATE_PAGE_SOURCE, -- EProcess: PVOID, -- WsPrivatePages: SIZE_T, -- TotalPrivatePages: SIZE_T, -- SessionID: ULONG, -- ImageName: [CHAR; 16], -- u: PF_PRIVSOURCE_INFO_u, -- WsTotalPages: ULONG_PTR, -- DeepFreezeTimeMs: ULONG, -- BitFields: ULONG, --}} --BITFIELD!{PF_PRIVSOURCE_INFO BitFields: ULONG [ -- ModernApp set_ModernApp[0..1], -- DeepFrozen set_DeepFrozen[1..2], -- Foreground set_Foreground[2..3], -- PerProcessStore set_PerProcessStore[3..4], -- Spare set_Spare[4..32], --]} --pub type PPF_PRIVSOURCE_INFO = *mut PF_PRIVSOURCE_INFO; --pub const PF_PRIVSOURCE_QUERY_REQUEST_VERSION: u32 = 3; --STRUCT!{struct PF_PRIVSOURCE_QUERY_REQUEST { -- Version: ULONG, -- Flags: ULONG, -- InfoCount: ULONG, -- InfoArray: [PF_PRIVSOURCE_INFO; 1], --}} --pub type PPF_PRIVSOURCE_QUERY_REQUEST = *mut PF_PRIVSOURCE_QUERY_REQUEST; --ENUM!{enum PF_PHASED_SCENARIO_TYPE { -- PfScenarioTypeNone = 0, -- PfScenarioTypeStandby = 1, -- PfScenarioTypeHibernate = 2, -- PfScenarioTypeFUS = 3, -- PfScenarioTypeMax = 4, --}} --pub const PF_SCENARIO_PHASE_INFO_VERSION: u32 = 4; --STRUCT!{struct PF_SCENARIO_PHASE_INFO { -- Version: ULONG, -- ScenType: PF_PHASED_SCENARIO_TYPE, -- PhaseId: ULONG, -- SequenceNumber: ULONG, -- Flags: ULONG, -- FUSUserId: ULONG, --}} --pub type PPF_SCENARIO_PHASE_INFO = *mut PF_SCENARIO_PHASE_INFO; --STRUCT!{struct PF_MEMORY_LIST_NODE { -- Bitfields: ULONGLONG, -- StandbyLowPageCount: ULONGLONG, -- StandbyMediumPageCount: ULONGLONG, -- StandbyHighPageCount: ULONGLONG, -- FreePageCount: ULONGLONG, -- ModifiedPageCount: ULONGLONG, --}} --BITFIELD!{PF_MEMORY_LIST_NODE Bitfields: ULONGLONG [ -- Node set_Node[0..8], -- Spare set_Spare[8..64], --]} --pub type PPF_MEMORY_LIST_NODE = *mut PF_MEMORY_LIST_NODE; --pub const PF_MEMORY_LIST_INFO_VERSION: u32 = 1; --STRUCT!{struct PF_MEMORY_LIST_INFO { -- Version: ULONG, -- Size: ULONG, -- NodeCount: ULONG, -- Nodes: [PF_MEMORY_LIST_NODE; 1], --}} --pub type PPF_MEMORY_LIST_INFO = *mut PF_MEMORY_LIST_INFO; --STRUCT!{struct PF_PHYSICAL_MEMORY_RANGE { -- BasePfn: ULONG_PTR, -- PageCount: ULONG_PTR, --}} --pub type PPF_PHYSICAL_MEMORY_RANGE = *mut PF_PHYSICAL_MEMORY_RANGE; --pub const PF_PHYSICAL_MEMORY_RANGE_INFO_VERSION: u32 = 1; --STRUCT!{struct PF_PHYSICAL_MEMORY_RANGE_INFO { -- Version: ULONG, -- RangeCount: ULONG, -- Ranges: [PF_PHYSICAL_MEMORY_RANGE; 1], --}} --pub type PPF_PHYSICAL_MEMORY_RANGE_INFO = *mut PF_PHYSICAL_MEMORY_RANGE_INFO; --pub const PF_REPURPOSED_BY_PREFETCH_INFO_VERSION: u32 = 1; --STRUCT!{struct PF_REPURPOSED_BY_PREFETCH_INFO { -- Version: ULONG, -- RepurposedByPrefetch: ULONG, --}} --pub type PPF_REPURPOSED_BY_PREFETCH_INFO = *mut PF_REPURPOSED_BY_PREFETCH_INFO; --ENUM!{enum SUPERFETCH_INFORMATION_CLASS { -- SuperfetchRetrieveTrace = 1, -- SuperfetchSystemParameters = 2, -- SuperfetchLogEvent = 3, -- SuperfetchGenerateTrace = 4, -- SuperfetchPrefetch = 5, -- SuperfetchPfnQuery = 6, -- SuperfetchPfnSetPriority = 7, -- SuperfetchPrivSourceQuery = 8, -- SuperfetchSequenceNumberQuery = 9, -- SuperfetchScenarioPhase = 10, -- SuperfetchWorkerPriority = 11, -- SuperfetchScenarioQuery = 12, -- SuperfetchScenarioPrefetch = 13, -- SuperfetchRobustnessControl = 14, -- SuperfetchTimeControl = 15, -- SuperfetchMemoryListQuery = 16, -- SuperfetchMemoryRangesQuery = 17, -- SuperfetchTracingControl = 18, -- SuperfetchTrimWhileAgingControl = 19, -- SuperfetchRepurposedByPrefetch = 20, -- SuperfetchInformationMax = 21, --}} --pub const SUPERFETCH_INFORMATION_VERSION: ULONG = 45; --pub const SUPERFETCH_INFORMATION_MAGIC: ULONG = 0x6b756843; --STRUCT!{struct SUPERFETCH_INFORMATION { -- Version: ULONG, -- Magic: ULONG, -- InfoClass: SUPERFETCH_INFORMATION_CLASS, -- Data: PVOID, -- Length: ULONG, --}} --pub type PSUPERFETCH_INFORMATION = *mut SUPERFETCH_INFORMATION; -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntpnpapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntpnpapi.rs -deleted file mode 100644 -index 0afc698b..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntpnpapi.rs -+++ /dev/null -@@ -1,118 +0,0 @@ --use winapi::shared::cfg::PNP_VETO_TYPE; --use winapi::shared::guiddef::GUID; --use winapi::shared::ntdef::{HANDLE, NTSTATUS, PULONG, PUNICODE_STRING, PVOID, ULONG, WCHAR}; --ENUM!{enum PLUGPLAY_EVENT_CATEGORY { -- HardwareProfileChangeEvent = 0, -- TargetDeviceChangeEvent = 1, -- DeviceClassChangeEvent = 2, -- CustomDeviceEvent = 3, -- DeviceInstallEvent = 4, -- DeviceArrivalEvent = 5, -- PowerEvent = 6, -- VetoEvent = 7, -- BlockedDriverEvent = 8, -- InvalidIDEvent = 9, -- MaxPlugEventCategory = 10, --}} --pub type PPLUGPLAY_EVENT_CATEGORY = *mut PLUGPLAY_EVENT_CATEGORY; --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_DeviceClass { -- ClassGuid: GUID, -- SymbolicLinkName: [WCHAR; 1], --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_TargetDevice { -- DeviceIds: [WCHAR; 1], --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_InstallDevice { -- DeviceId: [WCHAR; 1], --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_CustomNotification { -- NotificationStructure: PVOID, -- DeviceIds: [WCHAR; 1], --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_ProfileNotification { -- Notification: PVOID, --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_PowerNotification { -- NotificationCode: ULONG, -- NotificationData: ULONG, --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_VetoNotification { -- VetoType: PNP_VETO_TYPE, -- DeviceIdVetoNameBuffer: [WCHAR; 1], --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_BlockedDriverNotification { -- BlockedDriverGuid: GUID, --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_InvalidIDNotification { -- ParentId: [WCHAR; 1], --}} --UNION!{union PLUGPLAY_EVENT_BLOCK_u { -- DeviceClass: PLUGPLAY_EVENT_BLOCK_u_DeviceClass, -- TargetDevice: PLUGPLAY_EVENT_BLOCK_u_TargetDevice, -- InstallDevice: PLUGPLAY_EVENT_BLOCK_u_InstallDevice, -- CustomNotification: PLUGPLAY_EVENT_BLOCK_u_CustomNotification, -- ProfileNotification: PLUGPLAY_EVENT_BLOCK_u_ProfileNotification, -- PowerNotification: PLUGPLAY_EVENT_BLOCK_u_PowerNotification, -- VetoNotification: PLUGPLAY_EVENT_BLOCK_u_VetoNotification, -- BlockedDriverNotification: PLUGPLAY_EVENT_BLOCK_u_BlockedDriverNotification, -- InvalidIDNotification: PLUGPLAY_EVENT_BLOCK_u_InvalidIDNotification, --}} --STRUCT!{struct PLUGPLAY_EVENT_BLOCK { -- EventGuid: GUID, -- EventCategory: PLUGPLAY_EVENT_CATEGORY, -- Result: PULONG, -- Flags: ULONG, -- TotalSize: ULONG, -- DeviceObject: PVOID, -- u: PLUGPLAY_EVENT_BLOCK_u, --}} --pub type PPLUGPLAY_EVENT_BLOCK = *mut PLUGPLAY_EVENT_BLOCK; --ENUM!{enum PLUGPLAY_CONTROL_CLASS { -- PlugPlayControlEnumerateDevice = 0, -- PlugPlayControlRegisterNewDevice = 1, -- PlugPlayControlDeregisterDevice = 2, -- PlugPlayControlInitializeDevice = 3, -- PlugPlayControlStartDevice = 4, -- PlugPlayControlUnlockDevice = 5, -- PlugPlayControlQueryAndRemoveDevice = 6, -- PlugPlayControlUserResponse = 7, -- PlugPlayControlGenerateLegacyDevice = 8, -- PlugPlayControlGetInterfaceDeviceList = 9, -- PlugPlayControlProperty = 10, -- PlugPlayControlDeviceClassAssociation = 11, -- PlugPlayControlGetRelatedDevice = 12, -- PlugPlayControlGetInterfaceDeviceAlias = 13, -- PlugPlayControlDeviceStatus = 14, -- PlugPlayControlGetDeviceDepth = 15, -- PlugPlayControlQueryDeviceRelations = 16, -- PlugPlayControlTargetDeviceRelation = 17, -- PlugPlayControlQueryConflictList = 18, -- PlugPlayControlRetrieveDock = 19, -- PlugPlayControlResetDevice = 20, -- PlugPlayControlHaltDevice = 21, -- PlugPlayControlGetBlockedDriverList = 22, -- PlugPlayControlGetDeviceInterfaceEnabled = 23, -- MaxPlugPlayControl = 24, --}} --pub type PPLUGPLAY_CONTROL_CLASS = *mut PLUGPLAY_CONTROL_CLASS; --EXTERN!{extern "system" { -- fn NtGetPlugPlayEvent( -- EventHandle: HANDLE, -- Context: PVOID, -- EventBlock: PPLUGPLAY_EVENT_BLOCK, -- EventBufferSize: ULONG, -- ) -> NTSTATUS; -- fn NtPlugPlayControl( -- PnPControlClass: PLUGPLAY_CONTROL_CLASS, -- PnPControlData: PVOID, -- PnPControlDataLength: ULONG, -- ) -> NTSTATUS; -- fn NtSerializeBoot() -> NTSTATUS; -- fn NtEnableLastKnownGood() -> NTSTATUS; -- fn NtDisableLastKnownGood() -> NTSTATUS; -- fn NtReplacePartitionUnit( -- TargetInstancePath: PUNICODE_STRING, -- SpareInstancePath: PUNICODE_STRING, -- Flags: ULONG, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntpoapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntpoapi.rs -deleted file mode 100644 -index ecc68fc8..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntpoapi.rs -+++ /dev/null -@@ -1,134 +0,0 @@ --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, LONG, NTSTATUS, PLONG, PUNICODE_STRING, PVOID, UCHAR, ULONG, UNICODE_STRING, -- USHORT, --}; --use winapi::um::winnt::{ -- DEVICE_POWER_STATE, EXECUTION_STATE, LATENCY_TIME, PDEVICE_POWER_STATE, PEXECUTION_STATE, -- POWER_ACTION, POWER_INFORMATION_LEVEL, SYSTEM_POWER_STATE, --}; --UNION!{union POWER_STATE { -- SystemState: SYSTEM_POWER_STATE, -- DeviceState: DEVICE_POWER_STATE, --}} --pub type PPOWER_STATE = *mut POWER_STATE; --ENUM!{enum POWER_STATE_TYPE { -- SystemPowerState = 0, -- DevicePowerState = 1, --}} --pub type PPOWER_STATE_TYPE = *mut POWER_STATE_TYPE; --STRUCT!{struct SYSTEM_POWER_STATE_CONTEXT { -- ContextAsUlong: ULONG, --}} --BITFIELD!{SYSTEM_POWER_STATE_CONTEXT ContextAsUlong: ULONG [ -- Reserved1 set_Reserved1[0..8], -- TargetSystemState set_TargetSystemState[8..12], -- EffectiveSystemState set_EffectiveSystemState[12..16], -- CurrentSystemState set_CurrentSystemState[16..20], -- IgnoreHibernationPath set_IgnoreHibernationPath[20..21], -- PseudoTransition set_PseudoTransition[21..22], -- Reserved2 set_Reserved2[22..32], --]} --pub type PSYSTEM_POWER_STATE_CONTEXT = *mut SYSTEM_POWER_STATE_CONTEXT; --STRUCT!{struct COUNTED_REASON_CONTEXT_u_s { -- ResourceFileName: UNICODE_STRING, -- ResourceReasonId: USHORT, -- StringCount: ULONG, -- ReasonStrings: PUNICODE_STRING, --}} --UNION!{union COUNTED_REASON_CONTEXT_u { -- s: COUNTED_REASON_CONTEXT_u_s, -- SimpleString: UNICODE_STRING, --}} --STRUCT!{struct COUNTED_REASON_CONTEXT { -- Version: ULONG, -- Flags: ULONG, -- u: COUNTED_REASON_CONTEXT_u, --}} --pub type PCOUNTED_REASON_CONTEXT = *mut COUNTED_REASON_CONTEXT; --ENUM!{enum POWER_STATE_HANDLER_TYPE { -- PowerStateSleeping1 = 0, -- PowerStateSleeping2 = 1, -- PowerStateSleeping3 = 2, -- PowerStateSleeping4 = 3, -- PowerStateShutdownOff = 4, -- PowerStateShutdownReset = 5, -- PowerStateSleeping4Firmware = 6, -- PowerStateMaximum = 7, --}} --pub type PPOWER_STATE_HANDLER_TYPE = *mut POWER_STATE_HANDLER_TYPE; --FN!{stdcall PENTER_STATE_SYSTEM_HANDLER( -- SystemContext: PVOID, --) -> NTSTATUS} --FN!{stdcall PENTER_STATE_HANDLER( -- Context: PVOID, -- SystemHandler: PENTER_STATE_SYSTEM_HANDLER, -- SystemContext: PVOID, -- NumberProcessors: LONG, -- Number: PLONG, --) -> NTSTATUS} --STRUCT!{struct POWER_STATE_HANDLER { -- Type: POWER_STATE_HANDLER_TYPE, -- RtcWake: BOOLEAN, -- Spare: [UCHAR; 3], -- Handler: PENTER_STATE_HANDLER, -- Context: PVOID, --}} --pub type PPOWER_STATE_HANDLER = *mut POWER_STATE_HANDLER; --FN!{stdcall PENTER_STATE_NOTIFY_HANDLER( -- State: POWER_STATE_HANDLER_TYPE, -- Context: PVOID, -- Entering: BOOLEAN, --) -> NTSTATUS} --STRUCT!{struct POWER_STATE_NOTIFY_HANDLER { -- Handler: PENTER_STATE_NOTIFY_HANDLER, -- Context: PVOID, --}} --pub type PPOWER_STATE_NOTIFY_HANDLER = *mut POWER_STATE_NOTIFY_HANDLER; --STRUCT!{struct PROCESSOR_POWER_INFORMATION { -- Number: ULONG, -- MaxMhz: ULONG, -- CurrentMhz: ULONG, -- MhzLimit: ULONG, -- MaxIdleState: ULONG, -- CurrentIdleState: ULONG, --}} --pub type PPROCESSOR_POWER_INFORMATION = *mut PROCESSOR_POWER_INFORMATION; --STRUCT!{struct SYSTEM_POWER_INFORMATION { -- MaxIdlenessAllowed: ULONG, -- Idleness: ULONG, -- TimeRemaining: ULONG, -- CoolingMode: UCHAR, --}} --pub type PSYSTEM_POWER_INFORMATION = *mut SYSTEM_POWER_INFORMATION; --EXTERN!{extern "system" { -- fn NtPowerInformation( -- InformationLevel: POWER_INFORMATION_LEVEL, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- OutputBuffer: PVOID, -- OutputBufferLength: ULONG, -- ) -> NTSTATUS; -- fn NtSetThreadExecutionState( -- NewFlags: EXECUTION_STATE, -- PreviousFlags: PEXECUTION_STATE, -- ) -> NTSTATUS; -- fn NtRequestWakeupLatency( -- latency: LATENCY_TIME, -- ) -> NTSTATUS; -- fn NtInitiatePowerAction( -- SystemAction: POWER_ACTION, -- LightestSystemState: SYSTEM_POWER_STATE, -- Flags: ULONG, -- Asynchronous: BOOLEAN, -- ) -> NTSTATUS; -- fn NtSetSystemPowerState( -- SystemAction: POWER_ACTION, -- LightestSystemState: SYSTEM_POWER_STATE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtGetDevicePowerState( -- Device: HANDLE, -- State: PDEVICE_POWER_STATE, -- ) -> NTSTATUS; -- fn NtIsSystemResumeAutomatic() -> BOOLEAN; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntpsapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntpsapi.rs -deleted file mode 100644 -index b2ba28af..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntpsapi.rs -+++ /dev/null -@@ -1,1471 +0,0 @@ --use crate::ntapi_base::{CLIENT_ID, KPRIORITY, PCLIENT_ID}; --use crate::ntexapi::{PROCESS_DISK_COUNTERS, PROCESS_ENERGY_VALUES}; --use crate::ntpebteb::{PPEB, PTEB}; --use winapi::ctypes::c_void; --use winapi::shared::basetsd::{PSIZE_T, SIZE_T, ULONG64, ULONG_PTR}; --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, LARGE_INTEGER, LIST_ENTRY, LONG, LONGLONG, NTSTATUS, NT_PRODUCT_TYPE, -- PHANDLE, PLARGE_INTEGER, POBJECT_ATTRIBUTES, PROCESSOR_NUMBER, PSINGLE_LIST_ENTRY, PULONG, -- PVOID, SINGLE_LIST_ENTRY, UCHAR, ULONG, ULONGLONG, UNICODE_STRING, USHORT, WCHAR, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, CONTEXT, HARDWARE_COUNTER_TYPE, IO_COUNTERS, JOBOBJECTINFOCLASS, -- JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, LDT_ENTRY, MAX_HW_COUNTERS, PCONTEXT, PJOB_SET_ARRAY, -- PROCESS_MITIGATION_ASLR_POLICY, PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY, -- PROCESS_MITIGATION_CHILD_PROCESS_POLICY, PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY, -- PROCESS_MITIGATION_DYNAMIC_CODE_POLICY, PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, -- PROCESS_MITIGATION_FONT_DISABLE_POLICY, PROCESS_MITIGATION_IMAGE_LOAD_POLICY, -- PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY, PROCESS_MITIGATION_POLICY, -- PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, -- PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY, PSECURITY_QUALITY_OF_SERVICE, --}; --#[cfg(all(feature = "beta", not(target_arch = "aarch64")))] --use crate::winapi_local::um::winnt::NtCurrentTeb; --pub const GDI_HANDLE_BUFFER_SIZE32: usize = 34; --pub const GDI_HANDLE_BUFFER_SIZE64: usize = 60; --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --pub const GDI_HANDLE_BUFFER_SIZE: usize = GDI_HANDLE_BUFFER_SIZE64; --#[cfg(target_arch = "x86")] --pub const GDI_HANDLE_BUFFER_SIZE: usize = GDI_HANDLE_BUFFER_SIZE32; --pub type GDI_HANDLE_BUFFER = [ULONG; GDI_HANDLE_BUFFER_SIZE]; --pub type GDI_HANDLE_BUFFER32 = [ULONG; GDI_HANDLE_BUFFER_SIZE32]; --pub type GDI_HANDLE_BUFFER64 = [ULONG; GDI_HANDLE_BUFFER_SIZE]; --pub const TLS_EXPANSION_SLOTS: usize = 1024; --STRUCT!{struct PEB_LDR_DATA { -- Length: ULONG, -- Initialized: BOOLEAN, -- SsHandle: HANDLE, -- InLoadOrderModuleList: LIST_ENTRY, -- InMemoryOrderModuleList: LIST_ENTRY, -- InInitializationOrderModuleList: LIST_ENTRY, -- EntryInProgress: PVOID, -- ShutdownInProgress: BOOLEAN, -- ShutdownThreadId: HANDLE, --}} --pub type PPEB_LDR_DATA = *mut PEB_LDR_DATA; --STRUCT!{struct INITIAL_TEB_OldInitialTeb { -- OldStackBase: PVOID, -- OldStackLimit: PVOID, --}} --STRUCT!{struct INITIAL_TEB { -- OldInitialTeb: INITIAL_TEB_OldInitialTeb, -- StackBase: PVOID, -- StackLimit: PVOID, -- StackAllocationBase: PVOID, --}} --pub type PINITIAL_TEB = *mut INITIAL_TEB; --STRUCT!{struct WOW64_PROCESS { -- Wow64: PVOID, --}} --pub type PWOW64_PROCESS = *mut WOW64_PROCESS; --ENUM!{enum PROCESSINFOCLASS { -- ProcessBasicInformation = 0, -- ProcessQuotaLimits = 1, -- ProcessIoCounters = 2, -- ProcessVmCounters = 3, -- ProcessTimes = 4, -- ProcessBasePriority = 5, -- ProcessRaisePriority = 6, -- ProcessDebugPort = 7, -- ProcessExceptionPort = 8, -- ProcessAccessToken = 9, -- ProcessLdtInformation = 10, -- ProcessLdtSize = 11, -- ProcessDefaultHardErrorMode = 12, -- ProcessIoPortHandlers = 13, -- ProcessPooledUsageAndLimits = 14, -- ProcessWorkingSetWatch = 15, -- ProcessUserModeIOPL = 16, -- ProcessEnableAlignmentFaultFixup = 17, -- ProcessPriorityClass = 18, -- ProcessWx86Information = 19, -- ProcessHandleCount = 20, -- ProcessAffinityMask = 21, -- ProcessPriorityBoost = 22, -- ProcessDeviceMap = 23, -- ProcessSessionInformation = 24, -- ProcessForegroundInformation = 25, -- ProcessWow64Information = 26, -- ProcessImageFileName = 27, -- ProcessLUIDDeviceMapsEnabled = 28, -- ProcessBreakOnTermination = 29, -- ProcessDebugObjectHandle = 30, -- ProcessDebugFlags = 31, -- ProcessHandleTracing = 32, -- ProcessIoPriority = 33, -- ProcessExecuteFlags = 34, -- ProcessResourceManagement = 35, -- ProcessCookie = 36, -- ProcessImageInformation = 37, -- ProcessCycleTime = 38, -- ProcessPagePriority = 39, -- ProcessInstrumentationCallback = 40, -- ProcessThreadStackAllocation = 41, -- ProcessWorkingSetWatchEx = 42, -- ProcessImageFileNameWin32 = 43, -- ProcessImageFileMapping = 44, -- ProcessAffinityUpdateMode = 45, -- ProcessMemoryAllocationMode = 46, -- ProcessGroupInformation = 47, -- ProcessTokenVirtualizationEnabled = 48, -- ProcessConsoleHostProcess = 49, -- ProcessWindowInformation = 50, -- ProcessHandleInformation = 51, -- ProcessMitigationPolicy = 52, -- ProcessDynamicFunctionTableInformation = 53, -- ProcessHandleCheckingMode = 54, -- ProcessKeepAliveCount = 55, -- ProcessRevokeFileHandles = 56, -- ProcessWorkingSetControl = 57, -- ProcessHandleTable = 58, -- ProcessCheckStackExtentsMode = 59, -- ProcessCommandLineInformation = 60, -- ProcessProtectionInformation = 61, -- ProcessMemoryExhaustion = 62, -- ProcessFaultInformation = 63, -- ProcessTelemetryIdInformation = 64, -- ProcessCommitReleaseInformation = 65, -- ProcessDefaultCpuSetsInformation = 66, -- ProcessAllowedCpuSetsInformation = 67, -- ProcessSubsystemProcess = 68, -- ProcessJobMemoryInformation = 69, -- ProcessInPrivate = 70, -- ProcessRaiseUMExceptionOnInvalidHandleClose = 71, -- ProcessIumChallengeResponse = 72, -- ProcessChildProcessInformation = 73, -- ProcessHighGraphicsPriorityInformation = 74, -- ProcessSubsystemInformation = 75, -- ProcessEnergyValues = 76, -- ProcessActivityThrottleState = 77, -- ProcessActivityThrottlePolicy = 78, -- ProcessWin32kSyscallFilterInformation = 79, -- ProcessDisableSystemAllowedCpuSets = 80, -- ProcessWakeInformation = 81, -- ProcessEnergyTrackingState = 82, -- ProcessManageWritesToExecutableMemory = 83, -- ProcessCaptureTrustletLiveDump = 84, -- ProcessTelemetryCoverage = 85, -- ProcessEnclaveInformation = 86, -- ProcessEnableReadWriteVmLogging = 87, -- ProcessUptimeInformation = 88, -- ProcessImageSection = 89, -- ProcessDebugAuthInformation = 90, -- ProcessSystemResourceManagement = 91, -- ProcessSequenceNumber = 92, -- ProcessLoaderDetour = 93, -- ProcessSecurityDomainInformation = 94, -- ProcessCombineSecurityDomainsInformation = 95, -- ProcessEnableLogging = 96, -- ProcessLeapSecondInformation = 97, -- MaxProcessInfoClass = 98, --}} --ENUM!{enum THREADINFOCLASS { -- ThreadBasicInformation = 0, -- ThreadTimes = 1, -- ThreadPriority = 2, -- ThreadBasePriority = 3, -- ThreadAffinityMask = 4, -- ThreadImpersonationToken = 5, -- ThreadDescriptorTableEntry = 6, -- ThreadEnableAlignmentFaultFixup = 7, -- ThreadEventPair = 8, -- ThreadQuerySetWin32StartAddress = 9, -- ThreadZeroTlsCell = 10, -- ThreadPerformanceCount = 11, -- ThreadAmILastThread = 12, -- ThreadIdealProcessor = 13, -- ThreadPriorityBoost = 14, -- ThreadSetTlsArrayAddress = 15, -- ThreadIsIoPending = 16, -- ThreadHideFromDebugger = 17, -- ThreadBreakOnTermination = 18, -- ThreadSwitchLegacyState = 19, -- ThreadIsTerminated = 20, -- ThreadLastSystemCall = 21, -- ThreadIoPriority = 22, -- ThreadCycleTime = 23, -- ThreadPagePriority = 24, -- ThreadActualBasePriority = 25, -- ThreadTebInformation = 26, -- ThreadCSwitchMon = 27, -- ThreadCSwitchPmu = 28, -- ThreadWow64Context = 29, -- ThreadGroupInformation = 30, -- ThreadUmsInformation = 31, -- ThreadCounterProfiling = 32, -- ThreadIdealProcessorEx = 33, -- ThreadCpuAccountingInformation = 34, -- ThreadSuspendCount = 35, -- ThreadHeterogeneousCpuPolicy = 36, -- ThreadContainerId = 37, -- ThreadNameInformation = 38, -- ThreadSelectedCpuSets = 39, -- ThreadSystemThreadInformation = 40, -- ThreadActualGroupAffinity = 41, -- ThreadDynamicCodePolicyInfo = 42, -- ThreadExplicitCaseSensitivity = 43, -- ThreadWorkOnBehalfTicket = 44, -- ThreadSubsystemInformation = 45, -- ThreadDbgkWerReportActive = 46, -- ThreadAttachContainer = 47, -- ThreadManageWritesToExecutableMemory = 48, -- ThreadPowerThrottlingState = 49, -- ThreadWorkloadClass = 50, -- MaxThreadInfoClass = 51, --}} --STRUCT!{struct PAGE_PRIORITY_INFORMATION { -- PagePriority: ULONG, --}} --pub type PPAGE_PRIORITY_INFORMATION = *mut PAGE_PRIORITY_INFORMATION; --STRUCT!{struct PROCESS_BASIC_INFORMATION { -- ExitStatus: NTSTATUS, -- PebBaseAddress: PPEB, -- AffinityMask: ULONG_PTR, -- BasePriority: KPRIORITY, -- UniqueProcessId: HANDLE, -- InheritedFromUniqueProcessId: HANDLE, --}} --pub type PPROCESS_BASIC_INFORMATION = *mut PROCESS_BASIC_INFORMATION; --STRUCT!{struct PROCESS_EXTENDED_BASIC_INFORMATION { -- Size: SIZE_T, -- BasicInfo: PROCESS_BASIC_INFORMATION, -- Flags: ULONG, --}} --BITFIELD!{PROCESS_EXTENDED_BASIC_INFORMATION Flags: ULONG [ -- IsProtectedProcess set_IsProtectedProcess[0..1], -- IsWow64Process set_IsWow64Process[1..2], -- IsProcessDeleting set_IsProcessDeleting[2..3], -- IsCrossSessionCreate set_IsCrossSessionCreate[3..4], -- IsFrozen set_IsFrozen[4..5], -- IsBackground set_IsBackground[5..6], -- IsStronglyNamed set_IsStronglyNamed[6..7], -- IsSecureProcess set_IsSecureProcess[7..8], -- IsSubsystemProcess set_IsSubsystemProcess[8..9], -- SpareBits set_SpareBits[9..32], --]} --pub type PPROCESS_EXTENDED_BASIC_INFORMATION = *mut PROCESS_EXTENDED_BASIC_INFORMATION; --STRUCT!{struct VM_COUNTERS { -- PeakVirtualSize: SIZE_T, -- VirtualSize: SIZE_T, -- PageFaultCount: ULONG, -- PeakWorkingSetSize: SIZE_T, -- WorkingSetSize: SIZE_T, -- QuotaPeakPagedPoolUsage: SIZE_T, -- QuotaPagedPoolUsage: SIZE_T, -- QuotaPeakNonPagedPoolUsage: SIZE_T, -- QuotaNonPagedPoolUsage: SIZE_T, -- PagefileUsage: SIZE_T, -- PeakPagefileUsage: SIZE_T, --}} --pub type PVM_COUNTERS = *mut VM_COUNTERS; --STRUCT!{struct VM_COUNTERS_EX { -- PeakVirtualSize: SIZE_T, -- VirtualSize: SIZE_T, -- PageFaultCount: ULONG, -- PeakWorkingSetSize: SIZE_T, -- WorkingSetSize: SIZE_T, -- QuotaPeakPagedPoolUsage: SIZE_T, -- QuotaPagedPoolUsage: SIZE_T, -- QuotaPeakNonPagedPoolUsage: SIZE_T, -- QuotaNonPagedPoolUsage: SIZE_T, -- PagefileUsage: SIZE_T, -- PeakPagefileUsage: SIZE_T, -- PrivateUsage: SIZE_T, --}} --pub type PVM_COUNTERS_EX = *mut VM_COUNTERS_EX; --STRUCT!{struct VM_COUNTERS_EX2 { -- CountersEx: VM_COUNTERS_EX, -- PrivateWorkingSetSize: SIZE_T, -- SharedCommitUsage: SIZE_T, --}} --pub type PVM_COUNTERS_EX2 = *mut VM_COUNTERS_EX2; --STRUCT!{struct KERNEL_USER_TIMES { -- CreateTime: LARGE_INTEGER, -- ExitTime: LARGE_INTEGER, -- KernelTime: LARGE_INTEGER, -- UserTime: LARGE_INTEGER, --}} --pub type PKERNEL_USER_TIMES = *mut KERNEL_USER_TIMES; --STRUCT!{struct POOLED_USAGE_AND_LIMITS { -- PeakPagedPoolUsage: SIZE_T, -- PagedPoolUsage: SIZE_T, -- PagedPoolLimit: SIZE_T, -- PeakNonPagedPoolUsage: SIZE_T, -- NonPagedPoolUsage: SIZE_T, -- NonPagedPoolLimit: SIZE_T, -- PeakPagefileUsage: SIZE_T, -- PagefileUsage: SIZE_T, -- PagefileLimit: SIZE_T, --}} --pub type PPOOLED_USAGE_AND_LIMITS = *mut POOLED_USAGE_AND_LIMITS; --pub const PROCESS_EXCEPTION_PORT_ALL_STATE_BITS: ULONG_PTR = 0x00000003; --pub const PROCESS_EXCEPTION_PORT_ALL_STATE_FLAGS: ULONG_PTR = -- (1 << PROCESS_EXCEPTION_PORT_ALL_STATE_BITS) - 1; --STRUCT!{struct PROCESS_EXCEPTION_PORT { -- ExceptionPortHandle: HANDLE, -- StateFlags: ULONG, --}} --pub type PPROCESS_EXCEPTION_PORT = *mut PROCESS_EXCEPTION_PORT; --STRUCT!{struct PROCESS_ACCESS_TOKEN { -- Token: HANDLE, -- Thread: HANDLE, --}} --pub type PPROCESS_ACCESS_TOKEN = *mut PROCESS_ACCESS_TOKEN; --STRUCT!{struct PROCESS_LDT_INFORMATION { -- Start: ULONG, -- Length: ULONG, -- LdtEntries: [LDT_ENTRY; 1], --}} --pub type PPROCESS_LDT_INFORMATION = *mut PROCESS_LDT_INFORMATION; --STRUCT!{struct PROCESS_LDT_SIZE { -- Length: ULONG, --}} --pub type PPROCESS_LDT_SIZE = *mut PROCESS_LDT_SIZE; --STRUCT!{struct PROCESS_WS_WATCH_INFORMATION { -- FaultingPc: PVOID, -- FaultingVa: PVOID, --}} --pub type PPROCESS_WS_WATCH_INFORMATION = *mut PROCESS_WS_WATCH_INFORMATION; --STRUCT!{struct PROCESS_WS_WATCH_INFORMATION_EX { -- BasicInfo: PROCESS_WS_WATCH_INFORMATION, -- FaultingThreadId: ULONG_PTR, -- Flags: ULONG_PTR, --}} --pub type PPROCESS_WS_WATCH_INFORMATION_EX = *mut PROCESS_WS_WATCH_INFORMATION_EX; --pub const PROCESS_PRIORITY_CLASS_UNKNOWN: u32 = 0; --pub const PROCESS_PRIORITY_CLASS_IDLE: u32 = 1; --pub const PROCESS_PRIORITY_CLASS_NORMAL: u32 = 2; --pub const PROCESS_PRIORITY_CLASS_HIGH: u32 = 3; --pub const PROCESS_PRIORITY_CLASS_REALTIME: u32 = 4; --pub const PROCESS_PRIORITY_CLASS_BELOW_NORMAL: u32 = 5; --pub const PROCESS_PRIORITY_CLASS_ABOVE_NORMAL: u32 = 6; --STRUCT!{struct PROCESS_PRIORITY_CLASS { -- Foreground: BOOLEAN, -- PriorityClass: UCHAR, --}} --pub type PPROCESS_PRIORITY_CLASS = *mut PROCESS_PRIORITY_CLASS; --STRUCT!{struct PROCESS_FOREGROUND_BACKGROUND { -- Foreground: BOOLEAN, --}} --pub type PPROCESS_FOREGROUND_BACKGROUND = *mut PROCESS_FOREGROUND_BACKGROUND; --STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_Set { -- DirectoryHandle: HANDLE, --}} --STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_Query { -- DriveMap: ULONG, -- DriveType: [UCHAR; 32], --}} --UNION!{union PROCESS_DEVICEMAP_INFORMATION { -- Set: PROCESS_DEVICEMAP_INFORMATION_Set, -- Query: PROCESS_DEVICEMAP_INFORMATION_Query, --}} --pub type PPROCESS_DEVICEMAP_INFORMATION = *mut PROCESS_DEVICEMAP_INFORMATION; --pub const PROCESS_LUID_DOSDEVICES_ONLY: ULONG = 0x00000001; --STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_EX_u_Set { -- DirectoryHandle: HANDLE, --}} --STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_EX_u_Query { -- DriveMap: ULONG, -- DriveType: [UCHAR; 32], --}} --UNION!{union PROCESS_DEVICEMAP_INFORMATION_EX_u { -- Set: PROCESS_DEVICEMAP_INFORMATION_EX_u_Set, -- Query: PROCESS_DEVICEMAP_INFORMATION_EX_u_Query, --}} --STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_EX { -- u: PROCESS_DEVICEMAP_INFORMATION_EX_u, -- Flags: ULONG, --}} --pub type PPROCESS_DEVICEMAP_INFORMATION_EX = *mut PROCESS_DEVICEMAP_INFORMATION_EX; --STRUCT!{struct PROCESS_SESSION_INFORMATION { -- SessionId: ULONG, --}} --pub type PPROCESS_SESSION_INFORMATION = *mut PROCESS_SESSION_INFORMATION; --pub const PROCESS_HANDLE_EXCEPTIONS_ENABLED: ULONG = 0x00000001; --pub const PROCESS_HANDLE_RAISE_EXCEPTION_ON_INVALID_HANDLE_CLOSE_DISABLED: ULONG = 0x00000000; --pub const PROCESS_HANDLE_RAISE_EXCEPTION_ON_INVALID_HANDLE_CLOSE_ENABLED: ULONG = 0x00000001; --STRUCT!{struct PROCESS_HANDLE_TRACING_ENABLE { -- Flags: ULONG, --}} --pub type PPROCESS_HANDLE_TRACING_ENABLE = *mut PROCESS_HANDLE_TRACING_ENABLE; --pub const PROCESS_HANDLE_TRACING_MAX_SLOTS: ULONG = 0x20000; --STRUCT!{struct PROCESS_HANDLE_TRACING_ENABLE_EX { -- Flags: ULONG, -- TotalSlots: ULONG, --}} --pub type PPROCESS_HANDLE_TRACING_ENABLE_EX = *mut PROCESS_HANDLE_TRACING_ENABLE_EX; --pub const PROCESS_HANDLE_TRACING_MAX_STACKS: usize = 16; --pub const PROCESS_HANDLE_TRACE_TYPE_OPEN: ULONG = 1; --pub const PROCESS_HANDLE_TRACE_TYPE_CLOSE: ULONG = 2; --pub const PROCESS_HANDLE_TRACE_TYPE_BADREF: ULONG = 3; --STRUCT!{struct PROCESS_HANDLE_TRACING_ENTRY { -- Handle: HANDLE, -- ClientId: CLIENT_ID, -- Type: ULONG, -- Stacks: [PVOID; PROCESS_HANDLE_TRACING_MAX_STACKS], --}} --pub type PPROCESS_HANDLE_TRACING_ENTRY = *mut PROCESS_HANDLE_TRACING_ENTRY; --STRUCT!{struct PROCESS_HANDLE_TRACING_QUERY { -- Handle: HANDLE, -- TotalTraces: ULONG, -- HandleTrace: [PROCESS_HANDLE_TRACING_ENTRY; 1], --}} --pub type PPROCESS_HANDLE_TRACING_QUERY = *mut PROCESS_HANDLE_TRACING_QUERY; --STRUCT!{struct THREAD_TLS_INFORMATION { -- Flags: ULONG, -- NewTlsData: PVOID, -- OldTlsData: PVOID, -- ThreadId: HANDLE, --}} --pub type PTHREAD_TLS_INFORMATION = *mut THREAD_TLS_INFORMATION; --ENUM!{enum PROCESS_TLS_INFORMATION_TYPE { -- ProcessTlsReplaceIndex = 0, -- ProcessTlsReplaceVector = 1, -- MaxProcessTlsOperation = 2, --}} --pub type PPROCESS_TLS_INFORMATION_TYPE = *mut PROCESS_TLS_INFORMATION_TYPE; --STRUCT!{struct PROCESS_TLS_INFORMATION { -- Flags: ULONG, -- OperationType: ULONG, -- ThreadDataCount: ULONG, -- TlsIndex: ULONG, -- PreviousCount: ULONG, -- ThreadData: [THREAD_TLS_INFORMATION; 1], --}} --pub type PPROCESS_TLS_INFORMATION = *mut PROCESS_TLS_INFORMATION; --STRUCT!{struct PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION { -- Version: ULONG, -- Reserved: ULONG, -- Callback: PVOID, --}} --pub type PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION = -- *mut PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION; --STRUCT!{struct PROCESS_STACK_ALLOCATION_INFORMATION { -- ReserveSize: SIZE_T, -- ZeroBits: SIZE_T, -- StackBase: PVOID, --}} --pub type PPROCESS_STACK_ALLOCATION_INFORMATION = *mut PROCESS_STACK_ALLOCATION_INFORMATION; --STRUCT!{struct PROCESS_STACK_ALLOCATION_INFORMATION_EX { -- PreferredNode: ULONG, -- Reserved0: ULONG, -- Reserved1: ULONG, -- Reserved2: ULONG, -- AllocInfo: PROCESS_STACK_ALLOCATION_INFORMATION, --}} --pub type PPROCESS_STACK_ALLOCATION_INFORMATION_EX = *mut PROCESS_STACK_ALLOCATION_INFORMATION_EX; --STRUCT!{struct PROCESS_AFFINITY_UPDATE_MODE { -- Flags: ULONG, --}} --BITFIELD!{PROCESS_AFFINITY_UPDATE_MODE Flags: ULONG [ -- EnableAutoUpdate set_EnableAutoUpdate[0..1], -- Permanent set_Permanent[1..2], -- Reserved set_Reserved[2..32], --]} --pub type PPROCESS_AFFINITY_UPDATE_MODE = *mut PROCESS_AFFINITY_UPDATE_MODE; --STRUCT!{struct PROCESS_MEMORY_ALLOCATION_MODE { -- Flags: ULONG, --}} --BITFIELD!{PROCESS_MEMORY_ALLOCATION_MODE Flags: ULONG [ -- TopDown set_TopDown[0..1], -- Reserved set_Reserved[1..32], --]} --pub type PPROCESS_MEMORY_ALLOCATION_MODE = *mut PROCESS_MEMORY_ALLOCATION_MODE; --STRUCT!{struct PROCESS_HANDLE_INFORMATION { -- HandleCount: ULONG, -- HandleCountHighWatermark: ULONG, --}} --pub type PPROCESS_HANDLE_INFORMATION = *mut PROCESS_HANDLE_INFORMATION; --STRUCT!{struct PROCESS_CYCLE_TIME_INFORMATION { -- AccumulatedCycles: ULONGLONG, -- CurrentCycleCount: ULONGLONG, --}} --pub type PPROCESS_CYCLE_TIME_INFORMATION = *mut PROCESS_CYCLE_TIME_INFORMATION; --STRUCT!{struct PROCESS_WINDOW_INFORMATION { -- WindowFlags: ULONG, -- WindowTitleLength: USHORT, -- WindowTitle: [WCHAR; 1], --}} --pub type PPROCESS_WINDOW_INFORMATION = *mut PROCESS_WINDOW_INFORMATION; --STRUCT!{struct PROCESS_HANDLE_TABLE_ENTRY_INFO { -- HandleValue: HANDLE, -- HandleCount: ULONG_PTR, -- PointerCount: ULONG_PTR, -- GrantedAccess: ULONG, -- ObjectTypeIndex: ULONG, -- HandleAttributes: ULONG, -- Reserved: ULONG, --}} --pub type PPROCESS_HANDLE_TABLE_ENTRY_INFO = *mut PROCESS_HANDLE_TABLE_ENTRY_INFO; --STRUCT!{struct PROCESS_HANDLE_SNAPSHOT_INFORMATION { -- NumberOfHandles: ULONG_PTR, -- Reserved: ULONG_PTR, -- Handles: [PROCESS_HANDLE_TABLE_ENTRY_INFO; 1], --}} --pub type PPROCESS_HANDLE_SNAPSHOT_INFORMATION = *mut PROCESS_HANDLE_SNAPSHOT_INFORMATION; --UNION!{union PROCESS_MITIGATION_POLICY_INFORMATION_u { -- ASLRPolicy: PROCESS_MITIGATION_ASLR_POLICY, -- StrictHandleCheckPolicy: PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, -- SystemCallDisablePolicy: PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, -- ExtensionPointDisablePolicy: PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, -- DynamicCodePolicy: PROCESS_MITIGATION_DYNAMIC_CODE_POLICY, -- ControlFlowGuardPolicy: PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY, -- SignaturePolicy: PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY, -- FontDisablePolicy: PROCESS_MITIGATION_FONT_DISABLE_POLICY, -- ImageLoadPolicy: PROCESS_MITIGATION_IMAGE_LOAD_POLICY, -- SystemCallFilterPolicy: PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY, -- PayloadRestrictionPolicy: PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY, -- ChildProcessPolicy: PROCESS_MITIGATION_CHILD_PROCESS_POLICY, -- // SideChannelIsolationPolicy: PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY, //TODO --}} --STRUCT!{struct PROCESS_MITIGATION_POLICY_INFORMATION { -- Policy: PROCESS_MITIGATION_POLICY, -- u: PROCESS_MITIGATION_POLICY_INFORMATION_u, --}} --pub type PPROCESS_MITIGATION_POLICY_INFORMATION = *mut PROCESS_MITIGATION_POLICY_INFORMATION; --STRUCT!{struct PROCESS_KEEPALIVE_COUNT_INFORMATION { -- WakeCount: ULONG, -- NoWakeCount: ULONG, --}} --pub type PPROCESS_KEEPALIVE_COUNT_INFORMATION = *mut PROCESS_KEEPALIVE_COUNT_INFORMATION; --STRUCT!{struct PROCESS_REVOKE_FILE_HANDLES_INFORMATION { -- TargetDevicePath: UNICODE_STRING, --}} --pub type PPROCESS_REVOKE_FILE_HANDLES_INFORMATION = *mut PROCESS_REVOKE_FILE_HANDLES_INFORMATION; --ENUM!{enum PROCESS_WORKING_SET_OPERATION { -- ProcessWorkingSetSwap = 0, -- ProcessWorkingSetEmpty = 1, -- ProcessWorkingSetOperationMax = 2, --}} --STRUCT!{struct PROCESS_WORKING_SET_CONTROL { -- Version: ULONG, -- Operation: PROCESS_WORKING_SET_OPERATION, -- Flags: ULONG, --}} --pub type PPROCESS_WORKING_SET_CONTROL = *mut PROCESS_WORKING_SET_CONTROL; --ENUM!{enum PS_PROTECTED_TYPE { -- PsProtectedTypeNone = 0, -- PsProtectedTypeProtectedLight = 1, -- PsProtectedTypeProtected = 2, -- PsProtectedTypeMax = 3, --}} --ENUM!{enum PS_PROTECTED_SIGNER { -- PsProtectedSignerNone = 0, -- PsProtectedSignerAuthenticode = 1, -- PsProtectedSignerCodeGen = 2, -- PsProtectedSignerAntimalware = 3, -- PsProtectedSignerLsa = 4, -- PsProtectedSignerWindows = 5, -- PsProtectedSignerWinTcb = 6, -- PsProtectedSignerWinSystem = 7, -- PsProtectedSignerApp = 8, -- PsProtectedSignerMax = 9, --}} --pub const PS_PROTECTED_SIGNER_MASK: UCHAR = 0xFF; --pub const PS_PROTECTED_AUDIT_MASK: UCHAR = 0x08; --pub const PS_PROTECTED_TYPE_MASK: UCHAR = 0x07; --#[inline] --pub const fn PsProtectedValue( -- aSigner: PS_PROTECTED_SIGNER, -- aAudit: u8, -- aType: PS_PROTECTED_TYPE, --) -> UCHAR { -- (aSigner as u8 & PS_PROTECTED_SIGNER_MASK) << 4 | (aAudit & PS_PROTECTED_AUDIT_MASK) << 3 -- | (aType as u8 & PS_PROTECTED_TYPE_MASK) --} --#[inline] --pub fn InitializePsProtection( -- aProtectionLevelPtr: &mut PS_PROTECTION, -- aSigner: PS_PROTECTED_SIGNER, -- aAudit: u8, -- aType: PS_PROTECTED_TYPE, --) { -- aProtectionLevelPtr.set_Signer(aSigner as u8); -- aProtectionLevelPtr.set_Audit(aAudit); -- aProtectionLevelPtr.set_Type(aType as u8); --} --STRUCT!{struct PS_PROTECTION { -- Level: UCHAR, --}} --pub type PPS_PROTECTION = *mut PS_PROTECTION; --BITFIELD!{PS_PROTECTION Level: UCHAR [ -- Type set_Type[0..3], -- Audit set_Audit[3..4], -- Signer set_Signer[4..8], --]} --STRUCT!{struct PROCESS_FAULT_INFORMATION { -- FaultFlags: ULONG, -- AdditionalInfo: ULONG, --}} --pub type PPROCESS_FAULT_INFORMATION = *mut PROCESS_FAULT_INFORMATION; --STRUCT!{struct PROCESS_TELEMETRY_ID_INFORMATION { -- HeaderSize: ULONG, -- ProcessId: ULONG, -- ProcessStartKey: ULONGLONG, -- CreateTime: ULONGLONG, -- CreateInterruptTime: ULONGLONG, -- CreateUnbiasedInterruptTime: ULONGLONG, -- ProcessSequenceNumber: ULONGLONG, -- SessionCreateTime: ULONGLONG, -- SessionId: ULONG, -- BootId: ULONG, -- ImageChecksum: ULONG, -- ImageTimeDateStamp: ULONG, -- UserSidOffset: ULONG, -- ImagePathOffset: ULONG, -- PackageNameOffset: ULONG, -- RelativeAppNameOffset: ULONG, -- CommandLineOffset: ULONG, --}} --pub type PPROCESS_TELEMETRY_ID_INFORMATION = *mut PROCESS_TELEMETRY_ID_INFORMATION; --STRUCT!{struct PROCESS_COMMIT_RELEASE_INFORMATION { -- Version: ULONG, -- s: ULONG, -- CommitDebt: SIZE_T, -- CommittedMemResetSize: SIZE_T, -- RepurposedMemResetSize: SIZE_T, --}} --BITFIELD!{PROCESS_COMMIT_RELEASE_INFORMATION s: ULONG [ -- Eligible set_Eligible[0..1], -- ReleaseRepurposedMemResetCommit set_ReleaseRepurposedMemResetCommit[1..2], -- ForceReleaseMemResetCommit set_ForceReleaseMemResetCommit[2..3], -- Spare set_Spare[3..32], --]} --pub type PPROCESS_COMMIT_RELEASE_INFORMATION = *mut PROCESS_COMMIT_RELEASE_INFORMATION; --STRUCT!{struct PROCESS_JOB_MEMORY_INFO { -- SharedCommitUsage: ULONGLONG, -- PrivateCommitUsage: ULONGLONG, -- PeakPrivateCommitUsage: ULONGLONG, -- PrivateCommitLimit: ULONGLONG, -- TotalCommitLimit: ULONGLONG, --}} --pub type PPROCESS_JOB_MEMORY_INFO = *mut PROCESS_JOB_MEMORY_INFO; --STRUCT!{struct PROCESS_CHILD_PROCESS_INFORMATION { -- ProhibitChildProcesses: BOOLEAN, -- AlwaysAllowSecureChildProcess: BOOLEAN, -- AuditProhibitChildProcesses: BOOLEAN, --}} --pub type PPROCESS_CHILD_PROCESS_INFORMATION = *mut PROCESS_CHILD_PROCESS_INFORMATION; --STRUCT!{struct PROCESS_WAKE_INFORMATION { -- NotificationChannel: ULONGLONG, -- WakeCounters: [ULONG; 7], -- WakeFilter: *mut JOBOBJECT_WAKE_FILTER, --}} --pub type PPROCESS_WAKE_INFORMATION = *mut PROCESS_WAKE_INFORMATION; --STRUCT!{struct PROCESS_ENERGY_TRACKING_STATE { -- StateUpdateMask: ULONG, -- StateDesiredValue: ULONG, -- StateSequence: ULONG, -- UpdateTag: ULONG, -- Tag: [WCHAR; 64], --}} --pub type PPROCESS_ENERGY_TRACKING_STATE = *mut PROCESS_ENERGY_TRACKING_STATE; --BITFIELD!{PROCESS_ENERGY_TRACKING_STATE UpdateTag: ULONG [ -- UpdateTag set_UpdateTag[0..1], --]} --STRUCT!{struct MANAGE_WRITES_TO_EXECUTABLE_MEMORY { -- BitFields: ULONG, --}} --BITFIELD!{MANAGE_WRITES_TO_EXECUTABLE_MEMORY BitFields: ULONG [ -- Machine set_Machine[0..16], -- KernelMode set_KernelMode[16..17], -- UserMode set_UserMode[17..18], -- Native set_Native[18..19], -- Process set_Process[19..20], -- ReservedZero0 set_ReservedZero0[20..32], --]} --pub type PMANAGE_WRITES_TO_EXECUTABLE_MEMORY = *mut MANAGE_WRITES_TO_EXECUTABLE_MEMORY; --pub const PROCESS_READWRITEVM_LOGGING_ENABLE_READVM: UCHAR = 1; --pub const PROCESS_READWRITEVM_LOGGING_ENABLE_WRITEVM: UCHAR = 2; --pub const PROCESS_READWRITEVM_LOGGING_ENABLE_READVM_V: UCHAR = 1; --pub const PROCESS_READWRITEVM_LOGGING_ENABLE_WRITEVM_V: UCHAR = 2; --STRUCT!{struct PROCESS_READWRITEVM_LOGGING_INFORMATION { -- Flags: UCHAR, --}} --BITFIELD!{PROCESS_READWRITEVM_LOGGING_INFORMATION Flags: UCHAR [ -- EnableReadVmLogging set_EnableReadVmLogging[0..1], -- EnableWriteVmLogging set_EnableWriteVmLogging[1..2], -- Unused set_Unused[2..8], --]} --UNION!{union PROCESS_UPTIME_INFORMATION_u { -- HangCount: ULONG, -- GhostCount: ULONG, -- Crashed: ULONG, -- Terminated: ULONG, --}} --pub type PPROCESS_READWRITEVM_LOGGING_INFORMATION = *mut PROCESS_READWRITEVM_LOGGING_INFORMATION; --STRUCT!{struct PROCESS_UPTIME_INFORMATION { -- QueryInterruptTime: ULONGLONG, -- QueryUnbiasedTime: ULONGLONG, -- EndInterruptTime: ULONGLONG, -- TimeSinceCreation: ULONGLONG, -- Uptime: ULONGLONG, -- SuspendedTime: ULONGLONG, -- u: PROCESS_UPTIME_INFORMATION_u, --}} --pub type PPROCESS_UPTIME_INFORMATION = *mut PROCESS_UPTIME_INFORMATION; --STRUCT!{struct PROCESS_SYSTEM_RESOURCE_MANAGEMENT { -- Flags: ULONG, --}} --pub type PPROCESS_SYSTEM_RESOURCE_MANAGEMENT = *mut PROCESS_SYSTEM_RESOURCE_MANAGEMENT; --BITFIELD!{PROCESS_SYSTEM_RESOURCE_MANAGEMENT Flags: ULONG [ -- Foreground set_Foreground[0..1], -- Reserved set_Reserved[1..32], --]} --STRUCT!{struct PROCESS_SECURITY_DOMAIN_INFORMATION { -- SecurityDomain: ULONGLONG, --}} --pub type PPROCESS_SECURITY_DOMAIN_INFORMATION = *mut PROCESS_SECURITY_DOMAIN_INFORMATION; --STRUCT!{struct PROCESS_COMBINE_SECURITY_DOMAINS_INFORMATION { -- ProcessHandle: HANDLE, --}} --pub type PPROCESS_COMBINE_SECURITY_DOMAINS_INFORMATION = -- *mut PROCESS_COMBINE_SECURITY_DOMAINS_INFORMATION; --STRUCT!{struct PROCESS_LOGGING_INFORMATION { -- Flags: ULONG, -- BitFields: ULONG, --}} --BITFIELD!{PROCESS_LOGGING_INFORMATION BitFields: ULONG [ -- EnableReadVmLogging set_EnableReadVmLogging[0..1], -- EnableWriteVmLogging set_EnableWriteVmLogging[1..2], -- EnableProcessSuspendResumeLogging set_EnableProcessSuspendResumeLogging[2..3], -- EnableThreadSuspendResumeLogging set_EnableThreadSuspendResumeLogging[3..4], -- Reserved set_Reserved[4..32], --]} --pub type PPROCESS_LOGGING_INFORMATION = *mut PROCESS_LOGGING_INFORMATION; --STRUCT!{struct PROCESS_LEAP_SECOND_INFORMATION { -- Flags: ULONG, -- Reserved: ULONG, --}} --pub type PPROCESS_LEAP_SECOND_INFORMATION = *mut PROCESS_LEAP_SECOND_INFORMATION; --STRUCT!{struct THREAD_BASIC_INFORMATION { -- ExitStatus: NTSTATUS, -- TebBaseAddress: PTEB, -- ClientId: CLIENT_ID, -- AffinityMask: ULONG_PTR, -- Priority: KPRIORITY, -- BasePriority: LONG, --}} --pub type PTHREAD_BASIC_INFORMATION = *mut THREAD_BASIC_INFORMATION; --STRUCT!{struct THREAD_LAST_SYSCALL_INFORMATION { -- FirstArgument: PVOID, -- SystemCallNumber: USHORT, -- Pad: [USHORT; 1], -- WaitTime: ULONG64, --}} --pub type PTHREAD_LAST_SYSCALL_INFORMATION = *mut THREAD_LAST_SYSCALL_INFORMATION; --STRUCT!{struct THREAD_CYCLE_TIME_INFORMATION { -- AccumulatedCycles: ULONGLONG, -- CurrentCycleCount: ULONGLONG, --}} --pub type PTHREAD_CYCLE_TIME_INFORMATION = *mut THREAD_CYCLE_TIME_INFORMATION; --STRUCT!{struct THREAD_TEB_INFORMATION { -- TebInformation: PVOID, -- TebOffset: ULONG, -- BytesToRead: ULONG, --}} --pub type PTHREAD_TEB_INFORMATION = *mut THREAD_TEB_INFORMATION; --STRUCT!{struct COUNTER_READING { -- Type: HARDWARE_COUNTER_TYPE, -- Index: ULONG, -- Start: ULONG64, -- Total: ULONG64, --}} --pub type PCOUNTER_READING = *mut COUNTER_READING; --STRUCT!{struct THREAD_PERFORMANCE_DATA { -- Size: USHORT, -- Version: USHORT, -- ProcessorNumber: PROCESSOR_NUMBER, -- ContextSwitches: ULONG, -- HwCountersCount: ULONG, -- UpdateCount: ULONG64, -- WaitReasonBitMap: ULONG64, -- HardwareCounters: ULONG64, -- CycleTime: COUNTER_READING, -- HwCounters: [COUNTER_READING; MAX_HW_COUNTERS], --}} --pub type PTHREAD_PERFORMANCE_DATA = *mut THREAD_PERFORMANCE_DATA; --STRUCT!{struct THREAD_PROFILING_INFORMATION { -- HardwareCounters: ULONG64, -- Flags: ULONG, -- Enable: ULONG, -- PerformanceData: PTHREAD_PERFORMANCE_DATA, --}} --pub type PTHREAD_PROFILING_INFORMATION = *mut THREAD_PROFILING_INFORMATION; --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --STRUCT!{#[repr(align(16))] struct RTL_UMS_CONTEXT { -- Link: SINGLE_LIST_ENTRY, -- __padding: u64, -- Context: CONTEXT, -- Teb: PVOID, -- UserContext: PVOID, -- ScheduledThread: ULONG, -- Suspended: ULONG, -- VolatileContext: ULONG, -- Terminated: ULONG, -- DebugActive: ULONG, -- RunningOnSelfThread: ULONG, -- DenyRunningOnSelfThread: ULONG, -- Flags: LONG, -- KernelUpdateLock: ULONG64, -- PrimaryClientID: ULONG64, -- ContextLock: ULONG64, -- PrimaryUmsContext: *mut RTL_UMS_CONTEXT, -- SwitchCount: ULONG, -- KernelYieldCount: ULONG, -- MixedYieldCount: ULONG, -- YieldCount: ULONG, --}} --#[cfg(target_arch = "x86")] --STRUCT!{struct RTL_UMS_CONTEXT { -- Link: SINGLE_LIST_ENTRY, -- Context: CONTEXT, -- Teb: PVOID, -- UserContext: PVOID, -- ScheduledThread: ULONG, -- Suspended: ULONG, -- VolatileContext: ULONG, -- Terminated: ULONG, -- DebugActive: ULONG, -- RunningOnSelfThread: ULONG, -- DenyRunningOnSelfThread: ULONG, -- Flags: LONG, -- KernelUpdateLock: ULONG64, -- PrimaryClientID: ULONG64, -- ContextLock: ULONG64, -- PrimaryUmsContext: *mut RTL_UMS_CONTEXT, -- SwitchCount: ULONG, -- KernelYieldCount: ULONG, -- MixedYieldCount: ULONG, -- YieldCount: ULONG, -- __padding: u32, --}} --pub type PRTL_UMS_CONTEXT = *mut RTL_UMS_CONTEXT; --ENUM!{enum THREAD_UMS_INFORMATION_COMMAND { -- UmsInformationCommandInvalid = 0, -- UmsInformationCommandAttach = 1, -- UmsInformationCommandDetach = 2, -- UmsInformationCommandQuery = 3, --}} --STRUCT!{struct RTL_UMS_COMPLETION_LIST { -- ThreadListHead: PSINGLE_LIST_ENTRY, -- CompletionEvent: PVOID, -- CompletionFlags: ULONG, -- InternalListHead: SINGLE_LIST_ENTRY, --}} --pub type PRTL_UMS_COMPLETION_LIST = *mut RTL_UMS_COMPLETION_LIST; --STRUCT!{struct THREAD_UMS_INFORMATION { -- Command: THREAD_UMS_INFORMATION_COMMAND, -- CompletionList: PRTL_UMS_COMPLETION_LIST, -- UmsContext: PRTL_UMS_CONTEXT, -- Flags: ULONG, --}} --BITFIELD!{THREAD_UMS_INFORMATION Flags: ULONG [ -- IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1], -- IsUmsWorkerThread set_IsUmsWorkerThread[1..2], -- SpareBits set_SpareBits[2..32], --]} --pub type PTHREAD_UMS_INFORMATION = *mut THREAD_UMS_INFORMATION; --STRUCT!{struct THREAD_NAME_INFORMATION { -- ThreadName: UNICODE_STRING, --}} --pub type PTHREAD_NAME_INFORMATION = *mut THREAD_NAME_INFORMATION; --ENUM!{enum SUBSYSTEM_INFORMATION_TYPE { -- SubsystemInformationTypeWin32 = 0, -- SubsystemInformationTypeWSL = 1, -- MaxSubsystemInformationType = 2, --}} --ENUM!{enum THREAD_WORKLOAD_CLASS { -- ThreadWorkloadClassDefault = 0, -- ThreadWorkloadClassGraphics = 1, -- MaxThreadWorkloadClass = 2, --}} --EXTERN!{extern "system" { -- fn NtCreateProcess( -- ProcessHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ParentProcess: HANDLE, -- InheritObjectTable: BOOLEAN, -- SectionHandle: HANDLE, -- DebugPort: HANDLE, -- ExceptionPort: HANDLE, -- ) -> NTSTATUS; --}} --pub const PROCESS_CREATE_FLAGS_BREAKAWAY: ULONG = 0x00000001; --pub const PROCESS_CREATE_FLAGS_NO_DEBUG_INHERIT: ULONG = 0x00000002; --pub const PROCESS_CREATE_FLAGS_INHERIT_HANDLES: ULONG = 0x00000004; --pub const PROCESS_CREATE_FLAGS_OVERRIDE_ADDRESS_SPACE: ULONG = 0x00000008; --pub const PROCESS_CREATE_FLAGS_LARGE_PAGES: ULONG = 0x00000010; --EXTERN!{extern "system" { -- fn NtCreateProcessEx( -- ProcessHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ParentProcess: HANDLE, -- Flags: ULONG, -- SectionHandle: HANDLE, -- DebugPort: HANDLE, -- ExceptionPort: HANDLE, -- JobMemberLevel: ULONG, -- ) -> NTSTATUS; -- fn NtOpenProcess( -- ProcessHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ClientId: PCLIENT_ID, -- ) -> NTSTATUS; -- fn NtTerminateProcess( -- ProcessHandle: HANDLE, -- ExitStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn NtSuspendProcess( -- ProcessHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtResumeProcess( -- ProcessHandle: HANDLE, -- ) -> NTSTATUS; --}} --pub const NtCurrentProcess: HANDLE = -1isize as *mut c_void; --pub const ZwCurrentProcess: HANDLE = NtCurrentProcess; --pub const NtCurrentThread: HANDLE = -2isize as *mut c_void; --pub const ZwCurrentThread: HANDLE = NtCurrentThread; --pub const NtCurrentSession: HANDLE = -3isize as *mut c_void; --pub const ZwCurrentSession: HANDLE = NtCurrentSession; --#[inline] #[cfg(all(feature = "beta", not(target_arch = "aarch64")))] --pub unsafe fn NtCurrentPeb() -> PPEB { -- (*NtCurrentTeb()).ProcessEnvironmentBlock --} --pub const NtCurrentProcessToken: HANDLE = -4isize as *mut c_void; --pub const NtCurrentThreadToken: HANDLE = -5isize as *mut c_void; --pub const NtCurrentEffectiveToken: HANDLE = -6isize as *mut c_void; --pub const NtCurrentSilo: HANDLE = -1isize as *mut c_void; --#[inline] #[cfg(all(feature = "beta", not(target_arch = "aarch64")))] --pub unsafe fn NtCurrentProcessId() -> HANDLE { -- (*NtCurrentTeb()).ClientId.UniqueProcess --} --#[inline] #[cfg(all(feature = "beta", not(target_arch = "aarch64")))] --pub unsafe fn NtCurrentThreadId() -> HANDLE { -- (*NtCurrentTeb()).ClientId.UniqueThread --} --EXTERN!{extern "system" { -- fn NtQueryInformationProcess( -- ProcessHandle: HANDLE, -- ProcessInformationClass: PROCESSINFOCLASS, -- ProcessInformation: PVOID, -- ProcessInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtGetNextProcess( -- ProcessHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- HandleAttributes: ULONG, -- Flags: ULONG, -- NewProcessHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtGetNextThread( -- ProcessHandle: HANDLE, -- ThreadHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- HandleAttributes: ULONG, -- Flags: ULONG, -- NewThreadHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtSetInformationProcess( -- ProcessHandle: HANDLE, -- ProcessInformationClass: PROCESSINFOCLASS, -- ProcessInformation: PVOID, -- ProcessInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtQueryPortInformationProcess() -> NTSTATUS; -- fn NtCreateThread( -- ThreadHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ProcessHandle: HANDLE, -- ClientId: PCLIENT_ID, -- ThreadContext: PCONTEXT, -- InitialTeb: PINITIAL_TEB, -- CreateSuspended: BOOLEAN, -- ) -> NTSTATUS; -- fn NtOpenThread( -- ThreadHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ClientId: PCLIENT_ID, -- ) -> NTSTATUS; -- fn NtTerminateThread( -- ThreadHandle: HANDLE, -- ExitStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn NtSuspendThread( -- ThreadHandle: HANDLE, -- PreviousSuspendCount: PULONG, -- ) -> NTSTATUS; -- fn NtResumeThread( -- ThreadHandle: HANDLE, -- PreviousSuspendCount: PULONG, -- ) -> NTSTATUS; -- fn NtGetCurrentProcessorNumber() -> ULONG; -- fn NtGetContextThread( -- ThreadHandle: HANDLE, -- ThreadContext: PCONTEXT, -- ) -> NTSTATUS; -- fn NtSetContextThread( -- ThreadHandle: HANDLE, -- ThreadContext: PCONTEXT, -- ) -> NTSTATUS; -- fn NtQueryInformationThread( -- ThreadHandle: HANDLE, -- ThreadInformationClass: THREADINFOCLASS, -- ThreadInformation: PVOID, -- ThreadInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationThread( -- ThreadHandle: HANDLE, -- ThreadInformationClass: THREADINFOCLASS, -- ThreadInformation: PVOID, -- ThreadInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtAlertThread( -- ThreadHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtAlertResumeThread( -- ThreadHandle: HANDLE, -- PreviousSuspendCount: PULONG, -- ) -> NTSTATUS; -- fn NtTestAlert() -> NTSTATUS; -- fn NtImpersonateThread( -- ServerThreadHandle: HANDLE, -- ClientThreadHandle: HANDLE, -- SecurityQos: PSECURITY_QUALITY_OF_SERVICE, -- ) -> NTSTATUS; -- fn NtRegisterThreadTerminatePort( -- PortHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtSetLdtEntries( -- Selector0: ULONG, -- Entry0Low: ULONG, -- Entry0Hi: ULONG, -- Selector1: ULONG, -- Entry1Low: ULONG, -- Entry1Hi: ULONG, -- ) -> NTSTATUS; --}} --FN!{cdecl PPS_APC_ROUTINE( -- ApcArgument1: PVOID, -- ApcArgument2: PVOID, -- ApcArgument3: PVOID, --) -> ()} --EXTERN!{extern "system" { -- fn NtQueueApcThread( -- ThreadHandle: HANDLE, -- ApcRoutine: PPS_APC_ROUTINE, -- ApcArgument1: PVOID, -- ApcArgument2: PVOID, -- ApcArgument3: PVOID, -- ) -> NTSTATUS; --}} --pub const APC_FORCE_THREAD_SIGNAL: HANDLE = 1 as *mut c_void; --EXTERN!{extern "system" { -- fn NtQueueApcThreadEx( -- ThreadHandle: HANDLE, -- UserApcReserveHandle: HANDLE, -- ApcRoutine: PPS_APC_ROUTINE, -- ApcArgument1: PVOID, -- ApcArgument2: PVOID, -- ApcArgument3: PVOID, -- ) -> NTSTATUS; -- fn NtAlertThreadByThreadId( -- ThreadId: HANDLE, -- ) -> NTSTATUS; -- fn NtWaitForAlertByThreadId( -- Address: PVOID, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; --}} --pub const PS_ATTRIBUTE_NUMBER_MASK: u32 = 0x0000ffff; --pub const PS_ATTRIBUTE_THREAD: u32 = 0x00010000; --pub const PS_ATTRIBUTE_INPUT: u32 = 0x00020000; --pub const PS_ATTRIBUTE_ADDITIVE: u32 = 0x00040000; --ENUM!{enum PS_ATTRIBUTE_NUM { -- PsAttributeParentProcess = 0, -- PsAttributeDebugPort = 1, -- PsAttributeToken = 2, -- PsAttributeClientId = 3, -- PsAttributeTebAddress = 4, -- PsAttributeImageName = 5, -- PsAttributeImageInfo = 6, -- PsAttributeMemoryReserve = 7, -- PsAttributePriorityClass = 8, -- PsAttributeErrorMode = 9, -- PsAttributeStdHandleInfo = 10, -- PsAttributeHandleList = 11, -- PsAttributeGroupAffinity = 12, -- PsAttributePreferredNode = 13, -- PsAttributeIdealProcessor = 14, -- PsAttributeUmsThread = 15, -- PsAttributeMitigationOptions = 16, -- PsAttributeProtectionLevel = 17, -- PsAttributeSecureProcess = 18, -- PsAttributeJobList = 19, -- PsAttributeChildProcessPolicy = 20, -- PsAttributeAllApplicationPackagesPolicy = 21, -- PsAttributeWin32kFilter = 22, -- PsAttributeSafeOpenPromptOriginClaim = 23, -- PsAttributeBnoIsolation = 24, -- PsAttributeDesktopAppPolicy = 25, -- PsAttributeChpe = 26, -- PsAttributeMax = 27, --}} --#[inline] --pub const fn PsAttributeValue( -- Number: PS_ATTRIBUTE_NUM, -- Thread: bool, -- Input: bool, -- Additive: bool, --) -> ULONG_PTR { //fixme -- (Number & PS_ATTRIBUTE_NUMBER_MASK | [0, PS_ATTRIBUTE_THREAD][Thread as usize] -- | [0, PS_ATTRIBUTE_INPUT][Input as usize] | [0, PS_ATTRIBUTE_ADDITIVE][Additive as usize] -- ) as usize --} --pub const PS_ATTRIBUTE_PARENT_PROCESS: ULONG_PTR = 0x00060000; --pub const PS_ATTRIBUTE_DEBUG_PORT: ULONG_PTR = 0x00060001; --pub const PS_ATTRIBUTE_TOKEN: ULONG_PTR = 0x00060002; --pub const PS_ATTRIBUTE_CLIENT_ID: ULONG_PTR = 0x00010003; --pub const PS_ATTRIBUTE_TEB_ADDRESS: ULONG_PTR = 0x00010004; --pub const PS_ATTRIBUTE_IMAGE_NAME: ULONG_PTR = 0x00020005; --pub const PS_ATTRIBUTE_IMAGE_INFO: ULONG_PTR = 0x00000006; --pub const PS_ATTRIBUTE_MEMORY_RESERVE: ULONG_PTR = 0x00020007; --pub const PS_ATTRIBUTE_PRIORITY_CLASS: ULONG_PTR = 0x00020008; --pub const PS_ATTRIBUTE_ERROR_MODE: ULONG_PTR = 0x00020009; --pub const PS_ATTRIBUTE_STD_HANDLE_INFO: ULONG_PTR = 0x0002000a; --pub const PS_ATTRIBUTE_HANDLE_LIST: ULONG_PTR = 0x0002000b; --pub const PS_ATTRIBUTE_GROUP_AFFINITY: ULONG_PTR = 0x0003000c; --pub const PS_ATTRIBUTE_PREFERRED_NODE: ULONG_PTR = 0x0002000d; --pub const PS_ATTRIBUTE_IDEAL_PROCESSOR: ULONG_PTR = 0x0003000e; --pub const PS_ATTRIBUTE_UMS_THREAD: ULONG_PTR = 0x0003000f; --pub const PS_ATTRIBUTE_MITIGATION_OPTIONS: ULONG_PTR = 0x00060010; --pub const PS_ATTRIBUTE_PROTECTION_LEVEL: ULONG_PTR = 0x00060011; --pub const PS_ATTRIBUTE_SECURE_PROCESS: ULONG_PTR = 0x00020012; --pub const PS_ATTRIBUTE_JOB_LIST: ULONG_PTR = 0x00020013; --pub const PS_ATTRIBUTE_CHILD_PROCESS_POLICY: ULONG_PTR = 0x00020014; --pub const PS_ATTRIBUTE_ALL_APPLICATION_PACKAGES_POLICY: ULONG_PTR = 0x00020015; --pub const PS_ATTRIBUTE_WIN32K_FILTER: ULONG_PTR = 0x00020016; --pub const PS_ATTRIBUTE_SAFE_OPEN_PROMPT_ORIGIN_CLAIM: ULONG_PTR = 0x00020017; --pub const PS_ATTRIBUTE_BNO_ISOLATION: ULONG_PTR = 0x00020018; --pub const PS_ATTRIBUTE_DESKTOP_APP_POLICY: ULONG_PTR = 0x00020019; --UNION!{union PS_ATTRIBUTE_u { -- Value: ULONG_PTR, -- ValuePtr: PVOID, --}} --STRUCT!{struct PS_ATTRIBUTE { -- Attribute: ULONG_PTR, -- Size: SIZE_T, -- u: PS_ATTRIBUTE_u, -- ReturnLength: PSIZE_T, --}} --pub type PPS_ATTRIBUTE = *mut PS_ATTRIBUTE; --STRUCT!{struct PS_ATTRIBUTE_LIST { -- TotalLength: SIZE_T, -- Attributes: [PS_ATTRIBUTE; 1], --}} --pub type PPS_ATTRIBUTE_LIST = *mut PS_ATTRIBUTE_LIST; --STRUCT!{struct PS_MEMORY_RESERVE { -- ReserveAddress: PVOID, -- ReserveSize: SIZE_T, --}} --pub type PPS_MEMORY_RESERVE = *mut PS_MEMORY_RESERVE; --ENUM!{enum PS_STD_HANDLE_STATE { -- PsNeverDuplicate = 0, -- PsRequestDuplicate = 1, -- PsAlwaysDuplicate = 2, -- PsMaxStdHandleStates = 3, --}} --pub const PS_STD_INPUT_HANDLE: u32 = 0x1; --pub const PS_STD_OUTPUT_HANDLE: u32 = 0x2; --pub const PS_STD_ERROR_HANDLE: u32 = 0x4; --STRUCT!{struct PS_STD_HANDLE_INFO { -- Flags: ULONG, -- StdHandleSubsystemType: ULONG, --}} --pub type PPS_STD_HANDLE_INFO = *mut PS_STD_HANDLE_INFO; --BITFIELD!{PS_STD_HANDLE_INFO Flags: ULONG [ -- StdHandleState set_StdHandleState[0..2], -- PseudoHandleMask set_PseudoHandleMask[2..5], --]} --STRUCT!{struct PS_BNO_ISOLATION_PARAMETERS { -- IsolationPrefix: UNICODE_STRING, -- HandleCount: ULONG, -- Handles: *mut PVOID, -- IsolationEnabled: BOOLEAN, --}} --pub type PPS_BNO_ISOLATION_PARAMETERS = *mut PS_BNO_ISOLATION_PARAMETERS; --ENUM!{enum PS_MITIGATION_OPTION { -- PS_MITIGATION_OPTION_NX = 0, -- PS_MITIGATION_OPTION_SEHOP = 1, -- PS_MITIGATION_OPTION_FORCE_RELOCATE_IMAGES = 2, -- PS_MITIGATION_OPTION_HEAP_TERMINATE = 3, -- PS_MITIGATION_OPTION_BOTTOM_UP_ASLR = 4, -- PS_MITIGATION_OPTION_HIGH_ENTROPY_ASLR = 5, -- PS_MITIGATION_OPTION_STRICT_HANDLE_CHECKS = 6, -- PS_MITIGATION_OPTION_WIN32K_SYSTEM_CALL_DISABLE = 7, -- PS_MITIGATION_OPTION_EXTENSION_POINT_DISABLE = 8, -- PS_MITIGATION_OPTION_PROHIBIT_DYNAMIC_CODE = 9, -- PS_MITIGATION_OPTION_CONTROL_FLOW_GUARD = 10, -- PS_MITIGATION_OPTION_BLOCK_NON_MICROSOFT_BINARIES = 11, -- PS_MITIGATION_OPTION_FONT_DISABLE = 12, -- PS_MITIGATION_OPTION_IMAGE_LOAD_NO_REMOTE = 13, -- PS_MITIGATION_OPTION_IMAGE_LOAD_NO_LOW_LABEL = 14, -- PS_MITIGATION_OPTION_IMAGE_LOAD_PREFER_SYSTEM32 = 15, -- PS_MITIGATION_OPTION_RETURN_FLOW_GUARD = 16, -- PS_MITIGATION_OPTION_LOADER_INTEGRITY_CONTINUITY = 17, -- PS_MITIGATION_OPTION_STRICT_CONTROL_FLOW_GUARD = 18, -- PS_MITIGATION_OPTION_RESTRICT_SET_THREAD_CONTEXT = 19, -- PS_MITIGATION_OPTION_ROP_STACKPIVOT = 20, -- PS_MITIGATION_OPTION_ROP_CALLER_CHECK = 21, -- PS_MITIGATION_OPTION_ROP_SIMEXEC = 22, -- PS_MITIGATION_OPTION_EXPORT_ADDRESS_FILTER = 23, -- PS_MITIGATION_OPTION_EXPORT_ADDRESS_FILTER_PLUS = 24, -- PS_MITIGATION_OPTION_RESTRICT_CHILD_PROCESS_CREATION = 25, -- PS_MITIGATION_OPTION_IMPORT_ADDRESS_FILTER = 26, -- PS_MITIGATION_OPTION_MODULE_TAMPERING_PROTECTION = 27, -- PS_MITIGATION_OPTION_RESTRICT_INDIRECT_BRANCH_PREDICTION = 28, -- PS_MITIGATION_OPTION_SPECULATIVE_STORE_BYPASS_DISABLE = 29, -- PS_MITIGATION_OPTION_ALLOW_DOWNGRADE_DYNAMIC_CODE_POLICY = 30, -- PS_MITIGATION_OPTION_CET_SHADOW_STACKS = 31, --}} --ENUM!{enum PS_CREATE_STATE { -- PsCreateInitialState = 0, -- PsCreateFailOnFileOpen = 1, -- PsCreateFailOnSectionCreate = 2, -- PsCreateFailExeFormat = 3, -- PsCreateFailMachineMismatch = 4, -- PsCreateFailExeName = 5, -- PsCreateSuccess = 6, -- PsCreateMaximumStates = 7, --}} --STRUCT!{struct PS_CREATE_INFO_u_InitState { -- InitFlags: ULONG, -- AdditionalFileAccess: ACCESS_MASK, --}} --BITFIELD!{PS_CREATE_INFO_u_InitState InitFlags: ULONG [ -- WriteOutputOnExit set_WriteOutputOnExit[0..1], -- DetectManifest set_DetectManifest[1..2], -- IFEOSkipDebugger set_IFEOSkipDebugger[2..3], -- IFEODoNotPropagateKeyState set_IFEODoNotPropagateKeyState[3..4], -- SpareBits1 set_SpareBits1[4..8], -- SpareBits2 set_SpareBits2[8..16], -- ProhibitedImageCharacteristics set_ProhibitedImageCharacteristics[16..32], --]} --STRUCT!{struct PS_CREATE_INFO_u_SuccessState { -- OutputFlags: ULONG, -- FileHandle: HANDLE, -- SectionHandle: HANDLE, -- UserProcessParametersNative: ULONGLONG, -- UserProcessParametersWow64: ULONG, -- CurrentParameterFlags: ULONG, -- PebAddressNative: ULONGLONG, -- PebAddressWow64: ULONG, -- ManifestAddress: ULONGLONG, -- ManifestSize: ULONG, --}} --BITFIELD!{PS_CREATE_INFO_u_SuccessState OutputFlags: ULONG [ -- ProtectedProcess set_ProtectedProcess[0..1], -- AddressSpaceOverride set_AddressSpaceOverride[1..2], -- DevOverrideEnabled set_DevOverrideEnabled[2..3], -- ManifestDetected set_ManifestDetected[3..4], -- ProtectedProcessLight set_ProtectedProcessLight[4..5], -- SpareBits1 set_SpareBits1[5..8], -- SpareBits2 set_SpareBits2[8..16], -- SpareBits3 set_SpareBits3[16..32], --]} --UNION!{union PS_CREATE_INFO_u { -- InitState: PS_CREATE_INFO_u_InitState, -- FileHandle: HANDLE, -- DllCharacteristics: USHORT, -- IFEOKey: HANDLE, -- SuccessState: PS_CREATE_INFO_u_SuccessState, --}} --STRUCT!{struct PS_CREATE_INFO { -- Size: SIZE_T, -- State: PS_CREATE_STATE, -- u: PS_CREATE_INFO_u, --}} --pub type PPS_CREATE_INFO = *mut PS_CREATE_INFO; --pub const PROCESS_CREATE_FLAGS_LARGE_PAGE_SYSTEM_DLL: ULONG = 0x00000020; --pub const PROCESS_CREATE_FLAGS_PROTECTED_PROCESS: ULONG = 0x00000040; --pub const PROCESS_CREATE_FLAGS_CREATE_SESSION: ULONG = 0x00000080; --pub const PROCESS_CREATE_FLAGS_INHERIT_FROM_PARENT: ULONG = 0x00000100; --pub const PROCESS_CREATE_FLAGS_SUSPENDED: ULONG = 0x00000200; --pub const PROCESS_CREATE_FLAGS_EXTENDED_UNKNOWN: ULONG = 0x00000400; --EXTERN!{extern "system" { -- fn NtCreateUserProcess( -- ProcessHandle: PHANDLE, -- ThreadHandle: PHANDLE, -- ProcessDesiredAccess: ACCESS_MASK, -- ThreadDesiredAccess: ACCESS_MASK, -- ProcessObjectAttributes: POBJECT_ATTRIBUTES, -- ThreadObjectAttributes: POBJECT_ATTRIBUTES, -- ProcessFlags: ULONG, -- ThreadFlags: ULONG, -- ProcessParameters: PVOID, -- CreateInfo: PPS_CREATE_INFO, -- AttributeList: PPS_ATTRIBUTE_LIST, -- ) -> NTSTATUS; --}} --pub const THREAD_CREATE_FLAGS_CREATE_SUSPENDED: ULONG = 0x00000001; --pub const THREAD_CREATE_FLAGS_SKIP_THREAD_ATTACH: ULONG = 0x00000002; --pub const THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER: ULONG = 0x00000004; --pub const THREAD_CREATE_FLAGS_HAS_SECURITY_DESCRIPTOR: ULONG = 0x00000010; --pub const THREAD_CREATE_FLAGS_ACCESS_CHECK_IN_TARGET: ULONG = 0x00000020; --pub const THREAD_CREATE_FLAGS_INITIAL_THREAD: ULONG = 0x00000080; --EXTERN!{extern "system" { -- fn NtCreateThreadEx( -- ThreadHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ProcessHandle: HANDLE, -- StartRoutine: PVOID, -- Argument: PVOID, -- CreateFlags: ULONG, -- ZeroBits: SIZE_T, -- StackSize: SIZE_T, -- MaximumStackSize: SIZE_T, -- AttributeList: PPS_ATTRIBUTE_LIST, -- ) -> NTSTATUS; --}} --STRUCT!{struct JOBOBJECT_EXTENDED_ACCOUNTING_INFORMATION { -- BasicInfo: JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, -- IoInfo: IO_COUNTERS, -- DiskIoInfo: PROCESS_DISK_COUNTERS, -- ContextSwitches: ULONG64, -- TotalCycleTime: LARGE_INTEGER, -- ReadyTime: ULONG64, -- EnergyValues: PROCESS_ENERGY_VALUES, --}} --pub type PJOBOBJECT_EXTENDED_ACCOUNTING_INFORMATION = -- *mut JOBOBJECT_EXTENDED_ACCOUNTING_INFORMATION; --STRUCT!{struct JOBOBJECT_WAKE_INFORMATION { -- NotificationChannel: HANDLE, -- WakeCounters: [ULONG64; 7], --}} --pub type PJOBOBJECT_WAKE_INFORMATION = *mut JOBOBJECT_WAKE_INFORMATION; --STRUCT!{struct JOBOBJECT_WAKE_INFORMATION_V1 { -- NotificationChannel: HANDLE, -- WakeCounters: [ULONG64; 4], --}} --pub type PJOBOBJECT_WAKE_INFORMATION_V1 = *mut JOBOBJECT_WAKE_INFORMATION_V1; --STRUCT!{struct JOBOBJECT_INTERFERENCE_INFORMATION { -- Count: ULONG64, --}} --pub type PJOBOBJECT_INTERFERENCE_INFORMATION = *mut JOBOBJECT_INTERFERENCE_INFORMATION; --STRUCT!{struct JOBOBJECT_WAKE_FILTER { -- HighEdgeFilter: ULONG, -- LowEdgeFilter: ULONG, --}} --pub type PJOBOBJECT_WAKE_FILTER = *mut JOBOBJECT_WAKE_FILTER; --STRUCT!{struct JOBOBJECT_FREEZE_INFORMATION { -- Flags: ULONG, -- Freeze: BOOLEAN, -- Swap: BOOLEAN, -- Reserved0: [UCHAR; 2], -- WakeFilter: JOBOBJECT_WAKE_FILTER, --}} --pub type PJOBOBJECT_FREEZE_INFORMATION = *mut JOBOBJECT_FREEZE_INFORMATION; --BITFIELD!{JOBOBJECT_FREEZE_INFORMATION Flags: ULONG [ -- FreezeOperation set_FreezeOperation[0..1], -- FilterOperation set_FilterOperation[1..2], -- SwapOperation set_SwapOperation[2..3], -- Reserved set_Reserved[3..32], --]} --STRUCT!{struct JOBOBJECT_MEMORY_USAGE_INFORMATION { -- JobMemory: ULONG64, -- PeakJobMemoryUsed: ULONG64, --}} --pub type PJOBOBJECT_MEMORY_USAGE_INFORMATION = *mut JOBOBJECT_MEMORY_USAGE_INFORMATION; --STRUCT!{struct JOBOBJECT_MEMORY_USAGE_INFORMATION_V2 { -- BasicInfo: JOBOBJECT_MEMORY_USAGE_INFORMATION, -- JobSharedMemory: ULONG64, -- Reserved: [ULONG64; 2], --}} --pub type PJOBOBJECT_MEMORY_USAGE_INFORMATION_V2 = *mut JOBOBJECT_MEMORY_USAGE_INFORMATION_V2; --STRUCT!{struct SILO_USER_SHARED_DATA { -- ServiceSessionId: ULONG64, -- ActiveConsoleId: ULONG, -- ConsoleSessionForegroundProcessId: LONGLONG, -- NtProductType: NT_PRODUCT_TYPE, -- SuiteMask: ULONG, -- SharedUserSessionId: ULONG, -- IsMultiSessionSku: BOOLEAN, -- NtSystemRoot: [WCHAR; 260], -- UserModeGlobalLogger: [USHORT; 16], --}} --pub type PSILO_USER_SHARED_DATA = *mut SILO_USER_SHARED_DATA; --STRUCT!{struct SILOOBJECT_ROOT_DIRECTORY { -- ControlFlags: ULONG, -- Path: UNICODE_STRING, --}} --pub type PSILOOBJECT_ROOT_DIRECTORY = *mut SILOOBJECT_ROOT_DIRECTORY; --STRUCT!{struct JOBOBJECT_ENERGY_TRACKING_STATE { -- Value: ULONG64, -- UpdateMask: ULONG, -- DesiredState: ULONG, --}} --pub type PJOBOBJECT_ENERGY_TRACKING_STATE = *mut JOBOBJECT_ENERGY_TRACKING_STATE; --EXTERN!{extern "system" { -- fn NtCreateJobObject( -- JobHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtOpenJobObject( -- JobHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtAssignProcessToJobObject( -- JobHandle: HANDLE, -- ProcessHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtTerminateJobObject( -- JobHandle: HANDLE, -- ExitStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn NtIsProcessInJob( -- ProcessHandle: HANDLE, -- JobHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtQueryInformationJobObject( -- JobHandle: HANDLE, -- JobObjectInformationClass: JOBOBJECTINFOCLASS, -- JobObjectInformation: PVOID, -- JobObjectInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationJobObject( -- JobHandle: HANDLE, -- JobObjectInformationClass: JOBOBJECTINFOCLASS, -- JobObjectInformation: PVOID, -- JobObjectInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtCreateJobSet( -- NumJob: ULONG, -- UserJobSet: PJOB_SET_ARRAY, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtRevertContainerImpersonation() -> NTSTATUS; --}} --ENUM!{enum MEMORY_RESERVE_TYPE { -- MemoryReserveUserApc = 0, -- MemoryReserveIoCompletion = 1, -- MemoryReserveTypeMax = 2, --}} --EXTERN!{extern "system" { -- fn NtAllocateReserveObject( -- MemoryReserveHandle: PHANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Type: MEMORY_RESERVE_TYPE, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntregapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntregapi.rs -deleted file mode 100644 -index ccd79b2b..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntregapi.rs -+++ /dev/null -@@ -1,450 +0,0 @@ --use crate::ntioapi::{PIO_APC_ROUTINE, PIO_STATUS_BLOCK}; --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, LARGE_INTEGER, NTSTATUS, OBJECT_ATTRIBUTES, PHANDLE, POBJECT_ATTRIBUTES, -- PULONG, PUNICODE_STRING, PVOID, UCHAR, ULONG, UNICODE_STRING, USHORT, WCHAR, --}; --use winapi::um::winnt::ACCESS_MASK; --pub const REG_INIT_BOOT_SM: USHORT = 0x0000; --pub const REG_INIT_BOOT_SETUP: USHORT = 0x0001; --pub const REG_INIT_BOOT_ACCEPTED_BASE: USHORT = 0x0002; --pub const REG_INIT_BOOT_ACCEPTED_MAX: USHORT = REG_INIT_BOOT_ACCEPTED_BASE; --pub const REG_MAX_KEY_VALUE_NAME_LENGTH: u32 = 32767; --pub const REG_MAX_KEY_NAME_LENGTH: u32 = 512; --ENUM!{enum KEY_INFORMATION_CLASS { -- KeyBasicInformation = 0, -- KeyNodeInformation = 1, -- KeyFullInformation = 2, -- KeyNameInformation = 3, -- KeyCachedInformation = 4, -- KeyFlagsInformation = 5, -- KeyVirtualizationInformation = 6, -- KeyHandleTagsInformation = 7, -- KeyTrustInformation = 8, -- KeyLayerInformation = 9, -- MaxKeyInfoClass = 10, --}} --STRUCT!{struct KEY_BASIC_INFORMATION { -- LastWriteTime: LARGE_INTEGER, -- TitleIndex: ULONG, -- NameLength: ULONG, -- Name: [WCHAR; 1], --}} --pub type PKEY_BASIC_INFORMATION = *mut KEY_BASIC_INFORMATION; --STRUCT!{struct KEY_NODE_INFORMATION { -- LastWriteTime: LARGE_INTEGER, -- TitleIndex: ULONG, -- ClassOffset: ULONG, -- ClassLength: ULONG, -- NameLength: ULONG, -- Name: [WCHAR; 1], --}} --pub type PKEY_NODE_INFORMATION = *mut KEY_NODE_INFORMATION; --STRUCT!{struct KEY_FULL_INFORMATION { -- LastWriteTime: LARGE_INTEGER, -- TitleIndex: ULONG, -- ClassOffset: ULONG, -- ClassLength: ULONG, -- SubKeys: ULONG, -- MaxNameLen: ULONG, -- MaxClassLen: ULONG, -- Values: ULONG, -- MaxValueNameLen: ULONG, -- MaxValueDataLen: ULONG, -- Class: [WCHAR; 1], --}} --pub type PKEY_FULL_INFORMATION = *mut KEY_FULL_INFORMATION; --STRUCT!{struct KEY_NAME_INFORMATION { -- NameLength: ULONG, -- Name: [WCHAR; 1], --}} --pub type PKEY_NAME_INFORMATION = *mut KEY_NAME_INFORMATION; --STRUCT!{struct KEY_CACHED_INFORMATION { -- LastWriteTime: LARGE_INTEGER, -- TitleIndex: ULONG, -- SubKeys: ULONG, -- MaxNameLen: ULONG, -- Values: ULONG, -- MaxValueNameLen: ULONG, -- MaxValueDataLen: ULONG, -- NameLength: ULONG, -- Name: [WCHAR; 1], --}} --pub type PKEY_CACHED_INFORMATION = *mut KEY_CACHED_INFORMATION; --STRUCT!{struct KEY_FLAGS_INFORMATION { -- UserFlags: ULONG, --}} --pub type PKEY_FLAGS_INFORMATION = *mut KEY_FLAGS_INFORMATION; --STRUCT!{struct KEY_VIRTUALIZATION_INFORMATION { -- Bitfields: ULONG, --}} --BITFIELD!{KEY_VIRTUALIZATION_INFORMATION Bitfields: ULONG [ -- VirtualizationCandidate set_VirtualizationCandidate[0..1], -- VirtualizationEnabled set_VirtualizationEnabled[1..2], -- VirtualTarget set_VirtualTarget[2..3], -- VirtualStore set_VirtualStore[3..4], -- VirtualSource set_VirtualSource[4..5], -- Reserved set_Reserved[5..32], --]} --pub type PKEY_VIRTUALIZATION_INFORMATION = *mut KEY_VIRTUALIZATION_INFORMATION; --STRUCT!{struct KEY_TRUST_INFORMATION { -- Bitfields: ULONG, --}} --BITFIELD!{KEY_TRUST_INFORMATION Bitfields: ULONG [ -- TrustedKey set_TrustedKey[0..1], -- Reserved set_Reserved[1..32], --]} --pub type PKEY_TRUST_INFORMATION = *mut KEY_TRUST_INFORMATION; --STRUCT!{struct KEY_LAYER_INFORMATION { -- IsTombstone: ULONG, -- IsSupersedeLocal: ULONG, -- IsSupersedeTree: ULONG, -- ClassIsInherited: ULONG, -- Reserved: ULONG, --}} --pub type PKEY_LAYER_INFORMATION = *mut KEY_LAYER_INFORMATION; --ENUM!{enum KEY_SET_INFORMATION_CLASS { -- KeyWriteTimeInformation = 0, -- KeyWow64FlagsInformation = 1, -- KeyControlFlagsInformation = 2, -- KeySetVirtualizationInformation = 3, -- KeySetDebugInformation = 4, -- KeySetHandleTagsInformation = 5, -- KeySetLayerInformation = 6, -- MaxKeySetInfoClass = 7, --}} --STRUCT!{struct KEY_WRITE_TIME_INFORMATION { -- LastWriteTime: LARGE_INTEGER, --}} --pub type PKEY_WRITE_TIME_INFORMATION = *mut KEY_WRITE_TIME_INFORMATION; --STRUCT!{struct KEY_WOW64_FLAGS_INFORMATION { -- UserFlags: ULONG, --}} --pub type PKEY_WOW64_FLAGS_INFORMATION = *mut KEY_WOW64_FLAGS_INFORMATION; --STRUCT!{struct KEY_HANDLE_TAGS_INFORMATION { -- HandleTags: ULONG, --}} --pub type PKEY_HANDLE_TAGS_INFORMATION = *mut KEY_HANDLE_TAGS_INFORMATION; --STRUCT!{struct KEY_SET_LAYER_INFORMATION { -- Bitfields: ULONG, --}} --BITFIELD!{KEY_SET_LAYER_INFORMATION Bitfields: ULONG [ -- IsTombstone set_IsTombstone[0..1], -- IsSupersedeLocal set_IsSupersedeLocal[1..2], -- IsSupersedeTree set_IsSupersedeTree[2..3], -- ClassIsInherited set_ClassIsInherited[3..4], -- Reserved set_Reserved[4..32], --]} --pub type PKEY_SET_LAYER_INFORMATION = *mut KEY_SET_LAYER_INFORMATION; --STRUCT!{struct KEY_CONTROL_FLAGS_INFORMATION { -- ControlFlags: ULONG, --}} --pub type PKEY_CONTROL_FLAGS_INFORMATION = *mut KEY_CONTROL_FLAGS_INFORMATION; --STRUCT!{struct KEY_SET_VIRTUALIZATION_INFORMATION { -- HandleTags: ULONG, --}} --BITFIELD!{KEY_SET_VIRTUALIZATION_INFORMATION HandleTags: ULONG [ -- VirtualTarget set_VirtualTarget[0..1], -- VirtualStore set_VirtualStore[1..2], -- VirtualSource set_VirtualSource[2..3], -- Reserved set_Reserved[3..32], --]} --pub type PKEY_SET_VIRTUALIZATION_INFORMATION = *mut KEY_SET_VIRTUALIZATION_INFORMATION; --ENUM!{enum KEY_VALUE_INFORMATION_CLASS { -- KeyValueBasicInformation = 0, -- KeyValueFullInformation = 1, -- KeyValuePartialInformation = 2, -- KeyValueFullInformationAlign64 = 3, -- KeyValuePartialInformationAlign64 = 4, -- KeyValueLayerInformation = 5, -- MaxKeyValueInfoClass = 6, --}} --STRUCT!{struct KEY_VALUE_BASIC_INFORMATION { -- TitleIndex: ULONG, -- Type: ULONG, -- NameLength: ULONG, -- Name: [WCHAR; 1], --}} --pub type PKEY_VALUE_BASIC_INFORMATION = *mut KEY_VALUE_BASIC_INFORMATION; --STRUCT!{struct KEY_VALUE_FULL_INFORMATION { -- TitleIndex: ULONG, -- Type: ULONG, -- DataOffset: ULONG, -- DataLength: ULONG, -- NameLength: ULONG, -- Name: [WCHAR; 1], --}} --pub type PKEY_VALUE_FULL_INFORMATION = *mut KEY_VALUE_FULL_INFORMATION; --STRUCT!{struct KEY_VALUE_PARTIAL_INFORMATION { -- TitleIndex: ULONG, -- Type: ULONG, -- DataLength: ULONG, -- Data: [UCHAR; 1], --}} --pub type PKEY_VALUE_PARTIAL_INFORMATION = *mut KEY_VALUE_PARTIAL_INFORMATION; --STRUCT!{struct KEY_VALUE_PARTIAL_INFORMATION_ALIGN64 { -- Type: ULONG, -- DataLength: ULONG, -- Data: [UCHAR; 1], --}} --pub type PKEY_VALUE_PARTIAL_INFORMATION_ALIGN64 = *mut KEY_VALUE_PARTIAL_INFORMATION_ALIGN64; --STRUCT!{struct KEY_VALUE_LAYER_INFORMATION { -- IsTombstone: ULONG, -- Reserved: ULONG, --}} --pub type PKEY_VALUE_LAYER_INFORMATION = *mut KEY_VALUE_LAYER_INFORMATION; --STRUCT!{struct KEY_VALUE_ENTRY { -- ValueName: PUNICODE_STRING, -- DataLength: ULONG, -- DataOffset: ULONG, -- Type: ULONG, --}} --pub type PKEY_VALUE_ENTRY = *mut KEY_VALUE_ENTRY; --ENUM!{enum REG_ACTION { -- KeyAdded = 0, -- KeyRemoved = 1, -- KeyModified = 2, --}} --STRUCT!{struct REG_NOTIFY_INFORMATION { -- NextEntryOffset: ULONG, -- Action: REG_ACTION, -- KeyLength: ULONG, -- Key: [WCHAR; 1], --}} --pub type PREG_NOTIFY_INFORMATION = *mut REG_NOTIFY_INFORMATION; --STRUCT!{struct KEY_PID_ARRAY { -- PID: HANDLE, -- KeyName: UNICODE_STRING, --}} --pub type PKEY_PID_ARRAY = *mut KEY_PID_ARRAY; --STRUCT!{struct KEY_OPEN_SUBKEYS_INFORMATION { -- Count: ULONG, -- KeyArray: [KEY_PID_ARRAY; 1], --}} --pub type PKEY_OPEN_SUBKEYS_INFORMATION = *mut KEY_OPEN_SUBKEYS_INFORMATION; --EXTERN!{extern "system" { -- fn NtCreateKey( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TitleIndex: ULONG, -- Class: PUNICODE_STRING, -- CreateOptions: ULONG, -- Disposition: PULONG, -- ) -> NTSTATUS; -- fn NtCreateKeyTransacted( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TitleIndex: ULONG, -- Class: PUNICODE_STRING, -- CreateOptions: ULONG, -- TransactionHandle: HANDLE, -- Disposition: PULONG, -- ) -> NTSTATUS; -- fn NtOpenKey( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtOpenKeyTransacted( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TransactionHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtOpenKeyEx( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- OpenOptions: ULONG, -- ) -> NTSTATUS; -- fn NtOpenKeyTransactedEx( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- OpenOptions: ULONG, -- TransactionHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtDeleteKey( -- KeyHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtRenameKey( -- KeyHandle: HANDLE, -- NewName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn NtDeleteValueKey( -- KeyHandle: HANDLE, -- ValueName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn NtQueryKey( -- KeyHandle: HANDLE, -- KeyInformationClass: KEY_INFORMATION_CLASS, -- KeyInformation: PVOID, -- Length: ULONG, -- ResultLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationKey( -- KeyHandle: HANDLE, -- KeySetInformationClass: KEY_SET_INFORMATION_CLASS, -- KeySetInformation: PVOID, -- KeySetInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtQueryValueKey( -- KeyHandle: HANDLE, -- ValueName: PUNICODE_STRING, -- KeyValueInformationClass: KEY_VALUE_INFORMATION_CLASS, -- KeyValueInformation: PVOID, -- Length: ULONG, -- ResultLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetValueKey( -- KeyHandle: HANDLE, -- ValueName: PUNICODE_STRING, -- TitleIndex: ULONG, -- Type: ULONG, -- Data: PVOID, -- DataSize: ULONG, -- ) -> NTSTATUS; -- fn NtQueryMultipleValueKey( -- KeyHandle: HANDLE, -- ValueEntries: PKEY_VALUE_ENTRY, -- EntryCount: ULONG, -- ValueBuffer: PVOID, -- BufferLength: PULONG, -- RequiredBufferLength: PULONG, -- ) -> NTSTATUS; -- fn NtEnumerateKey( -- KeyHandle: HANDLE, -- Index: ULONG, -- KeyInformationClass: KEY_INFORMATION_CLASS, -- KeyInformation: PVOID, -- Length: ULONG, -- ResultLength: PULONG, -- ) -> NTSTATUS; -- fn NtEnumerateValueKey( -- KeyHandle: HANDLE, -- Index: ULONG, -- KeyValueInformationClass: KEY_VALUE_INFORMATION_CLASS, -- KeyValueInformation: PVOID, -- Length: ULONG, -- ResultLength: PULONG, -- ) -> NTSTATUS; -- fn NtFlushKey( -- KeyHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtCompactKeys( -- Count: ULONG, -- KeyArray: *mut HANDLE, -- ) -> NTSTATUS; -- fn NtCompressKey( -- Key: HANDLE, -- ) -> NTSTATUS; -- fn NtLoadKey( -- TargetKey: POBJECT_ATTRIBUTES, -- SourceFile: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtLoadKey2( -- TargetKey: POBJECT_ATTRIBUTES, -- SourceFile: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtLoadKeyEx( -- TargetKey: POBJECT_ATTRIBUTES, -- SourceFile: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- TrustClassKey: HANDLE, -- Event: HANDLE, -- DesiredAccess: ACCESS_MASK, -- RootHandle: PHANDLE, -- IoStatus: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn NtReplaceKey( -- NewFile: POBJECT_ATTRIBUTES, -- TargetHandle: HANDLE, -- OldFile: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtSaveKey( -- KeyHandle: HANDLE, -- FileHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtSaveKeyEx( -- KeyHandle: HANDLE, -- FileHandle: HANDLE, -- Format: ULONG, -- ) -> NTSTATUS; -- fn NtSaveMergedKeys( -- HighPrecedenceKeyHandle: HANDLE, -- LowPrecedenceKeyHandle: HANDLE, -- FileHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtRestoreKey( -- KeyHandle: HANDLE, -- FileHandle: HANDLE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtUnloadKey( -- TargetKey: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; --}} --pub const REG_FORCE_UNLOAD: ULONG = 1; --pub const REG_UNLOAD_LEGAL_FLAGS: ULONG = REG_FORCE_UNLOAD; --EXTERN!{extern "system" { -- fn NtUnloadKey2( -- TargetKey: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn NtUnloadKeyEx( -- TargetKey: POBJECT_ATTRIBUTES, -- Event: HANDLE, -- ) -> NTSTATUS; -- fn NtNotifyChangeKey( -- KeyHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- CompletionFilter: ULONG, -- WatchTree: BOOLEAN, -- Buffer: PVOID, -- BufferSize: ULONG, -- Asynchronous: BOOLEAN, -- ) -> NTSTATUS; -- fn NtNotifyChangeMultipleKeys( -- MasterKeyHandle: HANDLE, -- Count: ULONG, -- SubordinateObjects: *mut OBJECT_ATTRIBUTES, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- CompletionFilter: ULONG, -- WatchTree: BOOLEAN, -- Buffer: PVOID, -- BufferSize: ULONG, -- Asynchronous: BOOLEAN, -- ) -> NTSTATUS; -- fn NtQueryOpenSubKeys( -- TargetKey: POBJECT_ATTRIBUTES, -- HandleCount: PULONG, -- ) -> NTSTATUS; -- fn NtQueryOpenSubKeysEx( -- TargetKey: POBJECT_ATTRIBUTES, -- BufferLength: ULONG, -- Buffer: PVOID, -- RequiredSize: PULONG, -- ) -> NTSTATUS; -- fn NtInitializeRegistry( -- BootCondition: USHORT, -- ) -> NTSTATUS; -- fn NtLockRegistryKey( -- KeyHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtLockProductActivationKeys( -- pPrivateVer: *mut ULONG, -- pSafeMode: *mut ULONG, -- ) -> NTSTATUS; -- fn NtFreezeRegistry( -- TimeOutInSeconds: ULONG, -- ) -> NTSTATUS; -- fn NtThawRegistry() -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntrtl.rs b/KubeOS-Rust/vendor/ntapi/src/ntrtl.rs -deleted file mode 100644 -index 9dfa19f7..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntrtl.rs -+++ /dev/null -@@ -1,4378 +0,0 @@ --use core::ptr::null_mut; --use crate::ntapi_base::{CLIENT_ID, PCLIENT_ID}; --use crate::ntexapi::{RTL_PROCESS_BACKTRACES, RTL_PROCESS_LOCKS}; --use crate::ntioapi::FILE_INFORMATION_CLASS; --use crate::ntldr::{RTL_PROCESS_MODULES, RTL_PROCESS_MODULE_INFORMATION_EX}; --use crate::ntmmapi::SECTION_IMAGE_INFORMATION; --use crate::ntnls::{PCPTABLEINFO, PNLSTABLEINFO}; --use crate::ntpebteb::{PPEB, PTEB_ACTIVE_FRAME}; --use crate::ntpsapi::{PINITIAL_TEB, PPS_APC_ROUTINE, PS_PROTECTION}; --use crate::ntapi_base::{PRTL_ATOM, RTL_ATOM}; --use crate::string::UTF16Const; --use winapi::ctypes::c_void; --use winapi::shared::basetsd::{PULONG64, ULONG32, ULONG64, PSIZE_T, PULONG_PTR, SIZE_T, ULONG_PTR}; --use winapi::shared::guiddef::GUID; --use winapi::shared::in6addr::in6_addr; --use winapi::shared::inaddr::in_addr; --use winapi::shared::minwindef::{BOOL, DWORD, PBOOL}; --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --use winapi::shared::ntdef::{LARGE_INTEGER, RTL_BALANCED_NODE}; --use winapi::shared::ntdef::{ -- BOOLEAN, CCHAR, CHAR, CLONG, CSHORT, HANDLE, LCID, LIST_ENTRY, LOGICAL, LONG, LUID, NTSTATUS, -- PANSI_STRING, PBOOLEAN, PCANSI_STRING, PCCH, PCH, PCHAR, PCOEM_STRING, PCSZ, PCUNICODE_STRING, -- PCWCH, PCWSTR, PHANDLE, PLARGE_INTEGER, PLCID, PLIST_ENTRY, PLONG, PLUID, PNT_PRODUCT_TYPE, -- POEM_STRING, PPROCESSOR_NUMBER, PRTL_BALANCED_NODE, PSINGLE_LIST_ENTRY, PSTR, PSTRING, PUCHAR, -- PULONG, PULONGLONG, PUNICODE_STRING, PUSHORT, PVOID, PWCH, PWCHAR, PWSTR, SINGLE_LIST_ENTRY, -- STRING, UCHAR, ULONG, ULONGLONG, UNICODE_STRING, USHORT, VOID, WCHAR, --}; --use winapi::um::minwinbase::PTHREAD_START_ROUTINE; --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --use winapi::um::winnt::{PGET_RUNTIME_FUNCTION_CALLBACK, PRUNTIME_FUNCTION, PWOW64_CONTEXT}; --use winapi::um::winnt::{ -- ACCESS_MASK, ACL_INFORMATION_CLASS, APC_CALLBACK_FUNCTION, HEAP_INFORMATION_CLASS, -- HEAP_REALLOC_IN_PLACE_ONLY, HEAP_ZERO_MEMORY, OS_DEPLOYEMENT_STATE_VALUES, PACCESS_MASK, PACL, -- PCONTEXT, PEXCEPTION_POINTERS, PEXCEPTION_RECORD, PFLS_CALLBACK_FUNCTION, PGENERIC_MAPPING, -- PIMAGE_NT_HEADERS, PIMAGE_SECTION_HEADER, PLUID_AND_ATTRIBUTES, PMESSAGE_RESOURCE_ENTRY, -- PPERFORMANCE_DATA, PRTL_BARRIER, PRTL_CONDITION_VARIABLE, PRTL_CRITICAL_SECTION, -- PRTL_OSVERSIONINFOEXW, PRTL_OSVERSIONINFOW, PRTL_RESOURCE_DEBUG, PRTL_SRWLOCK, -- PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, PSID, PSID_AND_ATTRIBUTES, -- PSID_AND_ATTRIBUTES_HASH, PSID_IDENTIFIER_AUTHORITY, PVECTORED_EXCEPTION_HANDLER, -- PXSAVE_AREA_HEADER, RTL_CRITICAL_SECTION, RTL_SRWLOCK, SECURITY_DESCRIPTOR_CONTROL, -- SECURITY_IMPERSONATION_LEVEL, SECURITY_INFORMATION, WAITORTIMERCALLBACKFUNC, -- WORKERCALLBACKFUNC, --}; --use winapi::vc::vadefs::va_list; --#[inline] --pub fn InitializeListHead(ListHead: &mut LIST_ENTRY) { -- ListHead.Flink = ListHead; -- ListHead.Blink = ListHead; --} --#[inline] --pub fn IsListEmpty(ListHead: &LIST_ENTRY) -> bool { -- ListHead.Flink as *const _ == ListHead as *const _ --} --#[inline] --pub unsafe fn RemoveEntryList(Entry: &mut LIST_ENTRY) -> bool { -- let (Blink, Flink) = (Entry.Blink, Entry.Flink); -- (*Blink).Flink = Flink; -- (*Flink).Blink = Blink; -- Flink == Blink --} --#[inline] --pub unsafe fn RemoveHeadList(ListHead: &mut LIST_ENTRY) -> PLIST_ENTRY { -- let Entry = ListHead.Flink; -- let Flink = (*Entry).Flink; -- ListHead.Flink = Flink; -- (*Flink).Blink = ListHead; -- Entry --} --#[inline] --pub unsafe fn RemoveTailList(ListHead: &mut LIST_ENTRY) -> PLIST_ENTRY { -- let Entry = ListHead.Blink; -- let Blink = (*Entry).Blink; -- ListHead.Blink = Blink; -- (*Blink).Flink = ListHead; -- Entry --} --#[inline] --pub unsafe fn InsertTailList(ListHead: &mut LIST_ENTRY, Entry: &mut LIST_ENTRY) { -- let Blink = ListHead.Blink; -- Entry.Flink = ListHead; -- Entry.Blink = Blink; -- (*Blink).Flink = Entry; -- ListHead.Blink = Entry; --} --#[inline] --pub unsafe fn InsertHeadList(ListHead: &mut LIST_ENTRY, Entry: &mut LIST_ENTRY) { -- let Flink = ListHead.Flink; -- Entry.Flink = Flink; -- Entry.Blink = ListHead; -- (*Flink).Blink = Entry; -- ListHead.Flink = Entry; --} --#[inline] --pub unsafe fn AppendTailList(ListHead: &mut LIST_ENTRY, ListToAppend: &mut LIST_ENTRY) { -- let ListEnd = ListHead.Blink; -- (*ListHead.Blink).Flink = ListToAppend; -- ListHead.Blink = ListToAppend.Blink; -- (*ListToAppend.Blink).Flink = ListHead; -- ListToAppend.Blink = ListEnd; --} --#[inline] --pub unsafe fn PopEntryList(ListHead: &mut SINGLE_LIST_ENTRY) -> PSINGLE_LIST_ENTRY { -- let FirstEntry = ListHead.Next; -- if !FirstEntry.is_null() { -- ListHead.Next = (*FirstEntry).Next; -- } -- FirstEntry --} --#[inline] --pub fn PushEntryList(ListHead: &mut SINGLE_LIST_ENTRY, Entry: &mut SINGLE_LIST_ENTRY) { -- Entry.Next = ListHead.Next; -- ListHead.Next = Entry; --} --ENUM!{enum TABLE_SEARCH_RESULT { -- TableEmptyTree = 0, -- TableFoundNode = 1, -- TableInsertAsLeft = 2, -- TableInsertAsRight = 3, --}} --ENUM!{enum RTL_GENERIC_COMPARE_RESULTS { -- GenericLessThan = 0, -- GenericGreaterThan = 1, -- GenericEqual = 2, --}} --FN!{stdcall PRTL_AVL_COMPARE_ROUTINE( -- Table: *mut RTL_AVL_TABLE, -- FirstStruct: PVOID, -- SecondStruct: PVOID, --) -> RTL_GENERIC_COMPARE_RESULTS} --FN!{stdcall PRTL_AVL_ALLOCATE_ROUTINE( -- Table: *mut RTL_AVL_TABLE, -- ByteSize: CLONG, --) -> PVOID} --FN!{stdcall PRTL_AVL_FREE_ROUTINE( -- Table: *mut RTL_AVL_TABLE, -- Buffer: PVOID, --) -> ()} --FN!{stdcall PRTL_AVL_MATCH_FUNCTION( -- Table: *mut RTL_AVL_TABLE, -- UserData: PVOID, -- MatchData: PVOID, --) -> NTSTATUS} --STRUCT!{struct RTL_BALANCED_LINKS { -- Parent: *mut RTL_BALANCED_LINKS, -- LeftChild: *mut RTL_BALANCED_LINKS, -- RightChild: *mut RTL_BALANCED_LINKS, -- Balance: CHAR, -- Reserved: [UCHAR; 3], --}} --pub type PRTL_BALANCED_LINKS = *mut RTL_BALANCED_LINKS; --STRUCT!{struct RTL_AVL_TABLE { -- BalancedRoot: RTL_BALANCED_LINKS, -- OrderedPointer: PVOID, -- WhichOrderedElement: ULONG, -- NumberGenericTableElements: ULONG, -- DepthOfTree: ULONG, -- RestartKey: PRTL_BALANCED_LINKS, -- DeleteCount: ULONG, -- CompareRoutine: PRTL_AVL_COMPARE_ROUTINE, -- AllocateRoutine: PRTL_AVL_ALLOCATE_ROUTINE, -- FreeRoutine: PRTL_AVL_FREE_ROUTINE, -- TableContext: PVOID, --}} --pub type PRTL_AVL_TABLE = *mut RTL_AVL_TABLE; --EXTERN!{extern "system" { -- fn RtlInitializeGenericTableAvl( -- Table: PRTL_AVL_TABLE, -- CompareRoutine: PRTL_AVL_COMPARE_ROUTINE, -- AllocateRoutine: PRTL_AVL_ALLOCATE_ROUTINE, -- FreeRoutine: PRTL_AVL_FREE_ROUTINE, -- TableContext: PVOID, -- ); -- fn RtlInsertElementGenericTableAvl( -- Table: PRTL_AVL_TABLE, -- Buffer: PVOID, -- BufferSize: CLONG, -- NewElement: PBOOLEAN, -- ) -> PVOID; -- fn RtlInsertElementGenericTableFullAvl( -- Table: PRTL_AVL_TABLE, -- Buffer: PVOID, -- BufferSize: CLONG, -- NewElement: PBOOLEAN, -- NodeOrParent: PVOID, -- SearchResult: TABLE_SEARCH_RESULT, -- ) -> PVOID; -- fn RtlDeleteElementGenericTableAvl( -- Table: PRTL_AVL_TABLE, -- Buffer: PVOID, -- ) -> BOOLEAN; -- fn RtlLookupElementGenericTableAvl( -- Table: PRTL_AVL_TABLE, -- Buffer: PVOID, -- ) -> PVOID; -- fn RtlLookupElementGenericTableFullAvl( -- Table: PRTL_AVL_TABLE, -- Buffer: PVOID, -- NodeOrParent: *mut PVOID, -- SearchResult: *mut TABLE_SEARCH_RESULT, -- ) -> PVOID; -- fn RtlEnumerateGenericTableAvl( -- Table: PRTL_AVL_TABLE, -- Restart: BOOLEAN, -- ) -> PVOID; -- fn RtlEnumerateGenericTableWithoutSplayingAvl( -- Table: PRTL_AVL_TABLE, -- RestartKey: *mut PVOID, -- ) -> PVOID; -- fn RtlLookupFirstMatchingElementGenericTableAvl( -- Table: PRTL_AVL_TABLE, -- Buffer: PVOID, -- RestartKey: *mut PVOID, -- ) -> PVOID; -- fn RtlEnumerateGenericTableLikeADirectory( -- Table: PRTL_AVL_TABLE, -- MatchFunction: PRTL_AVL_MATCH_FUNCTION, -- MatchData: PVOID, -- NextFlag: ULONG, -- RestartKey: *mut PVOID, -- DeleteCount: PULONG, -- Buffer: PVOID, -- ) -> PVOID; -- fn RtlGetElementGenericTableAvl( -- Table: PRTL_AVL_TABLE, -- I: ULONG, -- ) -> PVOID; -- fn RtlNumberGenericTableElementsAvl( -- Table: PRTL_AVL_TABLE, -- ) -> ULONG; -- fn RtlIsGenericTableEmptyAvl( -- Table: PRTL_AVL_TABLE, -- ) -> BOOLEAN; --}} --STRUCT!{struct RTL_SPLAY_LINKS { -- Parent: *mut RTL_SPLAY_LINKS, -- LeftChild: *mut RTL_SPLAY_LINKS, -- RightChild: *mut RTL_SPLAY_LINKS, --}} --pub type PRTL_SPLAY_LINKS = *mut RTL_SPLAY_LINKS; --#[inline] --pub fn RtlInitializeSplayLinks(Links: &mut RTL_SPLAY_LINKS) { -- Links.Parent = Links; -- Links.LeftChild = null_mut(); -- Links.RightChild = null_mut(); --} --#[inline] --pub const fn RtlParent(Links: &RTL_SPLAY_LINKS) -> PRTL_SPLAY_LINKS { -- Links.Parent --} --#[inline] --pub const fn RtlLeftChild(Links: &RTL_SPLAY_LINKS) -> PRTL_SPLAY_LINKS { -- Links.LeftChild --} --#[inline] --pub const fn RtlRightChild(Links: &RTL_SPLAY_LINKS) -> PRTL_SPLAY_LINKS { -- Links.RightChild --} --#[inline] --pub unsafe fn RtlIsRoot(Links: *const RTL_SPLAY_LINKS) -> bool { -- (*Links).Parent as *const _ == Links --} --#[inline] --pub unsafe fn RtlIsLeftChild(Links: *const RTL_SPLAY_LINKS) -> bool { -- RtlLeftChild(&*RtlParent(&*Links)) as *const _ == Links --} --#[inline] --pub unsafe fn RtlIsRightChild(Links: *const RTL_SPLAY_LINKS) -> bool { -- RtlRightChild(&*RtlParent(&*Links)) as *const _ == Links --} --#[inline] --pub fn RtlInsertAsLeftChild( -- ParentLinks: &mut RTL_SPLAY_LINKS, -- ChildLinks: &mut RTL_SPLAY_LINKS, --) { -- ParentLinks.LeftChild = ChildLinks; -- ChildLinks.Parent = ParentLinks; --} --#[inline] --pub fn RtlInsertAsRightChild( -- ParentLinks: &mut RTL_SPLAY_LINKS, -- ChildLinks: &mut RTL_SPLAY_LINKS, --) { -- ParentLinks.RightChild = ChildLinks; -- ChildLinks.Parent = ParentLinks; --} --EXTERN!{extern "system" { -- fn RtlSplay( -- Links: PRTL_SPLAY_LINKS, -- ) -> PRTL_SPLAY_LINKS; -- fn RtlDelete( -- Links: PRTL_SPLAY_LINKS, -- ) -> PRTL_SPLAY_LINKS; -- fn RtlDeleteNoSplay( -- Links: PRTL_SPLAY_LINKS, -- Root: *mut PRTL_SPLAY_LINKS, -- ); -- fn RtlSubtreeSuccessor( -- Links: PRTL_SPLAY_LINKS, -- ) -> PRTL_SPLAY_LINKS; -- fn RtlSubtreePredecessor( -- Links: PRTL_SPLAY_LINKS, -- ) -> PRTL_SPLAY_LINKS; -- fn RtlRealSuccessor( -- Links: PRTL_SPLAY_LINKS, -- ) -> PRTL_SPLAY_LINKS; -- fn RtlRealPredecessor( -- Links: PRTL_SPLAY_LINKS, -- ) -> PRTL_SPLAY_LINKS; --}} --FN!{stdcall PRTL_GENERIC_COMPARE_ROUTINE( -- Table: *mut RTL_GENERIC_TABLE, -- FirstStruct: PVOID, -- SecondStruct: PVOID, --) -> RTL_GENERIC_COMPARE_RESULTS} --FN!{stdcall PRTL_GENERIC_ALLOCATE_ROUTINE( -- Table: *mut RTL_GENERIC_TABLE, -- ByteSize: CLONG, --) -> PVOID} --FN!{stdcall PRTL_GENERIC_FREE_ROUTINE( -- Table: *mut RTL_GENERIC_TABLE, -- Buffer: PVOID, --) -> ()} --STRUCT!{struct RTL_GENERIC_TABLE { -- TableRoot: PRTL_SPLAY_LINKS, -- InsertOrderList: LIST_ENTRY, -- OrderedPointer: PLIST_ENTRY, -- WhichOrderedElement: ULONG, -- NumberGenericTableElements: ULONG, -- CompareRoutine: PRTL_GENERIC_COMPARE_ROUTINE, -- AllocateRoutine: PRTL_GENERIC_ALLOCATE_ROUTINE, -- FreeRoutine: PRTL_GENERIC_FREE_ROUTINE, -- TableContext: PVOID, --}} --pub type PRTL_GENERIC_TABLE = *mut RTL_GENERIC_TABLE; --EXTERN!{extern "system" { -- fn RtlInitializeGenericTable( -- Table: PRTL_GENERIC_TABLE, -- CompareRoutine: PRTL_GENERIC_COMPARE_ROUTINE, -- AllocateRoutine: PRTL_GENERIC_ALLOCATE_ROUTINE, -- FreeRoutine: PRTL_GENERIC_FREE_ROUTINE, -- TableContext: PVOID, -- ); -- fn RtlInsertElementGenericTable( -- Table: PRTL_GENERIC_TABLE, -- Buffer: PVOID, -- BufferSize: CLONG, -- NewElement: PBOOLEAN, -- ) -> PVOID; -- fn RtlInsertElementGenericTableFull( -- Table: PRTL_GENERIC_TABLE, -- Buffer: PVOID, -- BufferSize: CLONG, -- NewElement: PBOOLEAN, -- NodeOrParent: PVOID, -- SearchResult: TABLE_SEARCH_RESULT, -- ) -> PVOID; -- fn RtlDeleteElementGenericTable( -- Table: PRTL_GENERIC_TABLE, -- Buffer: PVOID, -- ) -> BOOLEAN; -- fn RtlLookupElementGenericTable( -- Table: PRTL_GENERIC_TABLE, -- Buffer: PVOID, -- ) -> PVOID; -- fn RtlLookupElementGenericTableFull( -- Table: PRTL_GENERIC_TABLE, -- Buffer: PVOID, -- NodeOrParent: *mut PVOID, -- SearchResult: *mut TABLE_SEARCH_RESULT, -- ) -> PVOID; -- fn RtlEnumerateGenericTable( -- Table: PRTL_GENERIC_TABLE, -- Restart: BOOLEAN, -- ) -> PVOID; -- fn RtlEnumerateGenericTableWithoutSplaying( -- Table: PRTL_GENERIC_TABLE, -- RestartKey: *mut PVOID, -- ) -> PVOID; -- fn RtlGetElementGenericTable( -- Table: PRTL_GENERIC_TABLE, -- I: ULONG, -- ) -> PVOID; -- fn RtlNumberGenericTableElements( -- Table: PRTL_GENERIC_TABLE, -- ) -> ULONG; -- fn RtlIsGenericTableEmpty( -- Table: PRTL_GENERIC_TABLE, -- ) -> BOOLEAN; --}} --STRUCT!{struct RTL_RB_TREE { -- Root: PRTL_BALANCED_NODE, -- Min: PRTL_BALANCED_NODE, --}} --pub type PRTL_RB_TREE = *mut RTL_RB_TREE; --EXTERN!{extern "system" { -- fn RtlRbInsertNodeEx( -- Tree: PRTL_RB_TREE, -- Parent: PRTL_BALANCED_NODE, -- Right: BOOLEAN, -- Node: PRTL_BALANCED_NODE, -- ); -- fn RtlRbRemoveNode( -- Tree: PRTL_RB_TREE, -- Node: PRTL_BALANCED_NODE, -- ); --}} --pub const RTL_HASH_ALLOCATED_HEADER: u32 = 0x00000001; --pub const RTL_HASH_RESERVED_SIGNATURE: u32 = 0; --STRUCT!{struct RTL_DYNAMIC_HASH_TABLE_ENTRY { -- Linkage: LIST_ENTRY, -- Signature: ULONG_PTR, --}} --pub type PRTL_DYNAMIC_HASH_TABLE_ENTRY = *mut RTL_DYNAMIC_HASH_TABLE_ENTRY; --#[inline] --pub const fn HASH_ENTRY_KEY(x: &RTL_DYNAMIC_HASH_TABLE_ENTRY) -> ULONG_PTR { -- x.Signature --} --STRUCT!{struct RTL_DYNAMIC_HASH_TABLE_CONTEXT { -- ChainHead: PLIST_ENTRY, -- PrevLinkage: PLIST_ENTRY, -- Signature: ULONG_PTR, --}} --pub type PRTL_DYNAMIC_HASH_TABLE_CONTEXT = *mut RTL_DYNAMIC_HASH_TABLE_CONTEXT; --STRUCT!{struct RTL_DYNAMIC_HASH_TABLE_ENUMERATOR { -- HashEntry: RTL_DYNAMIC_HASH_TABLE_ENTRY, -- ChainHead: PLIST_ENTRY, -- BucketIndex: ULONG, --}} --pub type PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR = *mut RTL_DYNAMIC_HASH_TABLE_ENUMERATOR; --STRUCT!{struct RTL_DYNAMIC_HASH_TABLE { -- Flags: ULONG, -- Shift: ULONG, -- TableSize: ULONG, -- Pivot: ULONG, -- DivisorMask: ULONG, -- NumEntries: ULONG, -- NonEmptyBuckets: ULONG, -- NumEnumerators: ULONG, -- Directory: PVOID, --}} --pub type PRTL_DYNAMIC_HASH_TABLE = *mut RTL_DYNAMIC_HASH_TABLE; --#[inline] --pub fn RtlInitHashTableContext(Context: &mut RTL_DYNAMIC_HASH_TABLE_CONTEXT) { -- Context.ChainHead = null_mut(); -- Context.PrevLinkage = null_mut(); --} --#[inline] --pub fn RtlInitHashTableContextFromEnumerator( -- Context: &mut RTL_DYNAMIC_HASH_TABLE_CONTEXT, -- Enumerator: &RTL_DYNAMIC_HASH_TABLE_ENUMERATOR, --) { -- Context.ChainHead = Enumerator.ChainHead; -- Context.PrevLinkage = Enumerator.HashEntry.Linkage.Blink; --} --// RtlReleaseHashTableContext --#[inline] --pub const fn RtlTotalBucketsHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { -- HashTable.TableSize --} --#[inline] --pub const fn RtlNonEmptyBucketsHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { -- HashTable.NonEmptyBuckets --} --#[inline] --pub const fn RtlEmptyBucketsHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { -- HashTable.TableSize - HashTable.NonEmptyBuckets --} --#[inline] --pub const fn RtlTotalEntriesHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { -- HashTable.NumEntries --} --#[inline] --pub const fn RtlActiveEnumeratorsHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { -- HashTable.NumEnumerators --} --EXTERN!{extern "system" { -- fn RtlCreateHashTable( -- HashTable: *mut PRTL_DYNAMIC_HASH_TABLE, -- Shift: ULONG, -- Flags: ULONG, -- ) -> BOOLEAN; -- fn RtlDeleteHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- ); -- fn RtlInsertEntryHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Entry: PRTL_DYNAMIC_HASH_TABLE_ENTRY, -- Signature: ULONG_PTR, -- Context: PRTL_DYNAMIC_HASH_TABLE_CONTEXT, -- ) -> BOOLEAN; -- fn RtlRemoveEntryHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Entry: PRTL_DYNAMIC_HASH_TABLE_ENTRY, -- Context: PRTL_DYNAMIC_HASH_TABLE_CONTEXT, -- ) -> BOOLEAN; -- fn RtlLookupEntryHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Signature: ULONG_PTR, -- Context: PRTL_DYNAMIC_HASH_TABLE_CONTEXT, -- ) -> PRTL_DYNAMIC_HASH_TABLE_ENTRY; -- fn RtlGetNextEntryHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Context: PRTL_DYNAMIC_HASH_TABLE_CONTEXT, -- ) -> PRTL_DYNAMIC_HASH_TABLE_ENTRY; -- fn RtlInitEnumerationHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ) -> BOOLEAN; -- fn RtlEnumerateEntryHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ) -> PRTL_DYNAMIC_HASH_TABLE_ENTRY; -- fn RtlEndEnumerationHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ); -- fn RtlInitWeakEnumerationHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ) -> BOOLEAN; -- fn RtlWeaklyEnumerateEntryHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ) -> PRTL_DYNAMIC_HASH_TABLE_ENTRY; -- fn RtlEndWeakEnumerationHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ); -- fn RtlExpandHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- ) -> BOOLEAN; -- fn RtlContractHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- ) -> BOOLEAN; -- fn RtlInitStrongEnumerationHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ) -> BOOLEAN; -- fn RtlStronglyEnumerateEntryHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ) -> PRTL_DYNAMIC_HASH_TABLE_ENTRY; -- fn RtlEndStrongEnumerationHashTable( -- HashTable: PRTL_DYNAMIC_HASH_TABLE, -- Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, -- ); -- fn RtlInitializeCriticalSection( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ) -> NTSTATUS; -- fn RtlInitializeCriticalSectionAndSpinCount( -- CriticalSection: PRTL_CRITICAL_SECTION, -- SpinCount: ULONG, -- ) -> NTSTATUS; -- fn RtlDeleteCriticalSection( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ) -> NTSTATUS; -- fn RtlEnterCriticalSection( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ) -> NTSTATUS; -- fn RtlLeaveCriticalSection( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ) -> NTSTATUS; -- fn RtlTryEnterCriticalSection( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ) -> LOGICAL; -- fn RtlIsCriticalSectionLocked( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ) -> LOGICAL; -- fn RtlIsCriticalSectionLockedByThread( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ) -> LOGICAL; -- fn RtlGetCriticalSectionRecursionCount( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ) -> ULONG; -- fn RtlSetCriticalSectionSpinCount( -- CriticalSection: PRTL_CRITICAL_SECTION, -- SpinCount: ULONG, -- ) -> ULONG; -- fn RtlQueryCriticalSectionOwner( -- EventHandle: HANDLE, -- ) -> HANDLE; -- fn RtlCheckForOrphanedCriticalSections( -- ThreadHandle: HANDLE, -- ); --}} --STRUCT!{struct RTL_RESOURCE { -- CriticalSection: RTL_CRITICAL_SECTION, -- SharedSemaphore: HANDLE, -- NumberOfWaitingShared: ULONG, -- ExclusiveSemaphore: HANDLE, -- NumberOfWaitingExclusive: ULONG, -- NumberOfActive: LONG, -- ExclusiveOwnerThread: HANDLE, -- Flags: ULONG, -- DebugInfo: PRTL_RESOURCE_DEBUG, --}} --pub type PRTL_RESOURCE = *mut RTL_RESOURCE; --pub const RTL_RESOURCE_FLAG_LONG_TERM: ULONG = 0x00000001; --EXTERN!{extern "system" { -- fn RtlInitializeResource( -- Resource: PRTL_RESOURCE, -- ); -- fn RtlDeleteResource( -- Resource: PRTL_RESOURCE, -- ); -- fn RtlAcquireResourceShared( -- Resource: PRTL_RESOURCE, -- Wait: BOOLEAN, -- ) -> BOOLEAN; -- fn RtlAcquireResourceExclusive( -- Resource: PRTL_RESOURCE, -- Wait: BOOLEAN, -- ) -> BOOLEAN; -- fn RtlReleaseResource( -- Resource: PRTL_RESOURCE, -- ); -- fn RtlConvertSharedToExclusive( -- Resource: PRTL_RESOURCE, -- ); -- fn RtlConvertExclusiveToShared( -- Resource: PRTL_RESOURCE, -- ); -- fn RtlInitializeSRWLock( -- SRWLock: PRTL_SRWLOCK, -- ); -- fn RtlAcquireSRWLockExclusive( -- SRWLock: PRTL_SRWLOCK, -- ); -- fn RtlAcquireSRWLockShared( -- SRWLock: PRTL_SRWLOCK, -- ); -- fn RtlReleaseSRWLockExclusive( -- SRWLock: PRTL_SRWLOCK, -- ); -- fn RtlReleaseSRWLockShared( -- SRWLock: PRTL_SRWLOCK, -- ); -- fn RtlTryAcquireSRWLockExclusive( -- SRWLock: PRTL_SRWLOCK, -- ) -> BOOLEAN; -- fn RtlTryAcquireSRWLockShared( -- SRWLock: PRTL_SRWLOCK, -- ) -> BOOLEAN; -- fn RtlAcquireReleaseSRWLockExclusive( -- SRWLock: PRTL_SRWLOCK, -- ); -- fn RtlInitializeConditionVariable( -- ConditionVariable: PRTL_CONDITION_VARIABLE, -- ); -- fn RtlSleepConditionVariableCS( -- ConditionVariable: PRTL_CONDITION_VARIABLE, -- CriticalSection: PRTL_CRITICAL_SECTION, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn RtlSleepConditionVariableSRW( -- ConditionVariable: PRTL_CONDITION_VARIABLE, -- SRWLock: PRTL_SRWLOCK, -- Timeout: PLARGE_INTEGER, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlWakeConditionVariable( -- ConditionVariable: PRTL_CONDITION_VARIABLE, -- ); -- fn RtlWakeAllConditionVariable( -- ConditionVariable: PRTL_CONDITION_VARIABLE, -- ); --}} --pub const RTL_BARRIER_FLAGS_SPIN_ONLY: ULONG = 0x00000001; --pub const RTL_BARRIER_FLAGS_BLOCK_ONLY: ULONG = 0x00000002; --pub const RTL_BARRIER_FLAGS_NO_DELETE: ULONG = 0x00000004; --EXTERN!{extern "system" { -- fn RtlInitBarrier( -- Barrier: PRTL_BARRIER, -- TotalThreads: ULONG, -- SpinCount: ULONG, -- ) -> NTSTATUS; -- fn RtlDeleteBarrier( -- Barrier: PRTL_BARRIER, -- ) -> NTSTATUS; -- fn RtlBarrier( -- Barrier: PRTL_BARRIER, -- Flags: ULONG, -- ) -> BOOLEAN; -- fn RtlBarrierForDelete( -- Barrier: PRTL_BARRIER, -- Flags: ULONG, -- ) -> BOOLEAN; -- fn RtlWaitOnAddress( -- Address: *mut VOID, -- CompareAddress: PVOID, -- AddressSize: SIZE_T, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn RtlWakeAddressAll( -- Address: PVOID, -- ); -- fn RtlWakeAddressSingle( -- Address: PVOID, -- ); -- fn RtlInitString( -- DestinationString: PSTRING, -- SourceString: PCSZ, -- ); -- fn RtlInitStringEx( -- DestinationString: PSTRING, -- SourceString: PCSZ, -- ) -> NTSTATUS; -- fn RtlInitAnsiString( -- DestinationString: PANSI_STRING, -- SourceString: PCSZ, -- ); -- fn RtlInitAnsiStringEx( -- DestinationString: PANSI_STRING, -- SourceString: PCSZ, -- ) -> NTSTATUS; -- fn RtlFreeAnsiString( -- AnsiString: PANSI_STRING, -- ); -- fn RtlFreeOemString( -- OemString: POEM_STRING, -- ); -- fn RtlCopyString( -- DestinationString: PSTRING, -- SourceString: *const STRING, -- ); -- fn RtlUpperChar( -- Character: CHAR, -- ) -> CHAR; -- fn RtlCompareString( -- String1: *const STRING, -- String2: *const STRING, -- CaseInSensitive: BOOLEAN, -- ) -> LONG; -- fn RtlEqualString( -- String1: *const STRING, -- String2: *const STRING, -- CaseInSensitive: BOOLEAN, -- ) -> BOOLEAN; -- fn RtlPrefixString( -- String1: *const STRING, -- String2: *const STRING, -- CaseInSensitive: BOOLEAN, -- ) -> BOOLEAN; -- fn RtlAppendStringToString( -- Destination: PSTRING, -- Source: *const STRING, -- ) -> NTSTATUS; -- fn RtlAppendAsciizToString( -- Destination: PSTRING, -- Source: PSTR, -- ) -> NTSTATUS; -- fn RtlUpperString( -- DestinationString: PSTRING, -- SourceString: *const STRING, -- ); --}} --#[inline] --pub unsafe fn RtlIsNullOrEmptyUnicodeString(String: PUNICODE_STRING) -> bool { -- String.is_null() || (*String).Length == 0 --} --#[inline] --pub fn RtlInitEmptyUnicodeString( -- UnicodeString: &mut UNICODE_STRING, -- Buffer: PWCHAR, -- MaximumLength: USHORT, --) { -- UnicodeString.Buffer = Buffer; -- UnicodeString.MaximumLength = MaximumLength; -- UnicodeString.Length = 0; --} --EXTERN!{extern "system" { -- fn RtlInitUnicodeString( -- DestinationString: PUNICODE_STRING, -- SourceString: PCWSTR, -- ); -- fn RtlInitUnicodeStringEx( -- DestinationString: PUNICODE_STRING, -- SourceString: PCWSTR, -- ) -> NTSTATUS; -- fn RtlCreateUnicodeString( -- DestinationString: PUNICODE_STRING, -- SourceString: PCWSTR, -- ) -> BOOLEAN; -- fn RtlCreateUnicodeStringFromAsciiz( -- DestinationString: PUNICODE_STRING, -- SourceString: PSTR, -- ) -> BOOLEAN; -- fn RtlFreeUnicodeString( -- UnicodeString: PUNICODE_STRING, -- ); --}} --pub const RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE: ULONG = 0x00000001; --pub const RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING: ULONG = 0x00000002; --EXTERN!{extern "system" { -- fn RtlDuplicateUnicodeString( -- Flags: ULONG, -- StringIn: PCUNICODE_STRING, -- StringOut: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlCopyUnicodeString( -- DestinationString: PUNICODE_STRING, -- SourceString: PCUNICODE_STRING, -- ); -- fn RtlUpcaseUnicodeChar( -- SourceCharacter: WCHAR, -- ) -> WCHAR; -- fn RtlDowncaseUnicodeChar( -- SourceCharacter: WCHAR, -- ) -> WCHAR; -- fn RtlCompareUnicodeString( -- String1: PCUNICODE_STRING, -- String2: PCUNICODE_STRING, -- CaseInSensitive: BOOLEAN, -- ) -> LONG; -- fn RtlCompareUnicodeStrings( -- String1: PCWCH, -- String1Length: SIZE_T, -- String2: PCWCH, -- String2Length: SIZE_T, -- CaseInSensitive: BOOLEAN, -- ) -> LONG; -- fn RtlEqualUnicodeString( -- String1: PCUNICODE_STRING, -- String2: PCUNICODE_STRING, -- CaseInSensitive: BOOLEAN, -- ) -> BOOLEAN; --}} --pub const HASH_STRING_ALGORITHM_DEFAULT: ULONG = 0; --pub const HASH_STRING_ALGORITHM_X65599: ULONG = 1; --pub const HASH_STRING_ALGORITHM_INVALID: ULONG = 0xffffffff; --EXTERN!{extern "system" { -- fn RtlHashUnicodeString( -- String: PCUNICODE_STRING, -- CaseInSensitive: BOOLEAN, -- HashAlgorithm: ULONG, -- HashValue: PULONG, -- ) -> NTSTATUS; -- fn RtlValidateUnicodeString( -- Flags: ULONG, -- String: PCUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlPrefixUnicodeString( -- String1: PCUNICODE_STRING, -- String2: PCUNICODE_STRING, -- CaseInSensitive: BOOLEAN, -- ) -> BOOLEAN; -- fn RtlSuffixUnicodeString( -- String1: PUNICODE_STRING, -- String2: PUNICODE_STRING, -- CaseInSensitive: BOOLEAN, -- ) -> BOOLEAN; -- fn RtlFindUnicodeSubstring( -- FullString: PUNICODE_STRING, -- SearchString: PUNICODE_STRING, -- CaseInSensitive: BOOLEAN, -- ) -> PWCHAR; --}} --pub const RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END: ULONG = 0x00000001; --pub const RTL_FIND_CHAR_IN_UNICODE_STRING_COMPLEMENT_CHAR_SET: ULONG = 0x00000002; --pub const RTL_FIND_CHAR_IN_UNICODE_STRING_CASE_INSENSITIVE: ULONG = 0x00000004; --EXTERN!{extern "system" { -- fn RtlFindCharInUnicodeString( -- Flags: ULONG, -- StringToSearch: PUNICODE_STRING, -- CharSet: PUNICODE_STRING, -- NonInclusivePrefixLength: PUSHORT, -- ) -> NTSTATUS; -- fn RtlAppendUnicodeStringToString( -- Destination: PUNICODE_STRING, -- Source: PCUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlAppendUnicodeToString( -- Destination: PUNICODE_STRING, -- Source: PCWSTR, -- ) -> NTSTATUS; -- fn RtlUpcaseUnicodeString( -- DestinationString: PUNICODE_STRING, -- SourceString: PCUNICODE_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlDowncaseUnicodeString( -- DestinationString: PUNICODE_STRING, -- SourceString: PCUNICODE_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlEraseUnicodeString( -- String: PUNICODE_STRING, -- ); -- fn RtlAnsiStringToUnicodeString( -- DestinationString: PUNICODE_STRING, -- SourceString: PCANSI_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlUnicodeStringToAnsiString( -- DestinationString: PANSI_STRING, -- SourceString: PCUNICODE_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlAnsiCharToUnicodeChar( -- SourceCharacter: *mut PUCHAR, -- ) -> WCHAR; -- fn RtlUpcaseUnicodeStringToAnsiString( -- DestinationString: PANSI_STRING, -- SourceString: PUNICODE_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlOemStringToUnicodeString( -- DestinationString: PUNICODE_STRING, -- SourceString: PCOEM_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlUnicodeStringToOemString( -- DestinationString: POEM_STRING, -- SourceString: PCUNICODE_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlUpcaseUnicodeStringToOemString( -- DestinationString: POEM_STRING, -- SourceString: PUNICODE_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlUnicodeStringToCountedOemString( -- DestinationString: POEM_STRING, -- SourceString: PCUNICODE_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlUpcaseUnicodeStringToCountedOemString( -- DestinationString: POEM_STRING, -- SourceString: PCUNICODE_STRING, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlMultiByteToUnicodeN( -- UnicodeString: PWCH, -- MaxBytesInUnicodeString: ULONG, -- BytesInUnicodeString: PULONG, -- MultiByteString: *const CHAR, -- BytesInMultiByteString: ULONG, -- ) -> NTSTATUS; -- fn RtlMultiByteToUnicodeSize( -- BytesInUnicodeString: PULONG, -- MultiByteString: *const CHAR, -- BytesInMultiByteString: ULONG, -- ) -> NTSTATUS; -- fn RtlUnicodeToMultiByteN( -- MultiByteString: PCHAR, -- MaxBytesInMultiByteString: ULONG, -- BytesInMultiByteString: PULONG, -- UnicodeString: PCWCH, -- BytesInUnicodeString: ULONG, -- ) -> NTSTATUS; -- fn RtlUnicodeToMultiByteSize( -- BytesInMultiByteString: PULONG, -- UnicodeString: PCWCH, -- BytesInUnicodeString: ULONG, -- ) -> NTSTATUS; -- fn RtlUpcaseUnicodeToMultiByteN( -- MultiByteString: PCHAR, -- MaxBytesInMultiByteString: ULONG, -- BytesInMultiByteString: PULONG, -- UnicodeString: PCWCH, -- BytesInUnicodeString: ULONG, -- ) -> NTSTATUS; -- fn RtlOemToUnicodeN( -- UnicodeString: PWCH, -- MaxBytesInUnicodeString: ULONG, -- BytesInUnicodeString: PULONG, -- OemString: PCCH, -- BytesInOemString: ULONG, -- ) -> NTSTATUS; -- fn RtlUnicodeToOemN( -- OemString: PCHAR, -- MaxBytesInOemString: ULONG, -- BytesInOemString: PULONG, -- UnicodeString: PCWCH, -- BytesInUnicodeString: ULONG, -- ) -> NTSTATUS; -- fn RtlUpcaseUnicodeToOemN( -- OemString: PCHAR, -- MaxBytesInOemString: ULONG, -- BytesInOemString: PULONG, -- UnicodeString: PCWCH, -- BytesInUnicodeString: ULONG, -- ) -> NTSTATUS; -- fn RtlConsoleMultiByteToUnicodeN( -- UnicodeString: PWCH, -- MaxBytesInUnicodeString: ULONG, -- BytesInUnicodeString: PULONG, -- MultiByteString: PCH, -- BytesInMultiByteString: ULONG, -- pdwSpecialChar: PULONG, -- ) -> NTSTATUS; -- fn RtlUTF8ToUnicodeN( -- UnicodeStringDestination: PWSTR, -- UnicodeStringMaxByteCount: ULONG, -- UnicodeStringActualByteCount: PULONG, -- UTF8StringSource: PCCH, -- UTF8StringByteCount: ULONG, -- ) -> NTSTATUS; -- fn RtlUnicodeToUTF8N( -- UTF8StringDestination: PCHAR, -- UTF8StringMaxByteCount: ULONG, -- UTF8StringActualByteCount: PULONG, -- UnicodeStringSource: PCWCH, -- UnicodeStringByteCount: ULONG, -- ) -> NTSTATUS; -- fn RtlCustomCPToUnicodeN( -- CustomCP: PCPTABLEINFO, -- UnicodeString: PWCH, -- MaxBytesInUnicodeString: ULONG, -- BytesInUnicodeString: PULONG, -- CustomCPString: PCH, -- BytesInCustomCPString: ULONG, -- ) -> NTSTATUS; -- fn RtlUnicodeToCustomCPN( -- CustomCP: PCPTABLEINFO, -- CustomCPString: PCH, -- MaxBytesInCustomCPString: ULONG, -- BytesInCustomCPString: PULONG, -- UnicodeString: PWCH, -- BytesInUnicodeString: ULONG, -- ) -> NTSTATUS; -- fn RtlUpcaseUnicodeToCustomCPN( -- CustomCP: PCPTABLEINFO, -- CustomCPString: PCH, -- MaxBytesInCustomCPString: ULONG, -- BytesInCustomCPString: PULONG, -- UnicodeString: PWCH, -- BytesInUnicodeString: ULONG, -- ) -> NTSTATUS; -- fn RtlInitCodePageTable( -- TableBase: PUSHORT, -- CodePageTable: PCPTABLEINFO, -- ); -- fn RtlInitNlsTables( -- AnsiNlsBase: PUSHORT, -- OemNlsBase: PUSHORT, -- LanguageNlsBase: PUSHORT, -- TableInfo: PNLSTABLEINFO, -- ); -- fn RtlResetRtlTranslations( -- TableInfo: PNLSTABLEINFO, -- ); -- fn RtlIsTextUnicode( -- Buffer: PVOID, -- Size: ULONG, -- Result: PULONG, -- ) -> BOOLEAN; --}} --ENUM!{enum RTL_NORM_FORM { -- NormOther = 0x0, -- NormC = 0x1, -- NormD = 0x2, -- NormKC = 0x5, -- NormKD = 0x6, -- NormIdna = 0xd, -- DisallowUnassigned = 0x100, -- NormCDisallowUnassigned = 0x101, -- NormDDisallowUnassigned = 0x102, -- NormKCDisallowUnassigned = 0x105, -- NormKDDisallowUnassigned = 0x106, -- NormIdnaDisallowUnassigned = 0x10d, --}} --EXTERN!{extern "system" { -- fn RtlNormalizeString( -- NormForm: ULONG, -- SourceString: PCWSTR, -- SourceStringLength: LONG, -- DestinationString: PWSTR, -- DestinationStringLength: PLONG, -- ) -> NTSTATUS; -- fn RtlIsNormalizedString( -- NormForm: ULONG, -- SourceString: PCWSTR, -- SourceStringLength: LONG, -- Normalized: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlIsNameInExpression( -- Expression: PUNICODE_STRING, -- Name: PUNICODE_STRING, -- IgnoreCase: BOOLEAN, -- UpcaseTable: PWCH, -- ) -> BOOLEAN; -- fn RtlIsNameInUnUpcasedExpression( -- Expression: PUNICODE_STRING, -- Name: PUNICODE_STRING, -- IgnoreCase: BOOLEAN, -- UpcaseTable: PWCH, -- ) -> BOOLEAN; -- fn RtlEqualDomainName( -- String1: PUNICODE_STRING, -- String2: PUNICODE_STRING, -- ) -> BOOLEAN; -- fn RtlEqualComputerName( -- String1: PUNICODE_STRING, -- String2: PUNICODE_STRING, -- ) -> BOOLEAN; -- fn RtlDnsHostNameToComputerName( -- ComputerNameString: PUNICODE_STRING, -- DnsHostNameString: PUNICODE_STRING, -- AllocateComputerNameString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlStringFromGUID( -- Guid: *const GUID, -- GuidString: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlStringFromGUIDEx( -- Guid: *mut GUID, -- GuidString: PUNICODE_STRING, -- AllocateGuidString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlGUIDFromString( -- GuidString: PCUNICODE_STRING, -- Guid: *mut GUID, -- ) -> NTSTATUS; -- fn RtlCompareAltitudes( -- Altitude1: PCUNICODE_STRING, -- Altitude2: PCUNICODE_STRING, -- ) -> LONG; -- fn RtlIdnToAscii( -- Flags: ULONG, -- SourceString: PCWSTR, -- SourceStringLength: LONG, -- DestinationString: PWSTR, -- DestinationStringLength: PLONG, -- ) -> NTSTATUS; -- fn RtlIdnToUnicode( -- Flags: ULONG, -- SourceString: PCWSTR, -- SourceStringLength: LONG, -- DestinationString: PWSTR, -- DestinationStringLength: PLONG, -- ) -> NTSTATUS; -- fn RtlIdnToNameprepUnicode( -- Flags: ULONG, -- SourceString: PCWSTR, -- SourceStringLength: LONG, -- DestinationString: PWSTR, -- DestinationStringLength: PLONG, -- ) -> NTSTATUS; --}} --STRUCT!{struct PREFIX_TABLE_ENTRY { -- NodeTypeCode: CSHORT, -- NameLength: CSHORT, -- NextPrefixTree: *mut PREFIX_TABLE_ENTRY, -- Links: RTL_SPLAY_LINKS, -- Prefix: PSTRING, --}} --pub type PPREFIX_TABLE_ENTRY = *mut PREFIX_TABLE_ENTRY; --STRUCT!{struct PREFIX_TABLE { -- NodeTypeCode: CSHORT, -- NameLength: CSHORT, -- NextPrefixTree: PPREFIX_TABLE_ENTRY, --}} --pub type PPREFIX_TABLE = *mut PREFIX_TABLE; --EXTERN!{extern "system" { -- fn PfxInitialize( -- PrefixTable: PPREFIX_TABLE, -- ); -- fn PfxInsertPrefix( -- PrefixTable: PPREFIX_TABLE, -- Prefix: PSTRING, -- PrefixTableEntry: PPREFIX_TABLE_ENTRY, -- ) -> BOOLEAN; -- fn PfxRemovePrefix( -- PrefixTable: PPREFIX_TABLE, -- PrefixTableEntry: PPREFIX_TABLE_ENTRY, -- ); -- fn PfxFindPrefix( -- PrefixTable: PPREFIX_TABLE, -- FullName: PSTRING, -- ) -> PPREFIX_TABLE_ENTRY; --}} --STRUCT!{struct UNICODE_PREFIX_TABLE_ENTRY { -- NodeTypeCode: CSHORT, -- NameLength: CSHORT, -- NextPrefixTree: *mut UNICODE_PREFIX_TABLE_ENTRY, -- CaseMatch: *mut UNICODE_PREFIX_TABLE_ENTRY, -- Links: RTL_SPLAY_LINKS, -- Prefix: PUNICODE_STRING, --}} --pub type PUNICODE_PREFIX_TABLE_ENTRY = *mut UNICODE_PREFIX_TABLE_ENTRY; --STRUCT!{struct UNICODE_PREFIX_TABLE { -- NodeTypeCode: CSHORT, -- NameLength: CSHORT, -- NextPrefixTree: PUNICODE_PREFIX_TABLE_ENTRY, -- LastNextEntry: PUNICODE_PREFIX_TABLE_ENTRY, --}} --pub type PUNICODE_PREFIX_TABLE = *mut UNICODE_PREFIX_TABLE; --EXTERN!{extern "system" { -- fn RtlInitializeUnicodePrefix( -- PrefixTable: PUNICODE_PREFIX_TABLE, -- ); -- fn RtlInsertUnicodePrefix( -- PrefixTable: PUNICODE_PREFIX_TABLE, -- Prefix: PUNICODE_STRING, -- PrefixTableEntry: PUNICODE_PREFIX_TABLE_ENTRY, -- ) -> BOOLEAN; -- fn RtlRemoveUnicodePrefix( -- PrefixTable: PUNICODE_PREFIX_TABLE, -- PrefixTableEntry: PUNICODE_PREFIX_TABLE_ENTRY, -- ); -- fn RtlFindUnicodePrefix( -- PrefixTable: PUNICODE_PREFIX_TABLE, -- FullName: PCUNICODE_STRING, -- CaseInsensitiveIndex: ULONG, -- ) -> PUNICODE_PREFIX_TABLE_ENTRY; -- fn RtlNextUnicodePrefix( -- PrefixTable: PUNICODE_PREFIX_TABLE, -- Restart: BOOLEAN, -- ) -> PUNICODE_PREFIX_TABLE_ENTRY; --}} --STRUCT!{struct COMPRESSED_DATA_INFO { -- CompressionFormatAndEngine: USHORT, -- CompressionUnitShift: UCHAR, -- ChunkShift: UCHAR, -- ClusterShift: UCHAR, -- Reserved: UCHAR, -- NumberOfChunks: USHORT, -- CompressedChunkSizes: [ULONG; 1], --}} --pub type PCOMPRESSED_DATA_INFO = *mut COMPRESSED_DATA_INFO; --EXTERN!{extern "system" { -- fn RtlGetCompressionWorkSpaceSize( -- CompressionFormatAndEngine: USHORT, -- CompressBufferWorkSpaceSize: PULONG, -- CompressFragmentWorkSpaceSize: PULONG, -- ) -> NTSTATUS; -- fn RtlCompressBuffer( -- CompressionFormatAndEngine: USHORT, -- UncompressedBuffer: PUCHAR, -- UncompressedBufferSize: ULONG, -- CompressedBuffer: PUCHAR, -- CompressedBufferSize: ULONG, -- UncompressedChunkSize: ULONG, -- FinalCompressedSize: PULONG, -- WorkSpace: PVOID, -- ) -> NTSTATUS; -- fn RtlDecompressBuffer( -- CompressionFormat: USHORT, -- UncompressedBuffer: PUCHAR, -- UncompressedBufferSize: ULONG, -- CompressedBuffer: PUCHAR, -- CompressedBufferSize: ULONG, -- FinalUncompressedSize: PULONG, -- ) -> NTSTATUS; -- fn RtlDecompressBufferEx( -- CompressionFormat: USHORT, -- UncompressedBuffer: PUCHAR, -- UncompressedBufferSize: ULONG, -- CompressedBuffer: PUCHAR, -- CompressedBufferSize: ULONG, -- FinalUncompressedSize: PULONG, -- WorkSpace: PVOID, -- ) -> NTSTATUS; -- fn RtlDecompressFragment( -- CompressionFormat: USHORT, -- UncompressedFragment: PUCHAR, -- UncompressedFragmentSize: ULONG, -- CompressedBuffer: PUCHAR, -- CompressedBufferSize: ULONG, -- FragmentOffset: ULONG, -- FinalUncompressedSize: PULONG, -- WorkSpace: PVOID, -- ) -> NTSTATUS; -- fn RtlDescribeChunk( -- CompressionFormat: USHORT, -- CompressedBuffer: *mut PUCHAR, -- EndOfCompressedBufferPlus1: PUCHAR, -- ChunkBuffer: *mut PUCHAR, -- ChunkSize: PULONG, -- ) -> NTSTATUS; -- fn RtlReserveChunk( -- CompressionFormat: USHORT, -- CompressedBuffer: *mut PUCHAR, -- EndOfCompressedBufferPlus1: PUCHAR, -- ChunkBuffer: *mut PUCHAR, -- ChunkSize: ULONG, -- ) -> NTSTATUS; -- fn RtlDecompressChunks( -- UncompressedBuffer: PUCHAR, -- UncompressedBufferSize: ULONG, -- CompressedBuffer: PUCHAR, -- CompressedBufferSize: ULONG, -- CompressedTail: PUCHAR, -- CompressedTailSize: ULONG, -- CompressedDataInfo: PCOMPRESSED_DATA_INFO, -- ) -> NTSTATUS; -- fn RtlCompressChunks( -- UncompressedBuffer: PUCHAR, -- UncompressedBufferSize: ULONG, -- CompressedBuffer: PUCHAR, -- CompressedBufferSize: ULONG, -- CompressedDataInfo: PCOMPRESSED_DATA_INFO, -- CompressedDataInfoLength: ULONG, -- WorkSpace: PVOID, -- ) -> NTSTATUS; -- fn RtlConvertLCIDToString( -- LcidValue: LCID, -- Base: ULONG, -- Padding: ULONG, -- pResultBuf: PWSTR, -- Size: ULONG, -- ) -> NTSTATUS; -- fn RtlIsValidLocaleName( -- LocaleName: PWSTR, -- Flags: ULONG, -- ) -> BOOLEAN; -- fn RtlGetParentLocaleName( -- LocaleName: PWSTR, -- ParentLocaleName: PUNICODE_STRING, -- Flags: ULONG, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlLcidToLocaleName( -- lcid: LCID, -- LocaleName: PUNICODE_STRING, -- Flags: ULONG, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlLocaleNameToLcid( -- LocaleName: PWSTR, -- lcid: PLCID, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlLCIDToCultureName( -- Lcid: LCID, -- String: PUNICODE_STRING, -- ) -> BOOLEAN; -- fn RtlCultureNameToLCID( -- String: PUNICODE_STRING, -- Lcid: PLCID, -- ) -> BOOLEAN; -- fn RtlCleanUpTEBLangLists(); -- fn RtlGetLocaleFileMappingAddress( -- BaseAddress: *mut PVOID, -- DefaultLocaleId: PLCID, -- DefaultCasingTableSize: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn RtlGetCurrentPeb() -> PPEB; -- fn RtlAcquirePebLock(); -- fn RtlReleasePebLock(); -- fn RtlTryAcquirePebLock() -> LOGICAL; -- fn RtlAllocateFromPeb( -- Size: ULONG, -- Block: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlFreeToPeb( -- Block: PVOID, -- Size: ULONG, -- ) -> NTSTATUS; --}} --pub const DOS_MAX_COMPONENT_LENGTH: u32 = 255; --pub const DOS_MAX_PATH_LENGTH: u32 = DOS_MAX_COMPONENT_LENGTH + 5; --STRUCT!{struct CURDIR { -- DosPath: UNICODE_STRING, -- Handle: HANDLE, --}} --pub type PCURDIR = *mut CURDIR; --pub const RTL_USER_PROC_CURDIR_CLOSE: u32 = 0x00000002; --pub const RTL_USER_PROC_CURDIR_INHERIT: u32 = 0x00000003; --STRUCT!{struct RTL_DRIVE_LETTER_CURDIR { -- Flags: USHORT, -- Length: USHORT, -- TimeStamp: ULONG, -- DosPath: STRING, --}} --pub type PRTL_DRIVE_LETTER_CURDIR = *mut RTL_DRIVE_LETTER_CURDIR; --pub const RTL_MAX_DRIVE_LETTERS: usize = 32; --pub const RTL_DRIVE_LETTER_VALID: USHORT = 0x0001; --STRUCT!{struct RTL_USER_PROCESS_PARAMETERS { -- MaximumLength: ULONG, -- Length: ULONG, -- Flags: ULONG, -- DebugFlags: ULONG, -- ConsoleHandle: HANDLE, -- ConsoleFlags: ULONG, -- StandardInput: HANDLE, -- StandardOutput: HANDLE, -- StandardError: HANDLE, -- CurrentDirectory: CURDIR, -- DllPath: UNICODE_STRING, -- ImagePathName: UNICODE_STRING, -- CommandLine: UNICODE_STRING, -- Environment: PVOID, -- StartingX: ULONG, -- StartingY: ULONG, -- CountX: ULONG, -- CountY: ULONG, -- CountCharsX: ULONG, -- CountCharsY: ULONG, -- FillAttribute: ULONG, -- WindowFlags: ULONG, -- ShowWindowFlags: ULONG, -- WindowTitle: UNICODE_STRING, -- DesktopInfo: UNICODE_STRING, -- ShellInfo: UNICODE_STRING, -- RuntimeData: UNICODE_STRING, -- CurrentDirectories: [RTL_DRIVE_LETTER_CURDIR; RTL_MAX_DRIVE_LETTERS], -- EnvironmentSize: ULONG_PTR, -- EnvironmentVersion: ULONG_PTR, -- PackageDependencyData: PVOID, -- ProcessGroupId: ULONG, -- LoaderThreads: ULONG, --}} --pub type PRTL_USER_PROCESS_PARAMETERS = *mut RTL_USER_PROCESS_PARAMETERS; --pub const RTL_USER_PROC_PARAMS_NORMALIZED: ULONG = 0x00000001; --pub const RTL_USER_PROC_PROFILE_USER: ULONG = 0x00000002; --pub const RTL_USER_PROC_PROFILE_KERNEL: ULONG = 0x00000004; --pub const RTL_USER_PROC_PROFILE_SERVER: ULONG = 0x00000008; --pub const RTL_USER_PROC_RESERVE_1MB: ULONG = 0x00000020; --pub const RTL_USER_PROC_RESERVE_16MB: ULONG = 0x00000040; --pub const RTL_USER_PROC_CASE_SENSITIVE: ULONG = 0x00000080; --pub const RTL_USER_PROC_DISABLE_HEAP_DECOMMIT: ULONG = 0x00000100; --pub const RTL_USER_PROC_DLL_REDIRECTION_LOCAL: ULONG = 0x00001000; --pub const RTL_USER_PROC_APP_MANIFEST_PRESENT: ULONG = 0x00002000; --pub const RTL_USER_PROC_IMAGE_KEY_MISSING: ULONG = 0x00004000; --pub const RTL_USER_PROC_OPTIN_PROCESS: ULONG = 0x00020000; --EXTERN!{extern "system" { -- fn RtlCreateProcessParameters( -- pProcessParameters: *mut PRTL_USER_PROCESS_PARAMETERS, -- ImagePathName: PUNICODE_STRING, -- DllPath: PUNICODE_STRING, -- CurrentDirectory: PUNICODE_STRING, -- CommandLine: PUNICODE_STRING, -- Environment: PVOID, -- WindowTitle: PUNICODE_STRING, -- DesktopInfo: PUNICODE_STRING, -- ShellInfo: PUNICODE_STRING, -- RuntimeData: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlCreateProcessParametersEx( -- pProcessParameters: *mut PRTL_USER_PROCESS_PARAMETERS, -- ImagePathName: PUNICODE_STRING, -- DllPath: PUNICODE_STRING, -- CurrentDirectory: PUNICODE_STRING, -- CommandLine: PUNICODE_STRING, -- Environment: PVOID, -- WindowTitle: PUNICODE_STRING, -- DesktopInfo: PUNICODE_STRING, -- ShellInfo: PUNICODE_STRING, -- RuntimeData: PUNICODE_STRING, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlDestroyProcessParameters( -- ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, -- ) -> NTSTATUS; -- fn RtlNormalizeProcessParams( -- ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, -- ) -> PRTL_USER_PROCESS_PARAMETERS; -- fn RtlDeNormalizeProcessParams( -- ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, -- ) -> PRTL_USER_PROCESS_PARAMETERS; --}} --STRUCT!{struct RTL_USER_PROCESS_INFORMATION { -- Length: ULONG, -- Process: HANDLE, -- Thread: HANDLE, -- ClientId: CLIENT_ID, -- ImageInformation: SECTION_IMAGE_INFORMATION, --}} --pub type PRTL_USER_PROCESS_INFORMATION = *mut RTL_USER_PROCESS_INFORMATION; --EXTERN!{extern "system" { -- fn RtlCreateUserProcess( -- NtImagePathName: PUNICODE_STRING, -- AttributesDeprecated: ULONG, -- ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, -- ProcessSecurityDescriptor: PSECURITY_DESCRIPTOR, -- ThreadSecurityDescriptor: PSECURITY_DESCRIPTOR, -- ParentProcess: HANDLE, -- InheritHandles: BOOLEAN, -- DebugPort: HANDLE, -- TokenHandle: HANDLE, -- ProcessInformation: PRTL_USER_PROCESS_INFORMATION, -- ) -> NTSTATUS; -- fn RtlCreateUserProcessEx( -- NtImagePathName: PUNICODE_STRING, -- ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, -- InheritHandles: BOOLEAN, -- Flags: ULONG, -- ProcessInformation: PRTL_USER_PROCESS_INFORMATION, -- ) -> NTSTATUS; -- fn RtlExitUserProcess( -- ExitStatus: NTSTATUS, -- ); --}} --pub const RTL_CLONE_PROCESS_FLAGS_CREATE_SUSPENDED: ULONG = 0x00000001; --pub const RTL_CLONE_PROCESS_FLAGS_INHERIT_HANDLES: ULONG = 0x00000002; --pub const RTL_CLONE_PROCESS_FLAGS_NO_SYNCHRONIZE: ULONG = 0x00000004; --EXTERN!{extern "system" { -- fn RtlCloneUserProcess( -- ProcessFlags: ULONG, -- ProcessSecurityDescriptor: PSECURITY_DESCRIPTOR, -- ThreadSecurityDescriptor: PSECURITY_DESCRIPTOR, -- DebugPort: HANDLE, -- ProcessInformation: PRTL_USER_PROCESS_INFORMATION, -- ) -> NTSTATUS; -- fn RtlUpdateClonedCriticalSection( -- CriticalSection: PRTL_CRITICAL_SECTION, -- ); -- fn RtlUpdateClonedSRWLock( -- SRWLock: PRTL_SRWLOCK, -- Shared: LOGICAL, -- ); --}} --STRUCT!{struct RTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION { -- ReflectionProcessHandle: HANDLE, -- ReflectionThreadHandle: HANDLE, -- ReflectionClientId: CLIENT_ID, --}} --pub type PRTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION = -- *mut RTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION; --EXTERN!{extern "system" { -- fn RtlCreateProcessReflection( -- ProcessHandle: HANDLE, -- Flags: ULONG, -- StartRoutine: PVOID, -- StartContext: PVOID, -- EventHandle: HANDLE, -- ReflectionInformation: PRTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION, -- ) -> NTSTATUS; --}} --EXTERN!{extern "C" { -- fn RtlSetProcessIsCritical( -- NewValue: BOOLEAN, -- OldValue: PBOOLEAN, -- CheckFlag: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlSetThreadIsCritical( -- NewValue: BOOLEAN, -- OldValue: PBOOLEAN, -- CheckFlag: BOOLEAN, -- ) -> NTSTATUS; --}} --EXTERN!{extern "system" { -- fn RtlValidProcessProtection( -- ProcessProtection: PS_PROTECTION, -- ) -> BOOLEAN; -- fn RtlTestProtectedAccess( -- Source: PS_PROTECTION, -- Target: PS_PROTECTION, -- ) -> BOOLEAN; -- fn RtlIsCurrentProcess( -- ProcessHandle: HANDLE, -- ) -> BOOLEAN; -- fn RtlIsCurrentThread( -- ThreadHandle: HANDLE, -- ) -> BOOLEAN; --}} --FN!{stdcall PUSER_THREAD_START_ROUTINE( -- ThreadParameter: PVOID, --) -> NTSTATUS} --EXTERN!{extern "system" { -- fn RtlCreateUserThread( -- Process: HANDLE, -- ThreadSecurityDescriptor: PSECURITY_DESCRIPTOR, -- CreateSuspended: BOOLEAN, -- ZeroBits: ULONG, -- MaximumStackSize: SIZE_T, -- CommittedStackSize: SIZE_T, -- StartAddress: PUSER_THREAD_START_ROUTINE, -- Parameter: PVOID, -- Thread: PHANDLE, -- ClientId: PCLIENT_ID, -- ) -> NTSTATUS; -- fn RtlExitUserThread( -- ExitStatus: NTSTATUS, -- ); -- fn RtlIsCurrentThreadAttachExempt() -> BOOLEAN; -- fn RtlCreateUserStack( -- CommittedStackSize: SIZE_T, -- MaximumStackSize: SIZE_T, -- ZeroBits: ULONG_PTR, -- PageSize: SIZE_T, -- ReserveAlignment: ULONG_PTR, -- InitialTeb: PINITIAL_TEB, -- ) -> NTSTATUS; -- fn RtlFreeUserStack( -- AllocationBase: PVOID, -- ) -> NTSTATUS; --}} --STRUCT!{struct CONTEXT_CHUNK { -- Offset: LONG, -- Length: ULONG, --}} --pub type PCONTEXT_CHUNK = *mut CONTEXT_CHUNK; --STRUCT!{struct CONTEXT_EX { -- All: CONTEXT_CHUNK, -- Legacy: CONTEXT_CHUNK, -- XState: CONTEXT_CHUNK, --}} --pub type PCONTEXT_EX = *mut CONTEXT_EX; --pub const CONTEXT_EX_LENGTH: usize = 4096; --#[macro_export] --macro_rules! RTL_CONTEXT_EX_OFFSET { -- ($ContextEx:expr, $Chunk:ident) => { -- (*$ContextEx).$Chunk.Offset -- }; --} --#[macro_export] --macro_rules! RTL_CONTEXT_EX_LENGTH { -- ($ContextEx:expr, $Chunk:ident) => { -- (*$ContextEx).$Chunk.Length -- }; --} --#[macro_export] --macro_rules! RTL_CONTEXT_EX_CHUNK { -- ($Base:expr, $Layout:expr, $Chunk:ident) => { -- ($Base as usize + RTL_CONTEXT_EX_OFFSET!($Layout, $Chunk) as usize) as *mut c_void -- }; --} --#[macro_export] --macro_rules! RTL_CONTEXT_OFFSET { -- ($Context:expr, $Chunk:ident) => { -- RTL_CONTEXT_EX_OFFSET!(($Context as *const $crate::winapi::um::winnt::CONTEXT).offset(1) -- as *const $crate::ntrtl::CONTEXT_EX, $Chunk) -- }; --} --#[macro_export] --macro_rules! RTL_CONTEXT_LENGTH { -- ($Context:expr, $Chunk:ident) => { -- RTL_CONTEXT_EX_LENGTH!(($Context as *const $crate::winapi::um::winnt::CONTEXT).offset(1) -- as *const $crate::ntrtl::CONTEXT_EX, $Chunk) -- }; --} --#[macro_export] --macro_rules! RTL_CONTEXT_CHUNK { -- ($Context:expr, $Chunk:ident) => { -- RTL_CONTEXT_EX_CHUNK!( -- ($Context as *const $crate::winapi::um::winnt::CONTEXT).offset(1) -- as *const $crate::ntrtl::CONTEXT_EX, -- ($Context as *const $crate::winapi::um::winnt::CONTEXT).offset(1) -- as *const $crate::ntrtl::CONTEXT_EX, -- $Chunk -- ) -- }; --} --EXTERN!{extern "system" { -- fn RtlInitializeContext( -- Process: HANDLE, -- Context: PCONTEXT, -- Parameter: PVOID, -- InitialPc: PVOID, -- InitialSp: PVOID, -- ); -- fn RtlInitializeExtendedContext( -- Context: PCONTEXT, -- ContextFlags: ULONG, -- ContextEx: *mut PCONTEXT_EX, -- ) -> ULONG; -- fn RtlCopyExtendedContext( -- Destination: PCONTEXT_EX, -- ContextFlags: ULONG, -- Source: PCONTEXT_EX, -- ) -> ULONG; -- fn RtlGetExtendedContextLength( -- ContextFlags: ULONG, -- ContextLength: PULONG, -- ) -> ULONG; -- fn RtlGetExtendedFeaturesMask( -- ContextEx: PCONTEXT_EX, -- ) -> ULONG64; -- fn RtlLocateExtendedFeature( -- ContextEx: PCONTEXT_EX, -- FeatureId: ULONG, -- Length: PULONG, -- ) -> PVOID; -- fn RtlLocateLegacyContext( -- ContextEx: PCONTEXT_EX, -- Length: PULONG, -- ) -> PCONTEXT; -- fn RtlSetExtendedFeaturesMask( -- ContextEx: PCONTEXT_EX, -- FeatureMask: ULONG64, -- ); --}} --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --EXTERN!{extern "system" { -- fn RtlWow64GetThreadContext( -- ThreadHandle: HANDLE, -- ThreadContext: PWOW64_CONTEXT, -- ) -> NTSTATUS; -- fn RtlWow64SetThreadContext( -- ThreadHandle: HANDLE, -- ThreadContext: PWOW64_CONTEXT, -- ) -> NTSTATUS; --}} --EXTERN!{extern "system" { -- fn RtlRemoteCall( -- Process: HANDLE, -- Thread: HANDLE, -- CallSite: PVOID, -- ArgumentCount: ULONG, -- Arguments: PULONG_PTR, -- PassContext: BOOLEAN, -- AlreadySuspended: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlAddVectoredExceptionHandler( -- First: ULONG, -- Handler: PVECTORED_EXCEPTION_HANDLER, -- ) -> PVOID; -- fn RtlRemoveVectoredExceptionHandler( -- Handle: PVOID, -- ) -> ULONG; -- fn RtlAddVectoredContinueHandler( -- First: ULONG, -- Handler: PVECTORED_EXCEPTION_HANDLER, -- ) -> PVOID; -- fn RtlRemoveVectoredContinueHandler( -- Handle: PVOID, -- ) -> ULONG; --}} --FN!{stdcall PRTLP_UNHANDLED_EXCEPTION_FILTER( -- ExceptionInfo: PEXCEPTION_POINTERS, --) -> ULONG} --EXTERN!{extern "system" { -- fn RtlSetUnhandledExceptionFilter( -- UnhandledExceptionFilter: PRTLP_UNHANDLED_EXCEPTION_FILTER, -- ); -- fn RtlUnhandledExceptionFilter( -- ExceptionPointers: PEXCEPTION_POINTERS, -- ) -> LONG; -- fn RtlUnhandledExceptionFilter2( -- ExceptionPointers: PEXCEPTION_POINTERS, -- Flags: ULONG, -- ) -> LONG; -- fn RtlKnownExceptionFilter( -- ExceptionPointers: PEXCEPTION_POINTERS, -- ) -> LONG; --}} --#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] --IFDEF!{ --ENUM!{enum FUNCTION_TABLE_TYPE { -- RF_SORTED = 0, -- RF_UNSORTED = 1, -- RF_CALLBACK = 2, -- RF_KERNEL_DYNAMIC = 3, --}} --STRUCT!{struct DYNAMIC_FUNCTION_TABLE { -- ListEntry: LIST_ENTRY, -- FunctionTable: PRUNTIME_FUNCTION, -- TimeStamp: LARGE_INTEGER, -- MinimumAddress: ULONG64, -- MaximumAddress: ULONG64, -- BaseAddress: ULONG64, -- Callback: PGET_RUNTIME_FUNCTION_CALLBACK, -- Context: PVOID, -- OutOfProcessCallbackDll: PWSTR, -- Type: FUNCTION_TABLE_TYPE, -- EntryCount: ULONG, -- TreeNode: RTL_BALANCED_NODE, --}} --pub type PDYNAMIC_FUNCTION_TABLE = *mut DYNAMIC_FUNCTION_TABLE; --EXTERN!{extern "system" { -- fn RtlGetFunctionTableListHead() -> PLIST_ENTRY; --}} --} --EXTERN!{extern "system" { -- fn RtlImageNtHeader( -- BaseOfImage: PVOID, -- ) -> PIMAGE_NT_HEADERS; --}} --pub const RTL_IMAGE_NT_HEADER_EX_FLAG_NO_RANGE_CHECK: ULONG = 0x00000001; --EXTERN!{extern "system" { -- fn RtlImageNtHeaderEx( -- Flags: ULONG, -- BaseOfImage: PVOID, -- Size: ULONG64, -- OutHeaders: *mut PIMAGE_NT_HEADERS, -- ) -> NTSTATUS; -- fn RtlAddressInSectionTable( -- NtHeaders: PIMAGE_NT_HEADERS, -- BaseOfImage: PVOID, -- VirtualAddress: ULONG, -- ) -> PVOID; -- fn RtlSectionTableFromVirtualAddress( -- NtHeaders: PIMAGE_NT_HEADERS, -- BaseOfImage: PVOID, -- VirtualAddress: ULONG, -- ) -> PIMAGE_SECTION_HEADER; -- fn RtlImageDirectoryEntryToData( -- BaseOfImage: PVOID, -- MappedAsImage: BOOLEAN, -- DirectoryEntry: USHORT, -- Size: PULONG, -- ) -> PVOID; -- fn RtlImageRvaToSection( -- NtHeaders: PIMAGE_NT_HEADERS, -- BaseOfImage: PVOID, -- Rva: ULONG, -- ) -> PIMAGE_SECTION_HEADER; -- fn RtlImageRvaToVa( -- NtHeaders: PIMAGE_NT_HEADERS, -- BaseOfImage: PVOID, -- Rva: ULONG, -- LastRvaSection: *mut PIMAGE_SECTION_HEADER, -- ) -> PVOID; -- fn RtlFindExportedRoutineByName( -- BaseOfImage: PVOID, -- RoutineName: PSTR, -- ) -> PVOID; -- fn RtlGuardCheckLongJumpTarget( -- PcValue: PVOID, -- IsFastFail: BOOL, -- IsLongJumpTarget: PBOOL, -- ) -> NTSTATUS; -- fn RtlCompareMemoryUlong( -- Source: PVOID, -- Length: SIZE_T, -- Pattern: ULONG, -- ) -> SIZE_T; -- fn RtlFillMemoryUlong( -- Destination: PVOID, -- Length: SIZE_T, -- Pattern: ULONG, -- ); -- fn RtlFillMemoryUlonglong( -- Destination: PVOID, -- Length: SIZE_T, -- Pattern: ULONGLONG, -- ); -- fn RtlCreateEnvironment( -- CloneCurrentEnvironment: BOOLEAN, -- Environment: *mut PVOID, -- ) -> NTSTATUS; --}} --pub const RTL_CREATE_ENVIRONMENT_TRANSLATE: ULONG = 0x1; --pub const RTL_CREATE_ENVIRONMENT_TRANSLATE_FROM_OEM: ULONG = 0x2; --pub const RTL_CREATE_ENVIRONMENT_EMPTY: ULONG = 0x4; --EXTERN!{extern "system" { -- fn RtlCreateEnvironmentEx( -- SourceEnv: PVOID, -- Environment: *mut PVOID, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlDestroyEnvironment( -- Environment: PVOID, -- ) -> NTSTATUS; -- fn RtlSetCurrentEnvironment( -- Environment: PVOID, -- PreviousEnvironment: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlSetEnvironmentVar( -- Environment: *mut PWSTR, -- Name: PWSTR, -- NameLength: SIZE_T, -- Value: PWSTR, -- ValueLength: SIZE_T, -- ) -> NTSTATUS; -- fn RtlSetEnvironmentVariable( -- Environment: *mut PVOID, -- Name: PUNICODE_STRING, -- Value: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlQueryEnvironmentVariable( -- Environment: PVOID, -- Name: PWSTR, -- NameLength: SIZE_T, -- Value: PWSTR, -- ValueLength: SIZE_T, -- ReturnLength: PSIZE_T, -- ) -> NTSTATUS; -- fn RtlQueryEnvironmentVariable_U( -- Environment: PVOID, -- Name: PUNICODE_STRING, -- Value: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlExpandEnvironmentStrings( -- Environment: PVOID, -- Src: PWSTR, -- SrcLength: SIZE_T, -- Dst: PWSTR, -- DstLength: SIZE_T, -- ReturnLength: PSIZE_T, -- ) -> NTSTATUS; -- fn RtlExpandEnvironmentStrings_U( -- Environment: PVOID, -- Source: PUNICODE_STRING, -- Destination: PUNICODE_STRING, -- ReturnedLength: PULONG, -- ) -> NTSTATUS; -- fn RtlSetEnvironmentStrings( -- NewEnvironment: PWCHAR, -- NewEnvironmentSize: SIZE_T, -- ) -> NTSTATUS; --}} --STRUCT!{struct RTLP_CURDIR_REF { -- ReferenceCount: LONG, -- DirectoryHandle: HANDLE, --}} --pub type PRTLP_CURDIR_REF = *mut RTLP_CURDIR_REF; --STRUCT!{struct RTL_RELATIVE_NAME_U { -- RelativeName: UNICODE_STRING, -- ContainingDirectory: HANDLE, -- CurDirRef: PRTLP_CURDIR_REF, --}} --pub type PRTL_RELATIVE_NAME_U = *mut RTL_RELATIVE_NAME_U; --ENUM!{enum RTL_PATH_TYPE { -- RtlPathTypeUnknown = 0, -- RtlPathTypeUncAbsolute = 1, -- RtlPathTypeDriveAbsolute = 2, -- RtlPathTypeDriveRelative = 3, -- RtlPathTypeRooted = 4, -- RtlPathTypeRelative = 5, -- RtlPathTypeLocalDevice = 6, -- RtlPathTypeRootLocalDevice = 7, --}} --EXTERN!{extern "C" { -- static mut RtlDosPathSeperatorsString: UNICODE_STRING; -- static mut RtlAlternateDosPathSeperatorString: UNICODE_STRING; -- static mut RtlNtPathSeperatorString: UNICODE_STRING; --}} --/// "ntdll.dll" --pub const RtlNtdllName: UTF16Const = UTF16Const(&[ -- 0x006E, 0x0074, 0x0064, 0x006C, 0x006C, 0x002E, 0x0064, 0x006C, 0x006C, 0u16, --]); --EXTERN!{extern "system" { -- fn RtlDetermineDosPathNameType_U( -- DosFileName: PWSTR, -- ) -> RTL_PATH_TYPE; -- fn RtlDetermineDosPathNameType_Ustr( -- DosFileName: PCUNICODE_STRING, -- ) -> RTL_PATH_TYPE; -- fn RtlIsDosDeviceName_U( -- DosFileName: PWSTR, -- ) -> ULONG; -- fn RtlIsDosDeviceName_Ustr( -- DosFileName: PUNICODE_STRING, -- ) -> ULONG; -- fn RtlGetFullPathName_U( -- FileName: PWSTR, -- BufferLength: ULONG, -- Buffer: PWSTR, -- FilePart: *mut PWSTR, -- ) -> ULONG; -- fn RtlGetFullPathName_UEx( -- FileName: PWSTR, -- BufferLength: ULONG, -- Buffer: PWSTR, -- FilePart: *mut PWSTR, -- BytesRequired: *mut ULONG, -- ) -> NTSTATUS; -- fn RtlGetFullPathName_UstrEx( -- FileName: PUNICODE_STRING, -- StaticString: PUNICODE_STRING, -- DynamicString: PUNICODE_STRING, -- StringUsed: *mut PUNICODE_STRING, -- FilePartPrefixCch: *mut SIZE_T, -- NameInvalid: PBOOLEAN, -- InputPathType: *mut RTL_PATH_TYPE, -- BytesRequired: *mut SIZE_T, -- ) -> NTSTATUS; -- fn RtlGetCurrentDirectory_U( -- BufferLength: ULONG, -- Buffer: PWSTR, -- ) -> ULONG; -- fn RtlSetCurrentDirectory_U( -- PathName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlGetLongestNtPathLength() -> ULONG; -- fn RtlDosPathNameToNtPathName_U( -- DosFileName: PWSTR, -- NtFileName: PUNICODE_STRING, -- FilePart: *mut PWSTR, -- RelativeName: PRTL_RELATIVE_NAME_U, -- ) -> BOOLEAN; -- fn RtlDosPathNameToNtPathName_U_WithStatus( -- DosFileName: PWSTR, -- NtFileName: PUNICODE_STRING, -- FilePart: *mut PWSTR, -- RelativeName: PRTL_RELATIVE_NAME_U, -- ) -> NTSTATUS; -- fn RtlDosLongPathNameToNtPathName_U_WithStatus( -- DosFileName: PWSTR, -- NtFileName: PUNICODE_STRING, -- FilePart: *mut PWSTR, -- RelativeName: PRTL_RELATIVE_NAME_U, -- ) -> NTSTATUS; -- fn RtlDosPathNameToRelativeNtPathName_U( -- DosFileName: PWSTR, -- NtFileName: PUNICODE_STRING, -- FilePart: *mut PWSTR, -- RelativeName: PRTL_RELATIVE_NAME_U, -- ) -> BOOLEAN; -- fn RtlDosPathNameToRelativeNtPathName_U_WithStatus( -- DosFileName: PWSTR, -- NtFileName: PUNICODE_STRING, -- FilePart: *mut PWSTR, -- RelativeName: PRTL_RELATIVE_NAME_U, -- ) -> NTSTATUS; -- fn RtlDosLongPathNameToRelativeNtPathName_U_WithStatus( -- DosFileName: PWSTR, -- NtFileName: PUNICODE_STRING, -- FilePart: *mut PWSTR, -- RelativeName: PRTL_RELATIVE_NAME_U, -- ) -> NTSTATUS; -- fn RtlReleaseRelativeName( -- RelativeName: PRTL_RELATIVE_NAME_U, -- ); -- fn RtlDosSearchPath_U( -- Path: PWSTR, -- FileName: PWSTR, -- Extension: PWSTR, -- BufferLength: ULONG, -- Buffer: PWSTR, -- FilePart: *mut PWSTR, -- ) -> ULONG; --}} --pub const RTL_DOS_SEARCH_PATH_FLAG_APPLY_ISOLATION_REDIRECTION: ULONG = 0x00000001; --pub const RTL_DOS_SEARCH_PATH_FLAG_DISALLOW_DOT_RELATIVE_PATH_SEARCH: ULONG = 0x00000002; --pub const RTL_DOS_SEARCH_PATH_FLAG_APPLY_DEFAULT_EXTENSION_WHEN_NOT_RELATIVE_PATH_EVEN_IF_FILE_HAS_EXTENSION: ULONG = 0x00000004; --EXTERN!{extern "system" { -- fn RtlDosSearchPath_Ustr( -- Flags: ULONG, -- Path: PUNICODE_STRING, -- FileName: PUNICODE_STRING, -- DefaultExtension: PUNICODE_STRING, -- StaticString: PUNICODE_STRING, -- DynamicString: PUNICODE_STRING, -- FullFileNameOut: *mut PCUNICODE_STRING, -- FilePartPrefixCch: *mut SIZE_T, -- BytesRequired: *mut SIZE_T, -- ) -> NTSTATUS; -- fn RtlDoesFileExists_U( -- FileName: PWSTR, -- ) -> BOOLEAN; -- fn RtlGetLengthWithoutLastFullDosOrNtPathElement( -- Flags: ULONG, -- PathString: PUNICODE_STRING, -- Length: PULONG, -- ) -> NTSTATUS; -- fn RtlGetLengthWithoutTrailingPathSeperators( -- Flags: ULONG, -- PathString: PUNICODE_STRING, -- Length: PULONG, -- ) -> NTSTATUS; --}} --STRUCT!{struct GENERATE_NAME_CONTEXT { -- Checksum: USHORT, -- CheckSumInserted: BOOLEAN, -- NameLength: UCHAR, -- NameBuffer: [WCHAR; 8], -- ExtensionLength: ULONG, -- ExtensionBuffer: [WCHAR; 4], -- LastIndexValue: ULONG, --}} --pub type PGENERATE_NAME_CONTEXT = *mut GENERATE_NAME_CONTEXT; --EXTERN!{extern "system" { -- fn RtlGenerate8dot3Name( -- Name: PCUNICODE_STRING, -- AllowExtendedCharacters: BOOLEAN, -- Context: PGENERATE_NAME_CONTEXT, -- Name8dot3: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlComputePrivatizedDllName_U( -- DllName: PUNICODE_STRING, -- RealName: PUNICODE_STRING, -- LocalName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlGetSearchPath( -- SearchPathA: *mut PWSTR, -- ) -> BOOLEAN; -- fn RtlSetSearchPathMode( -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlGetExePath() -> PWSTR; -- fn RtlGetNtSystemRoot() -> PWSTR; -- fn RtlAreLongPathsEnabled() -> BOOLEAN; -- fn RtlIsThreadWithinLoaderCallout() -> BOOLEAN; -- fn RtlDllShutdownInProgress() -> BOOLEAN; --}} --STRUCT!{struct RTL_HEAP_ENTRY_u_s1 { -- Settable: SIZE_T, -- Tag: ULONG, --}} --STRUCT!{struct RTL_HEAP_ENTRY_u_s2 { -- CommittedSize: SIZE_T, -- FirstBlock: PVOID, --}} --UNION!{union RTL_HEAP_ENTRY_u { -- s1: RTL_HEAP_ENTRY_u_s1, -- s2: RTL_HEAP_ENTRY_u_s2, --}} --STRUCT!{struct RTL_HEAP_ENTRY { -- Size: SIZE_T, -- Flags: USHORT, -- AllocatorBackTraceIndex: USHORT, -- u: RTL_HEAP_ENTRY_u, --}} --pub type PRTL_HEAP_ENTRY = *mut RTL_HEAP_ENTRY; --pub const RTL_HEAP_BUSY: USHORT = 0x0001; --pub const RTL_HEAP_SEGMENT: USHORT = 0x0002; --pub const RTL_HEAP_SETTABLE_VALUE: USHORT = 0x0010; --pub const RTL_HEAP_SETTABLE_FLAG1: USHORT = 0x0020; --pub const RTL_HEAP_SETTABLE_FLAG2: USHORT = 0x0040; --pub const RTL_HEAP_SETTABLE_FLAG3: USHORT = 0x0080; --pub const RTL_HEAP_SETTABLE_FLAGS: USHORT = 0x00e0; --pub const RTL_HEAP_UNCOMMITTED_RANGE: USHORT = 0x0100; --pub const RTL_HEAP_PROTECTED_ENTRY: USHORT = 0x0200; --STRUCT!{struct RTL_HEAP_TAG { -- NumberOfAllocations: ULONG, -- NumberOfFrees: ULONG, -- BytesAllocated: SIZE_T, -- TagIndex: USHORT, -- CreatorBackTraceIndex: USHORT, -- TagName: [WCHAR; 24], --}} --pub type PRTL_HEAP_TAG = *mut RTL_HEAP_TAG; --STRUCT!{struct RTL_HEAP_INFORMATION { -- BaseAddress: PVOID, -- Flags: ULONG, -- EntryOverhead: USHORT, -- CreatorBackTraceIndex: USHORT, -- BytesAllocated: SIZE_T, -- BytesCommitted: SIZE_T, -- NumberOfTags: ULONG, -- NumberOfEntries: ULONG, -- NumberOfPseudoTags: ULONG, -- PseudoTagGranularity: ULONG, -- Reserved: [ULONG; 5], -- Tags: PRTL_HEAP_TAG, -- Entries: PRTL_HEAP_ENTRY, --}} --pub type PRTL_HEAP_INFORMATION = *mut RTL_HEAP_INFORMATION; --STRUCT!{struct RTL_PROCESS_HEAPS { -- NumberOfHeaps: ULONG, -- Heaps: [RTL_HEAP_INFORMATION; 1], --}} --pub type PRTL_PROCESS_HEAPS = *mut RTL_PROCESS_HEAPS; --FN!{stdcall PRTL_HEAP_COMMIT_ROUTINE( -- Base: PVOID, -- CommitAddress: *mut PVOID, -- CommitSize: PSIZE_T, --) -> NTSTATUS} --STRUCT!{struct RTL_HEAP_PARAMETERS { -- Length: ULONG, -- SegmentReserve: SIZE_T, -- SegmentCommit: SIZE_T, -- DeCommitFreeBlockThreshold: SIZE_T, -- DeCommitTotalFreeThreshold: SIZE_T, -- MaximumAllocationSize: SIZE_T, -- VirtualMemoryThreshold: SIZE_T, -- InitialCommit: SIZE_T, -- InitialReserve: SIZE_T, -- CommitRoutine: PRTL_HEAP_COMMIT_ROUTINE, -- Reserved: [SIZE_T; 2], --}} --pub type PRTL_HEAP_PARAMETERS = *mut RTL_HEAP_PARAMETERS; --pub const HEAP_SETTABLE_USER_VALUE: ULONG = 0x00000100; --pub const HEAP_SETTABLE_USER_FLAG1: ULONG = 0x00000200; --pub const HEAP_SETTABLE_USER_FLAG2: ULONG = 0x00000400; --pub const HEAP_SETTABLE_USER_FLAG3: ULONG = 0x00000800; --pub const HEAP_SETTABLE_USER_FLAGS: ULONG = 0x00000e00; --pub const HEAP_CLASS_0: ULONG = 0x00000000; --pub const HEAP_CLASS_1: ULONG = 0x00001000; --pub const HEAP_CLASS_2: ULONG = 0x00002000; --pub const HEAP_CLASS_3: ULONG = 0x00003000; --pub const HEAP_CLASS_4: ULONG = 0x00004000; --pub const HEAP_CLASS_5: ULONG = 0x00005000; --pub const HEAP_CLASS_6: ULONG = 0x00006000; --pub const HEAP_CLASS_7: ULONG = 0x00007000; --pub const HEAP_CLASS_8: ULONG = 0x00008000; --pub const HEAP_CLASS_MASK: ULONG = 0x0000f000; --EXTERN!{extern "system" { -- fn RtlCreateHeap( -- Flags: ULONG, -- HeapBase: PVOID, -- ReserveSize: SIZE_T, -- CommitSize: SIZE_T, -- Lock: PVOID, -- Parameters: PRTL_HEAP_PARAMETERS, -- ) -> PVOID; -- fn RtlDestroyHeap( -- HeapHandle: PVOID, -- ) -> PVOID; -- fn RtlAllocateHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- Size: SIZE_T, -- ) -> PVOID; -- fn RtlFreeHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- BaseAddress: PVOID, -- ) -> BOOLEAN; -- fn RtlSizeHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- BaseAddress: PVOID, -- ) -> SIZE_T; -- fn RtlZeroHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlProtectHeap( -- HeapHandle: PVOID, -- MakeReadOnly: BOOLEAN, -- ); --}} --#[inline] #[cfg(all(feature = "beta", not(target_arch = "aarch64")))] --pub unsafe fn RtlProcessHeap() -> PVOID { -- use crate::ntpsapi::NtCurrentPeb; -- (*NtCurrentPeb()).ProcessHeap --} --EXTERN!{extern "system" { -- fn RtlLockHeap( -- HeapHandle: PVOID, -- ) -> BOOLEAN; -- fn RtlUnlockHeap( -- HeapHandle: PVOID, -- ) -> BOOLEAN; -- fn RtlReAllocateHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- BaseAddress: PVOID, -- Size: SIZE_T, -- ) -> PVOID; -- fn RtlGetUserInfoHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- BaseAddress: PVOID, -- UserValue: *mut PVOID, -- UserFlags: PULONG, -- ) -> BOOLEAN; -- fn RtlSetUserValueHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- BaseAddress: PVOID, -- UserValue: PVOID, -- ) -> BOOLEAN; -- fn RtlSetUserFlagsHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- BaseAddress: PVOID, -- UserFlagsReset: ULONG, -- UserFlagsSet: ULONG, -- ) -> BOOLEAN; --}} --STRUCT!{struct RTL_HEAP_TAG_INFO { -- NumberOfAllocations: ULONG, -- NumberOfFrees: ULONG, -- BytesAllocated: SIZE_T, --}} --pub type PRTL_HEAP_TAG_INFO = *mut RTL_HEAP_TAG_INFO; --EXTERN!{extern "system" { -- fn RtlCreateTagHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- TagPrefix: PWSTR, -- TagNames: PWSTR, -- ) -> ULONG; -- fn RtlQueryTagHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- TagIndex: USHORT, -- ResetCounters: BOOLEAN, -- TagInfo: PRTL_HEAP_TAG_INFO, -- ) -> PWSTR; -- fn RtlExtendHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- Base: PVOID, -- Size: SIZE_T, -- ) -> NTSTATUS; -- fn RtlCompactHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- ) -> SIZE_T; -- fn RtlValidateHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- BaseAddress: PVOID, -- ) -> BOOLEAN; -- fn RtlValidateProcessHeaps() -> BOOLEAN; -- fn RtlGetProcessHeaps( -- NumberOfHeaps: ULONG, -- ProcessHeaps: *mut PVOID, -- ) -> ULONG; --}} --FN!{stdcall PRTL_ENUM_HEAPS_ROUTINE( -- HeapHandle: PVOID, -- Parameter: PVOID, --) -> NTSTATUS} --EXTERN!{extern "system" { -- fn RtlEnumProcessHeaps( -- EnumRoutine: PRTL_ENUM_HEAPS_ROUTINE, -- Parameter: PVOID, -- ) -> NTSTATUS; --}} --STRUCT!{struct RTL_HEAP_USAGE_ENTRY { -- Next: *mut RTL_HEAP_USAGE_ENTRY, -- Address: PVOID, -- Size: SIZE_T, -- AllocatorBackTraceIndex: USHORT, -- TagIndex: USHORT, --}} --pub type PRTL_HEAP_USAGE_ENTRY = *mut RTL_HEAP_USAGE_ENTRY; --STRUCT!{struct RTL_HEAP_USAGE { -- Length: ULONG, -- BytesAllocated: SIZE_T, -- BytesCommitted: SIZE_T, -- BytesReserved: SIZE_T, -- BytesReservedMaximum: SIZE_T, -- Entries: PRTL_HEAP_USAGE_ENTRY, -- AddedEntries: PRTL_HEAP_USAGE_ENTRY, -- RemovedEntries: PRTL_HEAP_USAGE_ENTRY, -- Reserved: [ULONG_PTR; 8], --}} --pub type PRTL_HEAP_USAGE = *mut RTL_HEAP_USAGE; --pub const HEAP_USAGE_ALLOCATED_BLOCKS: ULONG = HEAP_REALLOC_IN_PLACE_ONLY; --pub const HEAP_USAGE_FREE_BUFFER: ULONG = HEAP_ZERO_MEMORY; --EXTERN!{extern "system" { -- fn RtlUsageHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- Usage: PRTL_HEAP_USAGE, -- ) -> NTSTATUS; --}} --STRUCT!{struct RTL_HEAP_WALK_ENTRY_u_Block { -- Settable: SIZE_T, -- TagIndex: USHORT, -- AllocatorBackTraceIndex: USHORT, -- Reserved: [ULONG; 2], --}} --STRUCT!{struct RTL_HEAP_WALK_ENTRY_u_Segment { -- CommittedSize: ULONG, -- UnCommittedSize: ULONG, -- FirstEntry: PVOID, -- LastEntry: PVOID, --}} --UNION!{union RTL_HEAP_WALK_ENTRY_u { -- Block: RTL_HEAP_WALK_ENTRY_u_Block, -- Segment: RTL_HEAP_WALK_ENTRY_u_Segment, --}} --STRUCT!{struct RTL_HEAP_WALK_ENTRY { -- DataAddress: PVOID, -- DataSize: SIZE_T, -- OverheadBytes: UCHAR, -- SegmentIndex: UCHAR, -- Flags: USHORT, -- u: RTL_HEAP_WALK_ENTRY_u, --}} --pub type PRTL_HEAP_WALK_ENTRY = *mut RTL_HEAP_WALK_ENTRY; --EXTERN!{extern "system" { -- fn RtlWalkHeap( -- HeapHandle: PVOID, -- Entry: PRTL_HEAP_WALK_ENTRY, -- ) -> NTSTATUS; --}} --pub const HeapDetailedFailureInformation: u32 = 0x80000001; --pub const HeapSetDebuggingInformation: u32 = 0x80000002; --ENUM!{enum HEAP_COMPATIBILITY_MODE { -- HEAP_COMPATIBILITY_STANDARD = 0, -- HEAP_COMPATIBILITY_LAL = 1, -- HEAP_COMPATIBILITY_LFH = 2, --}} --STRUCT!{struct PROCESS_HEAP_INFORMATION { -- ReserveSize: ULONG_PTR, -- CommitSize: ULONG_PTR, -- NumberOfHeaps: ULONG, -- FirstHeapInformationOffset: ULONG_PTR, --}} --pub type PPROCESS_HEAP_INFORMATION = *mut PROCESS_HEAP_INFORMATION; --STRUCT!{struct HEAP_INFORMATION { -- Address: ULONG_PTR, -- Mode: ULONG, -- ReserveSize: ULONG_PTR, -- CommitSize: ULONG_PTR, -- FirstRegionInformationOffset: ULONG_PTR, -- NextHeapInformationOffset: ULONG_PTR, --}} --pub type PHEAP_INFORMATION = *mut HEAP_INFORMATION; --UNION!{union HEAP_EXTENDED_INFORMATION_u { -- ProcessHeapInformation: PROCESS_HEAP_INFORMATION, -- HeapInformation: HEAP_INFORMATION, --}} --STRUCT!{struct HEAP_EXTENDED_INFORMATION { -- Process: HANDLE, -- Heap: ULONG_PTR, -- Level: ULONG, -- CallbackRoutine: PVOID, -- CallbackContext: PVOID, -- u: HEAP_EXTENDED_INFORMATION_u, --}} --pub type PHEAP_EXTENDED_INFORMATION = *mut HEAP_EXTENDED_INFORMATION; --FN!{stdcall PRTL_HEAP_LEAK_ENUMERATION_ROUTINE( -- Reserved: LONG, -- HeapHandle: PVOID, -- BaseAddress: PVOID, -- BlockSize: SIZE_T, -- StackTraceDepth: ULONG, -- StackTrace: *mut PVOID, --) -> NTSTATUS} --STRUCT!{struct HEAP_DEBUGGING_INFORMATION { -- InterceptorFunction: PVOID, -- InterceptorValue: USHORT, -- ExtendedOptions: ULONG, -- StackTraceDepth: ULONG, -- MinTotalBlockSize: SIZE_T, -- MaxTotalBlockSize: SIZE_T, -- HeapLeakEnumerationRoutine: PRTL_HEAP_LEAK_ENUMERATION_ROUTINE, --}} --pub type PHEAP_DEBUGGING_INFORMATION = *mut HEAP_DEBUGGING_INFORMATION; --EXTERN!{extern "system" { -- fn RtlQueryHeapInformation( -- HeapHandle: PVOID, -- HeapInformationClass: HEAP_INFORMATION_CLASS, -- HeapInformation: PVOID, -- HeapInformationLength: SIZE_T, -- ReturnLength: PSIZE_T, -- ) -> NTSTATUS; -- fn RtlSetHeapInformation( -- HeapHandle: PVOID, -- HeapInformationClass: HEAP_INFORMATION_CLASS, -- HeapInformation: PVOID, -- HeapInformationLength: SIZE_T, -- ) -> NTSTATUS; -- fn RtlMultipleAllocateHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- Size: SIZE_T, -- Count: ULONG, -- Array: *mut PVOID, -- ) -> ULONG; -- fn RtlMultipleFreeHeap( -- HeapHandle: PVOID, -- Flags: ULONG, -- Count: ULONG, -- Array: *mut PVOID, -- ) -> ULONG; -- fn RtlDetectHeapLeaks(); -- fn RtlFlushHeaps(); --}} --STRUCT!{struct RTL_MEMORY_ZONE_SEGMENT { -- NextSegment: *mut RTL_MEMORY_ZONE_SEGMENT, -- Size: SIZE_T, -- Next: PVOID, -- Limit: PVOID, --}} --pub type PRTL_MEMORY_ZONE_SEGMENT = *mut RTL_MEMORY_ZONE_SEGMENT; --STRUCT!{struct RTL_MEMORY_ZONE { -- Segment: RTL_MEMORY_ZONE_SEGMENT, -- Lock: RTL_SRWLOCK, -- LockCount: ULONG, -- FirstSegment: PRTL_MEMORY_ZONE_SEGMENT, --}} --pub type PRTL_MEMORY_ZONE = *mut RTL_MEMORY_ZONE; --EXTERN!{extern "system" { -- fn RtlCreateMemoryZone( -- MemoryZone: *mut PVOID, -- InitialSize: SIZE_T, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlDestroyMemoryZone( -- MemoryZone: PVOID, -- ) -> NTSTATUS; -- fn RtlAllocateMemoryZone( -- MemoryZone: PVOID, -- BlockSize: SIZE_T, -- Block: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlResetMemoryZone( -- MemoryZone: PVOID, -- ) -> NTSTATUS; -- fn RtlLockMemoryZone( -- MemoryZone: PVOID, -- ) -> NTSTATUS; -- fn RtlUnlockMemoryZone( -- MemoryZone: PVOID, -- ) -> NTSTATUS; -- fn RtlCreateMemoryBlockLookaside( -- MemoryBlockLookaside: *mut PVOID, -- Flags: ULONG, -- InitialSize: ULONG, -- MinimumBlockSize: ULONG, -- MaximumBlockSize: ULONG, -- ) -> NTSTATUS; -- fn RtlDestroyMemoryBlockLookaside( -- MemoryBlockLookaside: PVOID, -- ) -> NTSTATUS; -- fn RtlAllocateMemoryBlockLookaside( -- MemoryBlockLookaside: PVOID, -- BlockSize: ULONG, -- Block: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlFreeMemoryBlockLookaside( -- MemoryBlockLookaside: PVOID, -- Block: PVOID, -- ) -> NTSTATUS; -- fn RtlExtendMemoryBlockLookaside( -- MemoryBlockLookaside: PVOID, -- Increment: ULONG, -- ) -> NTSTATUS; -- fn RtlResetMemoryBlockLookaside( -- MemoryBlockLookaside: PVOID, -- ) -> NTSTATUS; -- fn RtlLockMemoryBlockLookaside( -- MemoryBlockLookaside: PVOID, -- ) -> NTSTATUS; -- fn RtlUnlockMemoryBlockLookaside( -- MemoryBlockLookaside: PVOID, -- ) -> NTSTATUS; -- fn RtlGetCurrentTransaction() -> HANDLE; -- fn RtlSetCurrentTransaction( -- TransactionHandle: HANDLE, -- ) -> LOGICAL; --}} --#[inline] --pub const fn RtlIsEqualLuid(L1: &LUID, L2: &LUID) -> bool { -- ((L1.LowPart == L2.LowPart) & (L1.HighPart == L2.HighPart)) as u8 != 0 //fixme --} --#[inline] --pub const fn RtlIsZeroLuid(L1: &LUID) -> bool { -- (L1.LowPart | L1.HighPart as u32) == 0 --} --#[inline] --pub const fn RtlConvertLongToLuid(Long: LONG) -> LUID { -- LUID { LowPart: Long as u32, HighPart: ((Long as i64) >> 32) as i32 } --} --#[inline] --pub const fn RtlConvertUlongToLuid(Ulong: ULONG) -> LUID { -- LUID { LowPart: Ulong, HighPart: 0 } --} --EXTERN!{extern "system" { -- fn RtlCopyLuid( -- DestinationLuid: PLUID, -- SourceLuid: PLUID, -- ); -- fn RtlCopyLuidAndAttributesArray( -- Count: ULONG, -- Src: PLUID_AND_ATTRIBUTES, -- Dest: PLUID_AND_ATTRIBUTES, -- ); --}} --STRUCT!{struct RTL_PROCESS_VERIFIER_OPTIONS { -- SizeStruct: ULONG, -- Option: ULONG, -- OptionData: [UCHAR; 1], --}} --pub type PRTL_PROCESS_VERIFIER_OPTIONS = *mut RTL_PROCESS_VERIFIER_OPTIONS; --UNION!{union RTL_DEBUG_INFORMATION_u { -- Modules: *mut RTL_PROCESS_MODULES, -- ModulesEx: *mut RTL_PROCESS_MODULE_INFORMATION_EX, --}} --STRUCT!{struct RTL_DEBUG_INFORMATION { -- SectionHandleClient: HANDLE, -- ViewBaseClient: PVOID, -- ViewBaseTarget: PVOID, -- ViewBaseDelta: ULONG_PTR, -- EventPairClient: HANDLE, -- EventPairTarget: HANDLE, -- TargetProcessId: HANDLE, -- TargetThreadHandle: HANDLE, -- Flags: ULONG, -- OffsetFree: SIZE_T, -- CommitSize: SIZE_T, -- ViewSize: SIZE_T, -- u: RTL_DEBUG_INFORMATION_u, -- BackTraces: *mut RTL_PROCESS_BACKTRACES, -- Heaps: *mut RTL_PROCESS_HEAPS, -- Locks: *mut RTL_PROCESS_LOCKS, -- SpecificHeap: PVOID, -- TargetProcessHandle: HANDLE, -- VerifierOptions: PRTL_PROCESS_VERIFIER_OPTIONS, -- ProcessHeap: PVOID, -- CriticalSectionHandle: HANDLE, -- CriticalSectionOwnerThread: HANDLE, -- Reserved: [PVOID; 4], --}} --pub type PRTL_DEBUG_INFORMATION = *mut RTL_DEBUG_INFORMATION; --EXTERN!{extern "system" { -- fn RtlCreateQueryDebugBuffer( -- MaximumCommit: ULONG, -- UseEventPair: BOOLEAN, -- ) -> PRTL_DEBUG_INFORMATION; -- fn RtlDestroyQueryDebugBuffer( -- Buffer: PRTL_DEBUG_INFORMATION, -- ) -> NTSTATUS; -- fn RtlCommitDebugInfo( -- Buffer: PRTL_DEBUG_INFORMATION, -- Size: SIZE_T, -- ) -> PVOID; -- fn RtlDeCommitDebugInfo( -- Buffer: PRTL_DEBUG_INFORMATION, -- p: PVOID, -- Size: SIZE_T, -- ); --}} --pub const RTL_QUERY_PROCESS_MODULES: ULONG = 0x00000001; --pub const RTL_QUERY_PROCESS_BACKTRACES: ULONG = 0x00000002; --pub const RTL_QUERY_PROCESS_HEAP_SUMMARY: ULONG = 0x00000004; --pub const RTL_QUERY_PROCESS_HEAP_TAGS: ULONG = 0x00000008; --pub const RTL_QUERY_PROCESS_HEAP_ENTRIES: ULONG = 0x00000010; --pub const RTL_QUERY_PROCESS_LOCKS: ULONG = 0x00000020; --pub const RTL_QUERY_PROCESS_MODULES32: ULONG = 0x00000040; --pub const RTL_QUERY_PROCESS_VERIFIER_OPTIONS: ULONG = 0x00000080; --pub const RTL_QUERY_PROCESS_MODULESEX: ULONG = 0x00000100; --pub const RTL_QUERY_PROCESS_HEAP_ENTRIES_EX: ULONG = 0x00000200; --pub const RTL_QUERY_PROCESS_CS_OWNER: ULONG = 0x00000400; --pub const RTL_QUERY_PROCESS_NONINVASIVE: ULONG = 0x80000000; --EXTERN!{extern "system" { -- fn RtlQueryProcessDebugInformation( -- UniqueProcessId: HANDLE, -- Flags: ULONG, -- Buffer: PRTL_DEBUG_INFORMATION, -- ) -> NTSTATUS; -- fn RtlFindMessage( -- DllHandle: PVOID, -- MessageTableId: ULONG, -- MessageLanguageId: ULONG, -- MessageId: ULONG, -- MessageEntry: *mut PMESSAGE_RESOURCE_ENTRY, -- ) -> NTSTATUS; -- fn RtlFormatMessage( -- MessageFormat: PWSTR, -- MaximumWidth: ULONG, -- IgnoreInserts: BOOLEAN, -- ArgumentsAreAnsi: BOOLEAN, -- ArgumentsAreAnArray: BOOLEAN, -- Arguments: *mut va_list, -- Buffer: PWSTR, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; --}} --STRUCT!{struct PARSE_MESSAGE_CONTEXT { -- fFlags: ULONG, -- cwSavColumn: ULONG, -- iwSrc: SIZE_T, -- iwDst: SIZE_T, -- iwDstSpace: SIZE_T, -- lpvArgStart: va_list, --}} --pub type PPARSE_MESSAGE_CONTEXT = *mut PARSE_MESSAGE_CONTEXT; --#[inline] --pub fn INIT_PARSE_MESSAGE_CONTEXT(ctx: &mut PARSE_MESSAGE_CONTEXT) { -- ctx.fFlags = 0; --} --#[inline] --pub fn TEST_PARSE_MESSAGE_CONTEXT_FLAG(ctx: &mut PARSE_MESSAGE_CONTEXT, flag: ULONG) -> ULONG { -- ctx.fFlags & flag --} --#[inline] --pub fn SET_PARSE_MESSAGE_CONTEXT_FLAG(ctx: &mut PARSE_MESSAGE_CONTEXT, flag: ULONG) -> ULONG { -- ctx.fFlags |= flag; -- ctx.fFlags --} --#[inline] --pub fn CLEAR_PARSE_MESSAGE_CONTEXT_FLAG(ctx: &mut PARSE_MESSAGE_CONTEXT, flag: ULONG) -> ULONG { -- ctx.fFlags &= !flag; -- ctx.fFlags --} --EXTERN!{extern "system" { -- fn RtlFormatMessageEx( -- MessageFormat: PWSTR, -- MaximumWidth: ULONG, -- IgnoreInserts: BOOLEAN, -- ArgumentsAreAnsi: BOOLEAN, -- ArgumentsAreAnArray: BOOLEAN, -- Arguments: *mut va_list, -- Buffer: PWSTR, -- Length: ULONG, -- ReturnLength: PULONG, -- ParseContext: PPARSE_MESSAGE_CONTEXT, -- ) -> NTSTATUS; -- fn RtlNtStatusToDosError( -- Status: NTSTATUS, -- ) -> ULONG; -- fn RtlNtStatusToDosErrorNoTeb( -- Status: NTSTATUS, -- ) -> ULONG; -- fn RtlGetLastNtStatus() -> NTSTATUS; -- fn RtlGetLastWin32Error() -> LONG; -- fn RtlSetLastWin32ErrorAndNtStatusFromNtStatus( -- Status: NTSTATUS, -- ); -- fn RtlSetLastWin32Error( -- Win32Error: LONG, -- ); -- fn RtlRestoreLastWin32Error( -- Win32Error: LONG, -- ); --}} --pub const RTL_ERRORMODE_FAILCRITICALERRORS: ULONG = 0x0010; --pub const RTL_ERRORMODE_NOGPFAULTERRORBOX: ULONG = 0x0020; --pub const RTL_ERRORMODE_NOOPENFILEERRORBOX: ULONG = 0x0040; --EXTERN!{extern "system" { -- fn RtlGetThreadErrorMode() -> ULONG; -- fn RtlSetThreadErrorMode( -- NewMode: ULONG, -- OldMode: PULONG, -- ) -> NTSTATUS; -- fn RtlReportException( -- ExceptionRecord: PEXCEPTION_RECORD, -- ContextRecord: PCONTEXT, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlReportExceptionEx( -- ExceptionRecord: PEXCEPTION_RECORD, -- ContextRecord: PCONTEXT, -- Flags: ULONG, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn RtlWerpReportException( -- ProcessId: ULONG, -- CrashReportSharedMem: HANDLE, -- Flags: ULONG, -- CrashVerticalProcessHandle: PHANDLE, -- ) -> NTSTATUS; -- fn RtlReportSilentProcessExit( -- ProcessHandle: HANDLE, -- ExitStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn RtlUniform( -- Seed: PULONG, -- ) -> ULONG; -- fn RtlRandom( -- Seed: PULONG, -- ) -> ULONG; -- fn RtlRandomEx( -- Seed: PULONG, -- ) -> ULONG; -- fn RtlComputeImportTableHash( -- FileHandle: HANDLE, -- Hash: PCHAR, -- ImportTableHashRevision: ULONG, -- ) -> NTSTATUS; -- fn RtlIntegerToChar( -- Value: ULONG, -- Base: ULONG, -- OutputLength: LONG, -- String: PSTR, -- ) -> NTSTATUS; -- fn RtlCharToInteger( -- String: PCSZ, -- Base: ULONG, -- Value: PULONG, -- ) -> NTSTATUS; -- fn RtlLargeIntegerToChar( -- Value: PLARGE_INTEGER, -- Base: ULONG, -- OutputLength: LONG, -- String: PSTR, -- ) -> NTSTATUS; -- fn RtlIntegerToUnicodeString( -- Value: ULONG, -- Base: ULONG, -- String: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlInt64ToUnicodeString( -- Value: ULONGLONG, -- Base: ULONG, -- String: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlUnicodeStringToInteger( -- String: PCUNICODE_STRING, -- Base: ULONG, -- Value: PULONG, -- ) -> NTSTATUS; -- fn RtlIpv4AddressToStringExW( -- Address: *const in_addr, -- Port: USHORT, -- AddressString: PWSTR, -- AddressStringLength: PULONG, -- ) -> NTSTATUS; -- fn RtlIpv6AddressToStringExW( -- Address: *const in6_addr, -- ScopeId: ULONG, -- Port: USHORT, -- AddressString: PWSTR, -- AddressStringLength: PULONG, -- ) -> NTSTATUS; -- fn RtlIpv4StringToAddressExW( -- AddressString: PCWSTR, -- Strict: BOOLEAN, -- Address: *mut in_addr, -- Port: PUSHORT, -- ) -> NTSTATUS; -- fn RtlIpv6StringToAddressExW( -- AddressString: PCWSTR, -- Address: *mut in6_addr, -- ScopeId: PULONG, -- Port: PUSHORT, -- ) -> NTSTATUS; --}} --STRUCT!{struct TIME_FIELDS { -- Year: CSHORT, -- Month: CSHORT, -- Day: CSHORT, -- Hour: CSHORT, -- Minute: CSHORT, -- Second: CSHORT, -- Milliseconds: CSHORT, -- Weekday: CSHORT, --}} --pub type PTIME_FIELDS = *mut TIME_FIELDS; --EXTERN!{extern "system" { -- fn RtlCutoverTimeToSystemTime( -- CutoverTime: PTIME_FIELDS, -- SystemTime: PLARGE_INTEGER, -- CurrentSystemTime: PLARGE_INTEGER, -- ThisYear: BOOLEAN, -- ) -> BOOLEAN; -- fn RtlSystemTimeToLocalTime( -- SystemTime: PLARGE_INTEGER, -- LocalTime: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn RtlLocalTimeToSystemTime( -- LocalTime: PLARGE_INTEGER, -- SystemTime: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn RtlTimeToElapsedTimeFields( -- Time: PLARGE_INTEGER, -- TimeFields: PTIME_FIELDS, -- ); -- fn RtlTimeToTimeFields( -- Time: PLARGE_INTEGER, -- TimeFields: PTIME_FIELDS, -- ); -- fn RtlTimeFieldsToTime( -- TimeFields: PTIME_FIELDS, -- Time: PLARGE_INTEGER, -- ) -> BOOLEAN; -- fn RtlTimeToSecondsSince1980( -- Time: PLARGE_INTEGER, -- ElapsedSeconds: PULONG, -- ) -> BOOLEAN; -- fn RtlSecondsSince1980ToTime( -- ElapsedSeconds: ULONG, -- Time: PLARGE_INTEGER, -- ); -- fn RtlTimeToSecondsSince1970( -- Time: PLARGE_INTEGER, -- ElapsedSeconds: PULONG, -- ) -> BOOLEAN; -- fn RtlSecondsSince1970ToTime( -- ElapsedSeconds: ULONG, -- Time: PLARGE_INTEGER, -- ); --}} --STRUCT!{struct RTL_TIME_ZONE_INFORMATION { -- Bias: LONG, -- StandardName: [WCHAR; 32], -- StandardStart: TIME_FIELDS, -- StandardBias: LONG, -- DaylightName: [WCHAR; 32], -- DaylightStart: TIME_FIELDS, -- DaylightBias: LONG, --}} --pub type PRTL_TIME_ZONE_INFORMATION = *mut RTL_TIME_ZONE_INFORMATION; --EXTERN!{extern "system" { -- fn RtlQueryTimeZoneInformation( -- TimeZoneInformation: PRTL_TIME_ZONE_INFORMATION, -- ) -> NTSTATUS; -- fn RtlSetTimeZoneInformation( -- TimeZoneInformation: PRTL_TIME_ZONE_INFORMATION, -- ) -> NTSTATUS; --}} --STRUCT!{struct RTL_BITMAP { -- SizeOfBitMap: ULONG, -- Buffer: PULONG, --}} --pub type PRTL_BITMAP = *mut RTL_BITMAP; --EXTERN!{extern "system" { -- fn RtlInitializeBitMap( -- BitMapHeader: PRTL_BITMAP, -- BitMapBuffer: PULONG, -- SizeOfBitMap: ULONG, -- ); -- fn RtlClearBit( -- BitMapHeader: PRTL_BITMAP, -- BitNumber: ULONG, -- ); -- fn RtlSetBit( -- BitMapHeader: PRTL_BITMAP, -- BitNumber: ULONG, -- ); -- fn RtlTestBit( -- BitMapHeader: PRTL_BITMAP, -- BitNumber: ULONG, -- ) -> BOOLEAN; -- fn RtlClearAllBits( -- BitMapHeader: PRTL_BITMAP, -- ); -- fn RtlSetAllBits( -- BitMapHeader: PRTL_BITMAP, -- ); -- fn RtlFindClearBits( -- BitMapHeader: PRTL_BITMAP, -- NumberToFind: ULONG, -- HintIndex: ULONG, -- ) -> ULONG; -- fn RtlFindSetBits( -- BitMapHeader: PRTL_BITMAP, -- NumberToFind: ULONG, -- HintIndex: ULONG, -- ) -> ULONG; -- fn RtlFindClearBitsAndSet( -- BitMapHeader: PRTL_BITMAP, -- NumberToFind: ULONG, -- HintIndex: ULONG, -- ) -> ULONG; -- fn RtlFindSetBitsAndClear( -- BitMapHeader: PRTL_BITMAP, -- NumberToFind: ULONG, -- HintIndex: ULONG, -- ) -> ULONG; -- fn RtlClearBits( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: ULONG, -- NumberToClear: ULONG, -- ); -- fn RtlSetBits( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: ULONG, -- NumberToSet: ULONG, -- ); -- fn RtlFindMostSignificantBit( -- Set: ULONGLONG, -- ) -> CCHAR; -- fn RtlFindLeastSignificantBit( -- Set: ULONGLONG, -- ) -> CCHAR; --}} --STRUCT!{struct RTL_BITMAP_RUN { -- StartingIndex: ULONG, -- NumberOfBits: ULONG, --}} --pub type PRTL_BITMAP_RUN = *mut RTL_BITMAP_RUN; --EXTERN!{extern "system" { -- fn RtlFindClearRuns( -- BitMapHeader: PRTL_BITMAP, -- RunArray: PRTL_BITMAP_RUN, -- SizeOfRunArray: ULONG, -- LocateLongestRuns: BOOLEAN, -- ) -> ULONG; -- fn RtlFindLongestRunClear( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: PULONG, -- ) -> ULONG; -- fn RtlFindFirstRunClear( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: PULONG, -- ) -> ULONG; --}} --#[inline] --pub unsafe fn RtlCheckBit(BitMapHeader: &RTL_BITMAP, BitPosition: ULONG) -> u8 { -- #[cfg(all(target_arch = "x86_64", feature = "beta"))] { -- use crate::winapi_local::um::winnt::_bittest64; -- _bittest64(BitMapHeader.Buffer as *const i64, BitPosition as i64) -- } -- #[cfg(any( -- target_arch = "x86", -- all(target_arch = "x86_64", not(feature = "beta")), -- target_arch = "aarch64", -- ))] { -- (*BitMapHeader.Buffer.offset(BitPosition as isize / 32) >> (BitPosition % 32) & 1) as u8 -- } --} --EXTERN!{extern "system" { -- fn RtlNumberOfClearBits( -- BitMapHeader: PRTL_BITMAP, -- ) -> ULONG; -- fn RtlNumberOfSetBits( -- BitMapHeader: PRTL_BITMAP, -- ) -> ULONG; -- fn RtlAreBitsClear( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: ULONG, -- Length: ULONG, -- ) -> BOOLEAN; -- fn RtlAreBitsSet( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: ULONG, -- Length: ULONG, -- ) -> BOOLEAN; -- fn RtlFindNextForwardRunClear( -- BitMapHeader: PRTL_BITMAP, -- FromIndex: ULONG, -- StartingRunIndex: PULONG, -- ) -> ULONG; -- fn RtlFindLastBackwardRunClear( -- BitMapHeader: PRTL_BITMAP, -- FromIndex: ULONG, -- StartingRunIndex: PULONG, -- ) -> ULONG; -- fn RtlNumberOfSetBitsUlongPtr( -- Target: ULONG_PTR, -- ) -> ULONG; -- fn RtlInterlockedClearBitRun( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: ULONG, -- NumberToClear: ULONG, -- ); -- fn RtlInterlockedSetBitRun( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: ULONG, -- NumberToSet: ULONG, -- ); -- fn RtlCopyBitMap( -- Source: PRTL_BITMAP, -- Destination: PRTL_BITMAP, -- TargetBit: ULONG, -- ); -- fn RtlExtractBitMap( -- Source: PRTL_BITMAP, -- Destination: PRTL_BITMAP, -- TargetBit: ULONG, -- NumberOfBits: ULONG, -- ); -- fn RtlNumberOfClearBitsInRange( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: ULONG, -- Length: ULONG, -- ) -> ULONG; -- fn RtlNumberOfSetBitsInRange( -- BitMapHeader: PRTL_BITMAP, -- StartingIndex: ULONG, -- Length: ULONG, -- ) -> ULONG; --}} --STRUCT!{struct RTL_BITMAP_EX { -- SizeOfBitMap: ULONG64, -- Buffer: PULONG64, --}} --pub type PRTL_BITMAP_EX = *mut RTL_BITMAP_EX; --EXTERN!{extern "system" { -- fn RtlInitializeBitMapEx( -- BitMapHeader: PRTL_BITMAP_EX, -- BitMapBuffer: PULONG64, -- SizeOfBitMap: ULONG64, -- ); -- fn RtlTestBitEx( -- BitMapHeader: PRTL_BITMAP_EX, -- BitNumber: ULONG64, -- ) -> BOOLEAN; -- fn RtlClearAllBitsEx( -- BitMapHeader: PRTL_BITMAP_EX, -- ); -- fn RtlClearBitEx( -- BitMapHeader: PRTL_BITMAP_EX, -- BitNumber: ULONG64, -- ); -- fn RtlSetBitEx( -- BitMapHeader: PRTL_BITMAP_EX, -- BitNumber: ULONG64, -- ); -- fn RtlFindSetBitsEx( -- BitMapHeader: PRTL_BITMAP_EX, -- NumberToFind: ULONG64, -- HintIndex: ULONG64, -- ) -> ULONG64; -- fn RtlFindSetBitsAndClearEx( -- BitMapHeader: PRTL_BITMAP_EX, -- NumberToFind: ULONG64, -- HintIndex: ULONG64, -- ) -> ULONG64; --}} --UNION!{union RTL_HANDLE_TABLE_ENTRY { -- Flags: ULONG, -- NextFree: *mut RTL_HANDLE_TABLE_ENTRY, --}} --pub type PRTL_HANDLE_TABLE_ENTRY = *mut RTL_HANDLE_TABLE_ENTRY; --pub const RTL_HANDLE_ALLOCATED: USHORT = 0x0001; --STRUCT!{struct RTL_HANDLE_TABLE { -- MaximumNumberOfHandles: ULONG, -- SizeOfHandleTableEntry: ULONG, -- Reserved: [ULONG; 2], -- FreeHandles: PRTL_HANDLE_TABLE_ENTRY, -- CommittedHandles: PRTL_HANDLE_TABLE_ENTRY, -- UnCommittedHandles: PRTL_HANDLE_TABLE_ENTRY, -- MaxReservedHandles: PRTL_HANDLE_TABLE_ENTRY, --}} --pub type PRTL_HANDLE_TABLE = *mut RTL_HANDLE_TABLE; --EXTERN!{extern "system" { -- fn RtlInitializeHandleTable( -- MaximumNumberOfHandles: ULONG, -- SizeOfHandleTableEntry: ULONG, -- HandleTable: PRTL_HANDLE_TABLE, -- ); -- fn RtlDestroyHandleTable( -- HandleTable: PRTL_HANDLE_TABLE, -- ) -> NTSTATUS; -- fn RtlAllocateHandle( -- HandleTable: PRTL_HANDLE_TABLE, -- HandleIndex: PULONG, -- ) -> PRTL_HANDLE_TABLE_ENTRY; -- fn RtlFreeHandle( -- HandleTable: PRTL_HANDLE_TABLE, -- Handle: PRTL_HANDLE_TABLE_ENTRY, -- ) -> BOOLEAN; -- fn RtlIsValidHandle( -- HandleTable: PRTL_HANDLE_TABLE, -- Handle: PRTL_HANDLE_TABLE_ENTRY, -- ) -> BOOLEAN; -- fn RtlIsValidIndexHandle( -- HandleTable: PRTL_HANDLE_TABLE, -- HandleIndex: ULONG, -- Handle: *mut PRTL_HANDLE_TABLE_ENTRY, -- ) -> BOOLEAN; --}} --pub const RTL_ATOM_MAXIMUM_INTEGER_ATOM: RTL_ATOM = 0xc000; --pub const RTL_ATOM_INVALID_ATOM: RTL_ATOM = 0x0000; --pub const RTL_ATOM_TABLE_DEFAULT_NUMBER_OF_BUCKETS: u32 = 37; --pub const RTL_ATOM_MAXIMUM_NAME_LENGTH: u32 = 255; --pub const RTL_ATOM_PINNED: u32 = 0x01; --EXTERN!{extern "system" { -- fn RtlCreateAtomTable( -- NumberOfBuckets: ULONG, -- AtomTableHandle: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlDestroyAtomTable( -- AtomTableHandle: PVOID, -- ) -> NTSTATUS; -- fn RtlEmptyAtomTable( -- AtomTableHandle: PVOID, -- IncludePinnedAtoms: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlAddAtomToAtomTable( -- AtomTableHandle: PVOID, -- AtomName: PWSTR, -- Atom: PRTL_ATOM, -- ) -> NTSTATUS; -- fn RtlLookupAtomInAtomTable( -- AtomTableHandle: PVOID, -- AtomName: PWSTR, -- Atom: PRTL_ATOM, -- ) -> NTSTATUS; -- fn RtlDeleteAtomFromAtomTable( -- AtomTableHandle: PVOID, -- Atom: RTL_ATOM, -- ) -> NTSTATUS; -- fn RtlPinAtomInAtomTable( -- AtomTableHandle: PVOID, -- Atom: RTL_ATOM, -- ) -> NTSTATUS; -- fn RtlQueryAtomInAtomTable( -- AtomTableHandle: PVOID, -- Atom: RTL_ATOM, -- AtomUsage: PULONG, -- AtomFlags: PULONG, -- AtomName: PWSTR, -- AtomNameLength: PULONG, -- ) -> NTSTATUS; -- fn RtlGetIntegerAtom( -- AtomName: PWSTR, -- IntegerAtom: PUSHORT, -- ) -> BOOLEAN; -- fn RtlValidSid( -- Sid: PSID, -- ) -> BOOLEAN; -- fn RtlEqualSid( -- Sid1: PSID, -- Sid2: PSID, -- ) -> BOOLEAN; -- fn RtlEqualPrefixSid( -- Sid1: PSID, -- Sid2: PSID, -- ) -> BOOLEAN; -- fn RtlLengthRequiredSid( -- SubAuthorityCount: ULONG, -- ) -> ULONG; -- fn RtlFreeSid( -- Sid: PSID, -- ) -> PVOID; -- fn RtlAllocateAndInitializeSid( -- IdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, -- SubAuthorityCount: UCHAR, -- SubAuthority0: ULONG, -- SubAuthority1: ULONG, -- SubAuthority2: ULONG, -- SubAuthority3: ULONG, -- SubAuthority4: ULONG, -- SubAuthority5: ULONG, -- SubAuthority6: ULONG, -- SubAuthority7: ULONG, -- Sid: *mut PSID, -- ) -> NTSTATUS; -- fn RtlInitializeSid( -- Sid: PSID, -- IdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, -- SubAuthorityCount: UCHAR, -- ) -> NTSTATUS; --}} --EXTERN!{extern "C" { -- fn RtlInitializeSidEx( -- Sid: PSID, -- IdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, -- SubAuthorityCount: UCHAR, -- ... -- ) -> NTSTATUS; --}} --EXTERN!{extern "system" { -- fn RtlIdentifierAuthoritySid( -- Sid: PSID, -- ) -> PSID_IDENTIFIER_AUTHORITY; -- fn RtlSubAuthoritySid( -- Sid: PSID, -- SubAuthority: ULONG, -- ) -> PULONG; -- fn RtlSubAuthorityCountSid( -- Sid: PSID, -- ) -> PUCHAR; -- fn RtlLengthSid( -- Sid: PSID, -- ) -> ULONG; -- fn RtlCopySid( -- DestinationSidLength: ULONG, -- DestinationSid: PSID, -- SourceSid: PSID, -- ) -> NTSTATUS; -- fn RtlCopySidAndAttributesArray( -- Count: ULONG, -- Src: PSID_AND_ATTRIBUTES, -- SidAreaSize: ULONG, -- Dest: PSID_AND_ATTRIBUTES, -- SidArea: PSID, -- RemainingSidArea: *mut PSID, -- RemainingSidAreaSize: PULONG, -- ) -> NTSTATUS; -- fn RtlCreateServiceSid( -- ServiceName: PUNICODE_STRING, -- ServiceSid: PSID, -- ServiceSidLength: PULONG, -- ) -> NTSTATUS; -- fn RtlSidDominates( -- Sid1: PSID, -- Sid2: PSID, -- Dominates: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlSidDominatesForTrust( -- Sid1: PSID, -- Sid2: PSID, -- DominatesTrust: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlSidEqualLevel( -- Sid1: PSID, -- Sid2: PSID, -- EqualLevel: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlSidIsHigherLevel( -- Sid1: PSID, -- Sid2: PSID, -- HigherLevel: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlCreateVirtualAccountSid( -- Name: PCUNICODE_STRING, -- BaseSubAuthority: ULONG, -- Sid: PSID, -- SidLength: PULONG, -- ) -> NTSTATUS; -- fn RtlReplaceSidInSd( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- OldSid: PSID, -- NewSid: PSID, -- NumChanges: *mut ULONG, -- ) -> NTSTATUS; --}} --pub const MAX_UNICODE_STACK_BUFFER_LENGTH: usize = 256; --EXTERN!{extern "system" { -- fn RtlConvertSidToUnicodeString( -- UnicodeString: PUNICODE_STRING, -- Sid: PSID, -- AllocateDestinationString: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlSidHashInitialize( -- SidAttr: PSID_AND_ATTRIBUTES, -- SidCount: ULONG, -- SidAttrHash: PSID_AND_ATTRIBUTES_HASH, -- ) -> NTSTATUS; -- fn RtlSidHashLookup( -- SidAttrHash: PSID_AND_ATTRIBUTES_HASH, -- Sid: PSID, -- ) -> PSID_AND_ATTRIBUTES; -- fn RtlIsElevatedRid( -- SidAttr: PSID_AND_ATTRIBUTES, -- ) -> BOOLEAN; -- fn RtlDeriveCapabilitySidsFromName( -- UnicodeString: PUNICODE_STRING, -- CapabilityGroupSid: PSID, -- CapabilitySid: PSID, -- ) -> NTSTATUS; -- fn RtlCreateSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Revision: ULONG, -- ) -> NTSTATUS; -- fn RtlValidSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ) -> BOOLEAN; -- fn RtlLengthSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ) -> ULONG; -- fn RtlValidRelativeSecurityDescriptor( -- SecurityDescriptorInput: PSECURITY_DESCRIPTOR, -- SecurityDescriptorLength: ULONG, -- RequiredInformation: SECURITY_INFORMATION, -- ) -> BOOLEAN; -- fn RtlGetControlSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Control: PSECURITY_DESCRIPTOR_CONTROL, -- Revision: PULONG, -- ) -> NTSTATUS; -- fn RtlSetControlSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ControlBitsOfInterest: SECURITY_DESCRIPTOR_CONTROL, -- ControlBitsToSet: SECURITY_DESCRIPTOR_CONTROL, -- ) -> NTSTATUS; -- fn RtlSetAttributesSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Control: SECURITY_DESCRIPTOR_CONTROL, -- Revision: PULONG, -- ) -> NTSTATUS; -- fn RtlGetSecurityDescriptorRMControl( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- RMControl: PUCHAR, -- ) -> BOOLEAN; -- fn RtlSetSecurityDescriptorRMControl( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- RMControl: PUCHAR, -- ); -- fn RtlSetDaclSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- DaclPresent: BOOLEAN, -- Dacl: PACL, -- DaclDefaulted: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlGetDaclSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- DaclPresent: PBOOLEAN, -- Dacl: *mut PACL, -- DaclDefaulted: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlSetSaclSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- SaclPresent: BOOLEAN, -- Sacl: PACL, -- SaclDefaulted: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlGetSaclSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- SaclPresent: PBOOLEAN, -- Sacl: *mut PACL, -- SaclDefaulted: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlSetOwnerSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Owner: PSID, -- OwnerDefaulted: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlGetOwnerSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Owner: *mut PSID, -- OwnerDefaulted: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlSetGroupSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Group: PSID, -- GroupDefaulted: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlGetGroupSecurityDescriptor( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Group: *mut PSID, -- GroupDefaulted: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlMakeSelfRelativeSD( -- AbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, -- SelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, -- BufferLength: PULONG, -- ) -> NTSTATUS; -- fn RtlAbsoluteToSelfRelativeSD( -- AbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, -- SelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, -- BufferLength: PULONG, -- ) -> NTSTATUS; -- fn RtlSelfRelativeToAbsoluteSD( -- SelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, -- AbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, -- AbsoluteSecurityDescriptorSize: PULONG, -- Dacl: PACL, -- DaclSize: PULONG, -- Sacl: PACL, -- SaclSize: PULONG, -- Owner: PSID, -- OwnerSize: PULONG, -- PrimaryGroup: PSID, -- PrimaryGroupSize: PULONG, -- ) -> NTSTATUS; -- fn RtlSelfRelativeToAbsoluteSD2( -- pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, -- pBufferSize: PULONG, -- ) -> NTSTATUS; -- fn RtlAreAllAccessesGranted( -- GrantedAccess: ACCESS_MASK, -- DesiredAccess: ACCESS_MASK, -- ) -> BOOLEAN; -- fn RtlAreAnyAccessesGranted( -- GrantedAccess: ACCESS_MASK, -- DesiredAccess: ACCESS_MASK, -- ) -> BOOLEAN; -- fn RtlMapGenericMask( -- AccessMask: PACCESS_MASK, -- GenericMapping: PGENERIC_MAPPING, -- ); -- fn RtlCreateAcl( -- Acl: PACL, -- AclLength: ULONG, -- AclRevision: ULONG, -- ) -> NTSTATUS; -- fn RtlValidAcl( -- Acl: PACL, -- ) -> BOOLEAN; -- fn RtlQueryInformationAcl( -- Acl: PACL, -- AclInformation: PVOID, -- AclInformationLength: ULONG, -- AclInformationClass: ACL_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn RtlSetInformationAcl( -- Acl: PACL, -- AclInformation: PVOID, -- AclInformationLength: ULONG, -- AclInformationClass: ACL_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn RtlAddAce( -- Acl: PACL, -- AceRevision: ULONG, -- StartingAceIndex: ULONG, -- AceList: PVOID, -- AceListLength: ULONG, -- ) -> NTSTATUS; -- fn RtlDeleteAce( -- Acl: PACL, -- AceIndex: ULONG, -- ) -> NTSTATUS; -- fn RtlGetAce( -- Acl: PACL, -- AceIndex: ULONG, -- Ace: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlFirstFreeAce( -- Acl: PACL, -- FirstFree: *mut PVOID, -- ) -> BOOLEAN; -- fn RtlFindAceByType( -- pAcl: PACL, -- AceType: UCHAR, -- pIndex: PULONG, -- ) -> PVOID; -- fn RtlOwnerAcesPresent( -- pAcl: PACL, -- ) -> BOOLEAN; -- fn RtlAddAccessAllowedAce( -- Acl: PACL, -- AceRevision: ULONG, -- AccessMask: ACCESS_MASK, -- Sid: PSID, -- ) -> NTSTATUS; -- fn RtlAddAccessAllowedAceEx( -- Acl: PACL, -- AceRevision: ULONG, -- AceFlags: ULONG, -- AccessMask: ACCESS_MASK, -- Sid: PSID, -- ) -> NTSTATUS; -- fn RtlAddAccessDeniedAce( -- Acl: PACL, -- AceRevision: ULONG, -- AccessMask: ACCESS_MASK, -- Sid: PSID, -- ) -> NTSTATUS; -- fn RtlAddAccessDeniedAceEx( -- Acl: PACL, -- AceRevision: ULONG, -- AceFlags: ULONG, -- AccessMask: ACCESS_MASK, -- Sid: PSID, -- ) -> NTSTATUS; -- fn RtlAddAuditAccessAce( -- Acl: PACL, -- AceRevision: ULONG, -- AccessMask: ACCESS_MASK, -- Sid: PSID, -- AuditSuccess: BOOLEAN, -- AuditFailure: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlAddAuditAccessAceEx( -- Acl: PACL, -- AceRevision: ULONG, -- AceFlags: ULONG, -- AccessMask: ACCESS_MASK, -- Sid: PSID, -- AuditSuccess: BOOLEAN, -- AuditFailure: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlAddAccessAllowedObjectAce( -- Acl: PACL, -- AceRevision: ULONG, -- AceFlags: ULONG, -- AccessMask: ACCESS_MASK, -- ObjectTypeGuid: *mut GUID, -- InheritedObjectTypeGuid: *mut GUID, -- Sid: PSID, -- ) -> NTSTATUS; -- fn RtlAddAccessDeniedObjectAce( -- Acl: PACL, -- AceRevision: ULONG, -- AceFlags: ULONG, -- AccessMask: ACCESS_MASK, -- ObjectTypeGuid: *mut GUID, -- InheritedObjectTypeGuid: *mut GUID, -- Sid: PSID, -- ) -> NTSTATUS; -- fn RtlAddAuditAccessObjectAce( -- Acl: PACL, -- AceRevision: ULONG, -- AceFlags: ULONG, -- AccessMask: ACCESS_MASK, -- ObjectTypeGuid: *mut GUID, -- InheritedObjectTypeGuid: *mut GUID, -- Sid: PSID, -- AuditSuccess: BOOLEAN, -- AuditFailure: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlAddCompoundAce( -- Acl: PACL, -- AceRevision: ULONG, -- AceType: UCHAR, -- AccessMask: ACCESS_MASK, -- ServerSid: PSID, -- ClientSid: PSID, -- ) -> NTSTATUS; -- fn RtlAddMandatoryAce( -- Acl: PACL, -- AceRevision: ULONG, -- AceFlags: ULONG, -- Sid: PSID, -- AceType: UCHAR, -- AccessMask: ACCESS_MASK, -- ) -> NTSTATUS; -- fn RtlDefaultNpAcl( -- Acl: *mut PACL, -- ) -> NTSTATUS; -- fn RtlNewSecurityObject( -- ParentDescriptor: PSECURITY_DESCRIPTOR, -- CreatorDescriptor: PSECURITY_DESCRIPTOR, -- NewDescriptor: *mut PSECURITY_DESCRIPTOR, -- IsDirectoryObject: BOOLEAN, -- Token: HANDLE, -- GenericMapping: PGENERIC_MAPPING, -- ) -> NTSTATUS; -- fn RtlNewSecurityObjectEx( -- ParentDescriptor: PSECURITY_DESCRIPTOR, -- CreatorDescriptor: PSECURITY_DESCRIPTOR, -- NewDescriptor: *mut PSECURITY_DESCRIPTOR, -- ObjectType: *mut GUID, -- IsDirectoryObject: BOOLEAN, -- AutoInheritFlags: ULONG, -- Token: HANDLE, -- GenericMapping: PGENERIC_MAPPING, -- ) -> NTSTATUS; -- fn RtlNewSecurityObjectWithMultipleInheritance( -- ParentDescriptor: PSECURITY_DESCRIPTOR, -- CreatorDescriptor: PSECURITY_DESCRIPTOR, -- NewDescriptor: *mut PSECURITY_DESCRIPTOR, -- ObjectType: *mut *mut GUID, -- GuidCount: ULONG, -- IsDirectoryObject: BOOLEAN, -- AutoInheritFlags: ULONG, -- Token: HANDLE, -- GenericMapping: PGENERIC_MAPPING, -- ) -> NTSTATUS; -- fn RtlDeleteSecurityObject( -- ObjectDescriptor: *mut PSECURITY_DESCRIPTOR, -- ) -> NTSTATUS; -- fn RtlQuerySecurityObject( -- ObjectDescriptor: PSECURITY_DESCRIPTOR, -- SecurityInformation: SECURITY_INFORMATION, -- ResultantDescriptor: PSECURITY_DESCRIPTOR, -- DescriptorLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn RtlSetSecurityObject( -- SecurityInformation: SECURITY_INFORMATION, -- ModificationDescriptor: PSECURITY_DESCRIPTOR, -- ObjectsSecurityDescriptor: *mut PSECURITY_DESCRIPTOR, -- GenericMapping: PGENERIC_MAPPING, -- Token: HANDLE, -- ) -> NTSTATUS; -- fn RtlSetSecurityObjectEx( -- SecurityInformation: SECURITY_INFORMATION, -- ModificationDescriptor: PSECURITY_DESCRIPTOR, -- ObjectsSecurityDescriptor: *mut PSECURITY_DESCRIPTOR, -- AutoInheritFlags: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- Token: HANDLE, -- ) -> NTSTATUS; -- fn RtlConvertToAutoInheritSecurityObject( -- ParentDescriptor: PSECURITY_DESCRIPTOR, -- CurrentSecurityDescriptor: PSECURITY_DESCRIPTOR, -- NewSecurityDescriptor: *mut PSECURITY_DESCRIPTOR, -- ObjectType: *mut GUID, -- IsDirectoryObject: BOOLEAN, -- GenericMapping: PGENERIC_MAPPING, -- ) -> NTSTATUS; -- fn RtlNewInstanceSecurityObject( -- ParentDescriptorChanged: BOOLEAN, -- CreatorDescriptorChanged: BOOLEAN, -- OldClientTokenModifiedId: PLUID, -- NewClientTokenModifiedId: PLUID, -- ParentDescriptor: PSECURITY_DESCRIPTOR, -- CreatorDescriptor: PSECURITY_DESCRIPTOR, -- NewDescriptor: *mut PSECURITY_DESCRIPTOR, -- IsDirectoryObject: BOOLEAN, -- Token: HANDLE, -- GenericMapping: PGENERIC_MAPPING, -- ) -> NTSTATUS; -- fn RtlCopySecurityDescriptor( -- InputSecurityDescriptor: PSECURITY_DESCRIPTOR, -- OutputSecurityDescriptor: *mut PSECURITY_DESCRIPTOR, -- ) -> NTSTATUS; -- fn RtlRunEncodeUnicodeString( -- Seed: PUCHAR, -- String: PUNICODE_STRING, -- ); -- fn RtlRunDecodeUnicodeString( -- Seed: UCHAR, -- String: PUNICODE_STRING, -- ); -- fn RtlImpersonateSelf( -- ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, -- ) -> NTSTATUS; -- fn RtlImpersonateSelfEx( -- ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, -- AdditionalAccess: ACCESS_MASK, -- ThreadToken: PHANDLE, -- ) -> NTSTATUS; -- fn RtlAdjustPrivilege( -- Privilege: ULONG, -- Enable: BOOLEAN, -- Client: BOOLEAN, -- WasEnabled: PBOOLEAN, -- ) -> NTSTATUS; --}} --pub const RTL_ACQUIRE_PRIVILEGE_REVERT: ULONG = 0x00000001; --pub const RTL_ACQUIRE_PRIVILEGE_PROCESS: ULONG = 0x00000002; --EXTERN!{extern "system" { -- fn RtlAcquirePrivilege( -- Privilege: PULONG, -- NumPriv: ULONG, -- Flags: ULONG, -- ReturnedState: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlReleasePrivilege( -- StatePointer: PVOID, -- ); -- fn RtlRemovePrivileges( -- TokenHandle: HANDLE, -- PrivilegesToKeep: PULONG, -- PrivilegeCount: ULONG, -- ) -> NTSTATUS; -- fn RtlIsUntrustedObject( -- Handle: HANDLE, -- Object: PVOID, -- IsUntrustedObject: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlQueryValidationRunlevel( -- ComponentName: PUNICODE_STRING, -- ) -> ULONG; -- fn RtlCreateBoundaryDescriptor( -- Name: PUNICODE_STRING, -- Flags: ULONG, -- ) -> PVOID; -- fn RtlDeleteBoundaryDescriptor( -- BoundaryDescriptor: PVOID, -- ); -- fn RtlAddSIDToBoundaryDescriptor( -- BoundaryDescriptor: *mut PVOID, -- RequiredSid: PSID, -- ) -> NTSTATUS; -- fn RtlAddIntegrityLabelToBoundaryDescriptor( -- BoundaryDescriptor: *mut PVOID, -- IntegrityLabel: PSID, -- ) -> NTSTATUS; -- fn RtlGetVersion( -- lpVersionInformation: PRTL_OSVERSIONINFOW, -- ) -> NTSTATUS; -- fn RtlVerifyVersionInfo( -- VersionInfo: PRTL_OSVERSIONINFOEXW, -- TypeMask: ULONG, -- ConditionMask: ULONGLONG, -- ) -> NTSTATUS; -- fn RtlGetNtVersionNumbers( -- NtMajorVersion: PULONG, -- NtMinorVersion: PULONG, -- NtBuildNumber: PULONG, -- ); -- fn RtlGetNtGlobalFlags() -> ULONG; -- fn RtlGetNtProductType( -- NtProductType: PNT_PRODUCT_TYPE, -- ) -> BOOLEAN; -- fn RtlGetSuiteMask() -> ULONG; -- fn RtlRegisterWait( -- WaitHandle: PHANDLE, -- Handle: HANDLE, -- Function: WAITORTIMERCALLBACKFUNC, -- Context: PVOID, -- Milliseconds: ULONG, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlDeregisterWait( -- WaitHandle: HANDLE, -- ) -> NTSTATUS; -- fn RtlDeregisterWaitEx( -- WaitHandle: HANDLE, -- Event: HANDLE, -- ) -> NTSTATUS; -- fn RtlQueueWorkItem( -- Function: WORKERCALLBACKFUNC, -- Context: PVOID, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlSetIoCompletionCallback( -- FileHandle: HANDLE, -- CompletionProc: APC_CALLBACK_FUNCTION, -- Flags: ULONG, -- ) -> NTSTATUS; --}} --FN!{stdcall PRTL_START_POOL_THREAD( -- Function: PTHREAD_START_ROUTINE, -- Parameter: PVOID, -- ThreadHandle: PHANDLE, --) -> NTSTATUS} --FN!{stdcall PRTL_EXIT_POOL_THREAD( -- ExitStatus: NTSTATUS, --) -> NTSTATUS} --EXTERN!{extern "system" { -- fn RtlSetThreadPoolStartFunc( -- StartPoolThread: PRTL_START_POOL_THREAD, -- ExitPoolThread: PRTL_EXIT_POOL_THREAD, -- ) -> NTSTATUS; -- fn RtlUserThreadStart( -- Function: PTHREAD_START_ROUTINE, -- Parameter: PVOID, -- ); -- fn LdrInitializeThunk( -- ContextRecord: PCONTEXT, -- Parameter: PVOID, -- ); -- fn RtlCreateTimerQueue( -- TimerQueueHandle: PHANDLE, -- ) -> NTSTATUS; -- fn RtlCreateTimer( -- TimerQueueHandle: HANDLE, -- Handle: PHANDLE, -- Function: WAITORTIMERCALLBACKFUNC, -- Context: PVOID, -- DueTime: ULONG, -- Period: ULONG, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn RtlUpdateTimer( -- TimerQueueHandle: HANDLE, -- TimerHandle: HANDLE, -- DueTime: ULONG, -- Period: ULONG, -- ) -> NTSTATUS; -- fn RtlDeleteTimer( -- TimerQueueHandle: HANDLE, -- TimerToCancel: HANDLE, -- Event: HANDLE, -- ) -> NTSTATUS; -- fn RtlDeleteTimerQueue( -- TimerQueueHandle: HANDLE, -- ) -> NTSTATUS; -- fn RtlDeleteTimerQueueEx( -- TimerQueueHandle: HANDLE, -- Event: HANDLE, -- ) -> NTSTATUS; -- fn RtlFormatCurrentUserKeyPath( -- CurrentUserKeyPath: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlOpenCurrentUser( -- DesiredAccess: ACCESS_MASK, -- CurrentUserKey: PHANDLE, -- ) -> NTSTATUS; --}} --pub const RTL_REGISTRY_ABSOLUTE: ULONG = 0; --pub const RTL_REGISTRY_SERVICES: ULONG = 1; --pub const RTL_REGISTRY_CONTROL: ULONG = 2; --pub const RTL_REGISTRY_WINDOWS_NT: ULONG = 3; --pub const RTL_REGISTRY_DEVICEMAP: ULONG = 4; --pub const RTL_REGISTRY_USER: ULONG = 5; --pub const RTL_REGISTRY_MAXIMUM: ULONG = 6; --pub const RTL_REGISTRY_HANDLE: ULONG = 0x40000000; --pub const RTL_REGISTRY_OPTIONAL: ULONG = 0x80000000; --EXTERN!{extern "system" { -- fn RtlCreateRegistryKey( -- RelativeTo: ULONG, -- Path: PWSTR, -- ) -> NTSTATUS; -- fn RtlCheckRegistryKey( -- RelativeTo: ULONG, -- Path: PWSTR, -- ) -> NTSTATUS; --}} --FN!{stdcall PRTL_QUERY_REGISTRY_ROUTINE( -- ValueName: PWSTR, -- ValueType: ULONG, -- ValueData: PVOID, -- ValueLength: ULONG, -- Context: PVOID, -- EntryContext: PVOID, --) -> NTSTATUS} --STRUCT!{struct RTL_QUERY_REGISTRY_TABLE { -- QueryRoutine: PRTL_QUERY_REGISTRY_ROUTINE, -- Flags: ULONG, -- Name: PWSTR, -- EntryContext: PVOID, -- DefaultType: ULONG, -- DefaultData: PVOID, -- DefaultLength: ULONG, --}} --pub type PRTL_QUERY_REGISTRY_TABLE = *mut RTL_QUERY_REGISTRY_TABLE; --pub const RTL_QUERY_REGISTRY_SUBKEY: ULONG = 0x00000001; --pub const RTL_QUERY_REGISTRY_TOPKEY: ULONG = 0x00000002; --pub const RTL_QUERY_REGISTRY_REQUIRED: ULONG = 0x00000004; --pub const RTL_QUERY_REGISTRY_NOVALUE: ULONG = 0x00000008; --pub const RTL_QUERY_REGISTRY_NOEXPAND: ULONG = 0x00000010; --pub const RTL_QUERY_REGISTRY_DIRECT: ULONG = 0x00000020; --pub const RTL_QUERY_REGISTRY_DELETE: ULONG = 0x00000040; --EXTERN!{extern "system" { -- fn RtlQueryRegistryValues( -- RelativeTo: ULONG, -- Path: PCWSTR, -- QueryTable: PRTL_QUERY_REGISTRY_TABLE, -- Context: PVOID, -- Environment: PVOID, -- ) -> NTSTATUS; -- fn RtlQueryRegistryValuesEx( -- RelativeTo: ULONG, -- Path: PWSTR, -- QueryTable: PRTL_QUERY_REGISTRY_TABLE, -- Context: PVOID, -- Environment: PVOID, -- ) -> NTSTATUS; -- fn RtlWriteRegistryValue( -- RelativeTo: ULONG, -- Path: PCWSTR, -- ValueName: PCWSTR, -- ValueType: ULONG, -- ValueData: PVOID, -- ValueLength: ULONG, -- ) -> NTSTATUS; -- fn RtlDeleteRegistryValue( -- RelativeTo: ULONG, -- Path: PCWSTR, -- ValueName: PCWSTR, -- ) -> NTSTATUS; -- fn RtlEnableThreadProfiling( -- ThreadHandle: HANDLE, -- Flags: ULONG, -- HardwareCounters: ULONG64, -- PerformanceDataHandle: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlDisableThreadProfiling( -- PerformanceDataHandle: PVOID, -- ) -> NTSTATUS; -- fn RtlQueryThreadProfiling( -- ThreadHandle: HANDLE, -- Enabled: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlReadThreadProfilingData( -- PerformanceDataHandle: HANDLE, -- Flags: ULONG, -- PerformanceData: PPERFORMANCE_DATA, -- ) -> NTSTATUS; -- fn RtlGetNativeSystemInformation( -- SystemInformationClass: ULONG, -- NativeSystemInformation: PVOID, -- InformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn RtlQueueApcWow64Thread( -- ThreadHandle: HANDLE, -- ApcRoutine: PPS_APC_ROUTINE, -- ApcArgument1: PVOID, -- ApcArgument2: PVOID, -- ApcArgument3: PVOID, -- ) -> NTSTATUS; -- fn RtlWow64EnableFsRedirection( -- Wow64FsEnableRedirection: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlWow64EnableFsRedirectionEx( -- Wow64FsEnableRedirection: PVOID, -- OldFsRedirectionLevel: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlComputeCrc32( -- PartialCrc: ULONG32, -- Buffer: PVOID, -- Length: ULONG, -- ) -> ULONG32; -- fn RtlEncodePointer( -- Ptr: PVOID, -- ) -> PVOID; -- fn RtlDecodePointer( -- Ptr: PVOID, -- ) -> PVOID; -- fn RtlEncodeSystemPointer( -- Ptr: PVOID, -- ) -> PVOID; -- fn RtlDecodeSystemPointer( -- Ptr: PVOID, -- ) -> PVOID; -- fn RtlEncodeRemotePointer( -- ProcessHandle: HANDLE, -- Pointer: PVOID, -- EncodedPointer: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlDecodeRemotePointer( -- ProcessHandle: HANDLE, -- Pointer: PVOID, -- DecodedPointer: *mut PVOID, -- ) -> NTSTATUS; -- fn RtlIsProcessorFeaturePresent( -- ProcessorFeature: ULONG, -- ) -> BOOLEAN; -- fn RtlGetCurrentProcessorNumber() -> ULONG; -- fn RtlGetCurrentProcessorNumberEx( -- ProcessorNumber: PPROCESSOR_NUMBER, -- ); -- fn RtlPushFrame( -- Frame: PTEB_ACTIVE_FRAME, -- ); -- fn RtlPopFrame( -- Frame: PTEB_ACTIVE_FRAME, -- ); -- fn RtlGetFrame() -> PTEB_ACTIVE_FRAME; --}} --pub const RTL_WALK_USER_MODE_STACK: ULONG = 0x00000001; --pub const RTL_WALK_VALID_FLAGS: ULONG = 0x00000001; --pub const RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT: ULONG = 0x00000008; --EXTERN!{extern "system" { -- fn RtlWalkFrameChain( -- Callers: *mut PVOID, -- Count: ULONG, -- Flags: ULONG, -- ) -> ULONG; -- fn RtlGetCallersAddress( -- CallersAddress: *mut PVOID, -- CallersCaller: *mut PVOID, -- ); -- fn RtlGetEnabledExtendedFeatures( -- FeatureMask: ULONG64, -- ) -> ULONG64; -- fn RtlGetEnabledExtendedAndSupervisorFeatures( -- FeatureMask: ULONG64, -- ) -> ULONG64; -- fn RtlLocateSupervisorFeature( -- XStateHeader: PXSAVE_AREA_HEADER, -- FeatureId: ULONG, -- Length: PULONG, -- ) -> PVOID; --}} --STRUCT!{struct RTL_ELEVATION_FLAGS { -- Flags: ULONG, --}} --BITFIELD!{RTL_ELEVATION_FLAGS Flags: ULONG [ -- ElevationEnabled set_ElevationEnabled[0..1], -- VirtualizationEnabled set_VirtualizationEnabled[1..2], -- InstallerDetectEnabled set_InstallerDetectEnabled[2..3], -- ReservedBits set_ReservedBits[3..32], --]} --pub type PRTL_ELEVATION_FLAGS = *mut RTL_ELEVATION_FLAGS; --EXTERN!{extern "system" { -- fn RtlQueryElevationFlags( -- Flags: PRTL_ELEVATION_FLAGS, -- ) -> NTSTATUS; -- fn RtlRegisterThreadWithCsrss() -> NTSTATUS; -- fn RtlLockCurrentThread() -> NTSTATUS; -- fn RtlUnlockCurrentThread() -> NTSTATUS; -- fn RtlLockModuleSection( -- Address: PVOID, -- ) -> NTSTATUS; -- fn RtlUnlockModuleSection( -- Address: PVOID, -- ) -> NTSTATUS; --}} --pub const RTL_UNLOAD_EVENT_TRACE_NUMBER: u32 = 64; --STRUCT!{struct RTL_UNLOAD_EVENT_TRACE { -- BaseAddress: PVOID, -- SizeOfImage: SIZE_T, -- Sequence: ULONG, -- TimeDateStamp: ULONG, -- CheckSum: ULONG, -- ImageName: [WCHAR; 32], -- Version: [ULONG; 2], --}} --pub type PRTL_UNLOAD_EVENT_TRACE = *mut RTL_UNLOAD_EVENT_TRACE; --STRUCT!{struct RTL_UNLOAD_EVENT_TRACE32 { -- BaseAddress: ULONG, -- SizeOfImage: ULONG, -- Sequence: ULONG, -- TimeDateStamp: ULONG, -- CheckSum: ULONG, -- ImageName: [WCHAR; 32], -- Version: [ULONG; 2], --}} --pub type PRTL_UNLOAD_EVENT_TRACE32 = *mut RTL_UNLOAD_EVENT_TRACE32; --EXTERN!{extern "system" { -- fn RtlGetUnloadEventTrace() -> PRTL_UNLOAD_EVENT_TRACE; -- fn RtlGetUnloadEventTraceEx( -- ElementSize: *mut PULONG, -- ElementCount: *mut PULONG, -- EventTrace: *mut PVOID, -- ); -- fn RtlQueryPerformanceCounter( -- PerformanceCounter: PLARGE_INTEGER, -- ) -> LOGICAL; -- fn RtlQueryPerformanceFrequency( -- PerformanceFrequency: PLARGE_INTEGER, -- ) -> LOGICAL; --}} --ENUM!{enum IMAGE_MITIGATION_POLICY { -- ImageDepPolicy = 0, -- ImageAslrPolicy = 1, -- ImageDynamicCodePolicy = 2, -- ImageStrictHandleCheckPolicy = 3, -- ImageSystemCallDisablePolicy = 4, -- ImageMitigationOptionsMask = 5, -- ImageExtensionPointDisablePolicy = 6, -- ImageControlFlowGuardPolicy = 7, -- ImageSignaturePolicy = 8, -- ImageFontDisablePolicy = 9, -- ImageImageLoadPolicy = 10, -- ImagePayloadRestrictionPolicy = 11, -- ImageChildProcessPolicy = 12, -- ImageSehopPolicy = 13, -- ImageHeapPolicy = 14, -- MaxImageMitigationPolicy = 15, --}} --UNION!{union RTL_IMAGE_MITIGATION_POLICY { -- Bitfields1: ULONG64, -- Bitfields2: ULONG64, --}} --BITFIELD!{unsafe RTL_IMAGE_MITIGATION_POLICY Bitfields1: ULONG64 [ -- AuditState set_AuditState[0..2], -- AuditFlag set_AuditFlag[2..3], -- EnableAdditionalAuditingOption set_EnableAdditionalAuditingOption[3..4], -- Reserved set_Reserved[4..64], --]} --BITFIELD!{unsafe RTL_IMAGE_MITIGATION_POLICY Bitfields2: ULONG64 [ -- PolicyState set_PolicyState[0..2], -- AlwaysInherit set_AlwaysInherit[2..3], -- EnableAdditionalPolicyOption set_EnableAdditionalPolicyOption[3..4], -- AuditReserved set_AuditReserved[4..64], --]} --pub type PRTL_IMAGE_MITIGATION_POLICY = *mut RTL_IMAGE_MITIGATION_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_DEP_POLICY { -- Dep: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_DEP_POLICY = *mut RTL_IMAGE_MITIGATION_DEP_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_ASLR_POLICY { -- ForceRelocateImages: RTL_IMAGE_MITIGATION_POLICY, -- BottomUpRandomization: RTL_IMAGE_MITIGATION_POLICY, -- HighEntropyRandomization: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_ASLR_POLICY = *mut RTL_IMAGE_MITIGATION_ASLR_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY { -- BlockDynamicCode: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY = *mut RTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_STRICT_HANDLE_CHECK_POLICY { -- StrictHandleChecks: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_STRICT_HANDLE_CHECK_POLICY = -- *mut RTL_IMAGE_MITIGATION_STRICT_HANDLE_CHECK_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_SYSTEM_CALL_DISABLE_POLICY { -- BlockWin32kSystemCalls: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = -- *mut RTL_IMAGE_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_EXTENSION_POINT_DISABLE_POLICY { -- DisableExtensionPoints: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = -- *mut RTL_IMAGE_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_CONTROL_FLOW_GUARD_POLICY { -- ControlFlowGuard: RTL_IMAGE_MITIGATION_POLICY, -- StrictControlFlowGuard: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_CONTROL_FLOW_GUARD_POLICY = -- *mut RTL_IMAGE_MITIGATION_CONTROL_FLOW_GUARD_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_BINARY_SIGNATURE_POLICY { -- BlockNonMicrosoftSignedBinaries: RTL_IMAGE_MITIGATION_POLICY, -- EnforceSigningOnModuleDependencies: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_BINARY_SIGNATURE_POLICY = -- *mut RTL_IMAGE_MITIGATION_BINARY_SIGNATURE_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY { -- DisableNonSystemFonts: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY = *mut RTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY { -- BlockRemoteImageLoads: RTL_IMAGE_MITIGATION_POLICY, -- BlockLowLabelImageLoads: RTL_IMAGE_MITIGATION_POLICY, -- PreferSystem32: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY = *mut RTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_PAYLOAD_RESTRICTION_POLICY { -- EnableExportAddressFilter: RTL_IMAGE_MITIGATION_POLICY, -- EnableExportAddressFilterPlus: RTL_IMAGE_MITIGATION_POLICY, -- EnableImportAddressFilter: RTL_IMAGE_MITIGATION_POLICY, -- EnableRopStackPivot: RTL_IMAGE_MITIGATION_POLICY, -- EnableRopCallerCheck: RTL_IMAGE_MITIGATION_POLICY, -- EnableRopSimExec: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_PAYLOAD_RESTRICTION_POLICY = -- *mut RTL_IMAGE_MITIGATION_PAYLOAD_RESTRICTION_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_CHILD_PROCESS_POLICY { -- DisallowChildProcessCreation: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_CHILD_PROCESS_POLICY = -- *mut RTL_IMAGE_MITIGATION_CHILD_PROCESS_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_SEHOP_POLICY { -- Sehop: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_SEHOP_POLICY = *mut RTL_IMAGE_MITIGATION_SEHOP_POLICY; --STRUCT!{struct RTL_IMAGE_MITIGATION_HEAP_POLICY { -- TerminateOnHeapErrors: RTL_IMAGE_MITIGATION_POLICY, --}} --pub type PRTL_IMAGE_MITIGATION_HEAP_POLICY = *mut RTL_IMAGE_MITIGATION_HEAP_POLICY; --ENUM!{enum RTL_IMAGE_MITIGATION_OPTION_STATE { -- RtlMitigationOptionStateNotConfigured = 0, -- RtlMitigationOptionStateOn = 1, -- RtlMitigationOptionStateOff = 2, --}} --pub const RTL_IMAGE_MITIGATION_FLAG_RESET: ULONG = 0x1; --pub const RTL_IMAGE_MITIGATION_FLAG_REMOVE: ULONG = 0x2; --pub const RTL_IMAGE_MITIGATION_FLAG_OSDEFAULT: ULONG = 0x4; --pub const RTL_IMAGE_MITIGATION_FLAG_AUDIT: ULONG = 0x8; --EXTERN!{extern "system" { -- fn RtlQueryImageMitigationPolicy( -- ImagePath: PWSTR, -- Policy: IMAGE_MITIGATION_POLICY, -- Flags: ULONG, -- Buffer: PVOID, -- BufferSize: ULONG, -- ) -> NTSTATUS; -- fn RtlSetImageMitigationPolicy( -- ImagePath: PWSTR, -- Policy: IMAGE_MITIGATION_POLICY, -- Flags: ULONG, -- Buffer: PVOID, -- BufferSize: ULONG, -- ) -> NTSTATUS; -- fn RtlGetCurrentServiceSessionId() -> ULONG; -- fn RtlGetActiveConsoleId() -> ULONG; -- fn RtlGetConsoleSessionForegroundProcessId() -> ULONGLONG; -- fn RtlGetTokenNamedObjectPath( -- Token: HANDLE, -- Sid: PSID, -- ObjectPath: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlGetAppContainerNamedObjectPath( -- Token: HANDLE, -- AppContainerSid: PSID, -- RelativePath: BOOLEAN, -- ObjectPath: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn RtlGetAppContainerParent( -- AppContainerSid: PSID, -- AppContainerSidParent: *mut PSID, -- ) -> NTSTATUS; -- fn RtlCheckSandboxedToken( -- TokenHandle: HANDLE, -- IsSandboxed: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlCheckTokenCapability( -- TokenHandle: HANDLE, -- CapabilitySidToCheck: PSID, -- HasCapability: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlCapabilityCheck( -- TokenHandle: HANDLE, -- CapabilityName: PUNICODE_STRING, -- HasCapability: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlCheckTokenMembership( -- TokenHandle: HANDLE, -- SidToCheck: PSID, -- IsMember: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlCheckTokenMembershipEx( -- TokenHandle: HANDLE, -- SidToCheck: PSID, -- Flags: ULONG, -- IsMember: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlIsParentOfChildAppContainer( -- ParentAppContainerSid: PSID, -- ChildAppContainerSid: PSID, -- ) -> NTSTATUS; -- fn RtlIsCapabilitySid( -- Sid: PSID, -- ) -> BOOLEAN; -- fn RtlIsPackageSid( -- Sid: PSID, -- ) -> BOOLEAN; -- fn RtlIsValidProcessTrustLabelSid( -- Sid: PSID, -- ) -> BOOLEAN; -- fn RtlIsStateSeparationEnabled() -> BOOLEAN; --}} --ENUM!{enum APPCONTAINER_SID_TYPE { -- NotAppContainerSidType = 0, -- ChildAppContainerSidType = 1, -- ParentAppContainerSidType = 2, -- InvalidAppContainerSidType = 3, -- MaxAppContainerSidType = 4, --}} --pub type PAPPCONTAINER_SID_TYPE = *mut APPCONTAINER_SID_TYPE; --EXTERN!{extern "system" { -- fn RtlGetAppContainerSidType( -- AppContainerSid: PSID, -- AppContainerSidType: PAPPCONTAINER_SID_TYPE, -- ) -> NTSTATUS; -- fn RtlFlsAlloc( -- Callback: PFLS_CALLBACK_FUNCTION, -- FlsIndex: PULONG, -- ) -> NTSTATUS; -- fn RtlFlsFree( -- FlsIndex: ULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum STATE_LOCATION_TYPE { -- LocationTypeRegistry = 0, -- LocationTypeFileSystem = 1, -- LocationTypeMaximum = 2, --}} --EXTERN!{extern "system" { -- fn RtlGetPersistedStateLocation( -- SourceID: PCWSTR, -- CustomValue: PCWSTR, -- DefaultPath: PCWSTR, -- StateLocationType: STATE_LOCATION_TYPE, -- TargetPath: PWCHAR, -- BufferLengthIn: ULONG, -- BufferLengthOut: PULONG, -- ) -> NTSTATUS; -- fn RtlIsCloudFilesPlaceholder( -- FileAttributes: ULONG, -- ReparseTag: ULONG, -- ) -> BOOLEAN; -- fn RtlIsPartialPlaceholder( -- FileAttributes: ULONG, -- ReparseTag: ULONG, -- ) -> BOOLEAN; -- fn RtlIsPartialPlaceholderFileHandle( -- FileHandle: HANDLE, -- IsPartialPlaceholder: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlIsPartialPlaceholderFileInfo( -- InfoBuffer: *const c_void, -- InfoClass: FILE_INFORMATION_CLASS, -- IsPartialPlaceholder: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlIsNonEmptyDirectoryReparsePointAllowed( -- ReparseTag: ULONG, -- ) -> BOOLEAN; -- fn RtlAppxIsFileOwnedByTrustedInstaller( -- FileHandle: HANDLE, -- IsFileOwnedByTrustedInstaller: PBOOLEAN, -- ) -> NTSTATUS; --}} --STRUCT!{struct PS_PKG_CLAIM { -- Flags: ULONGLONG, -- Origin: ULONGLONG, --}} --pub type PPS_PKG_CLAIM = *mut PS_PKG_CLAIM; --EXTERN!{extern "system" { -- fn RtlQueryPackageClaims( -- TokenHandle: HANDLE, -- PackageFullName: PWSTR, -- PackageSize: PSIZE_T, -- AppId: PWSTR, -- AppIdSize: PSIZE_T, -- DynamicId: *mut GUID, -- PkgClaim: PPS_PKG_CLAIM, -- AttributesPresent: PULONG64, -- ) -> NTSTATUS; -- fn RtlQueryProtectedPolicy( -- PolicyGuid: *mut GUID, -- PolicyValue: PULONG_PTR, -- ) -> NTSTATUS; -- fn RtlSetProtectedPolicy( -- PolicyGuid: *mut GUID, -- PolicyValue: ULONG_PTR, -- OldPolicyValue: PULONG_PTR, -- ) -> NTSTATUS; -- fn RtlIsMultiSessionSku() -> BOOLEAN; -- fn RtlIsMultiUsersInSessionSku() -> BOOLEAN; --}} --ENUM!{enum RTL_BSD_ITEM_TYPE { -- RtlBsdItemVersionNumber = 0, -- RtlBsdItemProductType = 1, -- RtlBsdItemAabEnabled = 2, -- RtlBsdItemAabTimeout = 3, -- RtlBsdItemBootGood = 4, -- RtlBsdItemBootShutdown = 5, -- RtlBsdSleepInProgress = 6, -- RtlBsdPowerTransition = 7, -- RtlBsdItemBootAttemptCount = 8, -- RtlBsdItemBootCheckpoint = 9, -- RtlBsdItemBootId = 10, -- RtlBsdItemShutdownBootId = 11, -- RtlBsdItemReportedAbnormalShutdownBootId = 12, -- RtlBsdItemErrorInfo = 13, -- RtlBsdItemPowerButtonPressInfo = 14, -- RtlBsdItemChecksum = 15, -- RtlBsdItemMax = 16, --}} --STRUCT!{struct RTL_BSD_ITEM { -- Type: RTL_BSD_ITEM_TYPE, -- DataBuffer: PVOID, -- DataLength: ULONG, --}} --pub type PRTL_BSD_ITEM = *mut RTL_BSD_ITEM; --EXTERN!{extern "system" { -- fn RtlCreateBootStatusDataFile() -> NTSTATUS; -- fn RtlLockBootStatusData( -- FileHandle: PHANDLE, -- ) -> NTSTATUS; -- fn RtlUnlockBootStatusData( -- FileHandle: HANDLE, -- ) -> NTSTATUS; -- fn RtlGetSetBootStatusData( -- FileHandle: HANDLE, -- Read: BOOLEAN, -- DataClass: RTL_BSD_ITEM_TYPE, -- Buffer: PVOID, -- BufferSize: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn RtlCheckBootStatusIntegrity( -- FileHandle: HANDLE, -- Verified: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlCheckPortableOperatingSystem( -- IsPortable: PBOOLEAN, -- ) -> NTSTATUS; -- fn RtlSetPortableOperatingSystem( -- IsPortable: BOOLEAN, -- ) -> NTSTATUS; --}} --EXTERN!{extern "system" { -- fn RtlOsDeploymentState( -- Flags: DWORD, -- ) -> OS_DEPLOYEMENT_STATE_VALUES; -- fn RtlFindClosestEncodableLength( -- SourceLength: ULONGLONG, -- TargetLength: PULONGLONG, -- ) -> NTSTATUS; --}} --FN!{stdcall PRTL_SECURE_MEMORY_CACHE_CALLBACK( -- Address: PVOID, -- Length: SIZE_T, --) -> NTSTATUS} --EXTERN!{extern "system" { -- fn RtlRegisterSecureMemoryCacheCallback( -- Callback: PRTL_SECURE_MEMORY_CACHE_CALLBACK, -- ) -> NTSTATUS; -- fn RtlDeregisterSecureMemoryCacheCallback( -- Callback: PRTL_SECURE_MEMORY_CACHE_CALLBACK, -- ) -> NTSTATUS; -- fn RtlFlushSecureMemoryCache( -- MemoryCache: PVOID, -- MemoryLength: SIZE_T, -- ) -> BOOLEAN; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntsam.rs b/KubeOS-Rust/vendor/ntapi/src/ntsam.rs -deleted file mode 100644 -index a591f0bd..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntsam.rs -+++ /dev/null -@@ -1,1077 +0,0 @@ --use crate::string::UTF8Const; --use winapi::shared::basetsd::ULONG64; --use winapi::shared::minwindef::DWORD; --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, LARGE_INTEGER, NTSTATUS, OEM_STRING, PLARGE_INTEGER, POBJECT_ATTRIBUTES, -- PUCHAR, PULONG, PUNICODE_STRING, PVOID, PWSTR, ULONG, UNICODE_STRING, USHORT, --}; --use winapi::um::ntsecapi::PDOMAIN_PASSWORD_INFORMATION; --use winapi::um::subauth::LOGON_HOURS; --use winapi::um::winnt::{ -- ACCESS_MASK, PSECURITY_DESCRIPTOR, PSID, PSID_NAME_USE, SECURITY_INFORMATION, SID_NAME_USE, -- STANDARD_RIGHTS_EXECUTE, STANDARD_RIGHTS_READ, STANDARD_RIGHTS_REQUIRED, STANDARD_RIGHTS_WRITE, --}; --pub const SAM_MAXIMUM_LOOKUP_COUNT: u32 = 1000; --pub const SAM_MAXIMUM_LOOKUP_LENGTH: u32 = 32000; --pub const SAM_MAX_PASSWORD_LENGTH: u32 = 256; --pub const SAM_PASSWORD_ENCRYPTION_SALT_LEN: u32 = 16; --pub type PSAM_HANDLE = *mut PVOID; --pub type SAM_HANDLE = PVOID; --pub type SAM_ENUMERATE_HANDLE = ULONG; --pub type PSAM_ENUMERATE_HANDLE = *mut ULONG; --STRUCT!{struct SAM_RID_ENUMERATION { -- RelativeId: ULONG, -- Name: UNICODE_STRING, --}} --pub type PSAM_RID_ENUMERATION = *mut SAM_RID_ENUMERATION; --STRUCT!{struct SAM_SID_ENUMERATION { -- Sid: PSID, -- Name: UNICODE_STRING, --}} --pub type PSAM_SID_ENUMERATION = *mut SAM_SID_ENUMERATION; --STRUCT!{struct SAM_BYTE_ARRAY { -- Size: ULONG, -- Data: PUCHAR, --}} --pub type PSAM_BYTE_ARRAY = *mut SAM_BYTE_ARRAY; --STRUCT!{struct SAM_BYTE_ARRAY_32K { -- Size: ULONG, -- Data: PUCHAR, --}} --pub type PSAM_BYTE_ARRAY_32K = *mut SAM_BYTE_ARRAY_32K; --pub type PSAM_SHELL_OBJECT_PROPERTIES = *mut SAM_BYTE_ARRAY_32K; --pub type SAM_SHELL_OBJECT_PROPERTIES = SAM_BYTE_ARRAY_32K; --EXTERN!{extern "system" { -- fn SamFreeMemory( -- Buffer: PVOID, -- ) -> NTSTATUS; -- fn SamCloseHandle( -- SamHandle: SAM_HANDLE, -- ) -> NTSTATUS; -- fn SamSetSecurityObject( -- ObjectHandle: SAM_HANDLE, -- SecurityInformation: SECURITY_INFORMATION, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ) -> NTSTATUS; -- fn SamQuerySecurityObject( -- ObjectHandle: SAM_HANDLE, -- SecurityInformation: SECURITY_INFORMATION, -- SecurityDescriptor: *mut PSECURITY_DESCRIPTOR, -- ) -> NTSTATUS; -- fn SamRidToSid( -- ObjectHandle: SAM_HANDLE, -- Rid: ULONG, -- Sid: *mut PSID, -- ) -> NTSTATUS; --}} --pub const SAM_SERVER_CONNECT: ACCESS_MASK = 0x0001; --pub const SAM_SERVER_SHUTDOWN: ACCESS_MASK = 0x0002; --pub const SAM_SERVER_INITIALIZE: ACCESS_MASK = 0x0004; --pub const SAM_SERVER_CREATE_DOMAIN: ACCESS_MASK = 0x0008; --pub const SAM_SERVER_ENUMERATE_DOMAINS: ACCESS_MASK = 0x0010; --pub const SAM_SERVER_LOOKUP_DOMAIN: ACCESS_MASK = 0x0020; --pub const SAM_SERVER_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | SAM_SERVER_CONNECT -- | SAM_SERVER_INITIALIZE | SAM_SERVER_CREATE_DOMAIN | SAM_SERVER_SHUTDOWN -- | SAM_SERVER_ENUMERATE_DOMAINS | SAM_SERVER_LOOKUP_DOMAIN; --pub const SAM_SERVER_READ: ACCESS_MASK = STANDARD_RIGHTS_READ | SAM_SERVER_ENUMERATE_DOMAINS; --pub const SAM_SERVER_WRITE: ACCESS_MASK = -- STANDARD_RIGHTS_WRITE | SAM_SERVER_INITIALIZE | SAM_SERVER_CREATE_DOMAIN | SAM_SERVER_SHUTDOWN; --pub const SAM_SERVER_EXECUTE: ACCESS_MASK = -- STANDARD_RIGHTS_EXECUTE | SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN; --EXTERN!{extern "system" { -- fn SamConnect( -- ServerName: PUNICODE_STRING, -- ServerHandle: PSAM_HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn SamShutdownSamServer( -- ServerHandle: SAM_HANDLE, -- ) -> NTSTATUS; --}} --pub const DOMAIN_READ_PASSWORD_PARAMETERS: u32 = 0x0001; --pub const DOMAIN_WRITE_PASSWORD_PARAMS: u32 = 0x0002; --pub const DOMAIN_READ_OTHER_PARAMETERS: u32 = 0x0004; --pub const DOMAIN_WRITE_OTHER_PARAMETERS: u32 = 0x0008; --pub const DOMAIN_CREATE_USER: u32 = 0x0010; --pub const DOMAIN_CREATE_GROUP: u32 = 0x0020; --pub const DOMAIN_CREATE_ALIAS: u32 = 0x0040; --pub const DOMAIN_GET_ALIAS_MEMBERSHIP: u32 = 0x0080; --pub const DOMAIN_LIST_ACCOUNTS: u32 = 0x0100; --pub const DOMAIN_LOOKUP: u32 = 0x0200; --pub const DOMAIN_ADMINISTER_SERVER: u32 = 0x0400; --pub const DOMAIN_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | DOMAIN_READ_OTHER_PARAMETERS -- | DOMAIN_WRITE_OTHER_PARAMETERS | DOMAIN_WRITE_PASSWORD_PARAMS | DOMAIN_CREATE_USER -- | DOMAIN_CREATE_GROUP | DOMAIN_CREATE_ALIAS | DOMAIN_GET_ALIAS_MEMBERSHIP -- | DOMAIN_LIST_ACCOUNTS | DOMAIN_READ_PASSWORD_PARAMETERS | DOMAIN_LOOKUP -- | DOMAIN_ADMINISTER_SERVER; --pub const DOMAIN_READ: u32 = -- STANDARD_RIGHTS_READ | DOMAIN_GET_ALIAS_MEMBERSHIP | DOMAIN_READ_OTHER_PARAMETERS; --pub const DOMAIN_WRITE: u32 = STANDARD_RIGHTS_WRITE | DOMAIN_WRITE_OTHER_PARAMETERS -- | DOMAIN_WRITE_PASSWORD_PARAMS | DOMAIN_CREATE_USER | DOMAIN_CREATE_GROUP | DOMAIN_CREATE_ALIAS -- | DOMAIN_ADMINISTER_SERVER; --pub const DOMAIN_EXECUTE: u32 = STANDARD_RIGHTS_EXECUTE | DOMAIN_READ_PASSWORD_PARAMETERS -- | DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP; --ENUM!{enum DOMAIN_INFORMATION_CLASS { -- DomainPasswordInformation = 1, -- DomainGeneralInformation = 2, -- DomainLogoffInformation = 3, -- DomainOemInformation = 4, -- DomainNameInformation = 5, -- DomainReplicationInformation = 6, -- DomainServerRoleInformation = 7, -- DomainModifiedInformation = 8, -- DomainStateInformation = 9, -- DomainUasInformation = 10, -- DomainGeneralInformation2 = 11, -- DomainLockoutInformation = 12, -- DomainModifiedInformation2 = 13, --}} --ENUM!{enum DOMAIN_SERVER_ENABLE_STATE { -- DomainServerEnabled = 1, -- DomainServerDisabled = 2, --}} --pub type PDOMAIN_SERVER_ENABLE_STATE = *mut DOMAIN_SERVER_ENABLE_STATE; --ENUM!{enum DOMAIN_SERVER_ROLE { -- DomainServerRoleBackup = 2, -- DomainServerRolePrimary = 3, --}} --pub type PDOMAIN_SERVER_ROLE = *mut DOMAIN_SERVER_ROLE; --STRUCT!{#[repr(packed(4))] struct DOMAIN_GENERAL_INFORMATION { -- ForceLogoff: LARGE_INTEGER, -- OemInformation: UNICODE_STRING, -- DomainName: UNICODE_STRING, -- ReplicaSourceNodeName: UNICODE_STRING, -- DomainModifiedCount: LARGE_INTEGER, -- DomainServerState: DOMAIN_SERVER_ENABLE_STATE, -- DomainServerRole: DOMAIN_SERVER_ROLE, -- UasCompatibilityRequired: BOOLEAN, -- UserCount: ULONG, -- GroupCount: ULONG, -- AliasCount: ULONG, --}} --pub type PDOMAIN_GENERAL_INFORMATION = *mut DOMAIN_GENERAL_INFORMATION; --STRUCT!{#[repr(packed(4))] struct DOMAIN_GENERAL_INFORMATION2 { -- I1: DOMAIN_GENERAL_INFORMATION, -- LockoutDuration: LARGE_INTEGER, -- LockoutObservationWindow: LARGE_INTEGER, -- LockoutThreshold: USHORT, --}} --pub type PDOMAIN_GENERAL_INFORMATION2 = *mut DOMAIN_GENERAL_INFORMATION2; --STRUCT!{struct DOMAIN_UAS_INFORMATION { -- UasCompatibilityRequired: BOOLEAN, --}} --ENUM!{enum DOMAIN_PASSWORD_CONSTRUCTION { -- DomainPasswordSimple = 1, -- DomainPasswordComplex = 2, --}} --STRUCT!{struct DOMAIN_LOGOFF_INFORMATION { -- ForceLogoff: LARGE_INTEGER, --}} --pub type PDOMAIN_LOGOFF_INFORMATION = *mut DOMAIN_LOGOFF_INFORMATION; --STRUCT!{struct DOMAIN_OEM_INFORMATION { -- OemInformation: UNICODE_STRING, --}} --pub type PDOMAIN_OEM_INFORMATION = *mut DOMAIN_OEM_INFORMATION; --STRUCT!{struct DOMAIN_NAME_INFORMATION { -- DomainName: UNICODE_STRING, --}} --pub type PDOMAIN_NAME_INFORMATION = *mut DOMAIN_NAME_INFORMATION; --STRUCT!{struct DOMAIN_SERVER_ROLE_INFORMATION { -- DomainServerRole: DOMAIN_SERVER_ROLE, --}} --pub type PDOMAIN_SERVER_ROLE_INFORMATION = *mut DOMAIN_SERVER_ROLE_INFORMATION; --STRUCT!{struct DOMAIN_REPLICATION_INFORMATION { -- ReplicaSourceNodeName: UNICODE_STRING, --}} --pub type PDOMAIN_REPLICATION_INFORMATION = *mut DOMAIN_REPLICATION_INFORMATION; --STRUCT!{struct DOMAIN_MODIFIED_INFORMATION { -- DomainModifiedCount: LARGE_INTEGER, -- CreationTime: LARGE_INTEGER, --}} --pub type PDOMAIN_MODIFIED_INFORMATION = *mut DOMAIN_MODIFIED_INFORMATION; --STRUCT!{struct DOMAIN_MODIFIED_INFORMATION2 { -- DomainModifiedCount: LARGE_INTEGER, -- CreationTime: LARGE_INTEGER, -- ModifiedCountAtLastPromotion: LARGE_INTEGER, --}} --pub type PDOMAIN_MODIFIED_INFORMATION2 = *mut DOMAIN_MODIFIED_INFORMATION2; --STRUCT!{struct DOMAIN_STATE_INFORMATION { -- DomainServerState: DOMAIN_SERVER_ENABLE_STATE, --}} --pub type PDOMAIN_STATE_INFORMATION = *mut DOMAIN_STATE_INFORMATION; --STRUCT!{struct DOMAIN_LOCKOUT_INFORMATION { -- LockoutDuration: LARGE_INTEGER, -- LockoutObservationWindow: LARGE_INTEGER, -- LockoutThreshold: USHORT, --}} --pub type PDOMAIN_LOCKOUT_INFORMATION = *mut DOMAIN_LOCKOUT_INFORMATION; --ENUM!{enum DOMAIN_DISPLAY_INFORMATION { -- DomainDisplayUser = 1, -- DomainDisplayMachine = 2, -- DomainDisplayGroup = 3, -- DomainDisplayOemUser = 4, -- DomainDisplayOemGroup = 5, -- DomainDisplayServer = 6, --}} --pub type PDOMAIN_DISPLAY_INFORMATION = *mut DOMAIN_DISPLAY_INFORMATION; --STRUCT!{struct DOMAIN_DISPLAY_USER { -- Index: ULONG, -- Rid: ULONG, -- AccountControl: ULONG, -- LogonName: UNICODE_STRING, -- AdminComment: UNICODE_STRING, -- FullName: UNICODE_STRING, --}} --pub type PDOMAIN_DISPLAY_USER = *mut DOMAIN_DISPLAY_USER; --STRUCT!{struct DOMAIN_DISPLAY_MACHINE { -- Index: ULONG, -- Rid: ULONG, -- AccountControl: ULONG, -- Machine: UNICODE_STRING, -- Comment: UNICODE_STRING, --}} --pub type PDOMAIN_DISPLAY_MACHINE = *mut DOMAIN_DISPLAY_MACHINE; --STRUCT!{struct DOMAIN_DISPLAY_GROUP { -- Index: ULONG, -- Rid: ULONG, -- Attributes: ULONG, -- Group: UNICODE_STRING, -- Comment: UNICODE_STRING, --}} --pub type PDOMAIN_DISPLAY_GROUP = *mut DOMAIN_DISPLAY_GROUP; --STRUCT!{struct DOMAIN_DISPLAY_OEM_USER { -- Index: ULONG, -- User: OEM_STRING, --}} --pub type PDOMAIN_DISPLAY_OEM_USER = *mut DOMAIN_DISPLAY_OEM_USER; --STRUCT!{struct DOMAIN_DISPLAY_OEM_GROUP { -- Index: ULONG, -- Group: OEM_STRING, --}} --pub type PDOMAIN_DISPLAY_OEM_GROUP = *mut DOMAIN_DISPLAY_OEM_GROUP; --ENUM!{enum DOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION { -- DomainLocalizableAccountsBasic = 1, --}} --pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION = *mut DOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION; --STRUCT!{struct DOMAIN_LOCALIZABLE_ACCOUNT_ENTRY { -- Rid: ULONG, -- Use: SID_NAME_USE, -- Name: UNICODE_STRING, -- AdminComment: UNICODE_STRING, --}} --pub type PDOMAIN_LOCALIZABLE_ACCOUNT_ENTRY = *mut DOMAIN_LOCALIZABLE_ACCOUNT_ENTRY; --STRUCT!{struct DOMAIN_LOCALIZABLE_ACCOUNTS_BASIC { -- Count: ULONG, -- Entries: *mut DOMAIN_LOCALIZABLE_ACCOUNT_ENTRY, --}} --pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_BASIC = *mut DOMAIN_LOCALIZABLE_ACCOUNTS_BASIC; --UNION!{union DOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER { -- Basic: DOMAIN_LOCALIZABLE_ACCOUNTS_BASIC, --}} --pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER = *mut DOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER; --EXTERN!{extern "system" { -- fn SamLookupDomainInSamServer( -- ServerHandle: SAM_HANDLE, -- Name: PUNICODE_STRING, -- DomainId: *mut PSID, -- ) -> NTSTATUS; -- fn SamEnumerateDomainsInSamServer( -- ServerHandle: SAM_HANDLE, -- EnumerationContext: PSAM_ENUMERATE_HANDLE, -- Buffer: *mut PVOID, -- PreferedMaximumLength: ULONG, -- CountReturned: PULONG, -- ) -> NTSTATUS; -- fn SamOpenDomain( -- ServerHandle: SAM_HANDLE, -- DesiredAccess: ACCESS_MASK, -- DomainId: PSID, -- DomainHandle: PSAM_HANDLE, -- ) -> NTSTATUS; -- fn SamQueryInformationDomain( -- DomainHandle: SAM_HANDLE, -- DomainInformationClass: DOMAIN_INFORMATION_CLASS, -- Buffer: *mut PVOID, -- ) -> NTSTATUS; -- fn SamSetInformationDomain( -- DomainHandle: SAM_HANDLE, -- DomainInformationClass: DOMAIN_INFORMATION_CLASS, -- DomainInformation: PVOID, -- ) -> NTSTATUS; -- fn SamLookupNamesInDomain( -- DomainHandle: SAM_HANDLE, -- Count: ULONG, -- Names: PUNICODE_STRING, -- RelativeIds: *mut PULONG, -- Use: *mut PSID_NAME_USE, -- ) -> NTSTATUS; -- fn SamLookupIdsInDomain( -- DomainHandle: SAM_HANDLE, -- Count: ULONG, -- RelativeIds: PULONG, -- Names: *mut PUNICODE_STRING, -- Use: *mut PSID_NAME_USE, -- ) -> NTSTATUS; -- fn SamRemoveMemberFromForeignDomain( -- DomainHandle: SAM_HANDLE, -- MemberId: PSID, -- ) -> NTSTATUS; -- fn SamQueryLocalizableAccountsInDomain( -- Domain: SAM_HANDLE, -- Flags: ULONG, -- LanguageId: ULONG, -- Class: DOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION, -- Buffer: *mut PVOID, -- ) -> NTSTATUS; --}} --pub const GROUP_READ_INFORMATION: ACCESS_MASK = 0x0001; --pub const GROUP_WRITE_ACCOUNT: ACCESS_MASK = 0x0002; --pub const GROUP_ADD_MEMBER: ACCESS_MASK = 0x0004; --pub const GROUP_REMOVE_MEMBER: ACCESS_MASK = 0x0008; --pub const GROUP_LIST_MEMBERS: ACCESS_MASK = 0x0010; --pub const GROUP_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | GROUP_LIST_MEMBERS -- | GROUP_WRITE_ACCOUNT | GROUP_ADD_MEMBER | GROUP_REMOVE_MEMBER | GROUP_READ_INFORMATION; --pub const GROUP_READ: ACCESS_MASK = STANDARD_RIGHTS_READ | GROUP_LIST_MEMBERS; --pub const GROUP_WRITE: ACCESS_MASK = -- STANDARD_RIGHTS_WRITE | GROUP_WRITE_ACCOUNT | GROUP_ADD_MEMBER | GROUP_REMOVE_MEMBER; --pub const GROUP_EXECUTE: ACCESS_MASK = STANDARD_RIGHTS_EXECUTE | GROUP_READ_INFORMATION; --STRUCT!{struct GROUP_MEMBERSHIP { -- RelativeId: ULONG, -- Attributes: ULONG, --}} --pub type PGROUP_MEMBERSHIP = *mut GROUP_MEMBERSHIP; --ENUM!{enum GROUP_INFORMATION_CLASS { -- GroupGeneralInformation = 1, -- GroupNameInformation = 2, -- GroupAttributeInformation = 3, -- GroupAdminCommentInformation = 4, -- GroupReplicationInformation = 5, --}} --STRUCT!{struct GROUP_GENERAL_INFORMATION { -- Name: UNICODE_STRING, -- Attributes: ULONG, -- MemberCount: ULONG, -- AdminComment: UNICODE_STRING, --}} --pub type PGROUP_GENERAL_INFORMATION = *mut GROUP_GENERAL_INFORMATION; --STRUCT!{struct GROUP_NAME_INFORMATION { -- Name: UNICODE_STRING, --}} --pub type PGROUP_NAME_INFORMATION = *mut GROUP_NAME_INFORMATION; --STRUCT!{struct GROUP_ATTRIBUTE_INFORMATION { -- Attributes: ULONG, --}} --pub type PGROUP_ATTRIBUTE_INFORMATION = *mut GROUP_ATTRIBUTE_INFORMATION; --STRUCT!{struct GROUP_ADM_COMMENT_INFORMATION { -- AdminComment: UNICODE_STRING, --}} --pub type PGROUP_ADM_COMMENT_INFORMATION = *mut GROUP_ADM_COMMENT_INFORMATION; --EXTERN!{extern "system" { -- fn SamEnumerateGroupsInDomain( -- DomainHandle: SAM_HANDLE, -- EnumerationContext: PSAM_ENUMERATE_HANDLE, -- Buffer: *mut PVOID, -- PreferedMaximumLength: ULONG, -- CountReturned: PULONG, -- ) -> NTSTATUS; -- fn SamCreateGroupInDomain( -- DomainHandle: SAM_HANDLE, -- AccountName: PUNICODE_STRING, -- DesiredAccess: ACCESS_MASK, -- GroupHandle: PSAM_HANDLE, -- RelativeId: PULONG, -- ) -> NTSTATUS; -- fn SamOpenGroup( -- DomainHandle: SAM_HANDLE, -- DesiredAccess: ACCESS_MASK, -- GroupId: ULONG, -- GroupHandle: PSAM_HANDLE, -- ) -> NTSTATUS; -- fn SamDeleteGroup( -- GroupHandle: SAM_HANDLE, -- ) -> NTSTATUS; -- fn SamQueryInformationGroup( -- GroupHandle: SAM_HANDLE, -- GroupInformationClass: GROUP_INFORMATION_CLASS, -- Buffer: *mut PVOID, -- ) -> NTSTATUS; -- fn SamSetInformationGroup( -- GroupHandle: SAM_HANDLE, -- GroupInformationClass: GROUP_INFORMATION_CLASS, -- Buffer: PVOID, -- ) -> NTSTATUS; -- fn SamAddMemberToGroup( -- GroupHandle: SAM_HANDLE, -- MemberId: ULONG, -- Attributes: ULONG, -- ) -> NTSTATUS; -- fn SamRemoveMemberFromGroup( -- GroupHandle: SAM_HANDLE, -- MemberId: ULONG, -- ) -> NTSTATUS; -- fn SamGetMembersInGroup( -- GroupHandle: SAM_HANDLE, -- MemberIds: *mut PULONG, -- Attributes: *mut PULONG, -- MemberCount: PULONG, -- ) -> NTSTATUS; -- fn SamSetMemberAttributesOfGroup( -- GroupHandle: SAM_HANDLE, -- MemberId: ULONG, -- Attributes: ULONG, -- ) -> NTSTATUS; --}} --pub const ALIAS_ADD_MEMBER: ACCESS_MASK = 0x0001; --pub const ALIAS_REMOVE_MEMBER: ACCESS_MASK = 0x0002; --pub const ALIAS_LIST_MEMBERS: ACCESS_MASK = 0x0004; --pub const ALIAS_READ_INFORMATION: ACCESS_MASK = 0x0008; --pub const ALIAS_WRITE_ACCOUNT: ACCESS_MASK = 0x0010; --pub const ALIAS_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | ALIAS_READ_INFORMATION -- | ALIAS_WRITE_ACCOUNT | ALIAS_LIST_MEMBERS | ALIAS_ADD_MEMBER | ALIAS_REMOVE_MEMBER; --pub const ALIAS_READ: ACCESS_MASK = STANDARD_RIGHTS_READ | ALIAS_LIST_MEMBERS; --pub const ALIAS_WRITE: ACCESS_MASK = -- STANDARD_RIGHTS_WRITE | ALIAS_WRITE_ACCOUNT | ALIAS_ADD_MEMBER | ALIAS_REMOVE_MEMBER; --pub const ALIAS_EXECUTE: ACCESS_MASK = STANDARD_RIGHTS_EXECUTE | ALIAS_READ_INFORMATION; --ENUM!{enum ALIAS_INFORMATION_CLASS { -- AliasGeneralInformation = 1, -- AliasNameInformation = 2, -- AliasAdminCommentInformation = 3, -- AliasReplicationInformation = 4, -- AliasExtendedInformation = 5, --}} --STRUCT!{struct ALIAS_GENERAL_INFORMATION { -- Name: UNICODE_STRING, -- MemberCount: ULONG, -- AdminComment: UNICODE_STRING, --}} --pub type PALIAS_GENERAL_INFORMATION = *mut ALIAS_GENERAL_INFORMATION; --STRUCT!{struct ALIAS_NAME_INFORMATION { -- Name: UNICODE_STRING, --}} --pub type PALIAS_NAME_INFORMATION = *mut ALIAS_NAME_INFORMATION; --STRUCT!{struct ALIAS_ADM_COMMENT_INFORMATION { -- AdminComment: UNICODE_STRING, --}} --pub type PALIAS_ADM_COMMENT_INFORMATION = *mut ALIAS_ADM_COMMENT_INFORMATION; --pub const ALIAS_ALL_NAME: ULONG = 0x00000001; --pub const ALIAS_ALL_MEMBER_COUNT: ULONG = 0x00000002; --pub const ALIAS_ALL_ADMIN_COMMENT: ULONG = 0x00000004; --pub const ALIAS_ALL_SHELL_ADMIN_OBJECT_PROPERTIES: ULONG = 0x00000008; --STRUCT!{struct ALIAS_EXTENDED_INFORMATION { -- WhichFields: ULONG, -- ShellAdminObjectProperties: SAM_SHELL_OBJECT_PROPERTIES, --}} --pub type PALIAS_EXTENDED_INFORMATION = *mut ALIAS_EXTENDED_INFORMATION; --EXTERN!{extern "system" { -- fn SamEnumerateAliasesInDomain( -- DomainHandle: SAM_HANDLE, -- EnumerationContext: PSAM_ENUMERATE_HANDLE, -- Buffer: *mut PVOID, -- PreferedMaximumLength: ULONG, -- CountReturned: PULONG, -- ) -> NTSTATUS; -- fn SamCreateAliasInDomain( -- DomainHandle: SAM_HANDLE, -- AccountName: PUNICODE_STRING, -- DesiredAccess: ACCESS_MASK, -- AliasHandle: PSAM_HANDLE, -- RelativeId: PULONG, -- ) -> NTSTATUS; -- fn SamOpenAlias( -- DomainHandle: SAM_HANDLE, -- DesiredAccess: ACCESS_MASK, -- AliasId: ULONG, -- AliasHandle: PSAM_HANDLE, -- ) -> NTSTATUS; -- fn SamDeleteAlias( -- AliasHandle: SAM_HANDLE, -- ) -> NTSTATUS; -- fn SamQueryInformationAlias( -- AliasHandle: SAM_HANDLE, -- AliasInformationClass: ALIAS_INFORMATION_CLASS, -- Buffer: *mut PVOID, -- ) -> NTSTATUS; -- fn SamSetInformationAlias( -- AliasHandle: SAM_HANDLE, -- AliasInformationClass: ALIAS_INFORMATION_CLASS, -- Buffer: PVOID, -- ) -> NTSTATUS; -- fn SamAddMemberToAlias( -- AliasHandle: SAM_HANDLE, -- MemberId: PSID, -- ) -> NTSTATUS; -- fn SamAddMultipleMembersToAlias( -- AliasHandle: SAM_HANDLE, -- MemberIds: *mut PSID, -- MemberCount: ULONG, -- ) -> NTSTATUS; -- fn SamRemoveMemberFromAlias( -- AliasHandle: SAM_HANDLE, -- MemberId: PSID, -- ) -> NTSTATUS; -- fn SamRemoveMultipleMembersFromAlias( -- AliasHandle: SAM_HANDLE, -- MemberIds: *mut PSID, -- MemberCount: ULONG, -- ) -> NTSTATUS; -- fn SamGetMembersInAlias( -- AliasHandle: SAM_HANDLE, -- MemberIds: *mut *mut PSID, -- MemberCount: PULONG, -- ) -> NTSTATUS; -- fn SamGetAliasMembership( -- DomainHandle: SAM_HANDLE, -- PassedCount: ULONG, -- Sids: *mut PSID, -- MembershipCount: PULONG, -- Aliases: *mut PULONG, -- ) -> NTSTATUS; --}} --pub const GROUP_TYPE_BUILTIN_LOCAL_GROUP: u32 = 0x00000001; --pub const GROUP_TYPE_ACCOUNT_GROUP: u32 = 0x00000002; --pub const GROUP_TYPE_RESOURCE_GROUP: u32 = 0x00000004; --pub const GROUP_TYPE_UNIVERSAL_GROUP: u32 = 0x00000008; --pub const GROUP_TYPE_APP_BASIC_GROUP: u32 = 0x00000010; --pub const GROUP_TYPE_APP_QUERY_GROUP: u32 = 0x00000020; --pub const GROUP_TYPE_SECURITY_ENABLED: u32 = 0x80000000; --pub const GROUP_TYPE_RESOURCE_BEHAVOIR: u32 = -- GROUP_TYPE_RESOURCE_GROUP | GROUP_TYPE_APP_BASIC_GROUP | GROUP_TYPE_APP_QUERY_GROUP; --pub const USER_READ_GENERAL: DWORD = 0x0001; --pub const USER_READ_PREFERENCES: DWORD = 0x0002; --pub const USER_WRITE_PREFERENCES: DWORD = 0x0004; --pub const USER_READ_LOGON: DWORD = 0x0008; --pub const USER_READ_ACCOUNT: DWORD = 0x0010; --pub const USER_WRITE_ACCOUNT: DWORD = 0x0020; --pub const USER_CHANGE_PASSWORD: DWORD = 0x0040; --pub const USER_FORCE_PASSWORD_CHANGE: DWORD = 0x0080; --pub const USER_LIST_GROUPS: DWORD = 0x0100; --pub const USER_READ_GROUP_INFORMATION: DWORD = 0x0200; --pub const USER_WRITE_GROUP_INFORMATION: DWORD = 0x0400; --pub const USER_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | USER_READ_PREFERENCES -- | USER_READ_LOGON | USER_LIST_GROUPS | USER_READ_GROUP_INFORMATION | USER_WRITE_PREFERENCES -- | USER_CHANGE_PASSWORD | USER_FORCE_PASSWORD_CHANGE | USER_READ_GENERAL | USER_READ_ACCOUNT -- | USER_WRITE_ACCOUNT | USER_WRITE_GROUP_INFORMATION; --pub const USER_READ: DWORD = STANDARD_RIGHTS_READ | USER_READ_PREFERENCES | USER_READ_LOGON -- | USER_READ_ACCOUNT | USER_LIST_GROUPS | USER_READ_GROUP_INFORMATION; --pub const USER_WRITE: DWORD = -- STANDARD_RIGHTS_WRITE | USER_WRITE_PREFERENCES | USER_CHANGE_PASSWORD; --pub const USER_EXECUTE: DWORD = STANDARD_RIGHTS_EXECUTE | USER_READ_GENERAL | USER_CHANGE_PASSWORD; --ENUM!{enum USER_INFORMATION_CLASS { -- UserGeneralInformation = 1, -- UserPreferencesInformation = 2, -- UserLogonInformation = 3, -- UserLogonHoursInformation = 4, -- UserAccountInformation = 5, -- UserNameInformation = 6, -- UserAccountNameInformation = 7, -- UserFullNameInformation = 8, -- UserPrimaryGroupInformation = 9, -- UserHomeInformation = 10, -- UserScriptInformation = 11, -- UserProfileInformation = 12, -- UserAdminCommentInformation = 13, -- UserWorkStationsInformation = 14, -- UserSetPasswordInformation = 15, -- UserControlInformation = 16, -- UserExpiresInformation = 17, -- UserInternal1Information = 18, -- UserInternal2Information = 19, -- UserParametersInformation = 20, -- UserAllInformation = 21, -- UserInternal3Information = 22, -- UserInternal4Information = 23, -- UserInternal5Information = 24, -- UserInternal4InformationNew = 25, -- UserInternal5InformationNew = 26, -- UserInternal6Information = 27, -- UserExtendedInformation = 28, -- UserLogonUIInformation = 29, --}} --pub type PUSER_INFORMATION_CLASS = *mut USER_INFORMATION_CLASS; --pub const USER_ALL_USERNAME: ULONG = 0x00000001; --pub const USER_ALL_FULLNAME: ULONG = 0x00000002; --pub const USER_ALL_USERID: ULONG = 0x00000004; --pub const USER_ALL_PRIMARYGROUPID: ULONG = 0x00000008; --pub const USER_ALL_ADMINCOMMENT: ULONG = 0x00000010; --pub const USER_ALL_USERCOMMENT: ULONG = 0x00000020; --pub const USER_ALL_HOMEDIRECTORY: ULONG = 0x00000040; --pub const USER_ALL_HOMEDIRECTORYDRIVE: ULONG = 0x00000080; --pub const USER_ALL_SCRIPTPATH: ULONG = 0x00000100; --pub const USER_ALL_PROFILEPATH: ULONG = 0x00000200; --pub const USER_ALL_WORKSTATIONS: ULONG = 0x00000400; --pub const USER_ALL_LASTLOGON: ULONG = 0x00000800; --pub const USER_ALL_LASTLOGOFF: ULONG = 0x00001000; --pub const USER_ALL_LOGONHOURS: ULONG = 0x00002000; --pub const USER_ALL_BADPASSWORDCOUNT: ULONG = 0x00004000; --pub const USER_ALL_LOGONCOUNT: ULONG = 0x00008000; --pub const USER_ALL_PASSWORDCANCHANGE: ULONG = 0x00010000; --pub const USER_ALL_PASSWORDMUSTCHANGE: ULONG = 0x00020000; --pub const USER_ALL_PASSWORDLASTSET: ULONG = 0x00040000; --pub const USER_ALL_ACCOUNTEXPIRES: ULONG = 0x00080000; --pub const USER_ALL_USERACCOUNTCONTROL: ULONG = 0x00100000; --pub const USER_ALL_PARAMETERS: ULONG = 0x00200000; --pub const USER_ALL_COUNTRYCODE: ULONG = 0x00400000; --pub const USER_ALL_CODEPAGE: ULONG = 0x00800000; --pub const USER_ALL_NTPASSWORDPRESENT: ULONG = 0x01000000; --pub const USER_ALL_LMPASSWORDPRESENT: ULONG = 0x02000000; --pub const USER_ALL_PRIVATEDATA: ULONG = 0x04000000; --pub const USER_ALL_PASSWORDEXPIRED: ULONG = 0x08000000; --pub const USER_ALL_SECURITYDESCRIPTOR: ULONG = 0x10000000; --pub const USER_ALL_OWFPASSWORD: ULONG = 0x20000000; --pub const USER_ALL_UNDEFINED_MASK: ULONG = 0xc0000000; --pub const USER_ALL_READ_GENERAL_MASK: ULONG = USER_ALL_USERNAME | USER_ALL_FULLNAME -- | USER_ALL_USERID | USER_ALL_PRIMARYGROUPID | USER_ALL_ADMINCOMMENT | USER_ALL_USERCOMMENT; --pub const USER_ALL_READ_LOGON_MASK: ULONG = USER_ALL_HOMEDIRECTORY | USER_ALL_HOMEDIRECTORYDRIVE -- | USER_ALL_SCRIPTPATH | USER_ALL_PROFILEPATH | USER_ALL_WORKSTATIONS | USER_ALL_LASTLOGON -- | USER_ALL_LASTLOGOFF | USER_ALL_LOGONHOURS | USER_ALL_BADPASSWORDCOUNT | USER_ALL_LOGONCOUNT -- | USER_ALL_PASSWORDCANCHANGE | USER_ALL_PASSWORDMUSTCHANGE; --pub const USER_ALL_READ_ACCOUNT_MASK: ULONG = USER_ALL_PASSWORDLASTSET | USER_ALL_ACCOUNTEXPIRES -- | USER_ALL_USERACCOUNTCONTROL | USER_ALL_PARAMETERS; --pub const USER_ALL_READ_PREFERENCES_MASK: ULONG = USER_ALL_COUNTRYCODE | USER_ALL_CODEPAGE; --pub const USER_ALL_READ_TRUSTED_MASK: ULONG = USER_ALL_NTPASSWORDPRESENT -- | USER_ALL_LMPASSWORDPRESENT | USER_ALL_PASSWORDEXPIRED | USER_ALL_SECURITYDESCRIPTOR -- | USER_ALL_PRIVATEDATA; --pub const USER_ALL_READ_CANT_MASK: ULONG = USER_ALL_UNDEFINED_MASK; --pub const USER_ALL_WRITE_ACCOUNT_MASK: ULONG = USER_ALL_USERNAME | USER_ALL_FULLNAME -- | USER_ALL_PRIMARYGROUPID | USER_ALL_HOMEDIRECTORY | USER_ALL_HOMEDIRECTORYDRIVE -- | USER_ALL_SCRIPTPATH | USER_ALL_PROFILEPATH | USER_ALL_ADMINCOMMENT | USER_ALL_WORKSTATIONS -- | USER_ALL_LOGONHOURS | USER_ALL_ACCOUNTEXPIRES | USER_ALL_USERACCOUNTCONTROL -- | USER_ALL_PARAMETERS; --pub const USER_ALL_WRITE_PREFERENCES_MASK: ULONG = -- USER_ALL_USERCOMMENT | USER_ALL_COUNTRYCODE | USER_ALL_CODEPAGE; --pub const USER_ALL_WRITE_FORCE_PASSWORD_CHANGE_MASK: ULONG = -- USER_ALL_NTPASSWORDPRESENT | USER_ALL_LMPASSWORDPRESENT | USER_ALL_PASSWORDEXPIRED; --pub const USER_ALL_WRITE_TRUSTED_MASK: ULONG = USER_ALL_LASTLOGON | USER_ALL_LASTLOGOFF -- | USER_ALL_BADPASSWORDCOUNT | USER_ALL_LOGONCOUNT | USER_ALL_PASSWORDLASTSET -- | USER_ALL_SECURITYDESCRIPTOR | USER_ALL_PRIVATEDATA; --pub const USER_ALL_WRITE_CANT_MASK: ULONG = USER_ALL_USERID | USER_ALL_PASSWORDCANCHANGE -- | USER_ALL_PASSWORDMUSTCHANGE | USER_ALL_UNDEFINED_MASK; --STRUCT!{struct USER_GENERAL_INFORMATION { -- UserName: UNICODE_STRING, -- FullName: UNICODE_STRING, -- PrimaryGroupId: ULONG, -- AdminComment: UNICODE_STRING, -- UserComment: UNICODE_STRING, --}} --pub type PUSER_GENERAL_INFORMATION = *mut USER_GENERAL_INFORMATION; --STRUCT!{struct USER_PREFERENCES_INFORMATION { -- UserComment: UNICODE_STRING, -- Reserved1: UNICODE_STRING, -- CountryCode: USHORT, -- CodePage: USHORT, --}} --pub type PUSER_PREFERENCES_INFORMATION = *mut USER_PREFERENCES_INFORMATION; --STRUCT!{struct USER_PARAMETERS_INFORMATION { -- Parameters: UNICODE_STRING, --}} --pub type PUSER_PARAMETERS_INFORMATION = *mut USER_PARAMETERS_INFORMATION; --STRUCT!{#[repr(packed(4))] struct USER_LOGON_INFORMATION { -- UserName: UNICODE_STRING, -- FullName: UNICODE_STRING, -- UserId: ULONG, -- PrimaryGroupId: ULONG, -- HomeDirectory: UNICODE_STRING, -- HomeDirectoryDrive: UNICODE_STRING, -- ScriptPath: UNICODE_STRING, -- ProfilePath: UNICODE_STRING, -- WorkStations: UNICODE_STRING, -- LastLogon: LARGE_INTEGER, -- LastLogoff: LARGE_INTEGER, -- PasswordLastSet: LARGE_INTEGER, -- PasswordCanChange: LARGE_INTEGER, -- PasswordMustChange: LARGE_INTEGER, -- LogonHours: LOGON_HOURS, -- BadPasswordCount: USHORT, -- LogonCount: USHORT, -- UserAccountControl: ULONG, --}} --pub type PUSER_LOGON_INFORMATION = *mut USER_LOGON_INFORMATION; --STRUCT!{#[repr(packed(4))] struct USER_ACCOUNT_INFORMATION { -- UserName: UNICODE_STRING, -- FullName: UNICODE_STRING, -- UserId: ULONG, -- PrimaryGroupId: ULONG, -- HomeDirectory: UNICODE_STRING, -- HomeDirectoryDrive: UNICODE_STRING, -- ScriptPath: UNICODE_STRING, -- ProfilePath: UNICODE_STRING, -- AdminComment: UNICODE_STRING, -- WorkStations: UNICODE_STRING, -- LastLogon: LARGE_INTEGER, -- LastLogoff: LARGE_INTEGER, -- LogonHours: LOGON_HOURS, -- BadPasswordCount: USHORT, -- LogonCount: USHORT, -- PasswordLastSet: LARGE_INTEGER, -- AccountExpires: LARGE_INTEGER, -- UserAccountControl: ULONG, --}} --pub type PUSER_ACCOUNT_INFORMATION = *mut USER_ACCOUNT_INFORMATION; --STRUCT!{struct USER_ACCOUNT_NAME_INFORMATION { -- UserName: UNICODE_STRING, --}} --pub type PUSER_ACCOUNT_NAME_INFORMATION = *mut USER_ACCOUNT_NAME_INFORMATION; --STRUCT!{struct USER_FULL_NAME_INFORMATION { -- FullName: UNICODE_STRING, --}} --pub type PUSER_FULL_NAME_INFORMATION = *mut USER_FULL_NAME_INFORMATION; --STRUCT!{struct USER_NAME_INFORMATION { -- UserName: UNICODE_STRING, -- FullName: UNICODE_STRING, --}} --pub type PUSER_NAME_INFORMATION = *mut USER_NAME_INFORMATION; --STRUCT!{struct USER_PRIMARY_GROUP_INFORMATION { -- PrimaryGroupId: ULONG, --}} --pub type PUSER_PRIMARY_GROUP_INFORMATION = *mut USER_PRIMARY_GROUP_INFORMATION; --STRUCT!{struct USER_HOME_INFORMATION { -- HomeDirectory: UNICODE_STRING, -- HomeDirectoryDrive: UNICODE_STRING, --}} --pub type PUSER_HOME_INFORMATION = *mut USER_HOME_INFORMATION; --STRUCT!{struct USER_SCRIPT_INFORMATION { -- ScriptPath: UNICODE_STRING, --}} --pub type PUSER_SCRIPT_INFORMATION = *mut USER_SCRIPT_INFORMATION; --STRUCT!{struct USER_PROFILE_INFORMATION { -- ProfilePath: UNICODE_STRING, --}} --pub type PUSER_PROFILE_INFORMATION = *mut USER_PROFILE_INFORMATION; --STRUCT!{struct USER_ADMIN_COMMENT_INFORMATION { -- AdminComment: UNICODE_STRING, --}} --pub type PUSER_ADMIN_COMMENT_INFORMATION = *mut USER_ADMIN_COMMENT_INFORMATION; --STRUCT!{struct USER_WORKSTATIONS_INFORMATION { -- WorkStations: UNICODE_STRING, --}} --pub type PUSER_WORKSTATIONS_INFORMATION = *mut USER_WORKSTATIONS_INFORMATION; --STRUCT!{struct USER_SET_PASSWORD_INFORMATION { -- Password: UNICODE_STRING, -- PasswordExpired: BOOLEAN, --}} --pub type PUSER_SET_PASSWORD_INFORMATION = *mut USER_SET_PASSWORD_INFORMATION; --STRUCT!{struct USER_CONTROL_INFORMATION { -- UserAccountControl: ULONG, --}} --pub type PUSER_CONTROL_INFORMATION = *mut USER_CONTROL_INFORMATION; --STRUCT!{struct USER_EXPIRES_INFORMATION { -- AccountExpires: LARGE_INTEGER, --}} --pub type PUSER_EXPIRES_INFORMATION = *mut USER_EXPIRES_INFORMATION; --STRUCT!{struct USER_LOGON_HOURS_INFORMATION { -- LogonHours: LOGON_HOURS, --}} --pub type PUSER_LOGON_HOURS_INFORMATION = *mut USER_LOGON_HOURS_INFORMATION; --pub type SAM_USER_TILE = SAM_BYTE_ARRAY_32K; --pub type PSAM_USER_TILE = *mut SAM_BYTE_ARRAY_32K; --pub const USER_EXTENDED_FIELD_USER_TILE: ULONG = 0x00001000; --pub const USER_EXTENDED_FIELD_PASSWORD_HINT: ULONG = 0x00002000; --pub const USER_EXTENDED_FIELD_DONT_SHOW_IN_LOGON_UI: ULONG = 0x00004000; --pub const USER_EXTENDED_FIELD_SHELL_ADMIN_OBJECT_PROPERTIES: ULONG = 0x00008000; --STRUCT!{struct USER_EXTENDED_INFORMATION { -- ExtendedWhichFields: ULONG, -- UserTile: SAM_USER_TILE, -- PasswordHint: UNICODE_STRING, -- DontShowInLogonUI: BOOLEAN, -- ShellAdminObjectProperties: SAM_SHELL_OBJECT_PROPERTIES, --}} --pub type PUSER_EXTENDED_INFORMATION = *mut USER_EXTENDED_INFORMATION; --STRUCT!{struct USER_LOGON_UI_INFORMATION { -- PasswordIsBlank: BOOLEAN, -- AccountIsDisabled: BOOLEAN, --}} --pub type PUSER_LOGON_UI_INFORMATION = *mut USER_LOGON_UI_INFORMATION; --STRUCT!{struct USER_PWD_CHANGE_FAILURE_INFORMATION { -- ExtendedFailureReason: ULONG, -- FilterModuleName: UNICODE_STRING, --}} --pub type PUSER_PWD_CHANGE_FAILURE_INFORMATION = *mut USER_PWD_CHANGE_FAILURE_INFORMATION; --pub const SAM_PWD_CHANGE_NO_ERROR: u32 = 0; --pub const SAM_PWD_CHANGE_PASSWORD_TOO_SHORT: u32 = 1; --pub const SAM_PWD_CHANGE_PWD_IN_HISTORY: u32 = 2; --pub const SAM_PWD_CHANGE_USERNAME_IN_PASSWORD: u32 = 3; --pub const SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD: u32 = 4; --pub const SAM_PWD_CHANGE_NOT_COMPLEX: u32 = 5; --pub const SAM_PWD_CHANGE_MACHINE_PASSWORD_NOT_DEFAULT: u32 = 6; --pub const SAM_PWD_CHANGE_FAILED_BY_FILTER: u32 = 7; --pub const SAM_PWD_CHANGE_PASSWORD_TOO_LONG: u32 = 8; --pub const SAM_PWD_CHANGE_FAILURE_REASON_MAX: u32 = 8; --EXTERN!{extern "system" { -- fn SamEnumerateUsersInDomain( -- DomainHandle: SAM_HANDLE, -- EnumerationContext: PSAM_ENUMERATE_HANDLE, -- UserAccountControl: ULONG, -- Buffer: *mut PVOID, -- PreferedMaximumLength: ULONG, -- CountReturned: PULONG, -- ) -> NTSTATUS; -- fn SamCreateUserInDomain( -- DomainHandle: SAM_HANDLE, -- AccountName: PUNICODE_STRING, -- DesiredAccess: ACCESS_MASK, -- UserHandle: PSAM_HANDLE, -- RelativeId: PULONG, -- ) -> NTSTATUS; -- fn SamCreateUser2InDomain( -- DomainHandle: SAM_HANDLE, -- AccountName: PUNICODE_STRING, -- AccountType: ULONG, -- DesiredAccess: ACCESS_MASK, -- UserHandle: PSAM_HANDLE, -- GrantedAccess: PULONG, -- RelativeId: PULONG, -- ) -> NTSTATUS; -- fn SamOpenUser( -- DomainHandle: SAM_HANDLE, -- DesiredAccess: ACCESS_MASK, -- UserId: ULONG, -- UserHandle: PSAM_HANDLE, -- ) -> NTSTATUS; -- fn SamDeleteUser( -- UserHandle: SAM_HANDLE, -- ) -> NTSTATUS; -- fn SamQueryInformationUser( -- UserHandle: SAM_HANDLE, -- UserInformationClass: USER_INFORMATION_CLASS, -- Buffer: *mut PVOID, -- ) -> NTSTATUS; -- fn SamSetInformationUser( -- UserHandle: SAM_HANDLE, -- UserInformationClass: USER_INFORMATION_CLASS, -- Buffer: PVOID, -- ) -> NTSTATUS; -- fn SamGetGroupsForUser( -- UserHandle: SAM_HANDLE, -- Groups: *mut PGROUP_MEMBERSHIP, -- MembershipCount: PULONG, -- ) -> NTSTATUS; -- fn SamChangePasswordUser( -- UserHandle: SAM_HANDLE, -- OldPassword: PUNICODE_STRING, -- NewPassword: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn SamChangePasswordUser2( -- ServerName: PUNICODE_STRING, -- UserName: PUNICODE_STRING, -- OldPassword: PUNICODE_STRING, -- NewPassword: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn SamChangePasswordUser3( -- ServerName: PUNICODE_STRING, -- UserName: PUNICODE_STRING, -- OldPassword: PUNICODE_STRING, -- NewPassword: PUNICODE_STRING, -- EffectivePasswordPolicy: *mut PDOMAIN_PASSWORD_INFORMATION, -- PasswordChangeFailureInfo: *mut PUSER_PWD_CHANGE_FAILURE_INFORMATION, -- ) -> NTSTATUS; -- fn SamQueryDisplayInformation( -- DomainHandle: SAM_HANDLE, -- DisplayInformation: DOMAIN_DISPLAY_INFORMATION, -- Index: ULONG, -- EntryCount: ULONG, -- PreferredMaximumLength: ULONG, -- TotalAvailable: PULONG, -- TotalReturned: PULONG, -- ReturnedEntryCount: PULONG, -- SortedBuffer: *mut PVOID, -- ) -> NTSTATUS; -- fn SamGetDisplayEnumerationIndex( -- DomainHandle: SAM_HANDLE, -- DisplayInformation: DOMAIN_DISPLAY_INFORMATION, -- Prefix: PUNICODE_STRING, -- Index: PULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum SECURITY_DB_DELTA_TYPE { -- SecurityDbNew = 1, -- SecurityDbRename = 2, -- SecurityDbDelete = 3, -- SecurityDbChangeMemberAdd = 4, -- SecurityDbChangeMemberSet = 5, -- SecurityDbChangeMemberDel = 6, -- SecurityDbChange = 7, -- SecurityDbChangePassword = 8, --}} --pub type PSECURITY_DB_DELTA_TYPE = *mut SECURITY_DB_DELTA_TYPE; --ENUM!{enum SECURITY_DB_OBJECT_TYPE { -- SecurityDbObjectSamDomain = 1, -- SecurityDbObjectSamUser = 2, -- SecurityDbObjectSamGroup = 3, -- SecurityDbObjectSamAlias = 4, -- SecurityDbObjectLsaPolicy = 5, -- SecurityDbObjectLsaTDomain = 6, -- SecurityDbObjectLsaAccount = 7, -- SecurityDbObjectLsaSecret = 8, --}} --pub type PSECURITY_DB_OBJECT_TYPE = *mut SECURITY_DB_OBJECT_TYPE; --ENUM!{enum SAM_ACCOUNT_TYPE { -- SamObjectUser = 1, -- SamObjectGroup = 2, -- SamObjectAlias = 3, --}} --pub type PSAM_ACCOUNT_TYPE = *mut SAM_ACCOUNT_TYPE; --pub const SAM_USER_ACCOUNT: u32 = 0x00000001; --pub const SAM_GLOBAL_GROUP_ACCOUNT: u32 = 0x00000002; --pub const SAM_LOCAL_GROUP_ACCOUNT: u32 = 0x00000004; --STRUCT!{struct SAM_GROUP_MEMBER_ID { -- MemberRid: ULONG, --}} --pub type PSAM_GROUP_MEMBER_ID = *mut SAM_GROUP_MEMBER_ID; --STRUCT!{struct SAM_ALIAS_MEMBER_ID { -- MemberSid: PSID, --}} --pub type PSAM_ALIAS_MEMBER_ID = *mut SAM_ALIAS_MEMBER_ID; --UNION!{union SAM_DELTA_DATA { -- GroupMemberId: SAM_GROUP_MEMBER_ID, -- AliasMemberId: SAM_ALIAS_MEMBER_ID, -- AccountControl: ULONG, --}} --pub type PSAM_DELTA_DATA = *mut SAM_DELTA_DATA; --FN!{stdcall PSAM_DELTA_NOTIFICATION_ROUTINE( -- DomainSid: PSID, -- DeltaType: SECURITY_DB_DELTA_TYPE, -- ObjectType: SECURITY_DB_OBJECT_TYPE, -- ObjectRid: ULONG, -- ObjectName: PUNICODE_STRING, -- ModifiedCount: PLARGE_INTEGER, -- DeltaData: PSAM_DELTA_DATA, --) -> NTSTATUS} --pub const SAM_DELTA_NOTIFY_ROUTINE: UTF8Const = UTF8Const("DeltaNotify\0"); --EXTERN!{extern "system" { -- fn SamRegisterObjectChangeNotification( -- ObjectType: SECURITY_DB_OBJECT_TYPE, -- NotificationEventHandle: HANDLE, -- ) -> NTSTATUS; -- fn SamUnregisterObjectChangeNotification( -- ObjectType: SECURITY_DB_OBJECT_TYPE, -- NotificationEventHandle: HANDLE, -- ) -> NTSTATUS; --}} --pub const SAM_SID_COMPATIBILITY_ALL: u32 = 0; --pub const SAM_SID_COMPATIBILITY_LAX: u32 = 1; --pub const SAM_SID_COMPATIBILITY_STRICT: u32 = 2; --EXTERN!{extern "system" { -- fn SamGetCompatibilityMode( -- ObjectHandle: SAM_HANDLE, -- Mode: *mut ULONG, -- ) -> NTSTATUS; --}} --ENUM!{enum PASSWORD_POLICY_VALIDATION_TYPE { -- SamValidateAuthentication = 1, -- SamValidatePasswordChange = 2, -- SamValidatePasswordReset = 3, --}} --STRUCT!{struct SAM_VALIDATE_PASSWORD_HASH { -- Length: ULONG, -- Hash: PUCHAR, --}} --pub type PSAM_VALIDATE_PASSWORD_HASH = *mut SAM_VALIDATE_PASSWORD_HASH; --pub const SAM_VALIDATE_PASSWORD_LAST_SET: u32 = 0x00000001; --pub const SAM_VALIDATE_BAD_PASSWORD_TIME: u32 = 0x00000002; --pub const SAM_VALIDATE_LOCKOUT_TIME: u32 = 0x00000004; --pub const SAM_VALIDATE_BAD_PASSWORD_COUNT: u32 = 0x00000008; --pub const SAM_VALIDATE_PASSWORD_HISTORY_LENGTH: u32 = 0x00000010; --pub const SAM_VALIDATE_PASSWORD_HISTORY: u32 = 0x00000020; --STRUCT!{struct SAM_VALIDATE_PERSISTED_FIELDS { -- PresentFields: ULONG, -- PasswordLastSet: LARGE_INTEGER, -- BadPasswordTime: LARGE_INTEGER, -- LockoutTime: LARGE_INTEGER, -- BadPasswordCount: ULONG, -- PasswordHistoryLength: ULONG, -- PasswordHistory: PSAM_VALIDATE_PASSWORD_HASH, --}} --pub type PSAM_VALIDATE_PERSISTED_FIELDS = *mut SAM_VALIDATE_PERSISTED_FIELDS; --ENUM!{enum SAM_VALIDATE_VALIDATION_STATUS { -- SamValidateSuccess = 0, -- SamValidatePasswordMustChange = 1, -- SamValidateAccountLockedOut = 2, -- SamValidatePasswordExpired = 3, -- SamValidatePasswordIncorrect = 4, -- SamValidatePasswordIsInHistory = 5, -- SamValidatePasswordTooShort = 6, -- SamValidatePasswordTooLong = 7, -- SamValidatePasswordNotComplexEnough = 8, -- SamValidatePasswordTooRecent = 9, -- SamValidatePasswordFilterError = 10, --}} --pub type PSAM_VALIDATE_VALIDATION_STATUS = *mut SAM_VALIDATE_VALIDATION_STATUS; --STRUCT!{struct SAM_VALIDATE_STANDARD_OUTPUT_ARG { -- ChangedPersistedFields: SAM_VALIDATE_PERSISTED_FIELDS, -- ValidationStatus: SAM_VALIDATE_VALIDATION_STATUS, --}} --pub type PSAM_VALIDATE_STANDARD_OUTPUT_ARG = *mut SAM_VALIDATE_STANDARD_OUTPUT_ARG; --STRUCT!{struct SAM_VALIDATE_AUTHENTICATION_INPUT_ARG { -- InputPersistedFields: SAM_VALIDATE_PERSISTED_FIELDS, -- PasswordMatched: BOOLEAN, --}} --pub type PSAM_VALIDATE_AUTHENTICATION_INPUT_ARG = *mut SAM_VALIDATE_AUTHENTICATION_INPUT_ARG; --STRUCT!{struct SAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG { -- InputPersistedFields: SAM_VALIDATE_PERSISTED_FIELDS, -- ClearPassword: UNICODE_STRING, -- UserAccountName: UNICODE_STRING, -- HashedPassword: SAM_VALIDATE_PASSWORD_HASH, -- PasswordMatch: BOOLEAN, --}} --pub type PSAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG = *mut SAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG; --STRUCT!{struct SAM_VALIDATE_PASSWORD_RESET_INPUT_ARG { -- InputPersistedFields: SAM_VALIDATE_PERSISTED_FIELDS, -- ClearPassword: UNICODE_STRING, -- UserAccountName: UNICODE_STRING, -- HashedPassword: SAM_VALIDATE_PASSWORD_HASH, -- PasswordMustChangeAtNextLogon: BOOLEAN, -- ClearLockout: BOOLEAN, --}} --pub type PSAM_VALIDATE_PASSWORD_RESET_INPUT_ARG = *mut SAM_VALIDATE_PASSWORD_RESET_INPUT_ARG; --UNION!{union SAM_VALIDATE_INPUT_ARG { -- ValidateAuthenticationInput: SAM_VALIDATE_AUTHENTICATION_INPUT_ARG, -- ValidatePasswordChangeInput: SAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG, -- ValidatePasswordResetInput: SAM_VALIDATE_PASSWORD_RESET_INPUT_ARG, --}} --pub type PSAM_VALIDATE_INPUT_ARG = *mut SAM_VALIDATE_INPUT_ARG; --UNION!{union SAM_VALIDATE_OUTPUT_ARG { -- ValidateAuthenticationOutput: SAM_VALIDATE_STANDARD_OUTPUT_ARG, -- ValidatePasswordChangeOutput: SAM_VALIDATE_STANDARD_OUTPUT_ARG, -- ValidatePasswordResetOutput: SAM_VALIDATE_STANDARD_OUTPUT_ARG, --}} --pub type PSAM_VALIDATE_OUTPUT_ARG = *mut SAM_VALIDATE_OUTPUT_ARG; --EXTERN!{extern "system" { -- fn SamValidatePassword( -- ServerName: PUNICODE_STRING, -- ValidationType: PASSWORD_POLICY_VALIDATION_TYPE, -- InputArg: PSAM_VALIDATE_INPUT_ARG, -- OutputArg: *mut PSAM_VALIDATE_OUTPUT_ARG, -- ) -> NTSTATUS; --}} --ENUM!{enum SAM_GENERIC_OPERATION_TYPE { -- SamObjectChangeNotificationOperation = 0, --}} --pub type PSAM_GENERIC_OPERATION_TYPE = *mut SAM_GENERIC_OPERATION_TYPE; --STRUCT!{struct SAM_OPERATION_OBJCHG_INPUT { -- Register: BOOLEAN, -- EventHandle: ULONG64, -- ObjectType: SECURITY_DB_OBJECT_TYPE, -- ProcessID: ULONG, --}} --pub type PSAM_OPERATION_OBJCHG_INPUT = *mut SAM_OPERATION_OBJCHG_INPUT; --STRUCT!{struct SAM_OPERATION_OBJCHG_OUTPUT { -- Reserved: ULONG, --}} --pub type PSAM_OPERATION_OBJCHG_OUTPUT = *mut SAM_OPERATION_OBJCHG_OUTPUT; --UNION!{union SAM_GENERIC_OPERATION_INPUT { -- ObjChangeIn: SAM_OPERATION_OBJCHG_INPUT, --}} --pub type PSAM_GENERIC_OPERATION_INPUT = *mut SAM_GENERIC_OPERATION_INPUT; --UNION!{union SAM_GENERIC_OPERATION_OUTPUT { -- ObjChangeOut: SAM_OPERATION_OBJCHG_OUTPUT, --}} --pub type PSAM_GENERIC_OPERATION_OUTPUT = *mut SAM_GENERIC_OPERATION_OUTPUT; --EXTERN!{extern "system" { -- fn SamPerformGenericOperation( -- ServerName: PWSTR, -- OperationType: SAM_GENERIC_OPERATION_TYPE, -- OperationIn: PSAM_GENERIC_OPERATION_INPUT, -- OperationOut: *mut PSAM_GENERIC_OPERATION_OUTPUT, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntseapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntseapi.rs -deleted file mode 100644 -index 4cac9f4f..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntseapi.rs -+++ /dev/null -@@ -1,439 +0,0 @@ --use winapi::shared::basetsd::{PLONG64, PULONG64, ULONG64}; --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, LONG, NTSTATUS, PBOOLEAN, PHANDLE, PLARGE_INTEGER, PLUID, PNTSTATUS, -- POBJECT_ATTRIBUTES, PUCHAR, PULONG, PUNICODE_STRING, PVOID, ULONG, UNICODE_STRING, USHORT, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, AUDIT_EVENT_TYPE, PACCESS_MASK, PGENERIC_MAPPING, POBJECT_TYPE_LIST, -- PPRIVILEGE_SET, PSECURITY_DESCRIPTOR, PSE_SIGNING_LEVEL, PSID, PSID_AND_ATTRIBUTES, -- PTOKEN_DEFAULT_DACL, PTOKEN_GROUPS, PTOKEN_MANDATORY_POLICY, PTOKEN_OWNER, -- PTOKEN_PRIMARY_GROUP, PTOKEN_PRIVILEGES, PTOKEN_SOURCE, PTOKEN_USER, SE_SIGNING_LEVEL, -- TOKEN_INFORMATION_CLASS, TOKEN_TYPE, --}; --pub const SE_MIN_WELL_KNOWN_PRIVILEGE: LONG = 2; --pub const SE_CREATE_TOKEN_PRIVILEGE: LONG = 2; --pub const SE_ASSIGNPRIMARYTOKEN_PRIVILEGE: LONG = 3; --pub const SE_LOCK_MEMORY_PRIVILEGE: LONG = 4; --pub const SE_INCREASE_QUOTA_PRIVILEGE: LONG = 5; --pub const SE_MACHINE_ACCOUNT_PRIVILEGE: LONG = 6; --pub const SE_TCB_PRIVILEGE: LONG = 7; --pub const SE_SECURITY_PRIVILEGE: LONG = 8; --pub const SE_TAKE_OWNERSHIP_PRIVILEGE: LONG = 9; --pub const SE_LOAD_DRIVER_PRIVILEGE: LONG = 10; --pub const SE_SYSTEM_PROFILE_PRIVILEGE: LONG = 11; --pub const SE_SYSTEMTIME_PRIVILEGE: LONG = 12; --pub const SE_PROF_SINGLE_PROCESS_PRIVILEGE: LONG = 13; --pub const SE_INC_BASE_PRIORITY_PRIVILEGE: LONG = 14; --pub const SE_CREATE_PAGEFILE_PRIVILEGE: LONG = 15; --pub const SE_CREATE_PERMANENT_PRIVILEGE: LONG = 16; --pub const SE_BACKUP_PRIVILEGE: LONG = 17; --pub const SE_RESTORE_PRIVILEGE: LONG = 18; --pub const SE_SHUTDOWN_PRIVILEGE: LONG = 19; --pub const SE_DEBUG_PRIVILEGE: LONG = 20; --pub const SE_AUDIT_PRIVILEGE: LONG = 21; --pub const SE_SYSTEM_ENVIRONMENT_PRIVILEGE: LONG = 22; --pub const SE_CHANGE_NOTIFY_PRIVILEGE: LONG = 23; --pub const SE_REMOTE_SHUTDOWN_PRIVILEGE: LONG = 24; --pub const SE_UNDOCK_PRIVILEGE: LONG = 25; --pub const SE_SYNC_AGENT_PRIVILEGE: LONG = 26; --pub const SE_ENABLE_DELEGATION_PRIVILEGE: LONG = 27; --pub const SE_MANAGE_VOLUME_PRIVILEGE: LONG = 28; --pub const SE_IMPERSONATE_PRIVILEGE: LONG = 29; --pub const SE_CREATE_GLOBAL_PRIVILEGE: LONG = 30; --pub const SE_TRUSTED_CREDMAN_ACCESS_PRIVILEGE: LONG = 31; --pub const SE_RELABEL_PRIVILEGE: LONG = 32; --pub const SE_INC_WORKING_SET_PRIVILEGE: LONG = 33; --pub const SE_TIME_ZONE_PRIVILEGE: LONG = 34; --pub const SE_CREATE_SYMBOLIC_LINK_PRIVILEGE: LONG = 35; --pub const SE_DELEGATE_SESSION_USER_IMPERSONATE_PRIVILEGE: LONG = 36; --pub const SE_MAX_WELL_KNOWN_PRIVILEGE: LONG = SE_DELEGATE_SESSION_USER_IMPERSONATE_PRIVILEGE; --pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID: USHORT = 0x00; --pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64: USHORT = 0x01; --pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64: USHORT = 0x02; --pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING: USHORT = 0x03; --pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN: USHORT = 0x04; --pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_SID: USHORT = 0x05; --pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN: USHORT = 0x06; --pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING: USHORT = 0x10; --pub const TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE: USHORT = 0x0001; --pub const TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE: USHORT = 0x0002; --pub const TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY: USHORT = 0x0004; --pub const TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT: USHORT = 0x0008; --pub const TOKEN_SECURITY_ATTRIBUTE_DISABLED: USHORT = 0x0010; --pub const TOKEN_SECURITY_ATTRIBUTE_MANDATORY: USHORT = 0x0020; --pub const TOKEN_SECURITY_ATTRIBUTE_COMPARE_IGNORE: USHORT = 0x0040; --pub const TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS: USHORT = TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE -- | TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE | TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY -- | TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT | TOKEN_SECURITY_ATTRIBUTE_DISABLED -- | TOKEN_SECURITY_ATTRIBUTE_MANDATORY; --pub const TOKEN_SECURITY_ATTRIBUTE_CUSTOM_FLAGS: u32 = 0xffff0000; --STRUCT!{struct TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE { -- Version: ULONG64, -- Name: UNICODE_STRING, --}} --pub type PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE = *mut TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE; --STRUCT!{struct TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE { -- pValue: PVOID, -- ValueLength: ULONG, --}} --pub type PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = -- *mut TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE; --UNION!{union TOKEN_SECURITY_ATTRIBUTE_V1_Values { -- pInt64: PLONG64, -- pUint64: PULONG64, -- pString: PUNICODE_STRING, -- pFqbn: PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE, -- pOctetString: PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE, --}} --STRUCT!{struct TOKEN_SECURITY_ATTRIBUTE_V1 { -- Name: UNICODE_STRING, -- ValueType: USHORT, -- Reserved: USHORT, -- Flags: ULONG, -- ValueCount: ULONG, -- Values: TOKEN_SECURITY_ATTRIBUTE_V1_Values, --}} --pub type PTOKEN_SECURITY_ATTRIBUTE_V1 = *mut TOKEN_SECURITY_ATTRIBUTE_V1; --pub const TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1: USHORT = 1; --pub const TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION: USHORT = -- TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1; --STRUCT!{struct TOKEN_SECURITY_ATTRIBUTES_INFORMATION { -- Version: USHORT, -- Reserved: USHORT, -- AttributeCount: ULONG, -- pAttributeV1: PTOKEN_SECURITY_ATTRIBUTE_V1, --}} --pub type PTOKEN_SECURITY_ATTRIBUTES_INFORMATION = *mut TOKEN_SECURITY_ATTRIBUTES_INFORMATION; --STRUCT!{struct TOKEN_PROCESS_TRUST_LEVEL { -- TrustLevelSid: PSID, --}} --pub type PTOKEN_PROCESS_TRUST_LEVEL = *mut TOKEN_PROCESS_TRUST_LEVEL; --EXTERN!{extern "system" { -- fn NtCreateToken( -- TokenHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TokenType: TOKEN_TYPE, -- AuthenticationId: PLUID, -- ExpirationTime: PLARGE_INTEGER, -- User: PTOKEN_USER, -- Groups: PTOKEN_GROUPS, -- Privileges: PTOKEN_PRIVILEGES, -- Owner: PTOKEN_OWNER, -- PrimaryGroup: PTOKEN_PRIMARY_GROUP, -- DefaultDacl: PTOKEN_DEFAULT_DACL, -- TokenSource: PTOKEN_SOURCE, -- ) -> NTSTATUS; -- fn NtCreateLowBoxToken( -- TokenHandle: PHANDLE, -- ExistingTokenHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PackageSid: PSID, -- CapabilityCount: ULONG, -- Capabilities: PSID_AND_ATTRIBUTES, -- HandleCount: ULONG, -- Handles: *mut HANDLE, -- ) -> NTSTATUS; -- fn NtCreateTokenEx( -- TokenHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TokenType: TOKEN_TYPE, -- AuthenticationId: PLUID, -- ExpirationTime: PLARGE_INTEGER, -- User: PTOKEN_USER, -- Groups: PTOKEN_GROUPS, -- Privileges: PTOKEN_PRIVILEGES, -- UserAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- DeviceAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- DeviceGroups: PTOKEN_GROUPS, -- TokenMandatoryPolicy: PTOKEN_MANDATORY_POLICY, -- Owner: PTOKEN_OWNER, -- PrimaryGroup: PTOKEN_PRIMARY_GROUP, -- DefaultDacl: PTOKEN_DEFAULT_DACL, -- TokenSource: PTOKEN_SOURCE, -- ) -> NTSTATUS; -- fn NtOpenProcessToken( -- ProcessHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- TokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtOpenProcessTokenEx( -- ProcessHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- HandleAttributes: ULONG, -- TokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtOpenThreadToken( -- ThreadHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- OpenAsSelf: BOOLEAN, -- TokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtOpenThreadTokenEx( -- ThreadHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- OpenAsSelf: BOOLEAN, -- HandleAttributes: ULONG, -- TokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtDuplicateToken( -- ExistingTokenHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- EffectiveOnly: BOOLEAN, -- TokenType: TOKEN_TYPE, -- NewTokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtQueryInformationToken( -- TokenHandle: HANDLE, -- TokenInformationClass: TOKEN_INFORMATION_CLASS, -- TokenInformation: PVOID, -- TokenInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationToken( -- TokenHandle: HANDLE, -- TokenInformationClass: TOKEN_INFORMATION_CLASS, -- TokenInformation: PVOID, -- TokenInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtAdjustPrivilegesToken( -- TokenHandle: HANDLE, -- DisableAllPrivileges: BOOLEAN, -- NewState: PTOKEN_PRIVILEGES, -- BufferLength: ULONG, -- PreviousState: PTOKEN_PRIVILEGES, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtAdjustGroupsToken( -- TokenHandle: HANDLE, -- ResetToDefault: BOOLEAN, -- NewState: PTOKEN_GROUPS, -- BufferLength: ULONG, -- PreviousState: PTOKEN_GROUPS, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtAdjustTokenClaimsAndDeviceGroups( -- TokenHandle: HANDLE, -- UserResetToDefault: BOOLEAN, -- DeviceResetToDefault: BOOLEAN, -- DeviceGroupsResetToDefault: BOOLEAN, -- NewUserState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- NewDeviceState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- NewDeviceGroupsState: PTOKEN_GROUPS, -- UserBufferLength: ULONG, -- PreviousUserState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- DeviceBufferLength: ULONG, -- PreviousDeviceState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- DeviceGroupsBufferLength: ULONG, -- PreviousDeviceGroups: PTOKEN_GROUPS, -- UserReturnLength: PULONG, -- DeviceReturnLength: PULONG, -- DeviceGroupsReturnBufferLength: PULONG, -- ) -> NTSTATUS; -- fn NtFilterToken( -- ExistingTokenHandle: HANDLE, -- Flags: ULONG, -- SidsToDisable: PTOKEN_GROUPS, -- PrivilegesToDelete: PTOKEN_PRIVILEGES, -- RestrictedSids: PTOKEN_GROUPS, -- NewTokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtFilterTokenEx( -- ExistingTokenHandle: HANDLE, -- Flags: ULONG, -- SidsToDisable: PTOKEN_GROUPS, -- PrivilegesToDelete: PTOKEN_PRIVILEGES, -- RestrictedSids: PTOKEN_GROUPS, -- DisableUserClaimsCount: ULONG, -- UserClaimsToDisable: PUNICODE_STRING, -- DisableDeviceClaimsCount: ULONG, -- DeviceClaimsToDisable: PUNICODE_STRING, -- DeviceGroupsToDisable: PTOKEN_GROUPS, -- RestrictedUserAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- RestrictedDeviceAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- RestrictedDeviceGroups: PTOKEN_GROUPS, -- NewTokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn NtCompareTokens( -- FirstTokenHandle: HANDLE, -- SecondTokenHandle: HANDLE, -- Equal: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtPrivilegeCheck( -- ClientToken: HANDLE, -- RequiredPrivileges: PPRIVILEGE_SET, -- Result: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtImpersonateAnonymousToken( -- ThreadHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtQuerySecurityAttributesToken( -- TokenHandle: HANDLE, -- Attributes: PUNICODE_STRING, -- NumberOfAttributes: ULONG, -- Buffer: PVOID, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtAccessCheck( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- GenericMapping: PGENERIC_MAPPING, -- PrivilegeSet: PPRIVILEGE_SET, -- PrivilegeSetLength: PULONG, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- ) -> NTSTATUS; -- fn NtAccessCheckByType( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- PrivilegeSet: PPRIVILEGE_SET, -- PrivilegeSetLength: PULONG, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- ) -> NTSTATUS; -- fn NtAccessCheckByTypeResultList( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- PrivilegeSet: PPRIVILEGE_SET, -- PrivilegeSetLength: PULONG, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- ) -> NTSTATUS; -- fn NtSetCachedSigningLevel( -- Flags: ULONG, -- InputSigningLevel: SE_SIGNING_LEVEL, -- SourceFiles: PHANDLE, -- SourceFileCount: ULONG, -- TargetFile: HANDLE, -- ) -> NTSTATUS; -- fn NtGetCachedSigningLevel( -- File: HANDLE, -- Flags: PULONG, -- SigningLevel: PSE_SIGNING_LEVEL, -- Thumbprint: PUCHAR, -- ThumbprintSize: PULONG, -- ThumbprintAlgorithm: PULONG, -- ) -> NTSTATUS; -- fn NtAccessCheckAndAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- DesiredAccess: ACCESS_MASK, -- GenericMapping: PGENERIC_MAPPING, -- ObjectCreation: BOOLEAN, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtAccessCheckByTypeAndAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- DesiredAccess: ACCESS_MASK, -- AuditType: AUDIT_EVENT_TYPE, -- Flags: ULONG, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- ObjectCreation: BOOLEAN, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtAccessCheckByTypeResultListAndAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- DesiredAccess: ACCESS_MASK, -- AuditType: AUDIT_EVENT_TYPE, -- Flags: ULONG, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- ObjectCreation: BOOLEAN, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtAccessCheckByTypeResultListAndAuditAlarmByHandle( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ClientToken: HANDLE, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- DesiredAccess: ACCESS_MASK, -- AuditType: AUDIT_EVENT_TYPE, -- Flags: ULONG, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- ObjectCreation: BOOLEAN, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtOpenObjectAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- GrantedAccess: ACCESS_MASK, -- Privileges: PPRIVILEGE_SET, -- ObjectCreation: BOOLEAN, -- AccessGranted: BOOLEAN, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn NtPrivilegeObjectAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- Privileges: PPRIVILEGE_SET, -- AccessGranted: BOOLEAN, -- ) -> NTSTATUS; -- fn NtCloseObjectAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- GenerateOnClose: BOOLEAN, -- ) -> NTSTATUS; -- fn NtDeleteObjectAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- GenerateOnClose: BOOLEAN, -- ) -> NTSTATUS; -- fn NtPrivilegedServiceAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- ServiceName: PUNICODE_STRING, -- ClientToken: HANDLE, -- Privileges: PPRIVILEGE_SET, -- AccessGranted: BOOLEAN, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntsmss.rs b/KubeOS-Rust/vendor/ntapi/src/ntsmss.rs -deleted file mode 100644 -index b22991fb..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntsmss.rs -+++ /dev/null -@@ -1,15 +0,0 @@ --use crate::ntlpcapi::PPORT_MESSAGE; --use winapi::shared::minwindef::DWORD; --use winapi::shared::ntdef::{HANDLE, NTSTATUS, PHANDLE, PUNICODE_STRING}; --EXTERN!{extern "system" { -- fn RtlConnectToSm( -- ApiPortName: PUNICODE_STRING, -- ApiPortHandle: HANDLE, -- ProcessImageType: DWORD, -- SmssConnection: PHANDLE, -- ) -> NTSTATUS; -- fn RtlSendMsgToSm( -- ApiPortHandle: HANDLE, -- MessageData: PPORT_MESSAGE, -- ) -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/nttmapi.rs b/KubeOS-Rust/vendor/ntapi/src/nttmapi.rs -deleted file mode 100644 -index 3ed499a9..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/nttmapi.rs -+++ /dev/null -@@ -1,239 +0,0 @@ --use winapi::shared::basetsd::ULONG_PTR; --use winapi::shared::guiddef::LPGUID; --use winapi::shared::ktmtypes::{NOTIFICATION_MASK, PCRM_PROTOCOL_ID, PTRANSACTION_NOTIFICATION}; --use winapi::shared::ntdef::{ -- BOOLEAN, HANDLE, NTSTATUS, PHANDLE, PLARGE_INTEGER, POBJECT_ATTRIBUTES, PULONG, -- PUNICODE_STRING, PVOID, ULONG, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, ENLISTMENT_INFORMATION_CLASS, KTMOBJECT_TYPE, PKTMOBJECT_CURSOR, -- RESOURCEMANAGER_INFORMATION_CLASS, TRANSACTIONMANAGER_INFORMATION_CLASS, -- TRANSACTION_INFORMATION_CLASS, --}; --EXTERN!{extern "system" { -- fn NtCreateTransactionManager( -- TmHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- LogFileName: PUNICODE_STRING, -- CreateOptions: ULONG, -- CommitStrength: ULONG, -- ) -> NTSTATUS; -- fn NtOpenTransactionManager( -- TmHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- LogFileName: PUNICODE_STRING, -- TmIdentity: LPGUID, -- OpenOptions: ULONG, -- ) -> NTSTATUS; -- fn NtRenameTransactionManager( -- LogFileName: PUNICODE_STRING, -- ExistingTransactionManagerGuid: LPGUID, -- ) -> NTSTATUS; -- fn NtRollforwardTransactionManager( -- TransactionManagerHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtRecoverTransactionManager( -- TransactionManagerHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtQueryInformationTransactionManager( -- TransactionManagerHandle: HANDLE, -- TransactionManagerInformationClass: TRANSACTIONMANAGER_INFORMATION_CLASS, -- TransactionManagerInformation: PVOID, -- TransactionManagerInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationTransactionManager( -- TmHandle: HANDLE, -- TransactionManagerInformationClass: TRANSACTIONMANAGER_INFORMATION_CLASS, -- TransactionManagerInformation: PVOID, -- TransactionManagerInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtEnumerateTransactionObject( -- RootObjectHandle: HANDLE, -- QueryType: KTMOBJECT_TYPE, -- ObjectCursor: PKTMOBJECT_CURSOR, -- ObjectCursorLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtCreateTransaction( -- TransactionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Uow: LPGUID, -- TmHandle: HANDLE, -- CreateOptions: ULONG, -- IsolationLevel: ULONG, -- IsolationFlags: ULONG, -- Timeout: PLARGE_INTEGER, -- Description: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn NtOpenTransaction( -- TransactionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Uow: LPGUID, -- TmHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtQueryInformationTransaction( -- TransactionHandle: HANDLE, -- TransactionInformationClass: TRANSACTION_INFORMATION_CLASS, -- TransactionInformation: PVOID, -- TransactionInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationTransaction( -- TransactionHandle: HANDLE, -- TransactionInformationClass: TRANSACTION_INFORMATION_CLASS, -- TransactionInformation: PVOID, -- TransactionInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtCommitTransaction( -- TransactionHandle: HANDLE, -- Wait: BOOLEAN, -- ) -> NTSTATUS; -- fn NtRollbackTransaction( -- TransactionHandle: HANDLE, -- Wait: BOOLEAN, -- ) -> NTSTATUS; -- fn NtCreateEnlistment( -- EnlistmentHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ResourceManagerHandle: HANDLE, -- TransactionHandle: HANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- CreateOptions: ULONG, -- NotificationMask: NOTIFICATION_MASK, -- EnlistmentKey: PVOID, -- ) -> NTSTATUS; -- fn NtOpenEnlistment( -- EnlistmentHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ResourceManagerHandle: HANDLE, -- EnlistmentGuid: LPGUID, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtQueryInformationEnlistment( -- EnlistmentHandle: HANDLE, -- EnlistmentInformationClass: ENLISTMENT_INFORMATION_CLASS, -- EnlistmentInformation: PVOID, -- EnlistmentInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationEnlistment( -- EnlistmentHandle: HANDLE, -- EnlistmentInformationClass: ENLISTMENT_INFORMATION_CLASS, -- EnlistmentInformation: PVOID, -- EnlistmentInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtRecoverEnlistment( -- EnlistmentHandle: HANDLE, -- EnlistmentKey: PVOID, -- ) -> NTSTATUS; -- fn NtPrePrepareEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtPrepareEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtCommitEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtRollbackEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtPrePrepareComplete( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtPrepareComplete( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtCommitComplete( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtReadOnlyEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtRollbackComplete( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtSinglePhaseReject( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtCreateResourceManager( -- ResourceManagerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- TmHandle: HANDLE, -- RmGuid: LPGUID, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- CreateOptions: ULONG, -- Description: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn NtOpenResourceManager( -- ResourceManagerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- TmHandle: HANDLE, -- ResourceManagerGuid: LPGUID, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn NtRecoverResourceManager( -- ResourceManagerHandle: HANDLE, -- ) -> NTSTATUS; -- fn NtGetNotificationResourceManager( -- ResourceManagerHandle: HANDLE, -- TransactionNotification: PTRANSACTION_NOTIFICATION, -- NotificationLength: ULONG, -- Timeout: PLARGE_INTEGER, -- ReturnLength: PULONG, -- Asynchronous: ULONG, -- AsynchronousContext: ULONG_PTR, -- ) -> NTSTATUS; -- fn NtQueryInformationResourceManager( -- ResourceManagerHandle: HANDLE, -- ResourceManagerInformationClass: RESOURCEMANAGER_INFORMATION_CLASS, -- ResourceManagerInformation: PVOID, -- ResourceManagerInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn NtSetInformationResourceManager( -- ResourceManagerHandle: HANDLE, -- ResourceManagerInformationClass: RESOURCEMANAGER_INFORMATION_CLASS, -- ResourceManagerInformation: PVOID, -- ResourceManagerInformationLength: ULONG, -- ) -> NTSTATUS; -- fn NtRegisterProtocolAddressInformation( -- ResourceManager: HANDLE, -- ProtocolId: PCRM_PROTOCOL_ID, -- ProtocolInformationSize: ULONG, -- ProtocolInformation: PVOID, -- CreateOptions: ULONG, -- ) -> NTSTATUS; -- fn NtPropagationComplete( -- ResourceManagerHandle: HANDLE, -- RequestCookie: ULONG, -- BufferLength: ULONG, -- Buffer: PVOID, -- ) -> NTSTATUS; -- fn NtPropagationFailed( -- ResourceManagerHandle: HANDLE, -- RequestCookie: ULONG, -- PropStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn NtFreezeTransactions( -- FreezeTimeout: PLARGE_INTEGER, -- ThawTimeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn NtThawTransactions() -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/nttp.rs b/KubeOS-Rust/vendor/ntapi/src/nttp.rs -deleted file mode 100644 -index a41eb344..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/nttp.rs -+++ /dev/null -@@ -1,207 +0,0 @@ --use crate::ntioapi::PIO_STATUS_BLOCK; --use winapi::shared::ntdef::{HANDLE, LOGICAL, LONG, NTSTATUS, PLARGE_INTEGER, PVOID}; --use winapi::um::winnt::{ -- PRTL_CRITICAL_SECTION, PTP_CALLBACK_ENVIRON, PTP_CALLBACK_INSTANCE, PTP_CLEANUP_GROUP, PTP_IO, -- PTP_POOL, PTP_POOL_STACK_INFORMATION, PTP_SIMPLE_CALLBACK, PTP_TIMER, PTP_TIMER_CALLBACK, -- PTP_WAIT, PTP_WAIT_CALLBACK, PTP_WORK, PTP_WORK_CALLBACK, --}; --#[repr(C)] --pub struct TP_ALPC([u8; 0]); --pub type PTP_ALPC = *mut TP_ALPC; --FN!{stdcall PTP_ALPC_CALLBACK( -- Instance: PTP_CALLBACK_INSTANCE, -- Context: PVOID, -- Alpc: PTP_ALPC, --) -> ()} --FN!{stdcall PTP_ALPC_CALLBACK_EX( -- Instanc: PTP_CALLBACK_INSTANCE, -- Contex: PVOID, -- Alp: PTP_ALPC, -- ApcContext: PVOID, --) -> ()} --EXTERN!{extern "system" { -- fn TpAllocPool( -- PoolReturn: *mut PTP_POOL, -- Reserved: PVOID, -- ) -> NTSTATUS; -- fn TpReleasePool( -- Pool: PTP_POOL, -- ); -- fn TpSetPoolMaxThreads( -- Pool: PTP_POOL, -- MaxThreads: LONG, -- ); -- fn TpSetPoolMinThreads( -- Pool: PTP_POOL, -- MinThreads: LONG, -- ) -> NTSTATUS; -- fn TpQueryPoolStackInformation( -- Pool: PTP_POOL, -- PoolStackInformation: PTP_POOL_STACK_INFORMATION, -- ) -> NTSTATUS; -- fn TpSetPoolStackInformation( -- Pool: PTP_POOL, -- PoolStackInformation: PTP_POOL_STACK_INFORMATION, -- ) -> NTSTATUS; -- fn TpAllocCleanupGroup( -- CleanupGroupReturn: *mut PTP_CLEANUP_GROUP, -- ) -> NTSTATUS; -- fn TpReleaseCleanupGroup( -- CleanupGroup: PTP_CLEANUP_GROUP, -- ); -- fn TpReleaseCleanupGroupMembers( -- CleanupGroup: PTP_CLEANUP_GROUP, -- CancelPendingCallbacks: LOGICAL, -- CleanupParameter: PVOID, -- ); -- fn TpCallbackSetEventOnCompletion( -- Instance: PTP_CALLBACK_INSTANCE, -- Event: HANDLE, -- ); -- fn TpCallbackReleaseSemaphoreOnCompletion( -- Instance: PTP_CALLBACK_INSTANCE, -- Semaphore: HANDLE, -- ReleaseCount: LONG, -- ); -- fn TpCallbackReleaseMutexOnCompletion( -- Instance: PTP_CALLBACK_INSTANCE, -- Mutex: HANDLE, -- ); -- fn TpCallbackLeaveCriticalSectionOnCompletion( -- Instance: PTP_CALLBACK_INSTANCE, -- CriticalSection: PRTL_CRITICAL_SECTION, -- ); -- fn TpCallbackUnloadDllOnCompletion( -- Instance: PTP_CALLBACK_INSTANCE, -- DllHandle: PVOID, -- ); -- fn TpCallbackMayRunLong( -- Instance: PTP_CALLBACK_INSTANCE, -- ) -> NTSTATUS; -- fn TpDisassociateCallback( -- Instance: PTP_CALLBACK_INSTANCE, -- ); -- fn TpSimpleTryPost( -- Callback: PTP_SIMPLE_CALLBACK, -- Context: PVOID, -- CallbackEnviron: PTP_CALLBACK_ENVIRON, -- ) -> NTSTATUS; -- fn TpAllocWork( -- WorkReturn: *mut PTP_WORK, -- Callback: PTP_WORK_CALLBACK, -- Context: PVOID, -- CallbackEnviron: PTP_CALLBACK_ENVIRON, -- ) -> NTSTATUS; -- fn TpReleaseWork( -- Work: PTP_WORK, -- ); -- fn TpPostWork( -- Work: PTP_WORK, -- ); -- fn TpWaitForWork( -- Work: PTP_WORK, -- CancelPendingCallbacks: LOGICAL, -- ); -- fn TpAllocTimer( -- Timer: *mut PTP_TIMER, -- Callback: PTP_TIMER_CALLBACK, -- Context: PVOID, -- CallbackEnviron: PTP_CALLBACK_ENVIRON, -- ) -> NTSTATUS; -- fn TpReleaseTimer( -- Timer: PTP_TIMER, -- ); -- fn TpSetTimer( -- Timer: PTP_TIMER, -- DueTime: PLARGE_INTEGER, -- Period: LONG, -- WindowLength: LONG, -- ); -- fn TpIsTimerSet( -- Timer: PTP_TIMER, -- ) -> LOGICAL; -- fn TpWaitForTimer( -- Timer: PTP_TIMER, -- CancelPendingCallbacks: LOGICAL, -- ); -- fn TpAllocWait( -- WaitReturn: *mut PTP_WAIT, -- Callback: PTP_WAIT_CALLBACK, -- Context: PVOID, -- CallbackEnviron: PTP_CALLBACK_ENVIRON, -- ) -> NTSTATUS; -- fn TpReleaseWait( -- Wait: PTP_WAIT, -- ); -- fn TpSetWait( -- Wait: PTP_WAIT, -- Handle: HANDLE, -- Timeout: PLARGE_INTEGER, -- ); -- fn TpWaitForWait( -- Wait: PTP_WAIT, -- CancelPendingCallbacks: LOGICAL, -- ); --}} --FN!{stdcall PTP_IO_CALLBACK( -- Instance: PTP_CALLBACK_INSTANCE, -- Context: PVOID, -- ApcContext: PVOID, -- IoSB: PIO_STATUS_BLOCK, -- Io: PTP_IO, --) -> ()} --EXTERN!{extern "system" { -- fn TpAllocIoCompletion( -- IoReturn: *mut PTP_IO, -- File: HANDLE, -- Callback: PTP_IO_CALLBACK, -- Context: PVOID, -- CallbackEnviron: PTP_CALLBACK_ENVIRON, -- ) -> NTSTATUS; -- fn TpReleaseIoCompletion( -- Io: PTP_IO, -- ); -- fn TpStartAsyncIoOperation( -- Io: PTP_IO, -- ); -- fn TpCancelAsyncIoOperation( -- Io: PTP_IO, -- ); -- fn TpWaitForIoCompletion( -- Io: PTP_IO, -- CancelPendingCallbacks: LOGICAL, -- ); -- fn TpAllocAlpcCompletion( -- AlpcReturn: *mut PTP_ALPC, -- AlpcPort: HANDLE, -- Callback: PTP_ALPC_CALLBACK, -- Context: PVOID, -- CallbackEnviron: PTP_CALLBACK_ENVIRON, -- ) -> NTSTATUS; -- fn TpAllocAlpcCompletionEx( -- AlpcReturn: *mut PTP_ALPC, -- AlpcPort: HANDLE, -- Callback: PTP_ALPC_CALLBACK_EX, -- Context: PVOID, -- CallbackEnviron: PTP_CALLBACK_ENVIRON, -- ) -> NTSTATUS; -- fn TpReleaseAlpcCompletion( -- Alpc: PTP_ALPC, -- ); -- fn TpWaitForAlpcCompletion( -- Alpc: PTP_ALPC, -- ); --}} --ENUM!{enum TP_TRACE_TYPE { -- TpTraceThreadPriority = 1, -- TpTraceThreadAffinity = 2, -- MaxTpTraceType = 3, --}} --EXTERN!{extern "system" { -- fn TpCaptureCaller( -- Type: TP_TRACE_TYPE, -- ); -- fn TpCheckTerminateWorker( -- Thread: HANDLE, -- ); --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntwow64.rs b/KubeOS-Rust/vendor/ntapi/src/ntwow64.rs -deleted file mode 100644 -index 9a95ae2a..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntwow64.rs -+++ /dev/null -@@ -1,476 +0,0 @@ --use core::mem::size_of; --use crate::ntapi_base::CLIENT_ID32; --use crate::ntldr::{LDR_DDAG_STATE, LDR_DLL_LOAD_REASON}; --use crate::ntpsapi::GDI_HANDLE_BUFFER32; --use crate::ntrtl::RTL_MAX_DRIVE_LETTERS; --use crate::string::{UTF16Const, UTF8Const}; --use winapi::shared::guiddef::GUID; --use winapi::shared::ntdef::{ -- BOOLEAN, CHAR, LARGE_INTEGER, LCID, LIST_ENTRY32, LONG, NTSTATUS, PROCESSOR_NUMBER, -- SINGLE_LIST_ENTRY32, STRING32, UCHAR, ULARGE_INTEGER, ULONG, ULONGLONG, UNICODE_STRING, -- UNICODE_STRING32, USHORT, WCHAR, --}; --use winapi::um::winnt::{FLS_MAXIMUM_AVAILABLE, NT_TIB32}; --pub const WOW64_SYSTEM_DIRECTORY: UTF8Const = UTF8Const("SysWOW64\0"); --/// "SysWOW64" --pub const WOW64_SYSTEM_DIRECTORY_U: UTF16Const = UTF16Const(&[ -- 0x0053, 0x0079, 0x0073, 0x0057, 0x004F, 0x0057, 0x0036, 0x0034, 0u16, --]); --pub const WOW64_X86_TAG: UTF8Const = UTF8Const(" (x86)\0"); --/// " (x86)" --pub const WOW64_X86_TAG_U: UTF16Const = UTF16Const(&[ -- 0x0020, 0x0028, 0x0078, 0x0038, 0x0036, 0x0029, 0u16, --]); --ENUM!{enum WOW64_SHARED_INFORMATION { -- SharedNtdll32LdrInitializeThunk = 0, -- SharedNtdll32KiUserExceptionDispatcher = 1, -- SharedNtdll32KiUserApcDispatcher = 2, -- SharedNtdll32KiUserCallbackDispatcher = 3, -- SharedNtdll32ExpInterlockedPopEntrySListFault = 4, -- SharedNtdll32ExpInterlockedPopEntrySListResume = 5, -- SharedNtdll32ExpInterlockedPopEntrySListEnd = 6, -- SharedNtdll32RtlUserThreadStart = 7, -- SharedNtdll32pQueryProcessDebugInformationRemote = 8, -- SharedNtdll32BaseAddress = 9, -- SharedNtdll32LdrSystemDllInitBlock = 10, -- Wow64SharedPageEntriesCount = 11, --}} --STRUCT!{struct RTL_BALANCED_NODE32_u_s { -- Left: ULONG, // WOW64_POINTER -- Right: ULONG, // WOW64_POINTER --}} --UNION!{union RTL_BALANCED_NODE32_u { -- Children: [ULONG; 2], // WOW64_POINTER -- s: RTL_BALANCED_NODE32_u_s, --}} --STRUCT!{struct RTL_BALANCED_NODE32 { -- u: RTL_BALANCED_NODE32_u, -- ParentValue: ULONG, --}} --pub type PRTL_BALANCED_NODE32 = *mut RTL_BALANCED_NODE32; --STRUCT!{struct RTL_RB_TREE32 { -- Root: ULONG, // WOW64_POINTER -- Min: ULONG, // WOW64_POINTER --}} --pub type PRTL_RB_TREE32 = *mut RTL_RB_TREE32; --STRUCT!{struct PEB_LDR_DATA32 { -- Length: ULONG, -- Initialized: BOOLEAN, -- SsHandle: ULONG, -- InLoadOrderModuleList: LIST_ENTRY32, -- InMemoryOrderModuleList: LIST_ENTRY32, -- InInitializationOrderModuleList: LIST_ENTRY32, -- EntryInProgress: ULONG, -- ShutdownInProgress: BOOLEAN, -- ShutdownThreadId: ULONG, --}} --pub type PPEB_LDR_DATA32 = *mut PEB_LDR_DATA32; --STRUCT!{struct LDR_SERVICE_TAG_RECORD32 { -- Next: ULONG, -- ServiceTag: ULONG, --}} --pub type PLDR_SERVICE_TAG_RECORD32 = *mut LDR_SERVICE_TAG_RECORD32; --STRUCT!{struct LDRP_CSLIST32 { -- Tail: ULONG, // WOW64_POINTER --}} --pub type PLDRP_CSLIST32 = *mut LDRP_CSLIST32; --UNION!{union LDR_DDAG_NODE32_u { -- Dependencies: LDRP_CSLIST32, -- RemovalLink: SINGLE_LIST_ENTRY32, --}} --STRUCT!{struct LDR_DDAG_NODE32 { -- Modules: LIST_ENTRY32, -- ServiceTagList: ULONG, // WOW64_POINTER -- LoadCount: ULONG, -- LoadWhileUnloadingCount: ULONG, -- LowestLink: ULONG, -- u: LDR_DDAG_NODE32_u, -- IncomingDependencies: LDRP_CSLIST32, -- State: LDR_DDAG_STATE, -- CondenseLink: SINGLE_LIST_ENTRY32, -- PreorderNumber: ULONG, --}} --pub type PLDR_DDAG_NODE32 = *mut LDR_DDAG_NODE32; --pub const LDR_DATA_TABLE_ENTRY_SIZE_WINXP_32: usize = 80; --pub const LDR_DATA_TABLE_ENTRY_SIZE_WIN7_32: usize = 144; --pub const LDR_DATA_TABLE_ENTRY_SIZE_WIN8_32: usize = 152; --UNION!{union LDR_DATA_TABLE_ENTRY32_u1 { -- InInitializationOrderLinks: LIST_ENTRY32, -- InProgressLinks: LIST_ENTRY32, --}} --UNION!{union LDR_DATA_TABLE_ENTRY32_u2 { -- FlagGroup: [UCHAR; 4], -- Flags: ULONG, --}} --STRUCT!{struct LDR_DATA_TABLE_ENTRY32 { -- InLoadOrderLinks: LIST_ENTRY32, -- InMemoryOrderLinks: LIST_ENTRY32, -- u1: LDR_DATA_TABLE_ENTRY32_u1, -- DllBase: ULONG, // WOW64_POINTER -- EntryPoint: ULONG, // WOW64_POINTER -- SizeOfImage: ULONG, -- FullDllName: UNICODE_STRING32, -- BaseDllName: UNICODE_STRING32, -- u2: LDR_DATA_TABLE_ENTRY32_u2, -- ObsoleteLoadCount: USHORT, -- TlsIndex: USHORT, -- HashLinks: LIST_ENTRY32, -- TimeDateStamp: ULONG, -- EntryPointActivationContext: ULONG, // WOW64_POINTER -- Lock: ULONG, // WOW64_POINTER -- DdagNode: ULONG, // WOW64_POINTER -- NodeModuleLink: LIST_ENTRY32, -- LoadContext: ULONG, // WOW64_POINTER -- ParentDllBase: ULONG, // WOW64_POINTER -- SwitchBackContext: ULONG, // WOW64_POINTER -- BaseAddressIndexNode: RTL_BALANCED_NODE32, -- MappingInfoIndexNode: RTL_BALANCED_NODE32, -- OriginalBase: ULONG, -- LoadTime: LARGE_INTEGER, -- BaseNameHashValue: ULONG, -- LoadReason: LDR_DLL_LOAD_REASON, -- ImplicitPathOptions: ULONG, -- ReferenceCount: ULONG, -- DependentLoadFlags: ULONG, -- SigningLevel: UCHAR, --}} --BITFIELD!{unsafe LDR_DATA_TABLE_ENTRY32_u2 Flags: ULONG [ -- PackagedBinary set_PackagedBinary[0..1], -- MarkedForRemoval set_MarkedForRemoval[1..2], -- ImageDll set_ImageDll[2..3], -- LoadNotificationsSent set_LoadNotificationsSent[3..4], -- TelemetryEntryProcessed set_TelemetryEntryProcessed[4..5], -- ProcessStaticImport set_ProcessStaticImport[5..6], -- InLegacyLists set_InLegacyLists[6..7], -- InIndexes set_InIndexes[7..8], -- ShimDll set_ShimDll[8..9], -- InExceptionTable set_InExceptionTable[9..10], -- ReservedFlags1 set_ReservedFlags1[10..12], -- LoadInProgress set_LoadInProgress[12..13], -- LoadConfigProcessed set_LoadConfigProcessed[13..14], -- EntryProcessed set_EntryProcessed[14..15], -- ProtectDelayLoad set_ProtectDelayLoad[15..16], -- ReservedFlags3 set_ReservedFlags3[16..18], -- DontCallForThreads set_DontCallForThreads[18..19], -- ProcessAttachCalled set_ProcessAttachCalled[19..20], -- ProcessAttachFailed set_ProcessAttachFailed[20..21], -- CorDeferredValidate set_CorDeferredValidate[21..22], -- CorImage set_CorImage[22..23], -- DontRelocate set_DontRelocate[23..24], -- CorILOnly set_CorILOnly[24..25], -- ReservedFlags5 set_ReservedFlags5[25..28], -- Redirected set_Redirected[28..29], -- ReservedFlags6 set_ReservedFlags6[29..31], -- CompatDatabaseProcessed set_CompatDatabaseProcessed[31..32], --]} --pub type PLDR_DATA_TABLE_ENTRY32 = *mut LDR_DATA_TABLE_ENTRY32; --STRUCT!{struct CURDIR32 { -- DosPath: UNICODE_STRING32, -- Handle: ULONG, // WOW64_POINTER --}} --pub type PCURDIR32 = *mut CURDIR32; --STRUCT!{struct RTL_DRIVE_LETTER_CURDIR32 { -- Flags: USHORT, -- Length: USHORT, -- TimeStamp: ULONG, -- DosPath: STRING32, --}} --pub type PRTL_DRIVE_LETTER_CURDIR32 = *mut RTL_DRIVE_LETTER_CURDIR32; --STRUCT!{struct RTL_USER_PROCESS_PARAMETERS32 { -- MaximumLength: ULONG, -- Length: ULONG, -- Flags: ULONG, -- DebugFlags: ULONG, -- ConsoleHandle: ULONG, // WOW64_POINTER -- ConsoleFlags: ULONG, -- StandardInput: ULONG, // WOW64_POINTER -- StandardOutput: ULONG, // WOW64_POINTER -- StandardError: ULONG, // WOW64_POINTER -- CurrentDirectory: CURDIR32, -- DllPath: UNICODE_STRING32, -- ImagePathName: UNICODE_STRING32, -- CommandLine: UNICODE_STRING32, -- Environment: ULONG, // WOW64_POINTER -- StartingX: ULONG, -- StartingY: ULONG, -- CountX: ULONG, -- CountY: ULONG, -- CountCharsX: ULONG, -- CountCharsY: ULONG, -- FillAttribute: ULONG, -- WindowFlags: ULONG, -- ShowWindowFlags: ULONG, -- WindowTitle: UNICODE_STRING32, -- DesktopInfo: UNICODE_STRING32, -- ShellInfo: UNICODE_STRING32, -- RuntimeData: UNICODE_STRING32, -- CurrentDirectories: [RTL_DRIVE_LETTER_CURDIR32; RTL_MAX_DRIVE_LETTERS], -- EnvironmentSize: ULONG, -- EnvironmentVersion: ULONG, -- PackageDependencyData: ULONG, // WOW64_POINTER -- ProcessGroupId: ULONG, -- LoaderThreads: ULONG, --}} --pub type PRTL_USER_PROCESS_PARAMETERS32 = *mut RTL_USER_PROCESS_PARAMETERS32; --UNION!{union PEB32_u { -- KernelCallbackTable: ULONG, // WOW64_POINTER -- UserSharedInfoPtr: ULONG, // WOW64_POINTER --}} --STRUCT!{struct PEB32 { -- InheritedAddressSpace: BOOLEAN, -- ReadImageFileExecOptions: BOOLEAN, -- BeingDebugged: BOOLEAN, -- BitField: BOOLEAN, -- Mutant: ULONG, // WOW64_POINTER -- ImageBaseAddress: ULONG, // WOW64_POINTER -- Ldr: ULONG, // WOW64_POINTER -- ProcessParameters: ULONG, // WOW64_POINTER -- SubSystemData: ULONG, // WOW64_POINTER -- ProcessHeap: ULONG, // WOW64_POINTER -- FastPebLock: ULONG, // WOW64_POINTER -- AtlThunkSListPtr: ULONG, // WOW64_POINTER -- IFEOKey: ULONG, // WOW64_POINTER -- CrossProcessFlags: ULONG, -- u: PEB32_u, -- SystemReserved: [ULONG; 1], -- AtlThunkSListPtr32: ULONG, -- ApiSetMap: ULONG, // WOW64_POINTER -- TlsExpansionCounter: ULONG, -- TlsBitmap: ULONG, // WOW64_POINTER -- TlsBitmapBits: [ULONG; 2], -- ReadOnlySharedMemoryBase: ULONG, // WOW64_POINTER -- HotpatchInformation: ULONG, // WOW64_POINTER -- ReadOnlyStaticServerData: ULONG, // WOW64_POINTER -- AnsiCodePageData: ULONG, // WOW64_POINTER -- OemCodePageData: ULONG, // WOW64_POINTER -- UnicodeCaseTableData: ULONG, // WOW64_POINTER -- NumberOfProcessors: ULONG, -- NtGlobalFlag: ULONG, -- CriticalSectionTimeout: LARGE_INTEGER, -- HeapSegmentReserve: ULONG, -- HeapSegmentCommit: ULONG, -- HeapDeCommitTotalFreeThreshold: ULONG, -- HeapDeCommitFreeBlockThreshold: ULONG, -- NumberOfHeaps: ULONG, -- MaximumNumberOfHeaps: ULONG, -- ProcessHeaps: ULONG, // WOW64_POINTER -- GdiSharedHandleTable: ULONG, // WOW64_POINTER -- ProcessStarterHelper: ULONG, // WOW64_POINTER -- GdiDCAttributeList: ULONG, -- LoaderLock: ULONG, // WOW64_POINTER -- OSMajorVersion: ULONG, -- OSMinorVersion: ULONG, -- OSBuildNumber: USHORT, -- OSCSDVersion: USHORT, -- OSPlatformId: ULONG, -- ImageSubsystem: ULONG, -- ImageSubsystemMajorVersion: ULONG, -- ImageSubsystemMinorVersion: ULONG, -- ActiveProcessAffinityMask: ULONG, -- GdiHandleBuffer: GDI_HANDLE_BUFFER32, -- PostProcessInitRoutine: ULONG, // WOW64_POINTER -- TlsExpansionBitmap: ULONG, // WOW64_POINTER -- TlsExpansionBitmapBits: [ULONG; 32], -- SessionId: ULONG, -- AppCompatFlags: ULARGE_INTEGER, -- AppCompatFlagsUser: ULARGE_INTEGER, -- pShimData: ULONG, // WOW64_POINTER -- AppCompatInfo: ULONG, // WOW64_POINTER -- CSDVersion: UNICODE_STRING32, -- ActivationContextData: ULONG, // WOW64_POINTER -- ProcessAssemblyStorageMap: ULONG, // WOW64_POINTER -- SystemDefaultActivationContextData: ULONG, // WOW64_POINTER -- SystemAssemblyStorageMap: ULONG, // WOW64_POINTER -- MinimumStackCommit: ULONG, -- FlsCallback: ULONG, // WOW64_POINTER -- FlsListHead: LIST_ENTRY32, -- FlsBitmap: ULONG, // WOW64_POINTER -- FlsBitmapBits: [ULONG; FLS_MAXIMUM_AVAILABLE as usize / (size_of::() * 8)], -- FlsHighIndex: ULONG, -- WerRegistrationData: ULONG, // WOW64_POINTER -- WerShipAssertPtr: ULONG, // WOW64_POINTER -- pContextData: ULONG, // WOW64_POINTER -- pImageHeaderHash: ULONG, // WOW64_POINTER -- TracingFlags: ULONG, -- CsrServerReadOnlySharedMemoryBase: ULONGLONG, -- TppWorkerpListLock: ULONG, // WOW64_POINTER -- TppWorkerpList: LIST_ENTRY32, -- WaitOnAddressHashTable: [ULONG; 128], // WOW64_POINTER -- TelemetryCoverageHeader: ULONG, // WOW64_POINTER -- CloudFileFlags: ULONG, -- CloudFileDiagFlags: ULONG, -- PlaceholderCompatibilityMode: CHAR, -- PlaceholderCompatibilityModeReserved: [CHAR; 7], --}} --BITFIELD!{PEB32 BitField: BOOLEAN [ -- ImageUsesLargePages set_ImageUsesLargePages[0..1], -- IsProtectedProcess set_IsProtectedProcess[1..2], -- IsImageDynamicallyRelocated set_IsImageDynamicallyRelocated[2..3], -- SkipPatchingUser32Forwarders set_SkipPatchingUser32Forwarders[3..4], -- IsPackagedProcess set_IsPackagedProcess[4..5], -- IsAppContainer set_IsAppContainer[5..6], -- IsProtectedProcessLight set_IsProtectedProcessLight[6..7], -- IsLongPathAwareProcess set_IsLongPathAwareProcess[7..8], --]} --BITFIELD!{PEB32 CrossProcessFlags: ULONG [ -- ProcessInJob set_ProcessInJob[0..1], -- ProcessInitializing set_ProcessInitializing[1..2], -- ProcessUsingVEH set_ProcessUsingVEH[2..3], -- ProcessUsingVCH set_ProcessUsingVCH[3..4], -- ProcessUsingFTH set_ProcessUsingFTH[4..5], -- ReservedBits0 set_ReservedBits0[5..32], --]} --BITFIELD!{PEB32 TracingFlags: ULONG [ -- HeapTracingEnabled set_HeapTracingEnabled[0..1], -- CritSecTracingEnabled set_CritSecTracingEnabled[1..2], -- LibLoaderTracingEnabled set_LibLoaderTracingEnabled[2..3], -- SpareTracingBits set_SpareTracingBits[3..32], --]} --pub type PPEB32 = *mut PEB32; --pub const GDI_BATCH_BUFFER_SIZE: usize = 310; --STRUCT!{struct GDI_TEB_BATCH32 { -- Offset: ULONG, -- HDC: ULONG, -- Buffer: [ULONG; GDI_BATCH_BUFFER_SIZE], --}} --pub type PGDI_TEB_BATCH32 = *mut GDI_TEB_BATCH32; --STRUCT!{struct TEB32_u_s { -- ReservedPad0: UCHAR, -- ReservedPad1: UCHAR, -- ReservedPad2: UCHAR, -- IdealProcessor: UCHAR, --}} --UNION!{union TEB32_u { -- CurrentIdealProcessor: PROCESSOR_NUMBER, -- IdealProcessorValue: ULONG, -- s: TEB32_u_s, --}} --STRUCT!{struct TEB32 { -- NtTib: NT_TIB32, -- EnvironmentPointer: ULONG, // WOW64_POINTER -- ClientId: CLIENT_ID32, -- ActiveRpcHandle: ULONG, // WOW64_POINTER -- ThreadLocalStoragePointer: ULONG, // WOW64_POINTER -- ProcessEnvironmentBlock: ULONG, // WOW64_POINTER -- LastErrorValue: ULONG, -- CountOfOwnedCriticalSections: ULONG, -- CsrClientThread: ULONG, // WOW64_POINTER -- Win32ThreadInfo: ULONG, // WOW64_POINTER -- User32Reserved: [ULONG; 26], -- UserReserved: [ULONG; 5], -- WOW32Reserved: ULONG, // WOW64_POINTER -- CurrentLocale: LCID, -- FpSoftwareStatusRegister: ULONG, -- ReservedForDebuggerInstrumentation: [ULONG; 16], // WOW64_POINTER -- SystemReserved1: [ULONG; 36], // WOW64_POINTER -- WorkingOnBehalfTicket: [UCHAR; 8], -- ExceptionCode: NTSTATUS, -- ActivationContextStackPointer: ULONG, // WOW64_POINTER -- InstrumentationCallbackSp: ULONG, -- InstrumentationCallbackPreviousPc: ULONG, -- InstrumentationCallbackPreviousSp: ULONG, -- InstrumentationCallbackDisabled: BOOLEAN, -- SpareBytes: [UCHAR; 23], -- TxFsContext: ULONG, -- GdiTebBatch: GDI_TEB_BATCH32, -- RealClientId: CLIENT_ID32, -- GdiCachedProcessHandle: ULONG, // WOW64_POINTER -- GdiClientPID: ULONG, -- GdiClientTID: ULONG, -- GdiThreadLocalInfo: ULONG, // WOW64_POINTER -- Win32ClientInfo: [ULONG; 62], -- glDispatchTable: [ULONG; 233], // WOW64_POINTER -- glReserved1: [ULONG; 29], // WOW64_POINTER -- glReserved2: ULONG, // WOW64_POINTER -- glSectionInfo: ULONG, // WOW64_POINTER -- glSection: ULONG, // WOW64_POINTER -- glTable: ULONG, // WOW64_POINTER -- glCurrentRC: ULONG, // WOW64_POINTER -- glContext: ULONG, // WOW64_POINTER -- LastStatusValue: NTSTATUS, -- StaticUnicodeString: UNICODE_STRING32, -- StaticUnicodeBuffer: [WCHAR; 261], -- DeallocationStack: ULONG, // WOW64_POINTER -- TlsSlots: [ULONG; 64], // WOW64_POINTER -- TlsLinks: LIST_ENTRY32, -- Vdm: ULONG, // WOW64_POINTER -- ReservedForNtRpc: ULONG, // WOW64_POINTER -- DbgSsReserved: [ULONG; 2], // WOW64_POINTER -- HardErrorMode: ULONG, -- Instrumentation: [ULONG; 9], // WOW64_POINTER -- ActivityId: GUID, -- SubProcessTag: ULONG, // WOW64_POINTER -- PerflibData: ULONG, // WOW64_POINTER -- EtwTraceData: ULONG, // WOW64_POINTER -- WinSockData: ULONG, // WOW64_POINTER -- GdiBatchCount: ULONG, -- u: TEB32_u, -- GuaranteedStackBytes: ULONG, -- ReservedForPerf: ULONG, // WOW64_POINTER -- ReservedForOle: ULONG, // WOW64_POINTER -- WaitingOnLoaderLock: ULONG, -- SavedPriorityState: ULONG, // WOW64_POINTER -- ReservedForCodeCoverage: ULONG, -- ThreadPoolData: ULONG, // WOW64_POINTER -- TlsExpansionSlots: ULONG, // WOW64_POINTER -- MuiGeneration: ULONG, -- IsImpersonating: ULONG, -- NlsCache: ULONG, // WOW64_POINTER -- pShimData: ULONG, // WOW64_POINTER -- HeapVirtualAffinity: USHORT, -- LowFragHeapDataSlot: USHORT, -- CurrentTransactionHandle: ULONG, // WOW64_POINTER -- ActiveFrame: ULONG, // WOW64_POINTER -- FlsData: ULONG, // WOW64_POINTER -- PreferredLanguages: ULONG, // WOW64_POINTER -- UserPrefLanguages: ULONG, // WOW64_POINTER -- MergedPrefLanguages: ULONG, // WOW64_POINTER -- MuiImpersonation: ULONG, -- CrossTebFlags: USHORT, -- SameTebFlags: USHORT, -- TxnScopeEnterCallback: ULONG, // WOW64_POINTER -- TxnScopeExitCallback: ULONG, // WOW64_POINTER -- TxnScopeContext: ULONG, // WOW64_POINTER -- LockCount: ULONG, -- WowTebOffset: LONG, -- ResourceRetValue: ULONG, // WOW64_POINTER -- ReservedForWdf: ULONG, // WOW64_POINTER -- ReservedForCrt: ULONGLONG, -- EffectiveContainerId: GUID, --}} --BITFIELD!{TEB32 SameTebFlags: USHORT [ -- SafeThunkCall set_SafeThunkCall[0..1], -- InDebugPrint set_InDebugPrint[1..2], -- HasFiberData set_HasFiberData[2..3], -- SkipThreadAttach set_SkipThreadAttach[3..4], -- WerInShipAssertCode set_WerInShipAssertCode[4..5], -- RanProcessInit set_RanProcessInit[5..6], -- ClonedThread set_ClonedThread[6..7], -- SuppressDebugMsg set_SuppressDebugMsg[7..8], -- DisableUserStackWalk set_DisableUserStackWalk[8..9], -- RtlExceptionAttached set_RtlExceptionAttached[9..10], -- InitialThread set_InitialThread[10..11], -- SessionAware set_SessionAware[11..12], -- LoadOwner set_LoadOwner[12..13], -- LoaderWorker set_LoaderWorker[13..14], -- SpareSameTebBits set_SpareSameTebBits[14..16], --]} --pub type PTEB32 = *mut TEB32; --#[inline] --pub fn UStr32ToUStr( -- Destination: &mut UNICODE_STRING, -- Source: &UNICODE_STRING32, --) { -- Destination.Length = Source.Length; -- Destination.MaximumLength = Source.MaximumLength; -- Destination.Buffer = Source.Buffer as *mut u16; --} --#[inline] --pub fn UStrToUStr32( -- Destination: &mut UNICODE_STRING32, -- Source: &UNICODE_STRING, --) { -- Destination.Length = Source.Length; -- Destination.MaximumLength = Source.MaximumLength; -- Destination.Buffer = Source.Buffer as u32; --} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntxcapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntxcapi.rs -deleted file mode 100644 -index 56644dd5..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntxcapi.rs -+++ /dev/null -@@ -1,29 +0,0 @@ --use winapi::shared::ntdef::{BOOLEAN, NTSTATUS, PSTR, PVOID, ULONG}; --use winapi::um::winnt::{PCONTEXT, PEXCEPTION_RECORD}; --EXTERN!{extern "system" { -- fn RtlDispatchException( -- ExceptionRecord: PEXCEPTION_RECORD, -- ContextRecord: PCONTEXT, -- ) -> BOOLEAN; -- fn RtlRaiseStatus( -- Status: NTSTATUS, -- ); -- fn RtlRaiseException( -- ExceptionRecord: PEXCEPTION_RECORD, -- ); -- fn NtContinue( -- ContextRecord: PCONTEXT, -- TestAlert: BOOLEAN, -- ) -> NTSTATUS; -- fn NtRaiseException( -- ExceptionRecord: PEXCEPTION_RECORD, -- ContextRecord: PCONTEXT, -- FirstChance: BOOLEAN, -- ) -> NTSTATUS; -- fn RtlAssert( -- VoidFailedAssertion: PVOID, -- VoidFileName: PVOID, -- LineNumber: ULONG, -- MutableMessage: PSTR, -- ); --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/ntzwapi.rs b/KubeOS-Rust/vendor/ntapi/src/ntzwapi.rs -deleted file mode 100644 -index 9638bf83..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/ntzwapi.rs -+++ /dev/null -@@ -1,2699 +0,0 @@ --use crate::ntapi_base::{PCLIENT_ID, PRTL_ATOM, RTL_ATOM}; --use crate::ntdbg::DEBUGOBJECTINFOCLASS; --use crate::ntexapi::{ -- ATOM_INFORMATION_CLASS, EVENT_INFORMATION_CLASS, MUTANT_INFORMATION_CLASS, PBOOT_ENTRY, -- PBOOT_OPTIONS, PCWNF_TYPE_ID, PEFI_DRIVER_ENTRY, PFILE_PATH, PT2_CANCEL_PARAMETERS, -- PT2_SET_PARAMETERS, PTIMER_APC_ROUTINE, PWNF_CHANGE_STAMP, PWNF_DELIVERY_DESCRIPTOR, -- SEMAPHORE_INFORMATION_CLASS, SHUTDOWN_ACTION, SYSDBG_COMMAND, SYSTEM_INFORMATION_CLASS, -- TIMER_INFORMATION_CLASS, TIMER_SET_INFORMATION_CLASS, WNF_CHANGE_STAMP, WNF_DATA_SCOPE, -- WNF_STATE_NAME_INFORMATION, WNF_STATE_NAME_LIFETIME, WORKERFACTORYINFOCLASS, --}; --use crate::ntioapi::{ -- FILE_INFORMATION_CLASS, FILE_IO_COMPLETION_INFORMATION, FS_INFORMATION_CLASS, -- IO_COMPLETION_INFORMATION_CLASS, IO_SESSION_EVENT, IO_SESSION_STATE, PFILE_BASIC_INFORMATION, -- PFILE_IO_COMPLETION_INFORMATION, PFILE_NETWORK_OPEN_INFORMATION, PIO_APC_ROUTINE, -- PIO_STATUS_BLOCK, --}; --use crate::ntkeapi::KPROFILE_SOURCE; --use crate::ntlpcapi::{ -- ALPC_HANDLE, ALPC_MESSAGE_INFORMATION_CLASS, ALPC_PORT_INFORMATION_CLASS, PALPC_CONTEXT_ATTR, -- PALPC_DATA_VIEW_ATTR, PALPC_HANDLE, PALPC_MESSAGE_ATTRIBUTES, PALPC_PORT_ATTRIBUTES, -- PALPC_SECURITY_ATTR, PORT_INFORMATION_CLASS, PPORT_MESSAGE, PPORT_VIEW, PREMOTE_PORT_VIEW, --}; --use crate::ntmisc::VDMSERVICECLASS; --use crate::ntmmapi::{ -- MEMORY_INFORMATION_CLASS, MEMORY_PARTITION_INFORMATION_CLASS, PMEMORY_RANGE_ENTRY, -- SECTION_INFORMATION_CLASS, SECTION_INHERIT, VIRTUAL_MEMORY_INFORMATION_CLASS, --}; --use crate::ntobapi::OBJECT_INFORMATION_CLASS; --use crate::ntpnpapi::{PLUGPLAY_CONTROL_CLASS, PPLUGPLAY_EVENT_BLOCK}; --use crate::ntpsapi::{ -- MEMORY_RESERVE_TYPE, PINITIAL_TEB, PPS_APC_ROUTINE, PPS_ATTRIBUTE_LIST, PPS_CREATE_INFO, -- PROCESSINFOCLASS, THREADINFOCLASS, --}; --use crate::ntregapi::{ -- KEY_INFORMATION_CLASS, KEY_SET_INFORMATION_CLASS, KEY_VALUE_INFORMATION_CLASS, -- PKEY_VALUE_ENTRY, --}; --use crate::ntseapi::PTOKEN_SECURITY_ATTRIBUTES_INFORMATION; --use winapi::shared::basetsd::{ -- KAFFINITY, PSIZE_T, PULONG64, PULONG_PTR, SIZE_T, ULONG64, ULONG_PTR, --}; --use winapi::shared::guiddef::LPGUID; --use winapi::shared::ktmtypes::{NOTIFICATION_MASK, PCRM_PROTOCOL_ID, PTRANSACTION_NOTIFICATION}; --use winapi::shared::ntdef::{ -- BOOLEAN, EVENT_TYPE, HANDLE, LANGID, LCID, LOGICAL, LONG, NTSTATUS, OBJECT_ATTRIBUTES, -- PBOOLEAN, PCHAR, PCWNF_STATE_NAME, PGROUP_AFFINITY, PHANDLE, PLARGE_INTEGER, PLCID, PLONG, -- PLUID, PNTSTATUS, POBJECT_ATTRIBUTES, PUCHAR, PULARGE_INTEGER, PULONG, PULONGLONG, -- PUNICODE_STRING, PUSHORT, PVOID, PWNF_STATE_NAME, PWSTR, TIMER_TYPE, ULONG, USHORT, VOID, -- WAIT_TYPE, --}; --use winapi::um::winnt::{ -- ACCESS_MASK, AUDIT_EVENT_TYPE, ENLISTMENT_INFORMATION_CLASS, EXECUTION_STATE, -- JOBOBJECTINFOCLASS, KTMOBJECT_TYPE, LATENCY_TIME, PACCESS_MASK, PCONTEXT, PDEVICE_POWER_STATE, -- PEXCEPTION_RECORD, PFILE_SEGMENT_ELEMENT, PGENERIC_MAPPING, PJOB_SET_ARRAY, PKTMOBJECT_CURSOR, -- POBJECT_TYPE_LIST, POWER_ACTION, POWER_INFORMATION_LEVEL, PPRIVILEGE_SET, PSECURITY_DESCRIPTOR, -- PSECURITY_QUALITY_OF_SERVICE, PSE_SIGNING_LEVEL, PSID, PSID_AND_ATTRIBUTES, -- PTOKEN_DEFAULT_DACL, PTOKEN_GROUPS, PTOKEN_MANDATORY_POLICY, PTOKEN_OWNER, -- PTOKEN_PRIMARY_GROUP, PTOKEN_PRIVILEGES, PTOKEN_SOURCE, PTOKEN_USER, -- RESOURCEMANAGER_INFORMATION_CLASS, SECURITY_INFORMATION, SE_SIGNING_LEVEL, SYSTEM_POWER_STATE, -- TOKEN_INFORMATION_CLASS, TOKEN_TYPE, TRANSACTIONMANAGER_INFORMATION_CLASS, -- TRANSACTION_INFORMATION_CLASS, --}; --EXTERN!{extern "system" { -- fn ZwAcceptConnectPort( -- PortHandle: PHANDLE, -- PortContext: PVOID, -- ConnectionRequest: PPORT_MESSAGE, -- AcceptConnection: BOOLEAN, -- ServerView: PPORT_VIEW, -- ClientView: PREMOTE_PORT_VIEW, -- ) -> NTSTATUS; -- fn ZwAccessCheck( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- GenericMapping: PGENERIC_MAPPING, -- PrivilegeSet: PPRIVILEGE_SET, -- PrivilegeSetLength: PULONG, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- ) -> NTSTATUS; -- fn ZwAccessCheckAndAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- DesiredAccess: ACCESS_MASK, -- GenericMapping: PGENERIC_MAPPING, -- ObjectCreation: BOOLEAN, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwAccessCheckByType( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- PrivilegeSet: PPRIVILEGE_SET, -- PrivilegeSetLength: PULONG, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- ) -> NTSTATUS; -- fn ZwAccessCheckByTypeAndAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- DesiredAccess: ACCESS_MASK, -- AuditType: AUDIT_EVENT_TYPE, -- Flags: ULONG, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- ObjectCreation: BOOLEAN, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwAccessCheckByTypeResultList( -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- PrivilegeSet: PPRIVILEGE_SET, -- PrivilegeSetLength: PULONG, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- ) -> NTSTATUS; -- fn ZwAccessCheckByTypeResultListAndAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- DesiredAccess: ACCESS_MASK, -- AuditType: AUDIT_EVENT_TYPE, -- Flags: ULONG, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- ObjectCreation: BOOLEAN, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwAccessCheckByTypeResultListAndAuditAlarmByHandle( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ClientToken: HANDLE, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- PrincipalSelfSid: PSID, -- DesiredAccess: ACCESS_MASK, -- AuditType: AUDIT_EVENT_TYPE, -- Flags: ULONG, -- ObjectTypeList: POBJECT_TYPE_LIST, -- ObjectTypeListLength: ULONG, -- GenericMapping: PGENERIC_MAPPING, -- ObjectCreation: BOOLEAN, -- GrantedAccess: PACCESS_MASK, -- AccessStatus: PNTSTATUS, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwAcquireCMFViewOwnership( -- TimeStamp: PULONGLONG, -- tokenTaken: PBOOLEAN, -- replaceExisting: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwAddAtom( -- AtomName: PWSTR, -- Length: ULONG, -- Atom: PRTL_ATOM, -- ) -> NTSTATUS; -- fn ZwAddAtomEx( -- AtomName: PWSTR, -- Length: ULONG, -- Atom: PRTL_ATOM, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwAddBootEntry( -- BootEntry: PBOOT_ENTRY, -- Id: PULONG, -- ) -> NTSTATUS; -- fn ZwAddDriverEntry( -- DriverEntry: PEFI_DRIVER_ENTRY, -- Id: PULONG, -- ) -> NTSTATUS; -- fn ZwAdjustGroupsToken( -- TokenHandle: HANDLE, -- ResetToDefault: BOOLEAN, -- NewState: PTOKEN_GROUPS, -- BufferLength: ULONG, -- PreviousState: PTOKEN_GROUPS, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwAdjustPrivilegesToken( -- TokenHandle: HANDLE, -- DisableAllPrivileges: BOOLEAN, -- NewState: PTOKEN_PRIVILEGES, -- BufferLength: ULONG, -- PreviousState: PTOKEN_PRIVILEGES, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwAdjustTokenClaimsAndDeviceGroups( -- TokenHandle: HANDLE, -- UserResetToDefault: BOOLEAN, -- DeviceResetToDefault: BOOLEAN, -- DeviceGroupsResetToDefault: BOOLEAN, -- NewUserState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- NewDeviceState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- NewDeviceGroupsState: PTOKEN_GROUPS, -- UserBufferLength: ULONG, -- PreviousUserState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- DeviceBufferLength: ULONG, -- PreviousDeviceState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- DeviceGroupsBufferLength: ULONG, -- PreviousDeviceGroups: PTOKEN_GROUPS, -- UserReturnLength: PULONG, -- DeviceReturnLength: PULONG, -- DeviceGroupsReturnBufferLength: PULONG, -- ) -> NTSTATUS; -- fn ZwAlertResumeThread( -- ThreadHandle: HANDLE, -- PreviousSuspendCount: PULONG, -- ) -> NTSTATUS; -- fn ZwAlertThread( -- ThreadHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwAlertThreadByThreadId( -- ThreadId: HANDLE, -- ) -> NTSTATUS; -- fn ZwAllocateLocallyUniqueId( -- Luid: PLUID, -- ) -> NTSTATUS; -- fn ZwAllocateReserveObject( -- MemoryReserveHandle: PHANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Type: MEMORY_RESERVE_TYPE, -- ) -> NTSTATUS; -- fn ZwAllocateUserPhysicalPages( -- ProcessHandle: HANDLE, -- NumberOfPages: PULONG_PTR, -- UserPfnArray: PULONG_PTR, -- ) -> NTSTATUS; -- fn ZwAllocateUuids( -- Time: PULARGE_INTEGER, -- Range: PULONG, -- Sequence: PULONG, -- Seed: PCHAR, -- ) -> NTSTATUS; -- fn ZwAllocateVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- ZeroBits: ULONG_PTR, -- RegionSize: PSIZE_T, -- AllocationType: ULONG, -- Protect: ULONG, -- ) -> NTSTATUS; -- fn ZwAlpcAcceptConnectPort( -- PortHandle: PHANDLE, -- ConnectionPortHandle: HANDLE, -- Flags: ULONG, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PortAttributes: PALPC_PORT_ATTRIBUTES, -- PortContext: PVOID, -- ConnectionRequest: PPORT_MESSAGE, -- ConnectionMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- AcceptConnection: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwAlpcCancelMessage( -- PortHandle: HANDLE, -- Flags: ULONG, -- MessageContext: PALPC_CONTEXT_ATTR, -- ) -> NTSTATUS; -- fn ZwAlpcConnectPort( -- PortHandle: PHANDLE, -- PortName: PUNICODE_STRING, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PortAttributes: PALPC_PORT_ATTRIBUTES, -- Flags: ULONG, -- RequiredServerSid: PSID, -- ConnectionMessage: PPORT_MESSAGE, -- BufferLength: PULONG, -- OutMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- InMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwAlpcConnectPortEx( -- PortHandle: PHANDLE, -- ConnectionPortObjectAttributes: POBJECT_ATTRIBUTES, -- ClientPortObjectAttributes: POBJECT_ATTRIBUTES, -- PortAttributes: PALPC_PORT_ATTRIBUTES, -- Flags: ULONG, -- ServerSecurityRequirements: PSECURITY_DESCRIPTOR, -- ConnectionMessage: PPORT_MESSAGE, -- BufferLength: PSIZE_T, -- OutMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- InMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwAlpcCreatePort( -- PortHandle: PHANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PortAttributes: PALPC_PORT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwAlpcCreatePortSection( -- PortHandle: HANDLE, -- Flags: ULONG, -- SectionHandle: HANDLE, -- SectionSize: SIZE_T, -- AlpcSectionHandle: PALPC_HANDLE, -- ActualSectionSize: PSIZE_T, -- ) -> NTSTATUS; -- fn ZwAlpcCreateResourceReserve( -- PortHandle: HANDLE, -- Flags: ULONG, -- MessageSize: SIZE_T, -- ResourceId: PALPC_HANDLE, -- ) -> NTSTATUS; -- fn ZwAlpcCreateSectionView( -- PortHandle: HANDLE, -- Flags: ULONG, -- ViewAttributes: PALPC_DATA_VIEW_ATTR, -- ) -> NTSTATUS; -- fn ZwAlpcCreateSecurityContext( -- PortHandle: HANDLE, -- Flags: ULONG, -- SecurityAttribute: PALPC_SECURITY_ATTR, -- ) -> NTSTATUS; -- fn ZwAlpcDeletePortSection( -- PortHandle: HANDLE, -- Flags: ULONG, -- SectionHandle: ALPC_HANDLE, -- ) -> NTSTATUS; -- fn ZwAlpcDeleteResourceReserve( -- PortHandle: HANDLE, -- Flags: ULONG, -- ResourceId: ALPC_HANDLE, -- ) -> NTSTATUS; -- fn ZwAlpcDeleteSectionView( -- PortHandle: HANDLE, -- Flags: ULONG, -- ViewBase: PVOID, -- ) -> NTSTATUS; -- fn ZwAlpcDeleteSecurityContext( -- PortHandle: HANDLE, -- Flags: ULONG, -- ContextHandle: ALPC_HANDLE, -- ) -> NTSTATUS; -- fn ZwAlpcDisconnectPort( -- PortHandle: HANDLE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwAlpcImpersonateClientContainerOfPort( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwAlpcImpersonateClientOfPort( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- Flags: PVOID, -- ) -> NTSTATUS; -- fn ZwAlpcOpenSenderProcess( -- ProcessHandle: PHANDLE, -- PortHandle: HANDLE, -- PortMessage: PPORT_MESSAGE, -- Flags: ULONG, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwAlpcOpenSenderThread( -- ThreadHandle: PHANDLE, -- PortHandle: HANDLE, -- PortMessage: PPORT_MESSAGE, -- Flags: ULONG, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwAlpcQueryInformation( -- PortHandle: HANDLE, -- PortInformationClass: ALPC_PORT_INFORMATION_CLASS, -- PortInformation: PVOID, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwAlpcQueryInformationMessage( -- PortHandle: HANDLE, -- PortMessage: PPORT_MESSAGE, -- MessageInformationClass: ALPC_MESSAGE_INFORMATION_CLASS, -- MessageInformation: PVOID, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwAlpcRevokeSecurityContext( -- PortHandle: HANDLE, -- Flags: ULONG, -- ContextHandle: ALPC_HANDLE, -- ) -> NTSTATUS; -- fn ZwAlpcSendWaitReceivePort( -- PortHandle: HANDLE, -- Flags: ULONG, -- SendMessageA: PPORT_MESSAGE, -- SendMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- ReceiveMessage: PPORT_MESSAGE, -- BufferLength: PSIZE_T, -- ReceiveMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwAlpcSetInformation( -- PortHandle: HANDLE, -- PortInformationClass: ALPC_PORT_INFORMATION_CLASS, -- PortInformation: PVOID, -- Length: ULONG, -- ) -> NTSTATUS; -- fn ZwAreMappedFilesTheSame( -- File1MappedAsAnImage: PVOID, -- File2MappedAsFile: PVOID, -- ) -> NTSTATUS; -- fn ZwAssignProcessToJobObject( -- JobHandle: HANDLE, -- ProcessHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwAssociateWaitCompletionPacket( -- WaitCompletionPacketHandle: HANDLE, -- IoCompletionHandle: HANDLE, -- TargetObjectHandle: HANDLE, -- KeyContext: PVOID, -- ApcContext: PVOID, -- IoStatus: NTSTATUS, -- IoStatusInformation: ULONG_PTR, -- AlreadySignaled: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwCallbackReturn( -- OutputBuffer: PVOID, -- OutputLength: ULONG, -- Status: NTSTATUS, -- ) -> NTSTATUS; -- fn ZwCancelIoFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn ZwCancelIoFileEx( -- FileHandle: HANDLE, -- IoRequestToCancel: PIO_STATUS_BLOCK, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn ZwCancelSynchronousIoFile( -- ThreadHandle: HANDLE, -- IoRequestToCancel: PIO_STATUS_BLOCK, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn ZwCancelTimer( -- TimerHandle: HANDLE, -- CurrentState: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwCancelTimer2( -- TimerHandle: HANDLE, -- Parameters: PT2_CANCEL_PARAMETERS, -- ) -> NTSTATUS; -- fn ZwCancelWaitCompletionPacket( -- WaitCompletionPacketHandle: HANDLE, -- RemoveSignaledPacket: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwClearEvent( -- EventHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwClose( -- Handle: HANDLE, -- ) -> NTSTATUS; -- fn ZwCloseObjectAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- GenerateOnClose: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwCommitComplete( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwCommitEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwCommitTransaction( -- TransactionHandle: HANDLE, -- Wait: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwCompactKeys( -- Count: ULONG, -- KeyArray: *mut HANDLE, -- ) -> NTSTATUS; -- fn ZwCompareObjects( -- FirstObjectHandle: HANDLE, -- SecondObjectHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwCompareTokens( -- FirstTokenHandle: HANDLE, -- SecondTokenHandle: HANDLE, -- Equal: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwCompleteConnectPort( -- PortHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwCompressKey( -- Key: HANDLE, -- ) -> NTSTATUS; -- fn ZwConnectPort( -- PortHandle: PHANDLE, -- PortName: PUNICODE_STRING, -- SecurityQos: PSECURITY_QUALITY_OF_SERVICE, -- ClientView: PPORT_VIEW, -- ServerView: PREMOTE_PORT_VIEW, -- MaxMessageLength: PULONG, -- ConnectionInformation: PVOID, -- ConnectionInformationLength: PULONG, -- ) -> NTSTATUS; -- fn ZwContinue( -- ContextRecord: PCONTEXT, -- TestAlert: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwCreateDebugObject( -- DebugObjectHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateDirectoryObject( -- DirectoryHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwCreateDirectoryObjectEx( -- DirectoryHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ShadowDirectoryHandle: HANDLE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateEnlistment( -- EnlistmentHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ResourceManagerHandle: HANDLE, -- TransactionHandle: HANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- CreateOptions: ULONG, -- NotificationMask: NOTIFICATION_MASK, -- EnlistmentKey: PVOID, -- ) -> NTSTATUS; -- fn ZwCreateEvent( -- EventHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- EventType: EVENT_TYPE, -- InitialState: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwCreateEventPair( -- EventPairHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwCreateFile( -- FileHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- AllocationSize: PLARGE_INTEGER, -- FileAttributes: ULONG, -- ShareAccess: ULONG, -- CreateDisposition: ULONG, -- CreateOptions: ULONG, -- EaBuffer: PVOID, -- EaLength: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateIRTimer( -- TimerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ) -> NTSTATUS; -- fn ZwCreateIoCompletion( -- IoCompletionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Count: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateJobObject( -- JobHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwCreateJobSet( -- NumJob: ULONG, -- UserJobSet: PJOB_SET_ARRAY, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateKey( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TitleIndex: ULONG, -- Class: PUNICODE_STRING, -- CreateOptions: ULONG, -- Disposition: PULONG, -- ) -> NTSTATUS; -- fn ZwCreateKeyTransacted( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TitleIndex: ULONG, -- Class: PUNICODE_STRING, -- CreateOptions: ULONG, -- TransactionHandle: HANDLE, -- Disposition: PULONG, -- ) -> NTSTATUS; -- fn ZwCreateKeyedEvent( -- KeyedEventHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateLowBoxToken( -- TokenHandle: PHANDLE, -- ExistingTokenHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PackageSid: PSID, -- CapabilityCount: ULONG, -- Capabilities: PSID_AND_ATTRIBUTES, -- HandleCount: ULONG, -- Handles: *mut HANDLE, -- ) -> NTSTATUS; -- fn ZwCreateMailslotFile( -- FileHandle: PHANDLE, -- DesiredAccess: ULONG, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- CreateOptions: ULONG, -- MailslotQuota: ULONG, -- MaximumMessageSize: ULONG, -- ReadTimeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwCreateMutant( -- MutantHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- InitialOwner: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwCreateNamedPipeFile( -- FileHandle: PHANDLE, -- DesiredAccess: ULONG, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ShareAccess: ULONG, -- CreateDisposition: ULONG, -- CreateOptions: ULONG, -- NamedPipeType: ULONG, -- ReadMode: ULONG, -- CompletionMode: ULONG, -- MaximumInstances: ULONG, -- InboundQuota: ULONG, -- OutboundQuota: ULONG, -- DefaultTimeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwCreatePagingFile( -- PageFileName: PUNICODE_STRING, -- MinimumSize: PLARGE_INTEGER, -- MaximumSize: PLARGE_INTEGER, -- Priority: ULONG, -- ) -> NTSTATUS; -- fn ZwCreatePartition( -- PartitionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- PreferredNode: ULONG, -- ) -> NTSTATUS; -- fn ZwCreatePort( -- PortHandle: PHANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- MaxConnectionInfoLength: ULONG, -- MaxMessageLength: ULONG, -- MaxPoolUsage: ULONG, -- ) -> NTSTATUS; -- fn ZwCreatePrivateNamespace( -- NamespaceHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- BoundaryDescriptor: PVOID, -- ) -> NTSTATUS; -- fn ZwCreateProcess( -- ProcessHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ParentProcess: HANDLE, -- InheritObjectTable: BOOLEAN, -- SectionHandle: HANDLE, -- DebugPort: HANDLE, -- ExceptionPort: HANDLE, -- ) -> NTSTATUS; -- fn ZwCreateProcessEx( -- ProcessHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ParentProcess: HANDLE, -- Flags: ULONG, -- SectionHandle: HANDLE, -- DebugPort: HANDLE, -- ExceptionPort: HANDLE, -- JobMemberLevel: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateProfile( -- ProfileHandle: PHANDLE, -- Process: HANDLE, -- ProfileBase: PVOID, -- ProfileSize: SIZE_T, -- BucketSize: ULONG, -- Buffer: PULONG, -- BufferSize: ULONG, -- ProfileSource: KPROFILE_SOURCE, -- Affinity: KAFFINITY, -- ) -> NTSTATUS; -- fn ZwCreateProfileEx( -- ProfileHandle: PHANDLE, -- Process: HANDLE, -- ProfileBase: PVOID, -- ProfileSize: SIZE_T, -- BucketSize: ULONG, -- Buffer: PULONG, -- BufferSize: ULONG, -- ProfileSource: KPROFILE_SOURCE, -- GroupCount: USHORT, -- GroupAffinity: PGROUP_AFFINITY, -- ) -> NTSTATUS; -- fn ZwCreateResourceManager( -- ResourceManagerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- TmHandle: HANDLE, -- ResourceManagerGuid: LPGUID, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- CreateOptions: ULONG, -- Description: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwCreateSection( -- SectionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- MaximumSize: PLARGE_INTEGER, -- SectionPageProtection: ULONG, -- AllocationAttributes: ULONG, -- FileHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwCreateSemaphore( -- SemaphoreHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- InitialCount: LONG, -- MaximumCount: LONG, -- ) -> NTSTATUS; -- fn ZwCreateSymbolicLinkObject( -- LinkHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- LinkTarget: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwCreateThread( -- ThreadHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ProcessHandle: HANDLE, -- ClientId: PCLIENT_ID, -- ThreadContext: PCONTEXT, -- InitialTeb: PINITIAL_TEB, -- CreateSuspended: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwCreateThreadEx( -- ThreadHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ProcessHandle: HANDLE, -- StartRoutine: PVOID, -- Argument: PVOID, -- CreateFlags: ULONG, -- ZeroBits: SIZE_T, -- StackSize: SIZE_T, -- MaximumStackSize: SIZE_T, -- AttributeList: PPS_ATTRIBUTE_LIST, -- ) -> NTSTATUS; -- fn ZwCreateTimer( -- TimerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TimerType: TIMER_TYPE, -- ) -> NTSTATUS; -- fn ZwCreateTimer2( -- TimerHandle: PHANDLE, -- Reserved1: PVOID, -- Reserved2: PVOID, -- Attributes: ULONG, -- DesiredAccess: ACCESS_MASK, -- ) -> NTSTATUS; -- fn ZwCreateToken( -- TokenHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TokenType: TOKEN_TYPE, -- AuthenticationId: PLUID, -- ExpirationTime: PLARGE_INTEGER, -- User: PTOKEN_USER, -- Groups: PTOKEN_GROUPS, -- Privileges: PTOKEN_PRIVILEGES, -- Owner: PTOKEN_OWNER, -- PrimaryGroup: PTOKEN_PRIMARY_GROUP, -- DefaultDacl: PTOKEN_DEFAULT_DACL, -- TokenSource: PTOKEN_SOURCE, -- ) -> NTSTATUS; -- fn ZwCreateTokenEx( -- TokenHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TokenType: TOKEN_TYPE, -- AuthenticationId: PLUID, -- ExpirationTime: PLARGE_INTEGER, -- User: PTOKEN_USER, -- Groups: PTOKEN_GROUPS, -- Privileges: PTOKEN_PRIVILEGES, -- UserAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- DeviceAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- DeviceGroups: PTOKEN_GROUPS, -- TokenMandatoryPolicy: PTOKEN_MANDATORY_POLICY, -- Owner: PTOKEN_OWNER, -- PrimaryGroup: PTOKEN_PRIMARY_GROUP, -- DefaultDacl: PTOKEN_DEFAULT_DACL, -- TokenSource: PTOKEN_SOURCE, -- ) -> NTSTATUS; -- fn ZwCreateTransaction( -- TransactionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Uow: LPGUID, -- TmHandle: HANDLE, -- CreateOptions: ULONG, -- IsolationLevel: ULONG, -- IsolationFlags: ULONG, -- Timeout: PLARGE_INTEGER, -- Description: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwCreateTransactionManager( -- TmHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- LogFileName: PUNICODE_STRING, -- CreateOptions: ULONG, -- CommitStrength: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateUserProcess( -- ProcessHandle: PHANDLE, -- ThreadHandle: PHANDLE, -- ProcessDesiredAccess: ACCESS_MASK, -- ThreadDesiredAccess: ACCESS_MASK, -- ProcessObjectAttributes: POBJECT_ATTRIBUTES, -- ThreadObjectAttributes: POBJECT_ATTRIBUTES, -- ProcessFlags: ULONG, -- ThreadFlags: ULONG, -- ProcessParameters: PVOID, -- CreateInfo: PPS_CREATE_INFO, -- AttributeList: PPS_ATTRIBUTE_LIST, -- ) -> NTSTATUS; -- fn ZwCreateWaitCompletionPacket( -- WaitCompletionPacketHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwCreateWaitablePort( -- PortHandle: PHANDLE, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- MaxConnectionInfoLength: ULONG, -- MaxMessageLength: ULONG, -- MaxPoolUsage: ULONG, -- ) -> NTSTATUS; -- fn ZwCreateWnfStateName( -- StateName: PWNF_STATE_NAME, -- NameLifetime: WNF_STATE_NAME_LIFETIME, -- DataScope: WNF_DATA_SCOPE, -- PersistData: BOOLEAN, -- TypeId: PCWNF_TYPE_ID, -- MaximumStateSize: ULONG, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ) -> NTSTATUS; -- fn ZwCreateWorkerFactory( -- WorkerFactoryHandleReturn: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- CompletionPortHandle: HANDLE, -- WorkerProcessHandle: HANDLE, -- StartRoutine: PVOID, -- StartParameter: PVOID, -- MaxThreadCount: ULONG, -- StackReserve: SIZE_T, -- StackCommit: SIZE_T, -- ) -> NTSTATUS; -- fn ZwDebugActiveProcess( -- ProcessHandle: HANDLE, -- DebugObjectHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwDebugContinue( -- DebugObjectHandle: HANDLE, -- ClientId: PCLIENT_ID, -- ContinueStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn ZwDelayExecution( -- Alertable: BOOLEAN, -- DelayInterval: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwDeleteAtom( -- Atom: RTL_ATOM, -- ) -> NTSTATUS; -- fn ZwDeleteBootEntry( -- Id: ULONG, -- ) -> NTSTATUS; -- fn ZwDeleteDriverEntry( -- Id: ULONG, -- ) -> NTSTATUS; -- fn ZwDeleteFile( -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwDeleteKey( -- KeyHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwDeleteObjectAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- GenerateOnClose: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwDeletePrivateNamespace( -- NamespaceHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwDeleteValueKey( -- KeyHandle: HANDLE, -- ValueName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwDeleteWnfStateData( -- StateName: PCWNF_STATE_NAME, -- ExplicitScope: *const VOID, -- ) -> NTSTATUS; -- fn ZwDeleteWnfStateName( -- StateName: PCWNF_STATE_NAME, -- ) -> NTSTATUS; -- fn ZwDeviceIoControlFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- IoControlCode: ULONG, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- OutputBuffer: PVOID, -- OutputBufferLength: ULONG, -- ) -> NTSTATUS; -- fn ZwDisableLastKnownGood() -> NTSTATUS; -- fn ZwDisplayString( -- String: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwDrawText( -- String: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwDuplicateObject( -- SourceProcessHandle: HANDLE, -- SourceHandle: HANDLE, -- TargetProcessHandle: HANDLE, -- TargetHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- HandleAttributes: ULONG, -- Options: ULONG, -- ) -> NTSTATUS; -- fn ZwDuplicateToken( -- ExistingTokenHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- EffectiveOnly: BOOLEAN, -- TokenType: TOKEN_TYPE, -- NewTokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwEnableLastKnownGood() -> NTSTATUS; -- fn ZwEnumerateBootEntries( -- Buffer: PVOID, -- BufferLength: PULONG, -- ) -> NTSTATUS; -- fn ZwEnumerateDriverEntries( -- Buffer: PVOID, -- BufferLength: PULONG, -- ) -> NTSTATUS; -- fn ZwEnumerateKey( -- KeyHandle: HANDLE, -- Index: ULONG, -- KeyInformationClass: KEY_INFORMATION_CLASS, -- KeyInformation: PVOID, -- Length: ULONG, -- ResultLength: PULONG, -- ) -> NTSTATUS; -- fn ZwEnumerateSystemEnvironmentValuesEx( -- InformationClass: ULONG, -- Buffer: PVOID, -- BufferLength: PULONG, -- ) -> NTSTATUS; -- fn ZwEnumerateTransactionObject( -- RootObjectHandle: HANDLE, -- QueryType: KTMOBJECT_TYPE, -- ObjectCursor: PKTMOBJECT_CURSOR, -- ObjectCursorLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwEnumerateValueKey( -- KeyHandle: HANDLE, -- Index: ULONG, -- KeyValueInformationClass: KEY_VALUE_INFORMATION_CLASS, -- KeyValueInformation: PVOID, -- Length: ULONG, -- ResultLength: PULONG, -- ) -> NTSTATUS; -- fn ZwExtendSection( -- SectionHandle: HANDLE, -- NewSectionSize: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwFilterToken( -- ExistingTokenHandle: HANDLE, -- Flags: ULONG, -- SidsToDisable: PTOKEN_GROUPS, -- PrivilegesToDelete: PTOKEN_PRIVILEGES, -- RestrictedSids: PTOKEN_GROUPS, -- NewTokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwFilterTokenEx( -- ExistingTokenHandle: HANDLE, -- Flags: ULONG, -- SidsToDisable: PTOKEN_GROUPS, -- PrivilegesToDelete: PTOKEN_PRIVILEGES, -- RestrictedSids: PTOKEN_GROUPS, -- DisableUserClaimsCount: ULONG, -- UserClaimsToDisable: PUNICODE_STRING, -- DisableDeviceClaimsCount: ULONG, -- DeviceClaimsToDisable: PUNICODE_STRING, -- DeviceGroupsToDisable: PTOKEN_GROUPS, -- RestrictedUserAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- RestrictedDeviceAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, -- RestrictedDeviceGroups: PTOKEN_GROUPS, -- NewTokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwFindAtom( -- AtomName: PWSTR, -- Length: ULONG, -- Atom: PRTL_ATOM, -- ) -> NTSTATUS; -- fn ZwFlushBuffersFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn ZwFlushBuffersFileEx( -- FileHandle: HANDLE, -- Flags: ULONG, -- Parameters: PVOID, -- ParametersSize: ULONG, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn ZwFlushInstallUILanguage( -- InstallUILanguage: LANGID, -- SetComittedFlag: ULONG, -- ) -> NTSTATUS; -- fn ZwFlushInstructionCache( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- Length: SIZE_T, -- ) -> NTSTATUS; -- fn ZwFlushKey( -- KeyHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwFlushProcessWriteBuffers(); -- fn ZwFlushWriteBuffer() -> NTSTATUS; -- fn ZwFreeUserPhysicalPages( -- ProcessHandle: HANDLE, -- NumberOfPages: PULONG_PTR, -- UserPfnArray: PULONG_PTR, -- ) -> NTSTATUS; -- fn ZwFreeVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- RegionSize: PSIZE_T, -- FreeType: ULONG, -- ) -> NTSTATUS; -- fn ZwFreezeRegistry( -- TimeOutInSeconds: ULONG, -- ) -> NTSTATUS; -- fn ZwFreezeTransactions( -- FreezeTimeout: PLARGE_INTEGER, -- ThawTimeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwFsControlFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FsControlCode: ULONG, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- OutputBuffer: PVOID, -- OutputBufferLength: ULONG, -- ) -> NTSTATUS; -- fn ZwGetCachedSigningLevel( -- File: HANDLE, -- Flags: PULONG, -- SigningLevel: PSE_SIGNING_LEVEL, -- Thumbprint: PUCHAR, -- ThumbprintSize: PULONG, -- ThumbprintAlgorithm: PULONG, -- ) -> NTSTATUS; -- fn ZwGetCompleteWnfStateSubscription( -- OldDescriptorStateName: PWNF_STATE_NAME, -- OldSubscriptionId: *mut ULONG64, -- OldDescriptorEventMask: ULONG, -- OldDescriptorStatus: ULONG, -- NewDeliveryDescriptor: PWNF_DELIVERY_DESCRIPTOR, -- DescriptorSize: ULONG, -- ) -> NTSTATUS; -- fn ZwGetContextThread( -- ThreadHandle: HANDLE, -- ThreadContext: PCONTEXT, -- ) -> NTSTATUS; -- fn ZwGetCurrentProcessorNumber() -> ULONG; -- fn ZwGetDevicePowerState( -- Device: HANDLE, -- State: PDEVICE_POWER_STATE, -- ) -> NTSTATUS; -- fn ZwGetMUIRegistryInfo( -- Flags: ULONG, -- DataSize: PULONG, -- Data: PVOID, -- ) -> NTSTATUS; -- fn ZwGetNextProcess( -- ProcessHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- HandleAttributes: ULONG, -- Flags: ULONG, -- NewProcessHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwGetNextThread( -- ProcessHandle: HANDLE, -- ThreadHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- HandleAttributes: ULONG, -- Flags: ULONG, -- NewThreadHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwGetNlsSectionPtr( -- SectionType: ULONG, -- SectionData: ULONG, -- ContextData: PVOID, -- SectionPointer: *mut PVOID, -- SectionSize: PULONG, -- ) -> NTSTATUS; -- fn ZwGetNotificationResourceManager( -- ResourceManagerHandle: HANDLE, -- TransactionNotification: PTRANSACTION_NOTIFICATION, -- NotificationLength: ULONG, -- Timeout: PLARGE_INTEGER, -- ReturnLength: PULONG, -- Asynchronous: ULONG, -- AsynchronousContext: ULONG_PTR, -- ) -> NTSTATUS; -- fn ZwGetPlugPlayEvent( -- EventHandle: HANDLE, -- Context: PVOID, -- EventBlock: PPLUGPLAY_EVENT_BLOCK, -- EventBufferSize: ULONG, -- ) -> NTSTATUS; -- fn ZwGetWriteWatch( -- ProcessHandle: HANDLE, -- Flags: ULONG, -- BaseAddress: PVOID, -- RegionSize: SIZE_T, -- UserAddressArray: *mut PVOID, -- EntriesInUserAddressArray: PULONG_PTR, -- Granularity: PULONG, -- ) -> NTSTATUS; -- fn ZwImpersonateAnonymousToken( -- ThreadHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwImpersonateClientOfPort( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn ZwImpersonateThread( -- ServerThreadHandle: HANDLE, -- ClientThreadHandle: HANDLE, -- SecurityQos: PSECURITY_QUALITY_OF_SERVICE, -- ) -> NTSTATUS; -- fn ZwInitializeNlsFiles( -- BaseAddress: *mut PVOID, -- DefaultLocaleId: PLCID, -- DefaultCasingTableSize: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwInitializeRegistry( -- BootCondition: USHORT, -- ) -> NTSTATUS; -- fn ZwInitiatePowerAction( -- SystemAction: POWER_ACTION, -- LightestSystemState: SYSTEM_POWER_STATE, -- Flags: ULONG, -- Asynchronous: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwIsProcessInJob( -- ProcessHandle: HANDLE, -- JobHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwIsSystemResumeAutomatic() -> BOOLEAN; -- fn ZwIsUILanguageComitted() -> NTSTATUS; -- fn ZwListenPort( -- PortHandle: HANDLE, -- ConnectionRequest: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn ZwLoadDriver( -- DriverServiceName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwLoadKey( -- TargetKey: POBJECT_ATTRIBUTES, -- SourceFile: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwLoadKey2( -- TargetKey: POBJECT_ATTRIBUTES, -- SourceFile: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwLoadKeyEx( -- TargetKey: POBJECT_ATTRIBUTES, -- SourceFile: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- TrustClassKey: HANDLE, -- Event: HANDLE, -- DesiredAccess: ACCESS_MASK, -- RootHandle: PHANDLE, -- IoStatus: PIO_STATUS_BLOCK, -- ) -> NTSTATUS; -- fn ZwLockFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ByteOffset: PLARGE_INTEGER, -- Length: PLARGE_INTEGER, -- Key: ULONG, -- FailImmediately: BOOLEAN, -- ExclusiveLock: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwLockProductActivationKeys( -- pPrivateVer: *mut ULONG, -- pSafeMode: *mut ULONG, -- ) -> NTSTATUS; -- fn ZwLockRegistryKey( -- KeyHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwLockVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- RegionSize: PSIZE_T, -- MapType: ULONG, -- ) -> NTSTATUS; -- fn ZwMakePermanentObject( -- Handle: HANDLE, -- ) -> NTSTATUS; -- fn ZwMakeTemporaryObject( -- Handle: HANDLE, -- ) -> NTSTATUS; -- fn ZwManagePartition( -- PartitionInformationClass: MEMORY_PARTITION_INFORMATION_CLASS, -- PartitionInformation: PVOID, -- PartitionInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwMapCMFModule( -- What: ULONG, -- Index: ULONG, -- CacheIndexOut: PULONG, -- CacheFlagsOut: PULONG, -- ViewSizeOut: PULONG, -- BaseAddress: *mut PVOID, -- ) -> NTSTATUS; -- fn ZwMapUserPhysicalPages( -- VirtualAddress: PVOID, -- NumberOfPages: ULONG_PTR, -- UserPfnArray: PULONG_PTR, -- ) -> NTSTATUS; -- fn ZwMapUserPhysicalPagesScatter( -- VirtualAddresses: *mut PVOID, -- NumberOfPages: ULONG_PTR, -- UserPfnArray: PULONG_PTR, -- ) -> NTSTATUS; -- fn ZwMapViewOfSection( -- SectionHandle: HANDLE, -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- ZeroBits: ULONG_PTR, -- CommitSize: SIZE_T, -- SectionOffset: PLARGE_INTEGER, -- ViewSize: PSIZE_T, -- InheritDisposition: SECTION_INHERIT, -- AllocationType: ULONG, -- Win32Protect: ULONG, -- ) -> NTSTATUS; -- fn ZwModifyBootEntry( -- BootEntry: PBOOT_ENTRY, -- ) -> NTSTATUS; -- fn ZwModifyDriverEntry( -- DriverEntry: PEFI_DRIVER_ENTRY, -- ) -> NTSTATUS; -- fn ZwNotifyChangeDirectoryFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- CompletionFilter: ULONG, -- WatchTree: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwNotifyChangeKey( -- KeyHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- CompletionFilter: ULONG, -- WatchTree: BOOLEAN, -- Buffer: PVOID, -- BufferSize: ULONG, -- Asynchronous: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwNotifyChangeMultipleKeys( -- MasterKeyHandle: HANDLE, -- Count: ULONG, -- SubordinateObjects: *mut OBJECT_ATTRIBUTES, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- CompletionFilter: ULONG, -- WatchTree: BOOLEAN, -- Buffer: PVOID, -- BufferSize: ULONG, -- Asynchronous: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwNotifyChangeSession( -- SessionHandle: HANDLE, -- ChangeSequenceNumber: ULONG, -- ChangeTimeStamp: PLARGE_INTEGER, -- Event: IO_SESSION_EVENT, -- NewState: IO_SESSION_STATE, -- PreviousState: IO_SESSION_STATE, -- Payload: PVOID, -- PayloadSize: ULONG, -- ) -> NTSTATUS; -- fn ZwOpenDirectoryObject( -- DirectoryHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenEnlistment( -- EnlistmentHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- RmHandle: HANDLE, -- EnlistmentGuid: LPGUID, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenEvent( -- EventHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenEventPair( -- EventPairHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenFile( -- FileHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ShareAccess: ULONG, -- OpenOptions: ULONG, -- ) -> NTSTATUS; -- fn ZwOpenIoCompletion( -- IoCompletionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenJobObject( -- JobHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenKey( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenKeyEx( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- OpenOptions: ULONG, -- ) -> NTSTATUS; -- fn ZwOpenKeyTransacted( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- TransactionHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwOpenKeyTransactedEx( -- KeyHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- OpenOptions: ULONG, -- TransactionHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwOpenKeyedEvent( -- KeyedEventHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenMutant( -- MutantHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenObjectAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ObjectTypeName: PUNICODE_STRING, -- ObjectName: PUNICODE_STRING, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- GrantedAccess: ACCESS_MASK, -- Privileges: PPRIVILEGE_SET, -- ObjectCreation: BOOLEAN, -- AccessGranted: BOOLEAN, -- GenerateOnClose: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwOpenPartition( -- PartitionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenPrivateNamespace( -- NamespaceHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- BoundaryDescriptor: PVOID, -- ) -> NTSTATUS; -- fn ZwOpenProcess( -- ProcessHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ClientId: PCLIENT_ID, -- ) -> NTSTATUS; -- fn ZwOpenProcessToken( -- ProcessHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- TokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwOpenProcessTokenEx( -- ProcessHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- HandleAttributes: ULONG, -- TokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwOpenResourceManager( -- ResourceManagerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- TmHandle: HANDLE, -- ResourceManagerGuid: LPGUID, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenSection( -- SectionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenSemaphore( -- SemaphoreHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenSession( -- SessionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenSymbolicLinkObject( -- LinkHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenThread( -- ThreadHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ClientId: PCLIENT_ID, -- ) -> NTSTATUS; -- fn ZwOpenThreadToken( -- ThreadHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- OpenAsSelf: BOOLEAN, -- TokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwOpenThreadTokenEx( -- ThreadHandle: HANDLE, -- DesiredAccess: ACCESS_MASK, -- OpenAsSelf: BOOLEAN, -- HandleAttributes: ULONG, -- TokenHandle: PHANDLE, -- ) -> NTSTATUS; -- fn ZwOpenTimer( -- TimerHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwOpenTransaction( -- TransactionHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- Uow: LPGUID, -- TmHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwOpenTransactionManager( -- TmHandle: PHANDLE, -- DesiredAccess: ACCESS_MASK, -- ObjectAttributes: POBJECT_ATTRIBUTES, -- LogFileName: PUNICODE_STRING, -- TmIdentity: LPGUID, -- OpenOptions: ULONG, -- ) -> NTSTATUS; -- fn ZwPlugPlayControl( -- PnPControlClass: PLUGPLAY_CONTROL_CLASS, -- PnPControlData: PVOID, -- PnPControlDataLength: ULONG, -- ) -> NTSTATUS; -- fn ZwPowerInformation( -- InformationLevel: POWER_INFORMATION_LEVEL, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- OutputBuffer: PVOID, -- OutputBufferLength: ULONG, -- ) -> NTSTATUS; -- fn ZwPrePrepareComplete( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwPrePrepareEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwPrepareComplete( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwPrepareEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwPrivilegeCheck( -- ClientToken: HANDLE, -- RequiredPrivileges: PPRIVILEGE_SET, -- Result: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwPrivilegeObjectAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- HandleId: PVOID, -- ClientToken: HANDLE, -- DesiredAccess: ACCESS_MASK, -- Privileges: PPRIVILEGE_SET, -- AccessGranted: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwPrivilegedServiceAuditAlarm( -- SubsystemName: PUNICODE_STRING, -- ServiceName: PUNICODE_STRING, -- ClientToken: HANDLE, -- Privileges: PPRIVILEGE_SET, -- AccessGranted: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwPropagationComplete( -- ResourceManagerHandle: HANDLE, -- RequestCookie: ULONG, -- BufferLength: ULONG, -- Buffer: PVOID, -- ) -> NTSTATUS; -- fn ZwPropagationFailed( -- ResourceManagerHandle: HANDLE, -- RequestCookie: ULONG, -- PropStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn ZwProtectVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- RegionSize: PSIZE_T, -- NewProtect: ULONG, -- OldProtect: PULONG, -- ) -> NTSTATUS; -- fn ZwPulseEvent( -- EventHandle: HANDLE, -- PreviousState: PLONG, -- ) -> NTSTATUS; -- fn ZwQueryAttributesFile( -- ObjectAttributes: POBJECT_ATTRIBUTES, -- FileInformation: PFILE_BASIC_INFORMATION, -- ) -> NTSTATUS; -- fn ZwQueryBootEntryOrder( -- Ids: PULONG, -- Count: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryBootOptions( -- BootOptions: PBOOT_OPTIONS, -- BootOptionsLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryDebugFilterState( -- ComponentId: ULONG, -- Level: ULONG, -- ) -> NTSTATUS; -- fn ZwQueryDefaultLocale( -- UserProfile: BOOLEAN, -- DefaultLocaleId: PLCID, -- ) -> NTSTATUS; -- fn ZwQueryDefaultUILanguage( -- DefaultUILanguageId: *mut LANGID, -- ) -> NTSTATUS; -- fn ZwQueryDirectoryFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FileInformation: PVOID, -- Length: ULONG, -- FileInformationClass: FILE_INFORMATION_CLASS, -- ReturnSingleEntry: BOOLEAN, -- FileName: PUNICODE_STRING, -- RestartScan: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwQueryDirectoryObject( -- DirectoryHandle: HANDLE, -- Buffer: PVOID, -- Length: ULONG, -- ReturnSingleEntry: BOOLEAN, -- RestartScan: BOOLEAN, -- Context: PULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryDriverEntryOrder( -- Ids: PULONG, -- Count: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryEaFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ReturnSingleEntry: BOOLEAN, -- EaList: PVOID, -- EaListLength: ULONG, -- EaIndex: PULONG, -- RestartScan: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwQueryEvent( -- EventHandle: HANDLE, -- EventInformationClass: EVENT_INFORMATION_CLASS, -- EventInformation: PVOID, -- EventInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryFullAttributesFile( -- ObjectAttributes: POBJECT_ATTRIBUTES, -- FileInformation: PFILE_NETWORK_OPEN_INFORMATION, -- ) -> NTSTATUS; -- fn ZwQueryInformationAtom( -- Atom: RTL_ATOM, -- AtomInformationClass: ATOM_INFORMATION_CLASS, -- AtomInformation: PVOID, -- AtomInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationEnlistment( -- EnlistmentHandle: HANDLE, -- EnlistmentInformationClass: ENLISTMENT_INFORMATION_CLASS, -- EnlistmentInformation: PVOID, -- EnlistmentInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FileInformation: PVOID, -- Length: ULONG, -- FileInformationClass: FILE_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn ZwQueryInformationJobObject( -- JobHandle: HANDLE, -- JobObjectInformationClass: JOBOBJECTINFOCLASS, -- JobObjectInformation: PVOID, -- JobObjectInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationPort( -- PortHandle: HANDLE, -- PortInformationClass: PORT_INFORMATION_CLASS, -- PortInformation: PVOID, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationProcess( -- ProcessHandle: HANDLE, -- ProcessInformationClass: PROCESSINFOCLASS, -- ProcessInformation: PVOID, -- ProcessInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationResourceManager( -- ResourceManagerHandle: HANDLE, -- ResourceManagerInformationClass: RESOURCEMANAGER_INFORMATION_CLASS, -- ResourceManagerInformation: PVOID, -- ResourceManagerInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationThread( -- ThreadHandle: HANDLE, -- ThreadInformationClass: THREADINFOCLASS, -- ThreadInformation: PVOID, -- ThreadInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationToken( -- TokenHandle: HANDLE, -- TokenInformationClass: TOKEN_INFORMATION_CLASS, -- TokenInformation: PVOID, -- TokenInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationTransaction( -- TransactionHandle: HANDLE, -- TransactionInformationClass: TRANSACTION_INFORMATION_CLASS, -- TransactionInformation: PVOID, -- TransactionInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationTransactionManager( -- TransactionManagerHandle: HANDLE, -- TransactionManagerInformationClass: TRANSACTIONMANAGER_INFORMATION_CLASS, -- TransactionManagerInformation: PVOID, -- TransactionManagerInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInformationWorkerFactory( -- WorkerFactoryHandle: HANDLE, -- WorkerFactoryInformationClass: WORKERFACTORYINFOCLASS, -- WorkerFactoryInformation: PVOID, -- WorkerFactoryInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryInstallUILanguage( -- InstallUILanguageId: *mut LANGID, -- ) -> NTSTATUS; -- fn ZwQueryIntervalProfile( -- ProfileSource: KPROFILE_SOURCE, -- Interval: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryIoCompletion( -- IoCompletionHandle: HANDLE, -- IoCompletionInformationClass: IO_COMPLETION_INFORMATION_CLASS, -- IoCompletionInformation: PVOID, -- IoCompletionInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryKey( -- KeyHandle: HANDLE, -- KeyInformationClass: KEY_INFORMATION_CLASS, -- KeyInformation: PVOID, -- Length: ULONG, -- ResultLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryLicenseValue( -- ValueName: PUNICODE_STRING, -- Type: PULONG, -- Data: PVOID, -- DataSize: ULONG, -- ResultDataSize: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryMultipleValueKey( -- KeyHandle: HANDLE, -- ValueEntries: PKEY_VALUE_ENTRY, -- EntryCount: ULONG, -- ValueBuffer: PVOID, -- BufferLength: PULONG, -- RequiredBufferLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryMutant( -- MutantHandle: HANDLE, -- MutantInformationClass: MUTANT_INFORMATION_CLASS, -- MutantInformation: PVOID, -- MutantInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryObject( -- Handle: HANDLE, -- ObjectInformationClass: OBJECT_INFORMATION_CLASS, -- ObjectInformation: PVOID, -- ObjectInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryOpenSubKeys( -- TargetKey: POBJECT_ATTRIBUTES, -- HandleCount: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryOpenSubKeysEx( -- TargetKey: POBJECT_ATTRIBUTES, -- BufferLength: ULONG, -- Buffer: PVOID, -- RequiredSize: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryPerformanceCounter( -- PerformanceCounter: PLARGE_INTEGER, -- PerformanceFrequency: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwQueryPortInformationProcess() -> NTSTATUS; -- fn ZwQueryQuotaInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ReturnSingleEntry: BOOLEAN, -- SidList: PVOID, -- SidListLength: ULONG, -- StartSid: PSID, -- RestartScan: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwQuerySection( -- SectionHandle: HANDLE, -- SectionInformationClass: SECTION_INFORMATION_CLASS, -- SectionInformation: PVOID, -- SectionInformationLength: SIZE_T, -- ReturnLength: PSIZE_T, -- ) -> NTSTATUS; -- fn ZwQuerySecurityAttributesToken( -- TokenHandle: HANDLE, -- Attributes: PUNICODE_STRING, -- NumberOfAttributes: ULONG, -- Buffer: PVOID, -- Length: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQuerySecurityObject( -- Handle: HANDLE, -- SecurityInformation: SECURITY_INFORMATION, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- Length: ULONG, -- LengthNeeded: PULONG, -- ) -> NTSTATUS; -- fn ZwQuerySemaphore( -- SemaphoreHandle: HANDLE, -- SemaphoreInformationClass: SEMAPHORE_INFORMATION_CLASS, -- SemaphoreInformation: PVOID, -- SemaphoreInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQuerySymbolicLinkObject( -- LinkHandle: HANDLE, -- LinkTarget: PUNICODE_STRING, -- ReturnedLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQuerySystemEnvironmentValue( -- VariableName: PUNICODE_STRING, -- VariableValue: PWSTR, -- ValueLength: USHORT, -- ReturnLength: PUSHORT, -- ) -> NTSTATUS; -- fn ZwQuerySystemEnvironmentValueEx( -- VariableName: PUNICODE_STRING, -- VendorGuid: LPGUID, -- Value: PVOID, -- ValueLength: PULONG, -- Attributes: PULONG, -- ) -> NTSTATUS; -- fn ZwQuerySystemInformation( -- SystemInformationClass: SYSTEM_INFORMATION_CLASS, -- SystemInformation: PVOID, -- SystemInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQuerySystemInformationEx( -- SystemInformationClass: SYSTEM_INFORMATION_CLASS, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- SystemInformation: PVOID, -- SystemInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQuerySystemTime( -- SystemTime: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwQueryTimer( -- TimerHandle: HANDLE, -- TimerInformationClass: TIMER_INFORMATION_CLASS, -- TimerInformation: PVOID, -- TimerInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryTimerResolution( -- MaximumTime: PULONG, -- MinimumTime: PULONG, -- CurrentTime: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryValueKey( -- KeyHandle: HANDLE, -- ValueName: PUNICODE_STRING, -- KeyValueInformationClass: KEY_VALUE_INFORMATION_CLASS, -- KeyValueInformation: PVOID, -- Length: ULONG, -- ResultLength: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- MemoryInformationClass: MEMORY_INFORMATION_CLASS, -- MemoryInformation: PVOID, -- MemoryInformationLength: SIZE_T, -- ReturnLength: PSIZE_T, -- ) -> NTSTATUS; -- fn ZwQueryVolumeInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FsInformation: PVOID, -- Length: ULONG, -- FsInformationClass: FS_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn ZwQueryWnfStateData( -- StateName: PCWNF_STATE_NAME, -- TypeId: PCWNF_TYPE_ID, -- ExplicitScope: *const VOID, -- ChangeStamp: PWNF_CHANGE_STAMP, -- Buffer: PVOID, -- BufferSize: PULONG, -- ) -> NTSTATUS; -- fn ZwQueryWnfStateNameInformation( -- StateName: PCWNF_STATE_NAME, -- NameInfoClass: WNF_STATE_NAME_INFORMATION, -- ExplicitScope: *const VOID, -- InfoBuffer: PVOID, -- InfoBufferSize: ULONG, -- ) -> NTSTATUS; -- fn ZwQueueApcThread( -- ThreadHandle: HANDLE, -- ApcRoutine: PPS_APC_ROUTINE, -- ApcArgument1: PVOID, -- ApcArgument2: PVOID, -- ApcArgument3: PVOID, -- ) -> NTSTATUS; -- fn ZwQueueApcThreadEx( -- ThreadHandle: HANDLE, -- UserApcReserveHandle: HANDLE, -- ApcRoutine: PPS_APC_ROUTINE, -- ApcArgument1: PVOID, -- ApcArgument2: PVOID, -- ApcArgument3: PVOID, -- ) -> NTSTATUS; -- fn ZwRaiseException( -- ExceptionRecord: PEXCEPTION_RECORD, -- ContextRecord: PCONTEXT, -- FirstChance: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwRaiseHardError( -- ErrorStatus: NTSTATUS, -- NumberOfParameters: ULONG, -- UnicodeStringParameterMask: ULONG, -- Parameters: PULONG_PTR, -- ValidResponseOptions: ULONG, -- Response: PULONG, -- ) -> NTSTATUS; -- fn ZwReadFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ByteOffset: PLARGE_INTEGER, -- Key: PULONG, -- ) -> NTSTATUS; -- fn ZwReadFileScatter( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- SegmentArray: PFILE_SEGMENT_ELEMENT, -- Length: ULONG, -- ByteOffset: PLARGE_INTEGER, -- Key: PULONG, -- ) -> NTSTATUS; -- fn ZwReadOnlyEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwReadRequestData( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- DataEntryIndex: ULONG, -- Buffer: PVOID, -- BufferSize: SIZE_T, -- NumberOfBytesRead: PSIZE_T, -- ) -> NTSTATUS; -- fn ZwReadVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- Buffer: PVOID, -- BufferSize: SIZE_T, -- NumberOfBytesRead: PSIZE_T, -- ) -> NTSTATUS; -- fn ZwRecoverEnlistment( -- EnlistmentHandle: HANDLE, -- EnlistmentKey: PVOID, -- ) -> NTSTATUS; -- fn ZwRecoverResourceManager( -- ResourceManagerHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwRecoverTransactionManager( -- TransactionManagerHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwRegisterProtocolAddressInformation( -- ResourceManager: HANDLE, -- ProtocolId: PCRM_PROTOCOL_ID, -- ProtocolInformationSize: ULONG, -- ProtocolInformation: PVOID, -- CreateOptions: ULONG, -- ) -> NTSTATUS; -- fn ZwRegisterThreadTerminatePort( -- PortHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwReleaseCMFViewOwnership() -> NTSTATUS; -- fn ZwReleaseKeyedEvent( -- KeyedEventHandle: HANDLE, -- KeyValue: PVOID, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwReleaseMutant( -- MutantHandle: HANDLE, -- PreviousCount: PLONG, -- ) -> NTSTATUS; -- fn ZwReleaseSemaphore( -- SemaphoreHandle: HANDLE, -- ReleaseCount: LONG, -- PreviousCount: PLONG, -- ) -> NTSTATUS; -- fn ZwReleaseWorkerFactoryWorker( -- WorkerFactoryHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwRemoveIoCompletion( -- IoCompletionHandle: HANDLE, -- KeyContext: *mut PVOID, -- ApcContext: *mut PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwRemoveIoCompletionEx( -- IoCompletionHandle: HANDLE, -- IoCompletionInformation: PFILE_IO_COMPLETION_INFORMATION, -- Count: ULONG, -- NumEntriesRemoved: PULONG, -- Timeout: PLARGE_INTEGER, -- Alertable: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwRemoveProcessDebug( -- ProcessHandle: HANDLE, -- DebugObjectHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwRenameKey( -- KeyHandle: HANDLE, -- NewName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwRenameTransactionManager( -- LogFileName: PUNICODE_STRING, -- ExistingTransactionManagerGuid: LPGUID, -- ) -> NTSTATUS; -- fn ZwReplaceKey( -- NewFile: POBJECT_ATTRIBUTES, -- TargetHandle: HANDLE, -- OldFile: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwReplacePartitionUnit( -- TargetInstancePath: PUNICODE_STRING, -- SpareInstancePath: PUNICODE_STRING, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwReplyPort( -- PortHandle: HANDLE, -- ReplyMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn ZwReplyWaitReceivePort( -- PortHandle: HANDLE, -- PortContext: *mut PVOID, -- ReplyMessage: PPORT_MESSAGE, -- ReceiveMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn ZwReplyWaitReceivePortEx( -- PortHandle: HANDLE, -- PortContext: *mut PVOID, -- ReplyMessage: PPORT_MESSAGE, -- ReceiveMessage: PPORT_MESSAGE, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwReplyWaitReplyPort( -- PortHandle: HANDLE, -- ReplyMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn ZwRequestPort( -- PortHandle: HANDLE, -- RequestMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn ZwRequestWaitReplyPort( -- PortHandle: HANDLE, -- RequestMessage: PPORT_MESSAGE, -- ReplyMessage: PPORT_MESSAGE, -- ) -> NTSTATUS; -- fn ZwRequestWakeupLatency( -- latency: LATENCY_TIME, -- ) -> NTSTATUS; -- fn ZwResetEvent( -- EventHandle: HANDLE, -- PreviousState: PLONG, -- ) -> NTSTATUS; -- fn ZwResetWriteWatch( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- RegionSize: SIZE_T, -- ) -> NTSTATUS; -- fn ZwRestoreKey( -- KeyHandle: HANDLE, -- FileHandle: HANDLE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwResumeProcess( -- ProcessHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwResumeThread( -- ThreadHandle: HANDLE, -- PreviousSuspendCount: PULONG, -- ) -> NTSTATUS; -- fn ZwRevertContainerImpersonation() -> NTSTATUS; -- fn ZwRollbackComplete( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwRollbackEnlistment( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwRollbackTransaction( -- TransactionHandle: HANDLE, -- Wait: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwRollforwardTransactionManager( -- TransactionManagerHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwSaveKey( -- KeyHandle: HANDLE, -- FileHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSaveKeyEx( -- KeyHandle: HANDLE, -- FileHandle: HANDLE, -- Format: ULONG, -- ) -> NTSTATUS; -- fn ZwSaveMergedKeys( -- HighPrecedenceKeyHandle: HANDLE, -- LowPrecedenceKeyHandle: HANDLE, -- FileHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSecureConnectPort( -- PortHandle: PHANDLE, -- PortName: PUNICODE_STRING, -- SecurityQos: PSECURITY_QUALITY_OF_SERVICE, -- ClientView: PPORT_VIEW, -- RequiredServerSid: PSID, -- ServerView: PREMOTE_PORT_VIEW, -- MaxMessageLength: PULONG, -- ConnectionInformation: PVOID, -- ConnectionInformationLength: PULONG, -- ) -> NTSTATUS; -- fn ZwSerializeBoot() -> NTSTATUS; -- fn ZwSetBootEntryOrder( -- Ids: PULONG, -- Count: ULONG, -- ) -> NTSTATUS; -- fn ZwSetBootOptions( -- BootOptions: PBOOT_OPTIONS, -- FieldsToChange: ULONG, -- ) -> NTSTATUS; -- fn ZwSetCachedSigningLevel( -- Flags: ULONG, -- InputSigningLevel: SE_SIGNING_LEVEL, -- SourceFiles: PHANDLE, -- SourceFileCount: ULONG, -- TargetFile: HANDLE, -- ) -> NTSTATUS; -- fn ZwSetContextThread( -- ThreadHandle: HANDLE, -- ThreadContext: PCONTEXT, -- ) -> NTSTATUS; -- fn ZwSetDebugFilterState( -- ComponentId: ULONG, -- Level: ULONG, -- State: BOOLEAN, -- ) -> NTSTATUS; -- fn ZwSetDefaultHardErrorPort( -- DefaultHardErrorPort: HANDLE, -- ) -> NTSTATUS; -- fn ZwSetDefaultLocale( -- UserProfile: BOOLEAN, -- DefaultLocaleId: LCID, -- ) -> NTSTATUS; -- fn ZwSetDefaultUILanguage( -- DefaultUILanguageId: LANGID, -- ) -> NTSTATUS; -- fn ZwSetDriverEntryOrder( -- Ids: PULONG, -- Count: ULONG, -- ) -> NTSTATUS; -- fn ZwSetEaFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ) -> NTSTATUS; -- fn ZwSetEvent( -- EventHandle: HANDLE, -- PreviousState: PLONG, -- ) -> NTSTATUS; -- fn ZwSetEventBoostPriority( -- EventHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSetHighEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSetHighWaitLowEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSetIRTimer( -- TimerHandle: HANDLE, -- DueTime: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwSetInformationDebugObject( -- DebugObjectHandle: HANDLE, -- DebugObjectInformationClass: DEBUGOBJECTINFOCLASS, -- DebugInformation: PVOID, -- DebugInformationLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationEnlistment( -- EnlistmentHandle: HANDLE, -- EnlistmentInformationClass: ENLISTMENT_INFORMATION_CLASS, -- EnlistmentInformation: PVOID, -- EnlistmentInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FileInformation: PVOID, -- Length: ULONG, -- FileInformationClass: FILE_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn ZwSetInformationJobObject( -- JobHandle: HANDLE, -- JobObjectInformationClass: JOBOBJECTINFOCLASS, -- JobObjectInformation: PVOID, -- JobObjectInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationKey( -- KeyHandle: HANDLE, -- KeySetInformationClass: KEY_SET_INFORMATION_CLASS, -- KeySetInformation: PVOID, -- KeySetInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationObject( -- Handle: HANDLE, -- ObjectInformationClass: OBJECT_INFORMATION_CLASS, -- ObjectInformation: PVOID, -- ObjectInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationProcess( -- ProcessHandle: HANDLE, -- ProcessInformationClass: PROCESSINFOCLASS, -- ProcessInformation: PVOID, -- ProcessInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationResourceManager( -- ResourceManagerHandle: HANDLE, -- ResourceManagerInformationClass: RESOURCEMANAGER_INFORMATION_CLASS, -- ResourceManagerInformation: PVOID, -- ResourceManagerInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationThread( -- ThreadHandle: HANDLE, -- ThreadInformationClass: THREADINFOCLASS, -- ThreadInformation: PVOID, -- ThreadInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationToken( -- TokenHandle: HANDLE, -- TokenInformationClass: TOKEN_INFORMATION_CLASS, -- TokenInformation: PVOID, -- TokenInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationTransaction( -- TransactionHandle: HANDLE, -- TransactionInformationClass: TRANSACTION_INFORMATION_CLASS, -- TransactionInformation: PVOID, -- TransactionInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationTransactionManager( -- TmHandle: HANDLE, -- TransactionManagerInformationClass: TRANSACTIONMANAGER_INFORMATION_CLASS, -- TransactionManagerInformation: PVOID, -- TransactionManagerInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationVirtualMemory( -- ProcessHandle: HANDLE, -- VmInformationClass: VIRTUAL_MEMORY_INFORMATION_CLASS, -- NumberOfEntries: ULONG_PTR, -- VirtualAddresses: PMEMORY_RANGE_ENTRY, -- VmInformation: PVOID, -- VmInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetInformationWorkerFactory( -- WorkerFactoryHandle: HANDLE, -- WorkerFactoryInformationClass: WORKERFACTORYINFOCLASS, -- WorkerFactoryInformation: PVOID, -- WorkerFactoryInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetIntervalProfile( -- Interval: ULONG, -- Source: KPROFILE_SOURCE, -- ) -> NTSTATUS; -- fn ZwSetIoCompletion( -- IoCompletionHandle: HANDLE, -- KeyContext: PVOID, -- ApcContext: PVOID, -- IoStatus: NTSTATUS, -- IoStatusInformation: ULONG_PTR, -- ) -> NTSTATUS; -- fn ZwSetIoCompletionEx( -- IoCompletionHandle: HANDLE, -- IoCompletionPacketHandle: HANDLE, -- KeyContext: PVOID, -- ApcContext: PVOID, -- IoStatus: NTSTATUS, -- IoStatusInformation: ULONG_PTR, -- ) -> NTSTATUS; -- fn ZwSetLdtEntries( -- Selector0: ULONG, -- Entry0Low: ULONG, -- Entry0Hi: ULONG, -- Selector1: ULONG, -- Entry1Low: ULONG, -- Entry1Hi: ULONG, -- ) -> NTSTATUS; -- fn ZwSetLowEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSetLowWaitHighEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSetQuotaInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ) -> NTSTATUS; -- fn ZwSetSecurityObject( -- Handle: HANDLE, -- SecurityInformation: SECURITY_INFORMATION, -- SecurityDescriptor: PSECURITY_DESCRIPTOR, -- ) -> NTSTATUS; -- fn ZwSetSystemEnvironmentValue( -- VariableName: PUNICODE_STRING, -- VariableValue: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwSetSystemEnvironmentValueEx( -- VariableName: PUNICODE_STRING, -- VendorGuid: LPGUID, -- Value: PVOID, -- ValueLength: ULONG, -- Attributes: ULONG, -- ) -> NTSTATUS; -- fn ZwSetSystemInformation( -- SystemInformationClass: SYSTEM_INFORMATION_CLASS, -- SystemInformation: PVOID, -- SystemInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetSystemPowerState( -- SystemAction: POWER_ACTION, -- LightestSystemState: SYSTEM_POWER_STATE, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwSetSystemTime( -- SystemTime: PLARGE_INTEGER, -- PreviousTime: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwSetThreadExecutionState( -- NewFlags: EXECUTION_STATE, -- PreviousFlags: *mut EXECUTION_STATE, -- ) -> NTSTATUS; -- fn ZwSetTimer( -- TimerHandle: HANDLE, -- DueTime: PLARGE_INTEGER, -- TimerApcRoutine: PTIMER_APC_ROUTINE, -- TimerContext: PVOID, -- ResumeTimer: BOOLEAN, -- Period: LONG, -- PreviousState: PBOOLEAN, -- ) -> NTSTATUS; -- fn ZwSetTimer2( -- TimerHandle: HANDLE, -- DueTime: PLARGE_INTEGER, -- Period: PLARGE_INTEGER, -- Parameters: PT2_SET_PARAMETERS, -- ) -> NTSTATUS; -- fn ZwSetTimerEx( -- TimerHandle: HANDLE, -- TimerSetInformationClass: TIMER_SET_INFORMATION_CLASS, -- TimerSetInformation: PVOID, -- TimerSetInformationLength: ULONG, -- ) -> NTSTATUS; -- fn ZwSetTimerResolution( -- DesiredTime: ULONG, -- SetResolution: BOOLEAN, -- ActualTime: PULONG, -- ) -> NTSTATUS; -- fn ZwSetUuidSeed( -- Seed: PCHAR, -- ) -> NTSTATUS; -- fn ZwSetValueKey( -- KeyHandle: HANDLE, -- ValueName: PUNICODE_STRING, -- TitleIndex: ULONG, -- Type: ULONG, -- Data: PVOID, -- DataSize: ULONG, -- ) -> NTSTATUS; -- fn ZwSetVolumeInformationFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- FsInformation: PVOID, -- Length: ULONG, -- FsInformationClass: FS_INFORMATION_CLASS, -- ) -> NTSTATUS; -- fn ZwSetWnfProcessNotificationEvent( -- NotificationEvent: HANDLE, -- ) -> NTSTATUS; -- fn ZwShutdownSystem( -- Action: SHUTDOWN_ACTION, -- ) -> NTSTATUS; -- fn ZwShutdownWorkerFactory( -- WorkerFactoryHandle: HANDLE, -- PendingWorkerCount: *mut LONG, -- ) -> NTSTATUS; -- fn ZwSignalAndWaitForSingleObject( -- SignalHandle: HANDLE, -- WaitHandle: HANDLE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwSinglePhaseReject( -- EnlistmentHandle: HANDLE, -- TmVirtualClock: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwStartProfile( -- ProfileHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwStopProfile( -- ProfileHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSubscribeWnfStateChange( -- StateName: PCWNF_STATE_NAME, -- ChangeStamp: WNF_CHANGE_STAMP, -- EventMask: ULONG, -- SubscriptionId: PULONG64, -- ) -> NTSTATUS; -- fn ZwSuspendProcess( -- ProcessHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwSuspendThread( -- ThreadHandle: HANDLE, -- PreviousSuspendCount: PULONG, -- ) -> NTSTATUS; -- fn ZwSystemDebugControl( -- Command: SYSDBG_COMMAND, -- InputBuffer: PVOID, -- InputBufferLength: ULONG, -- OutputBuffer: PVOID, -- OutputBufferLength: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwTerminateJobObject( -- JobHandle: HANDLE, -- ExitStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn ZwTerminateProcess( -- ProcessHandle: HANDLE, -- ExitStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn ZwTerminateThread( -- ThreadHandle: HANDLE, -- ExitStatus: NTSTATUS, -- ) -> NTSTATUS; -- fn ZwTestAlert() -> NTSTATUS; -- fn ZwThawRegistry() -> NTSTATUS; -- fn ZwThawTransactions() -> NTSTATUS; -- fn ZwTraceControl( -- FunctionCode: ULONG, -- InBuffer: PVOID, -- InBufferLen: ULONG, -- OutBuffer: PVOID, -- OutBufferLen: ULONG, -- ReturnLength: PULONG, -- ) -> NTSTATUS; -- fn ZwTraceEvent( -- TraceHandle: HANDLE, -- Flags: ULONG, -- FieldSize: ULONG, -- Fields: PVOID, -- ) -> NTSTATUS; -- fn ZwTranslateFilePath( -- InputFilePath: PFILE_PATH, -- OutputType: ULONG, -- OutputFilePath: PFILE_PATH, -- OutputFilePathLength: PULONG, -- ) -> NTSTATUS; -- fn ZwUmsThreadYield( -- SchedulerParam: PVOID, -- ) -> NTSTATUS; -- fn ZwUnloadDriver( -- DriverServiceName: PUNICODE_STRING, -- ) -> NTSTATUS; -- fn ZwUnloadKey( -- TargetKey: POBJECT_ATTRIBUTES, -- ) -> NTSTATUS; -- fn ZwUnloadKey2( -- TargetKey: POBJECT_ATTRIBUTES, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwUnloadKeyEx( -- TargetKey: POBJECT_ATTRIBUTES, -- Event: HANDLE, -- ) -> NTSTATUS; -- fn ZwUnlockFile( -- FileHandle: HANDLE, -- IoStatusBlock: PIO_STATUS_BLOCK, -- ByteOffset: PLARGE_INTEGER, -- Length: PLARGE_INTEGER, -- Key: ULONG, -- ) -> NTSTATUS; -- fn ZwUnlockVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: *mut PVOID, -- RegionSize: PSIZE_T, -- MapType: ULONG, -- ) -> NTSTATUS; -- fn ZwUnmapViewOfSection( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- ) -> NTSTATUS; -- fn ZwUnmapViewOfSectionEx( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- Flags: ULONG, -- ) -> NTSTATUS; -- fn ZwUnsubscribeWnfStateChange( -- StateName: PCWNF_STATE_NAME, -- ) -> NTSTATUS; -- fn ZwUpdateWnfStateData( -- StateName: PCWNF_STATE_NAME, -- Buffer: *const VOID, -- Length: ULONG, -- TypeId: PCWNF_TYPE_ID, -- ExplicitScope: *const VOID, -- MatchingChangeStamp: WNF_CHANGE_STAMP, -- CheckStamp: LOGICAL, -- ) -> NTSTATUS; -- fn ZwVdmControl( -- Service: VDMSERVICECLASS, -- ServiceData: PVOID, -- ) -> NTSTATUS; -- fn ZwWaitForAlertByThreadId( -- Address: PVOID, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwWaitForDebugEvent( -- DebugObjectHandle: HANDLE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- WaitStateChange: PVOID, -- ) -> NTSTATUS; -- fn ZwWaitForKeyedEvent( -- KeyedEventHandle: HANDLE, -- KeyValue: PVOID, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwWaitForMultipleObjects( -- Count: ULONG, -- Handles: *mut HANDLE, -- WaitType: WAIT_TYPE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwWaitForMultipleObjects32( -- Count: ULONG, -- Handles: *mut LONG, -- WaitType: WAIT_TYPE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwWaitForSingleObject( -- Handle: HANDLE, -- Alertable: BOOLEAN, -- Timeout: PLARGE_INTEGER, -- ) -> NTSTATUS; -- fn ZwWaitForWorkViaWorkerFactory( -- WorkerFactoryHandle: HANDLE, -- MiniPacket: *mut FILE_IO_COMPLETION_INFORMATION, -- ) -> NTSTATUS; -- fn ZwWaitHighEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwWaitLowEventPair( -- EventPairHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwWorkerFactoryWorkerReady( -- WorkerFactoryHandle: HANDLE, -- ) -> NTSTATUS; -- fn ZwWriteFile( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- Buffer: PVOID, -- Length: ULONG, -- ByteOffset: PLARGE_INTEGER, -- Key: PULONG, -- ) -> NTSTATUS; -- fn ZwWriteFileGather( -- FileHandle: HANDLE, -- Event: HANDLE, -- ApcRoutine: PIO_APC_ROUTINE, -- ApcContext: PVOID, -- IoStatusBlock: PIO_STATUS_BLOCK, -- SegmentArray: PFILE_SEGMENT_ELEMENT, -- Length: ULONG, -- ByteOffset: PLARGE_INTEGER, -- Key: PULONG, -- ) -> NTSTATUS; -- fn ZwWriteRequestData( -- PortHandle: HANDLE, -- Message: PPORT_MESSAGE, -- DataEntryIndex: ULONG, -- Buffer: PVOID, -- BufferSize: SIZE_T, -- NumberOfBytesWritten: PSIZE_T, -- ) -> NTSTATUS; -- fn ZwWriteVirtualMemory( -- ProcessHandle: HANDLE, -- BaseAddress: PVOID, -- Buffer: PVOID, -- BufferSize: SIZE_T, -- NumberOfBytesWritten: PSIZE_T, -- ) -> NTSTATUS; -- fn ZwYieldExecution() -> NTSTATUS; --}} -diff --git a/KubeOS-Rust/vendor/ntapi/src/string.rs b/KubeOS-Rust/vendor/ntapi/src/string.rs -deleted file mode 100644 -index 32bfa502..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/string.rs -+++ /dev/null -@@ -1,58 +0,0 @@ --/// A wrapper over UTF16 string constants. --pub struct UTF16Const(pub &'static [u16]); --impl UTF16Const { -- #[inline] -- pub fn as_ptr(&self) -> *const u16 { -- self.0.as_ptr() -- } -- #[inline] -- pub fn as_mut_ptr(&self) -> *mut u16 { -- self.0.as_ptr() as *mut u16 -- } -- #[inline] -- pub fn len(&self) -> usize { -- self.0.len() - 1 -- } --} --impl AsRef<[u16]> for UTF16Const { -- #[inline] -- fn as_ref(&self) -> &[u16] { -- &self.0[..self.len()] -- } --} --impl Copy for UTF16Const {} --impl Clone for UTF16Const { -- #[inline] -- fn clone(&self) -> UTF16Const { *self } --} --/// A wrapper over UTF8 string constants. --pub struct UTF8Const(pub &'static str); --impl UTF8Const { -- #[inline] -- pub fn as_ptr(&self) -> *const i8 { -- self.0.as_ptr() as *const i8 -- } -- #[inline] -- pub fn as_mut_ptr(&self) -> *mut i8 { -- self.0.as_ptr() as *mut i8 -- } -- #[inline] -- pub fn len(&self) -> usize { -- self.0.len() - 1 -- } -- #[inline] -- pub fn as_str(&self) -> &str { -- &self.0[..self.len()] -- } --} --impl AsRef for UTF8Const { -- #[inline] -- fn as_ref(&self) -> &str { -- &self.0[..self.len()] -- } --} --impl Copy for UTF8Const {} --impl Clone for UTF8Const { -- #[inline] -- fn clone(&self) -> UTF8Const { *self } --} -diff --git a/KubeOS-Rust/vendor/ntapi/src/subprocesstag.rs b/KubeOS-Rust/vendor/ntapi/src/subprocesstag.rs -deleted file mode 100644 -index 7c8d17ce..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/subprocesstag.rs -+++ /dev/null -@@ -1,77 +0,0 @@ --use winapi::shared::minwindef::DWORD; --use winapi::shared::ntdef::{LPCWSTR, LPWSTR, PVOID}; --ENUM!{enum TAG_INFO_LEVEL { -- eTagInfoLevelNameFromTag = 1, -- eTagInfoLevelNamesReferencingModule = 2, -- eTagInfoLevelNameTagMapping = 3, -- eTagInfoLevelMax = 4, --}} --ENUM!{enum TAG_TYPE { -- eTagTypeService = 1, -- eTagTypeMax = 2, --}} --STRUCT!{struct TAG_INFO_NAME_FROM_TAG_IN_PARAMS { -- dwPid: DWORD, -- dwTag: DWORD, --}} --pub type PTAG_INFO_NAME_FROM_TAG_IN_PARAMS = *mut TAG_INFO_NAME_FROM_TAG_IN_PARAMS; --STRUCT!{struct TAG_INFO_NAME_FROM_TAG_OUT_PARAMS { -- eTagType: DWORD, -- pszName: LPWSTR, --}} --pub type PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS = *mut TAG_INFO_NAME_FROM_TAG_OUT_PARAMS; --STRUCT!{struct TAG_INFO_NAME_FROM_TAG { -- InParams: TAG_INFO_NAME_FROM_TAG_IN_PARAMS, -- OutParams: TAG_INFO_NAME_FROM_TAG_OUT_PARAMS, --}} --pub type PTAG_INFO_NAME_FROM_TAG = *mut TAG_INFO_NAME_FROM_TAG; --STRUCT!{struct TAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS { -- dwPid: DWORD, -- pszModule: LPWSTR, --}} --pub type PTAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS = -- *mut TAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS; --STRUCT!{struct TAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS { -- eTagType: DWORD, -- pmszNames: LPWSTR, --}} --pub type PTAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS = -- *mut TAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS; --STRUCT!{struct TAG_INFO_NAMES_REFERENCING_MODULE { -- InParams: TAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS, -- OutParams: TAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS, --}} --pub type PTAG_INFO_NAMES_REFERENCING_MODULE = *mut TAG_INFO_NAMES_REFERENCING_MODULE; --STRUCT!{struct TAG_INFO_NAME_TAG_MAPPING_IN_PARAMS { -- dwPid: DWORD, --}} --pub type PTAG_INFO_NAME_TAG_MAPPING_IN_PARAMS = *mut TAG_INFO_NAME_TAG_MAPPING_IN_PARAMS; --STRUCT!{struct TAG_INFO_NAME_TAG_MAPPING_ELEMENT { -- eTagType: DWORD, -- dwTag: DWORD, -- pszName: LPWSTR, -- pszGroupName: LPWSTR, --}} --pub type PTAG_INFO_NAME_TAG_MAPPING_ELEMENT = *mut TAG_INFO_NAME_TAG_MAPPING_ELEMENT; --STRUCT!{struct TAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS { -- cElements: DWORD, -- pNameTagMappingElements: PTAG_INFO_NAME_TAG_MAPPING_ELEMENT, --}} --pub type PTAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS = *mut TAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS; --STRUCT!{struct TAG_INFO_NAME_TAG_MAPPING { -- InParams: TAG_INFO_NAME_TAG_MAPPING_IN_PARAMS, -- pOutParams: PTAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS, --}} --pub type PTAG_INFO_NAME_TAG_MAPPING = *mut TAG_INFO_NAME_TAG_MAPPING; --EXTERN!{extern "system" { -- fn I_QueryTagInformation( -- pszMachineName: LPCWSTR, -- eInfoLevel: TAG_INFO_LEVEL, -- pTagInfo: PVOID, -- ) -> DWORD; --}} --FN!{stdcall PQUERY_TAG_INFORMATION( -- pszMachineName: LPCWSTR, -- eInfoLevel: TAG_INFO_LEVEL, -- pTagInfo: PVOID, --) -> DWORD} -diff --git a/KubeOS-Rust/vendor/ntapi/src/winapi_local.rs b/KubeOS-Rust/vendor/ntapi/src/winapi_local.rs -deleted file mode 100644 -index 2aa6fdd1..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/winapi_local.rs -+++ /dev/null -@@ -1 +0,0 @@ --pub mod um; -diff --git a/KubeOS-Rust/vendor/ntapi/src/winapi_local/um.rs b/KubeOS-Rust/vendor/ntapi/src/winapi_local/um.rs -deleted file mode 100644 -index 5f862d51..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/winapi_local/um.rs -+++ /dev/null -@@ -1,2 +0,0 @@ --pub(crate) mod winioctl; --pub mod winnt; -diff --git a/KubeOS-Rust/vendor/ntapi/src/winapi_local/um/winioctl.rs b/KubeOS-Rust/vendor/ntapi/src/winapi_local/um/winioctl.rs -deleted file mode 100644 -index da490269..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/winapi_local/um/winioctl.rs -+++ /dev/null -@@ -1,4 +0,0 @@ --#[inline] --pub(crate) const fn CTL_CODE(DeviceType: u32, Function: u32, Method: u32, Access: u32) -> u32 { -- (DeviceType << 16) | (Access << 14) | (Function << 2) | Method --} -diff --git a/KubeOS-Rust/vendor/ntapi/src/winapi_local/um/winnt.rs b/KubeOS-Rust/vendor/ntapi/src/winapi_local/um/winnt.rs -deleted file mode 100644 -index 5c4f7b2f..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/winapi_local/um/winnt.rs -+++ /dev/null -@@ -1,86 +0,0 @@ --#[cfg(all(feature = "beta", not(target_arch = "aarch64")))] --use core::arch::asm; --use winapi::shared::basetsd::{DWORD64, SIZE_T, ULONG64}; --use winapi::shared::minwindef::DWORD; --use winapi::um::winnt::{HANDLE, PVOID}; --#[doc(hidden)] --#[inline] --pub const fn UInt32x32To64(a: u32, b: u32) -> u64 { -- a as u64 * b as u64 --} --#[cfg(all(feature = "beta", not(target_arch = "aarch64")))] --IFDEF!{ --use crate::ntpebteb::TEB; --#[inline] --#[cfg(target_pointer_width = "64")] --pub unsafe fn _bittest64(Base: *const i64, Offset: i64) -> u8 { -- let out: u8; -- asm!( -- "bt {1}, {2}", -- "setb {0}", -- out(reg_byte) out, -- in(reg) Base, -- in(reg) Offset, -- options(nostack, pure, readonly), -- ); -- out --} --#[inline] --pub unsafe fn __readfsdword(Offset: DWORD) -> DWORD { -- let out: u32; -- asm!( -- "mov {:e}, fs:[{:e}]", -- lateout(reg) out, -- in(reg) Offset, -- options(nostack, pure, readonly), -- ); -- out --} --#[inline] --#[cfg(target_pointer_width = "64")] --pub unsafe fn __readgsqword(Offset: DWORD) -> DWORD64 { -- let out: u64; -- asm!( -- "mov {}, gs:[{:e}]", -- lateout(reg) out, -- in(reg) Offset, -- options(nostack, pure, readonly), -- ); -- out --} --#[inline] #[allow(unused_unsafe)] --pub unsafe fn NtCurrentTeb() -> *mut TEB { -- use winapi::um::winnt::NT_TIB; -- let teb_offset = FIELD_OFFSET!(NT_TIB, _Self) as u32; -- #[cfg(target_arch = "x86_64")] { -- __readgsqword(teb_offset) as *mut TEB -- } -- #[cfg(target_arch = "x86")] { -- __readfsdword(teb_offset) as *mut TEB -- } --} --} --ENUM!{enum MEM_EXTENDED_PARAMETER_TYPE { -- MemExtendedParameterInvalidType = 0, -- MemExtendedParameterAddressRequirements = 1, -- MemExtendedParameterNumaNode = 2, -- MemExtendedParameterPartitionHandle = 3, -- MemExtendedParameterMax = 4, --}} --pub type PMEM_EXTENDED_PARAMETER_TYPE = *mut MEM_EXTENDED_PARAMETER_TYPE; --UNION!{union MEM_EXTENDED_PARAMETER_u { -- ULong64: DWORD64, -- Pointer: PVOID, -- Size: SIZE_T, -- Handle: HANDLE, -- ULong: DWORD, --}} --STRUCT!{struct MEM_EXTENDED_PARAMETER { -- BitFields: ULONG64, -- u: MEM_EXTENDED_PARAMETER_u, --}} --BITFIELD!{MEM_EXTENDED_PARAMETER BitFields: ULONG64 [ -- Type set_Type[0..8], -- Reserved set_Reserved[8..64], --]} --pub type PMEM_EXTENDED_PARAMETER = *mut MEM_EXTENDED_PARAMETER; -diff --git a/KubeOS-Rust/vendor/ntapi/src/winsta.rs b/KubeOS-Rust/vendor/ntapi/src/winsta.rs -deleted file mode 100644 -index 162316d0..00000000 ---- a/KubeOS-Rust/vendor/ntapi/src/winsta.rs -+++ /dev/null -@@ -1,848 +0,0 @@ --use core::ptr::null_mut; --use crate::ntrtl::RTL_TIME_ZONE_INFORMATION; --use winapi::shared::basetsd::SIZE_T; --use winapi::shared::minwindef::{BYTE, DWORD, FILETIME}; --use winapi::shared::ntdef::{ -- BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, LONG, PULONG, PVOID, PWSTR, UCHAR, ULONG, UNICODE_STRING, -- USHORT, WCHAR, --}; --use winapi::shared::windef::HWND; --use winapi::um::winnt::{PSID, STANDARD_RIGHTS_REQUIRED}; --pub const WINSTATION_QUERY: u32 = 0x00000001; --pub const WINSTATION_SET: u32 = 0x00000002; --pub const WINSTATION_RESET: u32 = 0x00000004; --pub const WINSTATION_VIRTUAL: u32 = 0x00000008; --pub const WINSTATION_SHADOW: u32 = 0x00000010; --pub const WINSTATION_LOGON: u32 = 0x00000020; --pub const WINSTATION_LOGOFF: u32 = 0x00000040; --pub const WINSTATION_MSG: u32 = 0x00000080; --pub const WINSTATION_CONNECT: u32 = 0x00000100; --pub const WINSTATION_DISCONNECT: u32 = 0x00000200; --pub const WINSTATION_GUEST_ACCESS: u32 = WINSTATION_LOGON; --pub const WINSTATION_CURRENT_GUEST_ACCESS: u32 = WINSTATION_VIRTUAL | WINSTATION_LOGOFF; --pub const WINSTATION_USER_ACCESS: u32 = -- WINSTATION_GUEST_ACCESS | WINSTATION_QUERY | WINSTATION_CONNECT; --pub const WINSTATION_CURRENT_USER_ACCESS: u32 = WINSTATION_SET | WINSTATION_RESET -- | WINSTATION_VIRTUAL | WINSTATION_LOGOFF | WINSTATION_DISCONNECT; --pub const WINSTATION_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | WINSTATION_QUERY | WINSTATION_SET -- | WINSTATION_RESET | WINSTATION_VIRTUAL | WINSTATION_SHADOW | WINSTATION_LOGON | WINSTATION_MSG -- | WINSTATION_CONNECT | WINSTATION_DISCONNECT; --pub const WDPREFIX_LENGTH: usize = 12; --pub const CALLBACK_LENGTH: usize = 50; --pub const DLLNAME_LENGTH: usize = 32; --pub const CDNAME_LENGTH: usize = 32; --pub const WDNAME_LENGTH: usize = 32; --pub const PDNAME_LENGTH: usize = 32; --pub const DEVICENAME_LENGTH: usize = 128; --pub const MODEMNAME_LENGTH: usize = DEVICENAME_LENGTH; --pub const STACK_ADDRESS_LENGTH: usize = 128; --pub const MAX_BR_NAME: usize = 65; --pub const DIRECTORY_LENGTH: usize = 256; --pub const INITIALPROGRAM_LENGTH: usize = 256; --pub const USERNAME_LENGTH: usize = 20; --pub const DOMAIN_LENGTH: usize = 17; --pub const PASSWORD_LENGTH: usize = 14; --pub const NASISPECIFICNAME_LENGTH: usize = 14; --pub const NASIUSERNAME_LENGTH: usize = 47; --pub const NASIPASSWORD_LENGTH: usize = 24; --pub const NASISESSIONNAME_LENGTH: usize = 16; --pub const NASIFILESERVER_LENGTH: usize = 47; --pub const CLIENTDATANAME_LENGTH: usize = 7; --pub const CLIENTNAME_LENGTH: usize = 20; --pub const CLIENTADDRESS_LENGTH: usize = 30; --pub const IMEFILENAME_LENGTH: usize = 32; --pub const CLIENTLICENSE_LENGTH: usize = 32; --pub const CLIENTMODEM_LENGTH: usize = 40; --pub const CLIENT_PRODUCT_ID_LENGTH: usize = 32; --pub const MAX_COUNTER_EXTENSIONS: u32 = 2; --pub const WINSTATIONNAME_LENGTH: usize = 32; --pub const TERMSRV_TOTAL_SESSIONS: u32 = 1; --pub const TERMSRV_DISC_SESSIONS: u32 = 2; --pub const TERMSRV_RECON_SESSIONS: u32 = 3; --pub const TERMSRV_CURRENT_ACTIVE_SESSIONS: u32 = 4; --pub const TERMSRV_CURRENT_DISC_SESSIONS: u32 = 5; --pub const TERMSRV_PENDING_SESSIONS: u32 = 6; --pub const TERMSRV_SUCC_TOTAL_LOGONS: u32 = 7; --pub const TERMSRV_SUCC_LOCAL_LOGONS: u32 = 8; --pub const TERMSRV_SUCC_REMOTE_LOGONS: u32 = 9; --pub const TERMSRV_SUCC_SESSION0_LOGONS: u32 = 10; --pub const TERMSRV_CURRENT_TERMINATING_SESSIONS: u32 = 11; --pub const TERMSRV_CURRENT_LOGGEDON_SESSIONS: u32 = 12; --pub type PTS_TIME_ZONE_INFORMATION = *mut RTL_TIME_ZONE_INFORMATION; --pub type TS_TIME_ZONE_INFORMATION = RTL_TIME_ZONE_INFORMATION; --pub type WINSTATIONNAME = [WCHAR; WINSTATIONNAME_LENGTH + 1]; --STRUCT!{struct VARDATA_WIRE { -- Size: USHORT, -- Offset: USHORT, --}} --pub type PVARDATA_WIRE = *mut VARDATA_WIRE; --ENUM!{enum WINSTATIONSTATECLASS { -- State_Active = 0, -- State_Connected = 1, -- State_ConnectQuery = 2, -- State_Shadow = 3, -- State_Disconnected = 4, -- State_Idle = 5, -- State_Listen = 6, -- State_Reset = 7, -- State_Down = 8, -- State_Init = 9, --}} --UNION!{union SESSIONIDW_u { -- SessionId: ULONG, -- LogonId: ULONG, --}} --STRUCT!{struct SESSIONIDW { -- u: SESSIONIDW_u, -- WinStationName: WINSTATIONNAME, -- State: WINSTATIONSTATECLASS, --}} --pub type PSESSIONIDW = *mut SESSIONIDW; --ENUM!{enum WINSTATIONINFOCLASS { -- WinStationCreateData = 0, -- WinStationConfiguration = 1, -- WinStationPdParams = 2, -- WinStationWd = 3, -- WinStationPd = 4, -- WinStationPrinter = 5, -- WinStationClient = 6, -- WinStationModules = 7, -- WinStationInformation = 8, -- WinStationTrace = 9, -- WinStationBeep = 10, -- WinStationEncryptionOff = 11, -- WinStationEncryptionPerm = 12, -- WinStationNtSecurity = 13, -- WinStationUserToken = 14, -- WinStationUnused1 = 15, -- WinStationVideoData = 16, -- WinStationInitialProgram = 17, -- WinStationCd = 18, -- WinStationSystemTrace = 19, -- WinStationVirtualData = 20, -- WinStationClientData = 21, -- WinStationSecureDesktopEnter = 22, -- WinStationSecureDesktopExit = 23, -- WinStationLoadBalanceSessionTarget = 24, -- WinStationLoadIndicator = 25, -- WinStationShadowInfo = 26, -- WinStationDigProductId = 27, -- WinStationLockedState = 28, -- WinStationRemoteAddress = 29, -- WinStationIdleTime = 30, -- WinStationLastReconnectType = 31, -- WinStationDisallowAutoReconnect = 32, -- WinStationMprNotifyInfo = 33, -- WinStationExecSrvSystemPipe = 34, -- WinStationSmartCardAutoLogon = 35, -- WinStationIsAdminLoggedOn = 36, -- WinStationReconnectedFromId = 37, -- WinStationEffectsPolicy = 38, -- WinStationType = 39, -- WinStationInformationEx = 40, -- WinStationValidationInfo = 41, --}} --STRUCT!{struct WINSTATIONCREATE { -- Bitfields: ULONG, -- MaxInstanceCount: ULONG, --}} --BITFIELD!{WINSTATIONCREATE Bitfields: ULONG [ -- fEnableWinStation set_fEnableWinStation[0..1], --]} --pub type PWINSTATIONCREATE = *mut WINSTATIONCREATE; --STRUCT!{struct WINSTACONFIGWIRE { -- Comment: [WCHAR; 61], -- OEMId: [CHAR; 4], -- UserConfig: VARDATA_WIRE, -- NewFields: VARDATA_WIRE, --}} --pub type PWINSTACONFIGWIRE = *mut WINSTACONFIGWIRE; --ENUM!{enum CALLBACKCLASS { -- Callback_Disable = 0, -- Callback_Roving = 1, -- Callback_Fixed = 2, --}} --ENUM!{enum SHADOWCLASS { -- Shadow_Disable = 0, -- Shadow_EnableInputNotify = 1, -- Shadow_EnableInputNoNotify = 2, -- Shadow_EnableNoInputNotify = 3, -- Shadow_EnableNoInputNoNotify = 4, --}} --STRUCT!{struct USERCONFIG { -- Bitfields: ULONG, -- Bitfields2: ULONG, -- UserName: [WCHAR; USERNAME_LENGTH + 1], -- Domain: [WCHAR; DOMAIN_LENGTH + 1], -- Password: [WCHAR; PASSWORD_LENGTH + 1], -- WorkDirectory: [WCHAR; DIRECTORY_LENGTH + 1], -- InitialProgram: [WCHAR; INITIALPROGRAM_LENGTH + 1], -- CallbackNumber: [WCHAR; CALLBACK_LENGTH + 1], -- Callback: CALLBACKCLASS, -- Shadow: SHADOWCLASS, -- MaxConnectionTime: ULONG, -- MaxDisconnectionTime: ULONG, -- MaxIdleTime: ULONG, -- KeyboardLayout: ULONG, -- MinEncryptionLevel: BYTE, -- NWLogonServer: [WCHAR; NASIFILESERVER_LENGTH + 1], -- PublishedName: [WCHAR; MAX_BR_NAME], -- WFProfilePath: [WCHAR; DIRECTORY_LENGTH + 1], -- WFHomeDir: [WCHAR; DIRECTORY_LENGTH + 1], -- WFHomeDirDrive: [WCHAR; 4], --}} --BITFIELD!{USERCONFIG Bitfields: ULONG [ -- fInheritAutoLogon set_fInheritAutoLogon[0..1], -- fInheritResetBroken set_fInheritResetBroken[1..2], -- fInheritReconnectSame set_fInheritReconnectSame[2..3], -- fInheritInitialProgram set_fInheritInitialProgram[3..4], -- fInheritCallback set_fInheritCallback[4..5], -- fInheritCallbackNumber set_fInheritCallbackNumber[5..6], -- fInheritShadow set_fInheritShadow[6..7], -- fInheritMaxSessionTime set_fInheritMaxSessionTime[7..8], -- fInheritMaxDisconnectionTime set_fInheritMaxDisconnectionTime[8..9], -- fInheritMaxIdleTime set_fInheritMaxIdleTime[9..10], -- fInheritAutoClient set_fInheritAutoClient[10..11], -- fInheritSecurity set_fInheritSecurity[11..12], -- fPromptForPassword set_fPromptForPassword[12..13], -- fResetBroken set_fResetBroken[13..14], -- fReconnectSame set_fReconnectSame[14..15], -- fLogonDisabled set_fLogonDisabled[15..16], -- fWallPaperDisabled set_fWallPaperDisabled[16..17], -- fAutoClientDrives set_fAutoClientDrives[17..18], -- fAutoClientLpts set_fAutoClientLpts[18..19], -- fForceClientLptDef set_fForceClientLptDef[19..20], -- fRequireEncryption set_fRequireEncryption[20..21], -- fDisableEncryption set_fDisableEncryption[21..22], -- fUnused1 set_fUnused1[22..23], -- fHomeDirectoryMapRoot set_fHomeDirectoryMapRoot[23..24], -- fUseDefaultGina set_fUseDefaultGina[24..25], -- fCursorBlinkDisabled set_fCursorBlinkDisabled[25..26], -- fPublishedApp set_fPublishedApp[26..27], -- fHideTitleBar set_fHideTitleBar[27..28], -- fMaximize set_fMaximize[28..29], -- fDisableCpm set_fDisableCpm[29..30], -- fDisableCdm set_fDisableCdm[30..31], -- fDisableCcm set_fDisableCcm[31..32], --]} --BITFIELD!{USERCONFIG Bitfields2: ULONG [ -- fDisableLPT set_fDisableLPT[0..1], -- fDisableClip set_fDisableClip[1..2], -- fDisableExe set_fDisableExe[2..3], -- fDisableCam set_fDisableCam[3..4], -- fDisableAutoReconnect set_fDisableAutoReconnect[4..5], -- ColorDepth set_ColorDepth[5..6], -- fInheritColorDepth set_fInheritColorDepth[6..7], -- fErrorInvalidProfile set_fErrorInvalidProfile[7..8], -- fPasswordIsScPin set_fPasswordIsScPin[8..9], -- fDisablePNPRedir set_fDisablePNPRedir[9..10], --]} --pub type PUSERCONFIG = *mut USERCONFIG; --ENUM!{enum SDCLASS { -- SdNone = 0, -- SdConsole = 1, -- SdNetwork = 2, -- SdAsync = 3, -- SdOemTransport = 4, --}} --pub type DEVICENAME = [WCHAR; DEVICENAME_LENGTH + 1]; --pub type MODEMNAME = [WCHAR; MODEMNAME_LENGTH + 1]; --pub type NASISPECIFICNAME = [WCHAR; NASISPECIFICNAME_LENGTH + 1]; --pub type NASIUSERNAME = [WCHAR; NASIUSERNAME_LENGTH + 1]; --pub type NASIPASSWORD = [WCHAR; NASIPASSWORD_LENGTH + 1]; --pub type NASISESIONNAME = [WCHAR; NASISESSIONNAME_LENGTH + 1]; --pub type NASIFILESERVER = [WCHAR; NASIFILESERVER_LENGTH + 1]; --pub type WDNAME = [WCHAR; WDNAME_LENGTH + 1]; --pub type WDPREFIX = [WCHAR; WDPREFIX_LENGTH + 1]; --pub type CDNAME = [WCHAR; CDNAME_LENGTH + 1]; --pub type DLLNAME = [WCHAR; DLLNAME_LENGTH + 1]; --pub type PDNAME = [WCHAR; PDNAME_LENGTH + 1]; --STRUCT!{struct NETWORKCONFIG { -- LanAdapter: LONG, -- NetworkName: DEVICENAME, -- Flags: ULONG, --}} --pub type PNETWORKCONFIG = *mut NETWORKCONFIG; --ENUM!{enum FLOWCONTROLCLASS { -- FlowControl_None = 0, -- FlowControl_Hardware = 1, -- FlowControl_Software = 2, --}} --ENUM!{enum RECEIVEFLOWCONTROLCLASS { -- ReceiveFlowControl_None = 0, -- ReceiveFlowControl_RTS = 1, -- ReceiveFlowControl_DTR = 2, --}} --ENUM!{enum TRANSMITFLOWCONTROLCLASS { -- TransmitFlowControl_None = 0, -- TransmitFlowControl_CTS = 1, -- TransmitFlowControl_DSR = 2, --}} --ENUM!{enum ASYNCCONNECTCLASS { -- Connect_CTS = 0, -- Connect_DSR = 1, -- Connect_RI = 2, -- Connect_DCD = 3, -- Connect_FirstChar = 4, -- Connect_Perm = 5, --}} --STRUCT!{struct FLOWCONTROLCONFIG { -- Bitfields: ULONG, -- XonChar: CHAR, -- XoffChar: CHAR, -- Type: FLOWCONTROLCLASS, -- HardwareReceive: RECEIVEFLOWCONTROLCLASS, -- HardwareTransmit: TRANSMITFLOWCONTROLCLASS, --}} --BITFIELD!{FLOWCONTROLCONFIG Bitfields: ULONG [ -- fEnableSoftwareTx set_fEnableSoftwareTx[0..1], -- fEnableSoftwareRx set_fEnableSoftwareRx[1..2], -- fEnableDTR set_fEnableDTR[2..3], -- fEnableRTS set_fEnableRTS[3..4], --]} --pub type PFLOWCONTROLCONFIG = *mut FLOWCONTROLCONFIG; --STRUCT!{struct CONNECTCONFIG { -- Type: ASYNCCONNECTCLASS, -- Bitfields: ULONG, --}} --BITFIELD!{CONNECTCONFIG Bitfields: ULONG [ -- fEnableBreakDisconnect set_fEnableBreakDisconnect[0..1], --]} --pub type PCONNECTCONFIG = *mut CONNECTCONFIG; --STRUCT!{struct ASYNCCONFIG { -- DeviceName: DEVICENAME, -- ModemName: MODEMNAME, -- BaudRate: ULONG, -- Parity: ULONG, -- StopBits: ULONG, -- ByteSize: ULONG, -- Bitfields: ULONG, -- FlowControl: FLOWCONTROLCONFIG, -- Connect: CONNECTCONFIG, --}} --BITFIELD!{ASYNCCONFIG Bitfields: ULONG [ -- fEnableDsrSensitivity set_fEnableDsrSensitivity[0..1], -- fConnectionDriver set_fConnectionDriver[1..2], --]} --pub type PASYNCCONFIG = *mut ASYNCCONFIG; --STRUCT!{struct NASICONFIG { -- SpecificName: NASISPECIFICNAME, -- UserName: NASIUSERNAME, -- PassWord: NASIPASSWORD, -- SessionName: NASISESIONNAME, -- FileServer: NASIFILESERVER, -- GlobalSession: BOOLEAN, --}} --pub type PNASICONFIG = *mut NASICONFIG; --STRUCT!{struct OEMTDCONFIG { -- Adapter: LONG, -- DeviceName: DEVICENAME, -- Flags: ULONG, --}} --pub type POEMTDCONFIG = *mut OEMTDCONFIG; --UNION!{union PDPARAMS_u { -- Network: NETWORKCONFIG, -- Async: ASYNCCONFIG, -- Nasi: NASICONFIG, -- OemTd: OEMTDCONFIG, --}} --STRUCT!{struct PDPARAMS { -- SdClass: SDCLASS, -- u: PDPARAMS_u, --}} --pub type PPDPARAMS = *mut PDPARAMS; --STRUCT!{struct WDCONFIG { -- WdName: WDNAME, -- WdDLL: DLLNAME, -- WsxDLL: DLLNAME, -- WdFlag: ULONG, -- WdInputBufferLength: ULONG, -- CfgDLL: DLLNAME, -- WdPrefix: WDPREFIX, --}} --pub type PWDCONFIG = *mut WDCONFIG; --STRUCT!{struct PDCONFIG2 { -- PdName: PDNAME, -- SdClass: SDCLASS, -- PdDLL: DLLNAME, -- PdFlag: ULONG, -- OutBufLength: ULONG, -- OutBufCount: ULONG, -- OutBufDelay: ULONG, -- InteractiveDelay: ULONG, -- PortNumber: ULONG, -- KeepAliveTimeout: ULONG, --}} --pub type PPDCONFIG2 = *mut PDCONFIG2; --STRUCT!{struct WINSTATIONCLIENT { -- Bitfields: ULONG, -- ClientName: [WCHAR; CLIENTNAME_LENGTH + 1], -- Domain: [WCHAR; DOMAIN_LENGTH + 1], -- UserName: [WCHAR; USERNAME_LENGTH + 1], -- Password: [WCHAR; PASSWORD_LENGTH + 1], -- WorkDirectory: [WCHAR; DIRECTORY_LENGTH + 1], -- InitialProgram: [WCHAR; INITIALPROGRAM_LENGTH + 1], -- SerialNumber: ULONG, -- EncryptionLevel: BYTE, -- ClientAddressFamily: ULONG, -- ClientAddress: [WCHAR; CLIENTADDRESS_LENGTH + 1], -- HRes: USHORT, -- VRes: USHORT, -- ColorDepth: USHORT, -- ProtocolType: USHORT, -- KeyboardLayout: ULONG, -- KeyboardType: ULONG, -- KeyboardSubType: ULONG, -- KeyboardFunctionKey: ULONG, -- ImeFileName: [WCHAR; IMEFILENAME_LENGTH + 1], -- ClientDirectory: [WCHAR; DIRECTORY_LENGTH + 1], -- ClientLicense: [WCHAR; CLIENTLICENSE_LENGTH + 1], -- ClientModem: [WCHAR; CLIENTMODEM_LENGTH + 1], -- ClientBuildNumber: ULONG, -- ClientHardwareId: ULONG, -- ClientProductId: USHORT, -- OutBufCountHost: USHORT, -- OutBufCountClient: USHORT, -- OutBufLength: USHORT, -- AudioDriverName: [WCHAR; 9], -- ClientTimeZone: TS_TIME_ZONE_INFORMATION, -- ClientSessionId: ULONG, -- ClientDigProductId: [WCHAR; CLIENT_PRODUCT_ID_LENGTH], -- PerformanceFlags: ULONG, -- ActiveInputLocale: ULONG, --}} --BITFIELD!{WINSTATIONCLIENT Bitfields: ULONG [ -- fTextOnly set_fTextOnly[0..1], -- fDisableCtrlAltDel set_fDisableCtrlAltDel[1..2], -- fMouse set_fMouse[2..3], -- fDoubleClickDetect set_fDoubleClickDetect[3..4], -- fINetClient set_fINetClient[4..5], -- fPromptForPassword set_fPromptForPassword[5..6], -- fMaximizeShell set_fMaximizeShell[6..7], -- fEnableWindowsKey set_fEnableWindowsKey[7..8], -- fRemoteConsoleAudio set_fRemoteConsoleAudio[8..9], -- fPasswordIsScPin set_fPasswordIsScPin[9..10], -- fNoAudioPlayback set_fNoAudioPlayback[10..11], -- fUsingSavedCreds set_fUsingSavedCreds[11..12], --]} --pub type PWINSTATIONCLIENT = *mut WINSTATIONCLIENT; --STRUCT!{struct TSHARE_COUNTERS { -- Reserved: ULONG, --}} --pub type PTSHARE_COUNTERS = *mut TSHARE_COUNTERS; --UNION!{union PROTOCOLCOUNTERS_Specific { -- TShareCounters: TSHARE_COUNTERS, -- Reserved: [ULONG; 100], --}} --STRUCT!{struct PROTOCOLCOUNTERS { -- WdBytes: ULONG, -- WdFrames: ULONG, -- WaitForOutBuf: ULONG, -- Frames: ULONG, -- Bytes: ULONG, -- CompressedBytes: ULONG, -- CompressFlushes: ULONG, -- Errors: ULONG, -- Timeouts: ULONG, -- AsyncFramingError: ULONG, -- AsyncOverrunError: ULONG, -- AsyncOverflowError: ULONG, -- AsyncParityError: ULONG, -- TdErrors: ULONG, -- ProtocolType: USHORT, -- Length: USHORT, -- Specific: PROTOCOLCOUNTERS_Specific, --}} --pub type PPROTOCOLCOUNTERS = *mut PROTOCOLCOUNTERS; --STRUCT!{struct THINWIRECACHE { -- CacheReads: ULONG, -- CacheHits: ULONG, --}} --pub type PTHINWIRECACHE = *mut THINWIRECACHE; --pub const MAX_THINWIRECACHE: usize = 4; --STRUCT!{struct RESERVED_CACHE { -- ThinWireCache: [THINWIRECACHE; MAX_THINWIRECACHE], --}} --pub type PRESERVED_CACHE = *mut RESERVED_CACHE; --STRUCT!{struct TSHARE_CACHE { -- Reserved: ULONG, --}} --pub type PTSHARE_CACHE = *mut TSHARE_CACHE; --UNION!{union CACHE_STATISTICS_Specific { -- ReservedCacheStats: RESERVED_CACHE, -- TShareCacheStats: TSHARE_CACHE, -- Reserved: [ULONG; 20], --}} --STRUCT!{struct CACHE_STATISTICS { -- ProtocolType: USHORT, -- Length: USHORT, -- Specific: CACHE_STATISTICS_Specific, --}} --pub type PCACHE_STATISTICS = *mut CACHE_STATISTICS; --STRUCT!{struct PROTOCOLSTATUS { -- Output: PROTOCOLCOUNTERS, -- Input: PROTOCOLCOUNTERS, -- Cache: CACHE_STATISTICS, -- AsyncSignal: ULONG, -- AsyncSignalMask: ULONG, --}} --pub type PPROTOCOLSTATUS = *mut PROTOCOLSTATUS; --STRUCT!{struct WINSTATIONINFORMATION { -- ConnectState: WINSTATIONSTATECLASS, -- WinStationName: WINSTATIONNAME, -- LogonId: ULONG, -- ConnectTime: LARGE_INTEGER, -- DisconnectTime: LARGE_INTEGER, -- LastInputTime: LARGE_INTEGER, -- LogonTime: LARGE_INTEGER, -- Status: PROTOCOLSTATUS, -- Domain: [WCHAR; DOMAIN_LENGTH + 1], -- UserName: [WCHAR; USERNAME_LENGTH + 1], -- CurrentTime: LARGE_INTEGER, --}} --pub type PWINSTATIONINFORMATION = *mut WINSTATIONINFORMATION; --STRUCT!{struct WINSTATIONUSERTOKEN { -- ProcessId: HANDLE, -- ThreadId: HANDLE, -- UserToken: HANDLE, --}} --pub type PWINSTATIONUSERTOKEN = *mut WINSTATIONUSERTOKEN; --STRUCT!{struct WINSTATIONVIDEODATA { -- HResolution: USHORT, -- VResolution: USHORT, -- fColorDepth: USHORT, --}} --pub type PWINSTATIONVIDEODATA = *mut WINSTATIONVIDEODATA; --ENUM!{enum CDCLASS { -- CdNone = 0, -- CdModem = 1, -- CdClass_Maximum = 2, --}} --STRUCT!{struct CDCONFIG { -- CdClass: CDCLASS, -- CdName: CDNAME, -- CdDLL: DLLNAME, -- CdFlag: ULONG, --}} --pub type PCDCONFIG = *mut CDCONFIG; --pub type CLIENTDATANAME = [CHAR; CLIENTDATANAME_LENGTH + 1]; --pub type PCLIENTDATANAME = *mut CHAR; --STRUCT!{struct WINSTATIONCLIENTDATA { -- DataName: CLIENTDATANAME, -- fUnicodeData: BOOLEAN, --}} --pub type PWINSTATIONCLIENTDATA = *mut WINSTATIONCLIENTDATA; --ENUM!{enum LOADFACTORTYPE { -- ErrorConstraint = 0, -- PagedPoolConstraint = 1, -- NonPagedPoolConstraint = 2, -- AvailablePagesConstraint = 3, -- SystemPtesConstraint = 4, -- CPUConstraint = 5, --}} --STRUCT!{struct WINSTATIONLOADINDICATORDATA { -- RemainingSessionCapacity: ULONG, -- LoadFactor: LOADFACTORTYPE, -- TotalSessions: ULONG, -- DisconnectedSessions: ULONG, -- IdleCPU: LARGE_INTEGER, -- TotalCPU: LARGE_INTEGER, -- RawSessionCapacity: ULONG, -- reserved: [ULONG; 9], --}} --pub type PWINSTATIONLOADINDICATORDATA = *mut WINSTATIONLOADINDICATORDATA; --ENUM!{enum SHADOWSTATECLASS { -- State_NoShadow = 0, -- State_Shadowing = 1, -- State_Shadowed = 2, --}} --STRUCT!{struct WINSTATIONSHADOW { -- ShadowState: SHADOWSTATECLASS, -- ShadowClass: SHADOWCLASS, -- SessionId: ULONG, -- ProtocolType: ULONG, --}} --pub type PWINSTATIONSHADOW = *mut WINSTATIONSHADOW; --STRUCT!{struct WINSTATIONPRODID { -- DigProductId: [WCHAR; CLIENT_PRODUCT_ID_LENGTH], -- ClientDigProductId: [WCHAR; CLIENT_PRODUCT_ID_LENGTH], -- OuterMostDigProductId: [WCHAR; CLIENT_PRODUCT_ID_LENGTH], -- CurrentSessionId: ULONG, -- ClientSessionId: ULONG, -- OuterMostSessionId: ULONG, --}} --pub type PWINSTATIONPRODID = *mut WINSTATIONPRODID; --STRUCT!{struct WINSTATIONREMOTEADDRESS_u_ipv4 { -- sin_port: USHORT, -- sin_addr: ULONG, -- sin_zero: [UCHAR; 8], --}} --STRUCT!{struct WINSTATIONREMOTEADDRESS_u_ipv6 { -- sin6_port: USHORT, -- sin6_flowinfo: ULONG, -- sin6_addr: [USHORT; 8], -- sin6_scope_id: ULONG, --}} --UNION!{union WINSTATIONREMOTEADDRESS_u { -- ipv4: WINSTATIONREMOTEADDRESS_u_ipv4, -- ipv6: WINSTATIONREMOTEADDRESS_u_ipv6, --}} --STRUCT!{struct WINSTATIONREMOTEADDRESS { -- sin_family: USHORT, -- u: WINSTATIONREMOTEADDRESS_u, --}} --pub type PWINSTATIONREMOTEADDRESS = *mut WINSTATIONREMOTEADDRESS; --STRUCT!{struct WINSTATIONINFORMATIONEX_LEVEL1 { -- SessionId: ULONG, -- SessionState: WINSTATIONSTATECLASS, -- SessionFlags: LONG, -- WinStationName: WINSTATIONNAME, -- UserName: [WCHAR; USERNAME_LENGTH + 1], -- DomainName: [WCHAR; DOMAIN_LENGTH + 1], -- LogonTime: LARGE_INTEGER, -- ConnectTime: LARGE_INTEGER, -- DisconnectTime: LARGE_INTEGER, -- LastInputTime: LARGE_INTEGER, -- CurrentTime: LARGE_INTEGER, -- ProtocolStatus: PROTOCOLSTATUS, --}} --pub type PWINSTATIONINFORMATIONEX_LEVEL1 = *mut WINSTATIONINFORMATIONEX_LEVEL1; --STRUCT!{struct WINSTATIONINFORMATIONEX_LEVEL2 { -- SessionId: ULONG, -- SessionState: WINSTATIONSTATECLASS, -- SessionFlags: LONG, -- WinStationName: WINSTATIONNAME, -- SamCompatibleUserName: [WCHAR; USERNAME_LENGTH + 1], -- SamCompatibleDomainName: [WCHAR; DOMAIN_LENGTH + 1], -- LogonTime: LARGE_INTEGER, -- ConnectTime: LARGE_INTEGER, -- DisconnectTime: LARGE_INTEGER, -- LastInputTime: LARGE_INTEGER, -- CurrentTime: LARGE_INTEGER, -- ProtocolStatus: PROTOCOLSTATUS, -- UserName: [WCHAR; 257], -- DomainName: [WCHAR; 256], --}} --pub type PWINSTATIONINFORMATIONEX_LEVEL2 = *mut WINSTATIONINFORMATIONEX_LEVEL2; --UNION!{union WINSTATIONINFORMATIONEX_LEVEL { -- WinStationInfoExLevel1: WINSTATIONINFORMATIONEX_LEVEL1, -- WinStationInfoExLevel2: WINSTATIONINFORMATIONEX_LEVEL2, --}} --pub type PWINSTATIONINFORMATIONEX_LEVEL = *mut WINSTATIONINFORMATIONEX_LEVEL; --STRUCT!{struct WINSTATIONINFORMATIONEX { -- Level: ULONG, -- Data: WINSTATIONINFORMATIONEX_LEVEL, --}} --pub type PWINSTATIONINFORMATIONEX = *mut WINSTATIONINFORMATIONEX; --pub const TS_PROCESS_INFO_MAGIC_NT4: u32 = 0x23495452; --STRUCT!{struct TS_PROCESS_INFORMATION_NT4 { -- MagicNumber: ULONG, -- LogonId: ULONG, -- ProcessSid: PVOID, -- Pad: ULONG, --}} --pub type PTS_PROCESS_INFORMATION_NT4 = *mut TS_PROCESS_INFORMATION_NT4; --pub const SIZEOF_TS4_SYSTEM_THREAD_INFORMATION: u32 = 64; --pub const SIZEOF_TS4_SYSTEM_PROCESS_INFORMATION: u32 = 136; --STRUCT!{struct TS_SYS_PROCESS_INFORMATION { -- NextEntryOffset: ULONG, -- NumberOfThreads: ULONG, -- SpareLi1: LARGE_INTEGER, -- SpareLi2: LARGE_INTEGER, -- SpareLi3: LARGE_INTEGER, -- CreateTime: LARGE_INTEGER, -- UserTime: LARGE_INTEGER, -- KernelTime: LARGE_INTEGER, -- ImageName: UNICODE_STRING, -- BasePriority: LONG, -- UniqueProcessId: ULONG, -- InheritedFromUniqueProcessId: ULONG, -- HandleCount: ULONG, -- SessionId: ULONG, -- SpareUl3: ULONG, -- PeakVirtualSize: SIZE_T, -- VirtualSize: SIZE_T, -- PageFaultCount: ULONG, -- PeakWorkingSetSize: ULONG, -- WorkingSetSize: ULONG, -- QuotaPeakPagedPoolUsage: SIZE_T, -- QuotaPagedPoolUsage: SIZE_T, -- QuotaPeakNonPagedPoolUsage: SIZE_T, -- QuotaNonPagedPoolUsage: SIZE_T, -- PagefileUsage: SIZE_T, -- PeakPagefileUsage: SIZE_T, -- PrivatePageCount: SIZE_T, --}} --pub type PTS_SYS_PROCESS_INFORMATION = *mut TS_SYS_PROCESS_INFORMATION; --STRUCT!{struct TS_ALL_PROCESSES_INFO { -- pTsProcessInfo: PTS_SYS_PROCESS_INFORMATION, -- SizeOfSid: ULONG, -- pSid: PSID, --}} --pub type PTS_ALL_PROCESSES_INFO = *mut TS_ALL_PROCESSES_INFO; --STRUCT!{struct TS_COUNTER_HEADER { -- dwCounterID: DWORD, -- bResult: BOOLEAN, --}} --pub type PTS_COUNTER_HEADER = *mut TS_COUNTER_HEADER; --STRUCT!{struct TS_COUNTER { -- CounterHead: TS_COUNTER_HEADER, -- dwValue: DWORD, -- StartTime: LARGE_INTEGER, --}} --pub type PTS_COUNTER = *mut TS_COUNTER; --pub const WSD_LOGOFF: ULONG = 0x1; --pub const WSD_SHUTDOWN: ULONG = 0x2; --pub const WSD_REBOOT: ULONG = 0x4; --pub const WSD_POWEROFF: ULONG = 0x8; --pub const WEVENT_NONE: ULONG = 0x0; --pub const WEVENT_CREATE: ULONG = 0x1; --pub const WEVENT_DELETE: ULONG = 0x2; --pub const WEVENT_RENAME: ULONG = 0x4; --pub const WEVENT_CONNECT: ULONG = 0x8; --pub const WEVENT_DISCONNECT: ULONG = 0x10; --pub const WEVENT_LOGON: ULONG = 0x20; --pub const WEVENT_LOGOFF: ULONG = 0x40; --pub const WEVENT_STATECHANGE: ULONG = 0x80; --pub const WEVENT_LICENSE: ULONG = 0x100; --pub const WEVENT_ALL: ULONG = 0x7fffffff; --pub const WEVENT_FLUSH: ULONG = 0x80000000; --pub const KBDSHIFT: USHORT = 0x1; --pub const KBDCTRL: USHORT = 0x2; --pub const KBDALT: USHORT = 0x4; --pub const WNOTIFY_ALL_SESSIONS: ULONG = 0x1; --pub const LOGONID_CURRENT: i32 = -1; --pub const SERVERNAME_CURRENT: PWSTR = null_mut(); --EXTERN!{extern "system" { -- fn WinStationFreeMemory( -- Buffer: PVOID, -- ) -> BOOLEAN; -- fn WinStationOpenServerW( -- ServerName: PWSTR, -- ) -> HANDLE; -- fn WinStationCloseServer( -- ServerHandle: HANDLE, -- ) -> BOOLEAN; -- fn WinStationServerPing( -- ServerHandle: HANDLE, -- ) -> BOOLEAN; -- fn WinStationGetTermSrvCountersValue( -- ServerHandle: HANDLE, -- Count: ULONG, -- Counters: PTS_COUNTER, -- ) -> BOOLEAN; -- fn WinStationShutdownSystem( -- ServerHandle: HANDLE, -- ShutdownFlags: ULONG, -- ) -> BOOLEAN; -- fn WinStationWaitSystemEvent( -- ServerHandle: HANDLE, -- EventMask: ULONG, -- EventFlags: PULONG, -- ) -> BOOLEAN; -- fn WinStationRegisterConsoleNotification( -- ServerHandle: HANDLE, -- WindowHandle: HWND, -- Flags: ULONG, -- ) -> BOOLEAN; -- fn WinStationUnRegisterConsoleNotification( -- ServerHandle: HANDLE, -- WindowHandle: HWND, -- ) -> BOOLEAN; -- fn WinStationEnumerateW( -- ServerHandle: HANDLE, -- SessionIds: *mut PSESSIONIDW, -- Count: PULONG, -- ) -> BOOLEAN; -- fn WinStationQueryInformationW( -- ServerHandle: HANDLE, -- SessionId: ULONG, -- WinStationInformationClass: WINSTATIONINFOCLASS, -- pWinStationInformation: PVOID, -- WinStationInformationLength: ULONG, -- pReturnLength: PULONG, -- ) -> BOOLEAN; -- fn WinStationSetInformationW( -- ServerHandle: HANDLE, -- SessionId: ULONG, -- WinStationInformationClass: WINSTATIONINFOCLASS, -- pWinStationInformation: PVOID, -- WinStationInformationLength: ULONG, -- ) -> BOOLEAN; -- fn WinStationNameFromLogonIdW( -- ServerHandle: HANDLE, -- SessionId: ULONG, -- pWinStationName: PWSTR, -- ) -> BOOLEAN; -- fn WinStationSendMessageW( -- ServerHandle: HANDLE, -- SessionId: ULONG, -- Title: PWSTR, -- TitleLength: ULONG, -- Message: PWSTR, -- MessageLength: ULONG, -- Style: ULONG, -- Timeout: ULONG, -- Response: PULONG, -- DoNotWait: BOOLEAN, -- ) -> BOOLEAN; -- fn WinStationConnectW( -- ServerHandle: HANDLE, -- SessionId: ULONG, -- TargetSessionId: ULONG, -- pPassword: PWSTR, -- bWait: BOOLEAN, -- ) -> BOOLEAN; -- fn WinStationDisconnect( -- ServerHandle: HANDLE, -- SessionId: ULONG, -- bWait: BOOLEAN, -- ) -> BOOLEAN; -- fn WinStationReset( -- ServerHandle: HANDLE, -- SessionId: ULONG, -- bWait: BOOLEAN, -- ) -> BOOLEAN; -- fn WinStationShadow( -- ServerHandle: HANDLE, -- TargetServerName: PWSTR, -- TargetSessionId: ULONG, -- HotKeyVk: UCHAR, -- HotkeyModifiers: USHORT, -- ) -> BOOLEAN; -- fn WinStationShadowStop( -- ServerHandle: HANDLE, -- SessionId: ULONG, -- bWait: BOOLEAN, -- ) -> BOOLEAN; -- fn WinStationEnumerateProcesses( -- ServerHandle: HANDLE, -- Processes: *mut PVOID, -- ) -> BOOLEAN; -- fn WinStationGetAllProcesses( -- ServerHandle: HANDLE, -- Level: ULONG, -- NumberOfProcesses: PULONG, -- Processes: *mut PTS_ALL_PROCESSES_INFO, -- ) -> BOOLEAN; -- fn WinStationFreeGAPMemory( -- Level: ULONG, -- Processes: PTS_ALL_PROCESSES_INFO, -- NumberOfProcesses: ULONG, -- ) -> BOOLEAN; -- fn WinStationTerminateProcess( -- ServerHandle: HANDLE, -- ProcessId: ULONG, -- ExitCode: ULONG, -- ) -> BOOLEAN; -- fn WinStationGetProcessSid( -- ServerHandle: HANDLE, -- ProcessId: ULONG, -- ProcessStartTime: FILETIME, -- pProcessUserSid: PVOID, -- dwSidSize: PULONG, -- ) -> BOOLEAN; -- fn WinStationSwitchToServicesSession() -> BOOLEAN; -- fn WinStationRevertFromServicesSession() -> BOOLEAN; -- fn _WinStationWaitForConnect() -> BOOLEAN; --}} -diff --git a/KubeOS-Rust/vendor/tokio-macros/.cargo-checksum.json b/KubeOS-Rust/vendor/tokio-macros/.cargo-checksum.json -index 1b511d53..b0b0a0e3 100644 ---- a/KubeOS-Rust/vendor/tokio-macros/.cargo-checksum.json -+++ b/KubeOS-Rust/vendor/tokio-macros/.cargo-checksum.json -@@ -1 +1 @@ --{"files":{"CHANGELOG.md":"ba5e652ef032e22a1f27e97c96c8fa7748884714c47c7d02fc662a346feba35a","Cargo.toml":"6fdb78ffd36a616abadc11ad91fc04834a275c80ba0b262b2221510aded646c3","LICENSE":"3a967151b47fdf9910d4e85f68bd76da23fa4c7bf316d90d9d2fe141b52148c1","README.md":"6094ea500349ce239a12b07d7dfd4ea965a7f14c993da2abc4b3c39a0479683a","src/entry.rs":"9a05351d6b8b668b3b0dc048b403beb3d28735f5fff1782b4c845133e2553b36","src/lib.rs":"2a693ab232e6a4e0b4e83b76df1626947aaf2769d8fa078a86f08350a98bb3a0","src/select.rs":"f04622465df446fa5d73920c1ca74ecb32b012ade30caef2714f6fb017e9115e"},"package":"d266c00fde287f55d3f1c3e96c500c362a2b8c695076ec180f27918820bc6df8"} -\ No newline at end of file -+{"files":{"CHANGELOG.md":"0fa977ef55cfe5c26907f5f3c8700a777d205608ab9edf7fd98762b60ba95790","Cargo.toml":"8133ec808652d1d7aa1eb39b135c2afa559265bb46ebbaf2a3cfe8b552fa9202","LICENSE":"9797ea525350e8779aab3771e0276bbeea8b824893882172acfc94743b8d953d","README.md":"6094ea500349ce239a12b07d7dfd4ea965a7f14c993da2abc4b3c39a0479683a","src/entry.rs":"237a4a8e159e841aaa2b49ec1697a68fef6165542ac0197dba1ee963f688dc1d","src/lib.rs":"8ada51fda322e36e6b52a3e1fcbeab7c72332f79e54af111584f5a17b961afb5","src/select.rs":"e01c34fe0fdbc49a40b15b5b42816eea7d7b13db6e3a2774de92eb87f6e48231"},"package":"630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"} -\ No newline at end of file -diff --git a/KubeOS-Rust/vendor/tokio-macros/CHANGELOG.md b/KubeOS-Rust/vendor/tokio-macros/CHANGELOG.md -index 93d52e73..e9d58db3 100644 ---- a/KubeOS-Rust/vendor/tokio-macros/CHANGELOG.md -+++ b/KubeOS-Rust/vendor/tokio-macros/CHANGELOG.md -@@ -1,3 +1,26 @@ -+# 2.1.0 (April 25th, 2023) -+ -+- macros: fix typo in `#[tokio::test]` docs ([#5636]) -+- macros: make entrypoints more efficient ([#5621]) -+ -+[#5621]: https://github.com/tokio-rs/tokio/pull/5621 -+[#5636]: https://github.com/tokio-rs/tokio/pull/5636 -+ -+# 2.0.0 (March 24th, 2023) -+ -+This major release updates the dependency on the syn crate to 2.0.0, and -+increases the MSRV to 1.56. -+ -+As part of this release, we are adopting a policy of depending on a specific minor -+release of tokio-macros. This prevents Tokio from being able to pull in many different -+versions of tokio-macros. -+ -+- macros: update `syn` ([#5572]) -+- macros: accept path as crate rename ([#5557]) -+ -+[#5572]: https://github.com/tokio-rs/tokio/pull/5572 -+[#5557]: https://github.com/tokio-rs/tokio/pull/5557 -+ - # 1.8.2 (November 30th, 2022) - - - fix a regression introduced in 1.8.1 ([#5244]) -diff --git a/KubeOS-Rust/vendor/tokio-macros/Cargo.toml b/KubeOS-Rust/vendor/tokio-macros/Cargo.toml -index 04bfa41e..6bd8b818 100644 ---- a/KubeOS-Rust/vendor/tokio-macros/Cargo.toml -+++ b/KubeOS-Rust/vendor/tokio-macros/Cargo.toml -@@ -11,9 +11,9 @@ - - [package] - edition = "2018" --rust-version = "1.49" -+rust-version = "1.56" - name = "tokio-macros" --version = "1.8.2" -+version = "2.1.0" - authors = ["Tokio Contributors "] - description = """ - Tokio's proc macros. -@@ -37,7 +37,7 @@ version = "1.0.7" - version = "1" - - [dependencies.syn] --version = "1.0.56" -+version = "2.0" - features = ["full"] - - [dev-dependencies.tokio] -diff --git a/KubeOS-Rust/vendor/tokio-macros/LICENSE b/KubeOS-Rust/vendor/tokio-macros/LICENSE -index a3753c03..12d1037f 100644 ---- a/KubeOS-Rust/vendor/tokio-macros/LICENSE -+++ b/KubeOS-Rust/vendor/tokio-macros/LICENSE -@@ -1,4 +1,4 @@ --Copyright (c) 2022 Tokio Contributors -+Copyright (c) 2023 Tokio Contributors - - Permission is hereby granted, free of charge, to any - person obtaining a copy of this software and associated -diff --git a/KubeOS-Rust/vendor/tokio-macros/src/entry.rs b/KubeOS-Rust/vendor/tokio-macros/src/entry.rs -index 6460e70a..edac5302 100644 ---- a/KubeOS-Rust/vendor/tokio-macros/src/entry.rs -+++ b/KubeOS-Rust/vendor/tokio-macros/src/entry.rs -@@ -1,10 +1,10 @@ --use proc_macro::TokenStream; --use proc_macro2::{Ident, Span}; -+use proc_macro2::{Span, TokenStream, TokenTree}; - use quote::{quote, quote_spanned, ToTokens}; --use syn::parse::Parser; -+use syn::parse::{Parse, ParseStream, Parser}; -+use syn::{braced, Attribute, Ident, Path, Signature, Visibility}; - - // syn::AttributeArgs does not implement syn::Parse --type AttributeArgs = syn::punctuated::Punctuated; -+type AttributeArgs = syn::punctuated::Punctuated; - - #[derive(Clone, Copy, PartialEq)] - enum RuntimeFlavor { -@@ -29,7 +29,7 @@ struct FinalConfig { - flavor: RuntimeFlavor, - worker_threads: Option, - start_paused: Option, -- crate_name: Option, -+ crate_name: Option, - } - - /// Config used in case of the attribute not being able to build a valid config -@@ -47,7 +47,7 @@ struct Configuration { - worker_threads: Option<(usize, Span)>, - start_paused: Option<(bool, Span)>, - is_test: bool, -- crate_name: Option, -+ crate_name: Option, - } - - impl Configuration { -@@ -112,8 +112,8 @@ impl Configuration { - if self.crate_name.is_some() { - return Err(syn::Error::new(span, "`crate` set multiple times.")); - } -- let name_ident = parse_ident(name, span, "crate")?; -- self.crate_name = Some(name_ident.to_string()); -+ let name_path = parse_path(name, span, "crate")?; -+ self.crate_name = Some(name_path); - Ok(()) - } - -@@ -199,23 +199,22 @@ fn parse_string(int: syn::Lit, span: Span, field: &str) -> Result Result { -+fn parse_path(lit: syn::Lit, span: Span, field: &str) -> Result { - match lit { - syn::Lit::Str(s) => { - let err = syn::Error::new( - span, - format!( -- "Failed to parse value of `{}` as ident: \"{}\"", -+ "Failed to parse value of `{}` as path: \"{}\"", - field, - s.value() - ), - ); -- let path = s.parse::().map_err(|_| err.clone())?; -- path.get_ident().cloned().ok_or(err) -+ s.parse::().map_err(|_| err.clone()) - } - _ => Err(syn::Error::new( - span, -- format!("Failed to parse value of `{}` as ident.", field), -+ format!("Failed to parse value of `{}` as path.", field), - )), - } - } -@@ -231,7 +230,7 @@ fn parse_bool(bool: syn::Lit, span: Span, field: &str) -> Result { -+ syn::Meta::NameValue(namevalue) => { - let ident = namevalue - .path - .get_ident() -@@ -255,34 +254,26 @@ fn build_config( - })? - .to_string() - .to_lowercase(); -+ let lit = match &namevalue.value { -+ syn::Expr::Lit(syn::ExprLit { lit, .. }) => lit, -+ expr => return Err(syn::Error::new_spanned(expr, "Must be a literal")), -+ }; - match ident.as_str() { - "worker_threads" => { -- config.set_worker_threads( -- namevalue.lit.clone(), -- syn::spanned::Spanned::span(&namevalue.lit), -- )?; -+ config.set_worker_threads(lit.clone(), syn::spanned::Spanned::span(lit))?; - } - "flavor" => { -- config.set_flavor( -- namevalue.lit.clone(), -- syn::spanned::Spanned::span(&namevalue.lit), -- )?; -+ config.set_flavor(lit.clone(), syn::spanned::Spanned::span(lit))?; - } - "start_paused" => { -- config.set_start_paused( -- namevalue.lit.clone(), -- syn::spanned::Spanned::span(&namevalue.lit), -- )?; -+ config.set_start_paused(lit.clone(), syn::spanned::Spanned::span(lit))?; - } - "core_threads" => { - let msg = "Attribute `core_threads` is renamed to `worker_threads`"; - return Err(syn::Error::new_spanned(namevalue, msg)); - } - "crate" => { -- config.set_crate_name( -- namevalue.lit.clone(), -- syn::spanned::Spanned::span(&namevalue.lit), -- )?; -+ config.set_crate_name(lit.clone(), syn::spanned::Spanned::span(lit))?; - } - name => { - let msg = format!( -@@ -293,7 +284,7 @@ fn build_config( - } - } - } -- syn::NestedMeta::Meta(syn::Meta::Path(path)) => { -+ syn::Meta::Path(path) => { - let name = path - .get_ident() - .ok_or_else(|| syn::Error::new_spanned(&path, "Must have specified ident"))? -@@ -333,18 +324,13 @@ fn build_config( - config.build() - } - --fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> TokenStream { -+fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) -> TokenStream { - input.sig.asyncness = None; - - // If type mismatch occurs, the current rustc points to the last statement. - let (last_stmt_start_span, last_stmt_end_span) = { -- let mut last_stmt = input -- .block -- .stmts -- .last() -- .map(ToTokens::into_token_stream) -- .unwrap_or_default() -- .into_iter(); -+ let mut last_stmt = input.stmts.last().cloned().unwrap_or_default().into_iter(); -+ - // `Span` on stable Rust has a limitation that only points to the first - // token, not the whole tokens. We can work around this limitation by - // using the first/last span of the tokens like -@@ -354,16 +340,17 @@ fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> To - (start, end) - }; - -- let crate_name = config.crate_name.as_deref().unwrap_or("tokio"); -- -- let crate_ident = Ident::new(crate_name, last_stmt_start_span); -+ let crate_path = config -+ .crate_name -+ .map(ToTokens::into_token_stream) -+ .unwrap_or_else(|| Ident::new("tokio", last_stmt_start_span).into_token_stream()); - - let mut rt = match config.flavor { - RuntimeFlavor::CurrentThread => quote_spanned! {last_stmt_start_span=> -- #crate_ident::runtime::Builder::new_current_thread() -+ #crate_path::runtime::Builder::new_current_thread() - }, - RuntimeFlavor::Threaded => quote_spanned! {last_stmt_start_span=> -- #crate_ident::runtime::Builder::new_multi_thread() -+ #crate_path::runtime::Builder::new_multi_thread() - }, - }; - if let Some(v) = config.worker_threads { -@@ -381,10 +368,8 @@ fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> To - quote! {} - }; - -- let body = &input.block; -- let brace_token = input.block.brace_token; - let body_ident = quote! { body }; -- let block_expr = quote_spanned! {last_stmt_end_span=> -+ let last_block = quote_spanned! {last_stmt_end_span=> - #[allow(clippy::expect_used, clippy::diverging_sub_expression)] - { - return #rt -@@ -395,6 +380,8 @@ fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> To - } - }; - -+ let body = input.body(); -+ - // For test functions pin the body to the stack and use `Pin<&mut dyn - // Future>` to reduce the amount of `Runtime::block_on` (and related - // functions) copies we generate during compilation due to the generic -@@ -414,7 +401,7 @@ fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> To - }; - quote! { - let body = async #body; -- #crate_ident::pin!(body); -+ #crate_path::pin!(body); - let body: ::std::pin::Pin<&mut dyn ::std::future::Future> = body; - } - } else { -@@ -423,25 +410,11 @@ fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> To - } - }; - -- input.block = syn::parse2(quote! { -- { -- #body -- #block_expr -- } -- }) -- .expect("Parsing failure"); -- input.block.brace_token = brace_token; -- -- let result = quote! { -- #header -- #input -- }; -- -- result.into() -+ input.into_tokens(header, body, last_block) - } - - fn token_stream_with_error(mut tokens: TokenStream, error: syn::Error) -> TokenStream { -- tokens.extend(TokenStream::from(error.into_compile_error())); -+ tokens.extend(error.into_compile_error()); - tokens - } - -@@ -450,7 +423,7 @@ pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread: bool) - // If any of the steps for this macro fail, we still want to expand to an item that is as close - // to the expected output as possible. This helps out IDEs such that completions and other - // related features keep working. -- let input: syn::ItemFn = match syn::parse(item.clone()) { -+ let input: ItemFn = match syn::parse2(item.clone()) { - Ok(it) => it, - Err(e) => return token_stream_with_error(item, e), - }; -@@ -460,8 +433,8 @@ pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread: bool) - Err(syn::Error::new_spanned(&input.sig.ident, msg)) - } else { - AttributeArgs::parse_terminated -- .parse(args) -- .and_then(|args| build_config(input.clone(), args, false, rt_multi_thread)) -+ .parse2(args) -+ .and_then(|args| build_config(&input, args, false, rt_multi_thread)) - }; - - match config { -@@ -474,17 +447,17 @@ pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool) - // If any of the steps for this macro fail, we still want to expand to an item that is as close - // to the expected output as possible. This helps out IDEs such that completions and other - // related features keep working. -- let input: syn::ItemFn = match syn::parse(item.clone()) { -+ let input: ItemFn = match syn::parse2(item.clone()) { - Ok(it) => it, - Err(e) => return token_stream_with_error(item, e), - }; -- let config = if let Some(attr) = input.attrs.iter().find(|attr| attr.path.is_ident("test")) { -+ let config = if let Some(attr) = input.attrs().find(|attr| attr.meta.path().is_ident("test")) { - let msg = "second test attribute is supplied"; - Err(syn::Error::new_spanned(attr, msg)) - } else { - AttributeArgs::parse_terminated -- .parse(args) -- .and_then(|args| build_config(input.clone(), args, true, rt_multi_thread)) -+ .parse2(args) -+ .and_then(|args| build_config(&input, args, true, rt_multi_thread)) - }; - - match config { -@@ -492,3 +465,127 @@ pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool) - Err(e) => token_stream_with_error(parse_knobs(input, true, DEFAULT_ERROR_CONFIG), e), - } - } -+ -+struct ItemFn { -+ outer_attrs: Vec, -+ vis: Visibility, -+ sig: Signature, -+ brace_token: syn::token::Brace, -+ inner_attrs: Vec, -+ stmts: Vec, -+} -+ -+impl ItemFn { -+ /// Access all attributes of the function item. -+ fn attrs(&self) -> impl Iterator { -+ self.outer_attrs.iter().chain(self.inner_attrs.iter()) -+ } -+ -+ /// Get the body of the function item in a manner so that it can be -+ /// conveniently used with the `quote!` macro. -+ fn body(&self) -> Body<'_> { -+ Body { -+ brace_token: self.brace_token, -+ stmts: &self.stmts, -+ } -+ } -+ -+ /// Convert our local function item into a token stream. -+ fn into_tokens( -+ self, -+ header: proc_macro2::TokenStream, -+ body: proc_macro2::TokenStream, -+ last_block: proc_macro2::TokenStream, -+ ) -> TokenStream { -+ let mut tokens = proc_macro2::TokenStream::new(); -+ header.to_tokens(&mut tokens); -+ -+ // Outer attributes are simply streamed as-is. -+ for attr in self.outer_attrs { -+ attr.to_tokens(&mut tokens); -+ } -+ -+ // Inner attributes require extra care, since they're not supported on -+ // blocks (which is what we're expanded into) we instead lift them -+ // outside of the function. This matches the behaviour of `syn`. -+ for mut attr in self.inner_attrs { -+ attr.style = syn::AttrStyle::Outer; -+ attr.to_tokens(&mut tokens); -+ } -+ -+ self.vis.to_tokens(&mut tokens); -+ self.sig.to_tokens(&mut tokens); -+ -+ self.brace_token.surround(&mut tokens, |tokens| { -+ body.to_tokens(tokens); -+ last_block.to_tokens(tokens); -+ }); -+ -+ tokens -+ } -+} -+ -+impl Parse for ItemFn { -+ #[inline] -+ fn parse(input: ParseStream<'_>) -> syn::Result { -+ // This parse implementation has been largely lifted from `syn`, with -+ // the exception of: -+ // * We don't have access to the plumbing necessary to parse inner -+ // attributes in-place. -+ // * We do our own statements parsing to avoid recursively parsing -+ // entire statements and only look for the parts we're interested in. -+ -+ let outer_attrs = input.call(Attribute::parse_outer)?; -+ let vis: Visibility = input.parse()?; -+ let sig: Signature = input.parse()?; -+ -+ let content; -+ let brace_token = braced!(content in input); -+ let inner_attrs = Attribute::parse_inner(&content)?; -+ -+ let mut buf = proc_macro2::TokenStream::new(); -+ let mut stmts = Vec::new(); -+ -+ while !content.is_empty() { -+ if let Some(semi) = content.parse::>()? { -+ semi.to_tokens(&mut buf); -+ stmts.push(buf); -+ buf = proc_macro2::TokenStream::new(); -+ continue; -+ } -+ -+ // Parse a single token tree and extend our current buffer with it. -+ // This avoids parsing the entire content of the sub-tree. -+ buf.extend([content.parse::()?]); -+ } -+ -+ if !buf.is_empty() { -+ stmts.push(buf); -+ } -+ -+ Ok(Self { -+ outer_attrs, -+ vis, -+ sig, -+ brace_token, -+ inner_attrs, -+ stmts, -+ }) -+ } -+} -+ -+struct Body<'a> { -+ brace_token: syn::token::Brace, -+ // Statements, with terminating `;`. -+ stmts: &'a [TokenStream], -+} -+ -+impl ToTokens for Body<'_> { -+ fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { -+ self.brace_token.surround(tokens, |tokens| { -+ for stmt in self.stmts { -+ stmt.to_tokens(tokens); -+ } -+ }) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio-macros/src/lib.rs b/KubeOS-Rust/vendor/tokio-macros/src/lib.rs -index 34041afa..1d024f59 100644 ---- a/KubeOS-Rust/vendor/tokio-macros/src/lib.rs -+++ b/KubeOS-Rust/vendor/tokio-macros/src/lib.rs -@@ -39,6 +39,13 @@ use proc_macro::TokenStream; - /// function is called often, it is preferable to create the runtime using the - /// runtime builder so the runtime can be reused across calls. - /// -+/// # Non-worker async function -+/// -+/// Note that the async function marked with this macro does not run as a -+/// worker. The expectation is that other tasks are spawned by the function here. -+/// Awaiting on other futures from the function provided here will not -+/// perform as fast as those spawned as workers. -+/// - /// # Multi-threaded runtime - /// - /// To use the multi-threaded runtime, the macro can be configured using -@@ -197,7 +204,7 @@ use proc_macro::TokenStream; - #[proc_macro_attribute] - #[cfg(not(test))] // Work around for rust-lang/rust#62127 - pub fn main(args: TokenStream, item: TokenStream) -> TokenStream { -- entry::main(args, item, true) -+ entry::main(args.into(), item.into(), true).into() - } - - /// Marks async function to be executed by selected runtime. This macro helps set up a `Runtime` -@@ -262,7 +269,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream { - #[proc_macro_attribute] - #[cfg(not(test))] // Work around for rust-lang/rust#62127 - pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream { -- entry::main(args, item, false) -+ entry::main(args.into(), item.into(), false).into() - } - - /// Marks async function to be executed by runtime, suitable to test environment. -@@ -288,8 +295,7 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream { - /// ``` - /// - /// The `worker_threads` option configures the number of worker threads, and --/// defaults to the number of cpus on the system. This is the default --/// flavor. -+/// defaults to the number of cpus on the system. - /// - /// Note: The multi-threaded runtime requires the `rt-multi-thread` feature - /// flag. -@@ -420,7 +426,7 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream { - /// ``` - #[proc_macro_attribute] - pub fn test(args: TokenStream, item: TokenStream) -> TokenStream { -- entry::test(args, item, true) -+ entry::test(args.into(), item.into(), true).into() - } - - /// Marks async function to be executed by runtime, suitable to test environment -@@ -435,7 +441,7 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream { - /// ``` - #[proc_macro_attribute] - pub fn test_rt(args: TokenStream, item: TokenStream) -> TokenStream { -- entry::test(args, item, false) -+ entry::test(args.into(), item.into(), false).into() - } - - /// Always fails with the error message below. -diff --git a/KubeOS-Rust/vendor/tokio-macros/src/select.rs b/KubeOS-Rust/vendor/tokio-macros/src/select.rs -index 23e280a1..dd491f84 100644 ---- a/KubeOS-Rust/vendor/tokio-macros/src/select.rs -+++ b/KubeOS-Rust/vendor/tokio-macros/src/select.rs -@@ -1,7 +1,7 @@ - use proc_macro::{TokenStream, TokenTree}; - use proc_macro2::Span; - use quote::quote; --use syn::Ident; -+use syn::{parse::Parser, Ident}; - - pub(crate) fn declare_output_enum(input: TokenStream) -> TokenStream { - // passed in is: `(_ _ _)` with one `_` per branch -@@ -46,7 +46,7 @@ pub(crate) fn clean_pattern_macro(input: TokenStream) -> TokenStream { - // If this isn't a pattern, we return the token stream as-is. The select! - // macro is using it in a location requiring a pattern, so an error will be - // emitted there. -- let mut input: syn::Pat = match syn::parse(input.clone()) { -+ let mut input: syn::Pat = match syn::Pat::parse_single.parse(input.clone()) { - Ok(it) => it, - Err(_) => return input, - }; -@@ -58,7 +58,6 @@ pub(crate) fn clean_pattern_macro(input: TokenStream) -> TokenStream { - // Removes any occurrences of ref or mut in the provided pattern. - fn clean_pattern(pat: &mut syn::Pat) { - match pat { -- syn::Pat::Box(_box) => {} - syn::Pat::Lit(_literal) => {} - syn::Pat::Macro(_macro) => {} - syn::Pat::Path(_path) => {} -@@ -94,16 +93,16 @@ fn clean_pattern(pat: &mut syn::Pat) { - } - } - syn::Pat::TupleStruct(tuple) => { -- for elem in tuple.pat.elems.iter_mut() { -+ for elem in tuple.elems.iter_mut() { - clean_pattern(elem); - } - } - syn::Pat::Reference(reference) => { - reference.mutability = None; -- clean_pattern(&mut *reference.pat); -+ clean_pattern(&mut reference.pat); - } - syn::Pat::Type(type_pat) => { -- clean_pattern(&mut *type_pat.pat); -+ clean_pattern(&mut type_pat.pat); - } - _ => {} - } -diff --git a/KubeOS-Rust/vendor/tokio/.cargo-checksum.json b/KubeOS-Rust/vendor/tokio/.cargo-checksum.json -index a59b764b..761c738e 100644 ---- a/KubeOS-Rust/vendor/tokio/.cargo-checksum.json -+++ b/KubeOS-Rust/vendor/tokio/.cargo-checksum.json -@@ -1 +1 @@ --{"files":{"CHANGELOG.md":"a01792a6bf9aa829037c377c96f063262abc0bc368567ca517c86d94a28c2e09","Cargo.toml":"0d28025edc7277aec7511b96c71c6a33cf55fb8205b9b51a43f9282ed6e5cdaf","LICENSE":"d4ecf952201c14fd13203c2aa64dee75d81271e3d7e3ca0e8aa0e59b9aeeb9c6","README.md":"cba56d408edb2016de8761f6f6b14dbbf5b7bc174fc72a31dbf20eb59ff00518","build.rs":"fe6db39a280cf0d2b6d3abc365416321f48591a58d7ee39a4ad50f3b1da76beb","docs/reactor-refactor.md":"f7dcc42be8ae33446be399add73f234fc217a5d67478cfcac65601058ab50d47","src/blocking.rs":"5dbfd006f7d1c13c569a4210670a0729226e67ec5414c939ced33e331714b56d","src/coop.rs":"41c84f5ec64af4c02291343f9f3daedc4bd55acde32b7f3f79bbd40c5e035bf4","src/doc/mod.rs":"313fe6b3eb0e0e7a9d9cb070cc18e8749f5dd44724b651a90af46acf02a4f7af","src/doc/os.rs":"4af4a78a0af962f94e5e8f67858350e4fedb3a5f990db277a0aa8bf4f7b923b1","src/doc/winapi.rs":"f8b16da97e4822116be6a59ef0d9549a857861cecd584353a7fb02df173dde9c","src/fs/canonicalize.rs":"93c64b72abdca17877d6ab61d50a43765d6aef9e0a9f7aaf41b6b0b7d9a8a380","src/fs/copy.rs":"262180fadc66e5ac2bf1e8389628fdd039f14788e66a4f8b10e10633e7310f20","src/fs/create_dir.rs":"233cbab2579a787614aeee88845a57f1578e9c2e064a3456c799f61430e911ad","src/fs/create_dir_all.rs":"56081d541caadca0fc59e84d55e78e702fe9373679598016224ad0b072b189a7","src/fs/dir_builder.rs":"b5b21229c7bf15e2074afab1accfbc392f3c69e546c7b652cfdc8e90d5a4a301","src/fs/file.rs":"07463ddf4c627336e9a99606835deeee87775482d709c7f1ccdf4ca1ce0a9c03","src/fs/file/tests.rs":"2c7c1e81d2f960d00753fac1fd35697ff9dbfe4273a09c7820e4004f2ad09bbb","src/fs/hard_link.rs":"98cccbbb3719baee11c232e79723ab1cb3d6c8056bddb109c4990fe2c236c1fb","src/fs/metadata.rs":"782a1a5dbc2cd6c40e928579fbfcf39e5f1de28def78781590c0280acdf02960","src/fs/mocks.rs":"6eede7dba34801f78026da50cc8ed64eea4c3e7ab7aa87d717faac28fdb9182b","src/fs/mod.rs":"eced6fd2a09a6e458556caafbd444753a3577a5dbbe11688f31c0e1e122879c2","src/fs/open_options.rs":"e1f78d96005082e6886de6fc8e6545cdb72e4e4fd444549b53c5bd7addd8510a","src/fs/open_options/mock_open_options.rs":"f08d384602bbd165eed4cf8811a19512d62c4d9573457f8d22c78c77b1091629","src/fs/read.rs":"055ae8b6ae96ebae2d05f8780e7592bb587a742506c6df8ee8b380fc7d2820ef","src/fs/read_dir.rs":"76a90e7a465da2e977392b65265dfa766c19d8b25967a278a5ac20f6a0543243","src/fs/read_link.rs":"93c104a21253372fef7056ab82e6065b0a1a8fc9be8b7329dfd5a8dd07c618b0","src/fs/read_to_string.rs":"9e5b2d476a6084e32a92c5421a8abc9d4f335f4ec677beec4bf8bfa109d7d106","src/fs/remove_dir.rs":"96475771e9c52678768288d8df6814216e0801bebc848481597ad34e829a5854","src/fs/remove_dir_all.rs":"b85abd05c7ab64ee8dc6cf5663a11e713aa51b357759ef660ef3cae3365ccc42","src/fs/remove_file.rs":"1cdf8bf16b3a164c594dac8773b7d1f9ebb28de169343184d34d6aac3b3a7eaa","src/fs/rename.rs":"a97875e92626fa46e23fece7b8698c9c4cea2bae8f1be8726f30ae6fe80ae0c7","src/fs/set_permissions.rs":"8adccafa475dcfc1bc3989af73374d90683c1be4953ef812e5fd606f968d7b7a","src/fs/symlink.rs":"32cf3e906531d30ebe6d8be7ee3bfe049949759b566015b56d0851f51abcff50","src/fs/symlink_dir.rs":"5fbd05365555ba7942ffc1c2dfddf201ddad2cf9b005be2ea99849a473fe982b","src/fs/symlink_file.rs":"a1170fd40a000dc449de972267f579a0d14f50dbb39466f985f183fdcd1d3438","src/fs/symlink_metadata.rs":"f5ce1e05f137da995e3e0d9582bae0a5f7ef4251285c64e912b0eedbb068b395","src/fs/write.rs":"1ffb734d31748bd879ad398b0fe99bdec569782b42677022957db2cae95c4d2d","src/future/block_on.rs":"ef7fd744d2727f169b6d8997e2202af88a256bf41a894c93a4490ade65fa0e57","src/future/maybe_done.rs":"9042619f2a907e81763ac6082c080faa28af5d571dd49e82b60f3f14d58598f3","src/future/mod.rs":"6abc3b25570075121f594a1cc3a7a91425f985dcca85b7b6c5aab92bc8841d11","src/future/poll_fn.rs":"e1a8393f18d6cfa9d7d0c8912b10b5b65cc9a2b507d8d1ac1c5c3be4e2ba057a","src/future/ready.rs":"168e965951c21794b21e0f151b29614c07371caa040271fc51541f97451fe94c","src/future/trace.rs":"c42712a8d372922eba7e05cd21382fe5df5eec02cbcc870062100b59ab99654f","src/future/try_join.rs":"0ea5a069b17a34bbc091acbd74b9d51794a55a85dfa63fe2404d5ee91a4f0038","src/io/async_buf_read.rs":"b37caa8f6c974b3c97327c635218803e573c531d4197950840549aa794357c99","src/io/async_fd.rs":"3bbef097420e7a1fccedc618bd3a8e95bd4ad0e5037bebf05f029134005ff500","src/io/async_read.rs":"f52c8d2f4a283c0dc8d06dc974484749973125b0b691bc0c3d100972ac67cb92","src/io/async_seek.rs":"a9a0df389ff2be3d79208ec475fcfede46a86f6ea0b822b1a4ce8273ec714b0b","src/io/async_write.rs":"198ed6a475b6f093fd2ff15e618d816d7e33cb8bc28d2e2299533e5df0bd78d6","src/io/blocking.rs":"d6613950dc10f17287ff396d6acc7f386bed1ffaaeb71dcbb10ad4ffcfb29ed7","src/io/bsd/poll_aio.rs":"893aab3d616e33fbb6ea61e6d590e80d2871e676c0647a58041b16e4698ca34e","src/io/driver/interest.rs":"726c813211a8606f68e58a2693cccdf3788f252aa1e9700af088ba756ba36c1d","src/io/driver/mod.rs":"66325853609db8e4cf51de3f4887a1de0a5c42879128aac66d1aa2cf39da6577","src/io/driver/platform.rs":"023acd3f2703d241b3e91ab6e4d4c0bc5ccc3451655fffd9f37938224f915494","src/io/driver/ready.rs":"e4bac7c50bf7c2d29b3516e9184c2a46cc4631366ae940c41cc5320bb35a9250","src/io/driver/registration.rs":"b3a62b64014181839c8d13aa5d13da27d8d173c18feb18c3f03246b08404c0d2","src/io/driver/scheduled_io.rs":"d8da8185d1c72af922746737769a612457f053eb529a465d242de641fde1c731","src/io/mod.rs":"1d32445c95577065827eb98ef842bf4c9be842da376ef95c565c0a65820c55f6","src/io/poll_evented.rs":"8945a4a7886418405721f27033c5e55823485172a2ae85b41ac6aa662ac42c86","src/io/read_buf.rs":"bce0f5fb30f34702a290342d0474c9eb6756e2dcbacbdbcf2080ff63ce5c7699","src/io/seek.rs":"e9e346fc926c3360601b80a8319a25fd0567dd6f77fab666694e9787deaef633","src/io/split.rs":"2c6982598a86620b76826ba6065953e9fc78a0434652fe97d82d79f7bbcb66b3","src/io/stderr.rs":"8f4d9fc5e596180171b68919bde951c49d134446d30af06dbbbe413ff2882ff5","src/io/stdin.rs":"5c15de00a7fe2ffee2f48f2ecb2a4fa765f3de891f8cdbc240e2988db7cc0d13","src/io/stdio_common.rs":"6e54019e53594a632dd3536e575ca11ee7b279977ee92c556ef39c46255f6b1f","src/io/stdout.rs":"2c1b11ae547b0eec06e2b21039655a2acf34125b789548c7bd362babf5b05cd2","src/io/util/async_buf_read_ext.rs":"7f7fde910ecd9e526bb85882a318f457dedf6ccc2cdbc693112562186dfb78de","src/io/util/async_read_ext.rs":"f70825f0be7ebecce5473c53c716cc57f1123e5818f7b917444c3892639a5e2c","src/io/util/async_seek_ext.rs":"804ea19c98a28aacedc38852f692f59c52f1327807a0620c1740182ac6b01e02","src/io/util/async_write_ext.rs":"6256ed8320aa225fbe9ba159cdc20b08e1e22bcab4c090fdb1dca1cdbc2d97b4","src/io/util/buf_reader.rs":"0f28c7dba62059b0b129e76d5e56d02094b1af490cc8eaac4cda20080bfce2b5","src/io/util/buf_stream.rs":"2246fe71b707c15d7168c5da5ee158cec6e854d4fd11b685531c16a9c3cf2c6a","src/io/util/buf_writer.rs":"f9c3e018c9f9177fb6d910096503caee727bebd3c36f5f67dca2c4c55044408a","src/io/util/chain.rs":"5cd8df2cc7bbcd18ca2336a78507fa8009c0a9e595f81730a8c16cadb8f731a2","src/io/util/copy.rs":"34f164f2169caa58fc9c43415108e61c662aece2e2f3010470d89b3fc3e2aedd","src/io/util/copy_bidirectional.rs":"0f72d957fa2d1b3517224e34c65f06016f5e04857d45b01c368398fb95e555f5","src/io/util/copy_buf.rs":"b029d0ee8da5301a06722d425828418027234a8b111a209fa49ead161263aa8e","src/io/util/empty.rs":"78cb27e38a9562e90fae41fdc9fe89125f0c930976945162f3eef2427eff860d","src/io/util/fill_buf.rs":"d39dea0831f4ab1c159136b6e8a739f8c445e4235736c8594e323f5858c1cabc","src/io/util/flush.rs":"fe3b4ff226e294843b8cbea9dc4e02d581582b78ddaafce137c96e290699c718","src/io/util/lines.rs":"1d9f9b99567111c911e72a4caa2abb19b277f2cdd0ca3268ac5ca6df5276259f","src/io/util/mem.rs":"b76590bfe286fc69d565ac4cb28a57d6e727810a29bc08ac8fb452f4f3b3b451","src/io/util/mod.rs":"6a9012d78fe2bed8240e7a628e9421cbef45433551522624065fdcbb329f3594","src/io/util/read.rs":"01c1113b6171c83ba2a0ad774703c3139b0ff11f47953f1b50861334d44f86ec","src/io/util/read_buf.rs":"a87be2d115c09a6782ec8cadeafc92fb1fbe534580e71540087c3298a03bfca2","src/io/util/read_exact.rs":"7562ef794d46585c6f3c0a4245618a9c0acf1546d214973a1ab336c4e78351e0","src/io/util/read_int.rs":"49da230796335df584832cd7deb8370b4d1e0350d743046389a9d9ae17dbd94f","src/io/util/read_line.rs":"9cdb2d778b81bc50098a6851981ed9f541bd0c7896c0763b811971b5a598b7e8","src/io/util/read_to_end.rs":"7aca8032ee911467c24ce435b7bcf023c72ca6f19c2663269ff50d31913d6e01","src/io/util/read_to_string.rs":"fafb5463b013cc8f76def3a505dbebd179afc95bde0e2ca9388e428265788924","src/io/util/read_until.rs":"b2a2a7c434439fd2c9269494e59edbe1f75eb45449dd6be384663a6ceaf137ac","src/io/util/repeat.rs":"d4effcd81338831eb373cf2db972a99218b8379b91066940a732edcf4524c7c2","src/io/util/shutdown.rs":"971454342b4636fbd68e123d59d87017d81f72afb410c385846069b11def8efe","src/io/util/sink.rs":"0dcb794e48ca9b1c28e5f9f2051073ea0951a54c9c7dfc903ce9e5489d3d8cd7","src/io/util/split.rs":"03a59adccda29608886e38a1f484fbd4d6a6019180c4cfa851372d250796aa5a","src/io/util/take.rs":"559c062409ffc80202ab792bdae094e691c4910e24aee5cf76ef9c8f26c7be3b","src/io/util/vec_with_initialized.rs":"06f3a452c0158b4b72c6fdbddd6505eec8ce1893abce0420db1e79897d63380b","src/io/util/write.rs":"20d14ee545ab1f67732915522e97808d1ddde13d151505c1289b596be519f7c8","src/io/util/write_all.rs":"a53b89e3a716d53fc6cc50a4068200a92edce585c9fefd3c9c21ab158d53d7dc","src/io/util/write_all_buf.rs":"5911bf673ef89097938f4e2e38d9012865b28a0ce5ebb217ebe0e2507de6c1e3","src/io/util/write_buf.rs":"ab51d6174de24cbb729ce77dbaeea27e16059b8253e4830d8243ec5f08a08a8c","src/io/util/write_int.rs":"f321e69b0c7c01728b079e9fdeedb96c26475667e8b259d0c5f4a83d060990d1","src/io/util/write_vectored.rs":"7a335a9f796daa048fa9708dc44d32d2567b36461a6d88f07893eb31f304b69d","src/lib.rs":"e2a353e1283dbf112b0aaa4b07f7c02c1b4dfe2bbd8f152a1f13d5a7ccb59fcf","src/loom/mocked.rs":"6db5ed42cd469ac1f98d04c535e59aea174d6c06aed5f9f0c5b5254dc6e476b9","src/loom/mod.rs":"b14b9333a7a21bd125a4ae82f01e5ea9c9ed2f78d7d1ad49a13d9b176f1fe8ab","src/loom/std/atomic_ptr.rs":"16d7e6f841697020aa315a303f26cca714c35a96c4912ae45b90ad3ab0715e28","src/loom/std/atomic_u16.rs":"8793a4927367270305a6a3a68423ccc838cead0960ab1a7cb345681182916c14","src/loom/std/atomic_u32.rs":"39889c3295f5a201ecbd4ce3f5f942d88931fa9988071f771935dfd0c6c3443c","src/loom/std/atomic_u64.rs":"dbde383b3a2119926583dbada2a55a440c166913527011479d676244e0b9f08f","src/loom/std/atomic_u8.rs":"98f6baee74059eea2fc950dabc273a2fcb3518950015fb3a5acb3dbc58ffac03","src/loom/std/atomic_usize.rs":"ce7e840ac029a91adb90d7834c2bec3a8ef5fcf0b311de0bb6900c0be199301f","src/loom/std/mod.rs":"37385f768bc948984f324ba8d7b62c725efda00403cdbdc91e4b7deed88b9e47","src/loom/std/mutex.rs":"83938246987904d2cf0fbd76566170e62ab89a2e10dc309f8aa4e149cdaba74e","src/loom/std/parking_lot.rs":"cd835d0693d1e531ad4fd004aab74ae10df8f95968c248ec024eddb8480869d5","src/loom/std/unsafe_cell.rs":"05e2b4d8e78b0435650c6da6239ce8c53b4de2573e64ba098354b049f23429ec","src/macros/cfg.rs":"16ef8f590c8446f913cc1391686e722a0d2a957718371c470a5e354e249983ca","src/macros/join.rs":"54fb8935246c4524e958a5bd80b9286f3c523c3a613adecfe204bfd4504f925a","src/macros/loom.rs":"80d2e4af9fc50d0bda1b20b95f8873b2f59c3c0e70f2e812a6207855df76204e","src/macros/mod.rs":"913c824be0242590352d952a2ec445ef1d3d77e1512cdea4e2be7f4956cb9bf5","src/macros/pin.rs":"294e5644061e41801dcee5494b7334439e09af0b6219ce164090feb624864631","src/macros/ready.rs":"6efd4c866c4718c3a9a7b5564b435e2d13e9c1ae91fd98b1313d5e7c182942d6","src/macros/scoped_tls.rs":"d598cf0c6e57d91d56432898ebab741aec3fa07b08e0ab5f91dd151127f4ae3e","src/macros/select.rs":"4832b4aacaff0f7c79c97f3c707e613086accadec6a3f15857c94832ee35aeb3","src/macros/support.rs":"0cf0789ba2dc5a196ccbabba9ca9f1861a71284032b98dc7c372078c12c5d5ce","src/macros/thread_local.rs":"8602495ed102b63e3048a261eda7483dc9a24b15a74d7059c31635e8f45de19a","src/macros/trace.rs":"43ab0411fdb7ed6cab9825961a192c4882610a74c49b0078577c0121e5986333","src/macros/try_join.rs":"fdeb6c3d4b56b81cd62f2532bf2373494fecd301e3c3a4afc66e4f1651bd7a9e","src/net/addr.rs":"a58fa02863059dc77fb82ac115635d2928ffce4437a37412b732799e6fe7a7eb","src/net/lookup_host.rs":"c7a21d735225e316253d822f6b11a17107e6a8db004f947a54d8bc12ec782baf","src/net/mod.rs":"b75d65aee9871a9b5ead894a01199d0af48f993e12a5e49041a91148739876bc","src/net/tcp/listener.rs":"c0f9d5e115da4127ce6792122e48d39dba1888928411241a3e4982ea68f38767","src/net/tcp/mod.rs":"d33297e086d7fcc6c46584782d7b24f65578bf9895844f1ec6cde95cc5b8902d","src/net/tcp/socket.rs":"68c04b3e6c4a9d74ad94536b702f5f05ada8fd7739120def578192f929343e97","src/net/tcp/split.rs":"e477c847baf20c5f0235a40720a60fd3564cab66bef37f48c2a17cdf95de96ad","src/net/tcp/split_owned.rs":"55f393899efa77a41571e64d96507a374c413050ee866144c8f57b3d2935b2d4","src/net/tcp/stream.rs":"918ff446e0289e00a12624e51353273a35ce414582610f4625f79509c9d04103","src/net/udp.rs":"1f6c8263e82425df6046d7823ce7568b67c2276b708a1dd73981369a945a6471","src/net/unix/datagram/mod.rs":"fc48924e5d1e551405b0708a2d122473cdafeeee802a5722f64b4cf41a1c01da","src/net/unix/datagram/socket.rs":"f888d8c1499693e1b4fd92e17596a310c81679a0dcb5a3f528d151ec36158665","src/net/unix/listener.rs":"eb9f0deb2f6f292b3224f5fc4c6aa12fd4e842e867e75ededcf4859276dc1b8a","src/net/unix/mod.rs":"2c18ab3fef385be4b1603cdd391f557f36a3188b8bebc3949647b27bbd6d84b4","src/net/unix/socketaddr.rs":"66bf18321a81baeb394a7094567632b113e44e12d2643109b6a97c89d919bf3a","src/net/unix/split.rs":"9f6c51cc59c8b2c6bd8e7b8f918486ccd8d200973e240c58ce26490569db2182","src/net/unix/split_owned.rs":"e0640e4fd2b6be95139f7f1aa014c149fc2dc834e7264382b7ff84750b93e10b","src/net/unix/stream.rs":"3a9073f8c6ee7dabe170c19b06e09db0bb280c7e3f20aea8a6ee49325f60d7e1","src/net/unix/ucred.rs":"836fe68abe151abcaaf4d9bc92025a12030f1c2b7beb314cc453d0d88aa316d1","src/net/windows/mod.rs":"a1525f35c1acb92b15bec788a625b76acb42f9424f392074db697102ce79760d","src/net/windows/named_pipe.rs":"670aa7d368c84b92c29ceb3cd21776cf1e8dc310aa4f46600ab0f4cb9d5637a6","src/park/either.rs":"251c6255768445ca2bcfb037b1fcffa05e9ca0f4f31923ffcf341eb3cd794180","src/park/mod.rs":"0e8d343742e6e498c4f4d44a837d01da2e75012aada2117641937c56f85abc8f","src/park/thread.rs":"f5c4885e6c7e3f6e33e87774e79ef3bbef13fc7a4e7f9c5f27a86d74fec8f275","src/process/kill.rs":"2f98bd1bd28ab37bedc34ab7b737760407ab5315420538acbd18da31d2662d94","src/process/mod.rs":"7cf0d7e12fd713d6c29aa0ff48a8df1398d4c03a25db48626ca664731def348b","src/process/unix/driver.rs":"073baa2a7b1065745793a219cb7045907f339f71945943dcb3c52a2cfeb7ea45","src/process/unix/mod.rs":"ab58ab44dfd8ec1da5dbd064faad0ffdb10c2c70c56e741cb5726648dec12f4e","src/process/unix/orphan.rs":"e63952a6469703d4734939b8ceed056489023cbabe3ab80b4d7fabf698c04e6c","src/process/unix/reap.rs":"62868319849b8482d8d927dcd00cc8a74b9af61fd47494b39bd41fe2f4dcf0b6","src/process/windows.rs":"feb605a16ea975886b38a66f30b3aad97f7e9ae73d35eb2ad45ccaae36d0e4e8","src/runtime/basic_scheduler.rs":"a3f1b7cbafe89a85ac512440cfb69b0971f8836ea490300b3237442252a2013c","src/runtime/blocking/mod.rs":"0ad39897f8400a62e18f237a7244a143234b8cf399484924e4a7707bff90b2f1","src/runtime/blocking/pool.rs":"0f722eb92ca43e69a1858b9c6bbddcad37457b89aed5cc7536df931731949afc","src/runtime/blocking/schedule.rs":"fef31b442b9e743a4e0f3d490cc320ecab17b475f2be7c995a57fd2af7b34b88","src/runtime/blocking/shutdown.rs":"964c67d028152e4daa3d424d90297f4589973114a527dd081c90cbc6c80f6fec","src/runtime/blocking/task.rs":"60b68f1dc13c84a64376f078a0eed4cd9e9f160e9ac0a069b2a8b11eb748eb5b","src/runtime/builder.rs":"4380af8e914969e4c9a092c45110e856d95dd9b7e37c93723dc1866f5bc3b7be","src/runtime/context.rs":"fcaf27b7a953435fd0c3204f259d229a881c66e89eb0c0293d40750dc19a0571","src/runtime/driver.rs":"763324ba05d5901acd060532551cc25c539ee9c1c9a5a87b72450fe74f2df394","src/runtime/enter.rs":"76d42510a6f0bf159746268c316071d44daebf7523347c032917f55031f7880f","src/runtime/handle.rs":"8a291220ba9efebe2bd7f8a56668de46f411cf2c57503e15ea5065e3f2af9d9b","src/runtime/mod.rs":"fda83d496aa38c1988aa3b5724a8935762e0122b7fd7e0c19756d4c0f8f35110","src/runtime/park.rs":"e1d66e859e402068e70580277b4b128b48bda145de77ddab90c55b8a19799083","src/runtime/queue.rs":"ad4ff17a6391a39b87fa2836ef880bbd48f250444eaae68fcc68485ac256fd4c","src/runtime/spawner.rs":"fafd0c25e17e2dbe8e483e794f5cf33e1f4a460f9e9b24e30f22af6a0ea0a397","src/runtime/stats/mock.rs":"42e3d1ac41d0974c5556551ec266a2d92c5f0ea001ebe4b4d12a8eedc1881884","src/runtime/stats/mod.rs":"13f8c6deb03a9c805f081b334c0729156f4e7015b587e2fdb6b2a1712cb75a05","src/runtime/stats/stats.rs":"e39ec9217b11388dbdb82a90917917ff421b267cbeccc6b141be00f665d4577d","src/runtime/task/core.rs":"801361712c9a930478dfd7d55f738d0c7374e0676366bf6dfa9891a3ca64737c","src/runtime/task/error.rs":"eb3ef53fbcd235b44bb25c759f0fd8fd46a0548e299d36fdf7785dd55d4e816a","src/runtime/task/harness.rs":"e093b5bedaa7a9f8cff7e5db422016097c4f0548e0c363606877096100e4a185","src/runtime/task/inject.rs":"34cd85d0d9d241ad1bc34d710bac708ee2f3fbe43bb68732123a30ed99ca2e36","src/runtime/task/join.rs":"fb095b466a0d30c83e9f9f4e366f5e3ebdfdd465f0a060488a3e5be659910ae0","src/runtime/task/list.rs":"0c671142c97b3223fc060f8c4ad281c96d5e8edcd5142bc704e612dcb8820d97","src/runtime/task/mod.rs":"271846c33870f8bd07b3f4ed89bada0d85a9c008eac406f2e400b96b8846ff9b","src/runtime/task/raw.rs":"0614f9b64bcc1bdd9901c45dd40dfd74a3891bc7248bf2747daebab2a4b6a5a5","src/runtime/task/state.rs":"6b872d5c489daa68091f9b17be8dee645b5c960a1eba8df8852f27646202d20a","src/runtime/task/waker.rs":"7f8a74298464a7eaaec6ac75026382180dcdd29189b4881aed60a3166d8eac2a","src/runtime/tests/loom_basic_scheduler.rs":"c0d426c07e6be5bb881a46f958e8343c5533b068bb2c2a82cd2c6f3de4649ceb","src/runtime/tests/loom_blocking.rs":"2435b6e5165d09780156e78a2edcc5d43cd8f8f13136e9957a5d9c60cbf4ddf5","src/runtime/tests/loom_local.rs":"69cf7fa67da9e3efe3eee722791f811efb395dcf821780051e62842654de09e3","src/runtime/tests/loom_oneshot.rs":"cb0cb66e1014708a10a2236c2dbbac9441b6a6e36a49c419fa3a51af62b054ce","src/runtime/tests/loom_pool.rs":"30ea07a942c39bf1eff70cc6d7ae10cc5f0162c0389029ef0bf8b14ebaf4533d","src/runtime/tests/loom_queue.rs":"6231580e1e30ec45e4d4b49fe13ceb42747098ef404dbeb06261bfad305c11b6","src/runtime/tests/loom_shutdown_join.rs":"2f48626eb0a4135d480aa5bf72e514c4abf39aa17711c96d3829f93c03758557","src/runtime/tests/mod.rs":"334e311c0ad080139564aa56b91f227344693985ab25babc45b1d030d7d960e1","src/runtime/tests/queue.rs":"5654b688b80191b93c6e3020fa0eabb3ec22733a676a9eadab0ed4e8fa9c7560","src/runtime/tests/task.rs":"52e9bdd03d931bd24020214ddd2390dcb9ce5aca36c039853f4257b42796ab1d","src/runtime/tests/task_combinations.rs":"9ec3bfdd62aa8beed6738b36870a383be9db452b67dd4a08a6992bb23fba8564","src/runtime/thread_pool/atomic_cell.rs":"c754ad96915210f96c0169d006db224f711df4aece3447fa9f39baeb6259a836","src/runtime/thread_pool/idle.rs":"cfb7d544f925d8fe40fbdf08357fd84317bcf0058a7625e8e488ca313c116267","src/runtime/thread_pool/mod.rs":"4562ca8f2dc5d44d3cdea8fb911bb6d4db7bf742af4980f51825373642d1ee7a","src/runtime/thread_pool/worker.rs":"9b820c558e627c00956558f41be662e45e37c167032d27da7937d81489323bf9","src/signal/ctrl_c.rs":"3e1d98df851b9ea1418f607c260434e906ada4e3d6c14cdfa5c81a0c4d55cdd3","src/signal/mod.rs":"e326c839b0b8d549aff9e4e9204b99c544ab49f32ab2c5066fe3c7b8bc7767eb","src/signal/registry.rs":"2e282b0d929015a12f8264c24880333ad7d9f899cbea0b0501982dab42f1fb05","src/signal/reusable_box.rs":"3d3b710b1794d9f8f5463e9ca380ece60c426b58786a5cb5f40add627da01aeb","src/signal/unix.rs":"c88b98373a9eec9f509e45ad94de9e725de3b0d1c1552d3c78ee0aa943ebb4e7","src/signal/unix/driver.rs":"78ead5545500535c20e061b0e5809fcec15369286083ce9208a0a1fad771aa37","src/signal/windows.rs":"18680b96548ce1269615587b803186eda94521f9af8519f5ef6aa04cd706c816","src/signal/windows/stub.rs":"e080a121465461e6de2b7756956975cc755820bb7c54248b903d7d18aa79e255","src/signal/windows/sys.rs":"8a7178e52c33689420e54bbfc2db78f1b15e3c7f16632594d6d668ca1d865fb3","src/sync/barrier.rs":"ca26bd1aec007b508735dd16a43fed5ff07a080f0b7b16b4d3714ea6986ee1fd","src/sync/batch_semaphore.rs":"c47ccab2fd4ff9ef7f8fa8b8cb61e7ea162c00554802f137115926e6b995844d","src/sync/broadcast.rs":"123abe24e57759871d42b6dbdd90809ff47abd06908a140e14870cdc58c0e0b0","src/sync/mod.rs":"339338d51c28f55b70c2050d0dfb527d5111fa321c7b0be065bff41150cda215","src/sync/mpsc/block.rs":"c8ee862dabbecaa67b848abf62e97a5c445ab99e4fa7ec0a8c024e3c7bec0bf8","src/sync/mpsc/bounded.rs":"62c1cbb2712f7be5a51be75c123b1dbb26476268f1770978588ea3b9307efd42","src/sync/mpsc/chan.rs":"2c3564e8217fcbaf6d69e0217e71f8196d8617a158c7c8d9aa8195a1ae50d242","src/sync/mpsc/error.rs":"280fbf00c9d4c5ec0dabcab25d7f6ab8dac087b7aac6691efdc42bc895838746","src/sync/mpsc/list.rs":"45b165d0965695248d63bcadc17e571bc81dc2e9d7448e86517d5a9a818401ed","src/sync/mpsc/mod.rs":"e82e08d2c6ddb4e248c01c1bd1da204a4985cd279750385b41a7918b1567ad82","src/sync/mpsc/unbounded.rs":"01d047a3e2fe57a25b2fb13e489765ccfca15cce110242565087afd913cc8afc","src/sync/mutex.rs":"edcc6395db46ff67799e49b9ab9f1919ef941e65ff076fe27d0f7dccea4ec2ca","src/sync/notify.rs":"99c27e060cda27009ee4a78cd6e48f38d641ddc47a2b02c4fb55c6641177bf74","src/sync/once_cell.rs":"935cdcb05ac86fe10731c6946f3c89b52851da61e42297fc6a98eb1418eb6a53","src/sync/oneshot.rs":"065b33712b59b28cfad749412fe1aab43c07498d23381a14306309424a4c5a81","src/sync/rwlock.rs":"205900e037c49514da7c819fcf1cf36c9365f91e4ac315b67530ff041a8efc67","src/sync/rwlock/owned_read_guard.rs":"84dea0e18c35df4db00a3f77779fdc3ec4aeef29a5bc3881c9e7b26156113385","src/sync/rwlock/owned_write_guard.rs":"ac90c858c680f7d1703b06e8c8fc75d2eeedf5dc99fe57cdebecb4efaac180bb","src/sync/rwlock/owned_write_guard_mapped.rs":"6d2291d81bd6bd8563cb12bc552eaa255534c1d3e87c71254734796de0aa1d66","src/sync/rwlock/read_guard.rs":"a530ac6e221d4bfd5079ee99e73702a632599443f5f7ba94a0aeabdf37a8bdf7","src/sync/rwlock/write_guard.rs":"0d520595d4f4e6f9d1edbeadf6c51e260b8254da8f1f6fe7e4c0342c5d3f7768","src/sync/rwlock/write_guard_mapped.rs":"97dd4b14815e17efe1075d08db917df0641a693615c430b8f3ec2fd4b694e57d","src/sync/semaphore.rs":"c8636de31ff648e8f7037745c4ff85485852288535f47b825da0e725710dabe3","src/sync/task/atomic_waker.rs":"fb5cd7b7a040897e35b4585ab8128c751e556cab413cef9147aafcc234bc8945","src/sync/task/mod.rs":"f5e38105c7f8a942c0e49b973bad0a8c2a1df81deea19f3c5228edc4896c1725","src/sync/tests/atomic_waker.rs":"846a0e57db7041766298f68f47f5de520dd792c2e3a323015286b5735077a0e3","src/sync/tests/loom_atomic_waker.rs":"984b52699c47383b9b62e6c4ff93fd458bbe64cb4ca836463adbaf94d27c38ee","src/sync/tests/loom_broadcast.rs":"b2c6f138707fc389ee7d91109bc38093af9060b3465e68d3543cb652e0070406","src/sync/tests/loom_list.rs":"f0ce15a0f965fe558a21bca24863c712156eaeb10feb8ef91031a6d6e3cc5dba","src/sync/tests/loom_mpsc.rs":"4883352b9d75a81c878609613545ae14910eca4f2e7f3718053dfdb792aa0760","src/sync/tests/loom_notify.rs":"c571a81799e617222f1d07e2b9b0ae9b21ead982aea90205757b6038859abd04","src/sync/tests/loom_oneshot.rs":"c3596c15692b16e7cb8cd6957362adb3a98b3d7f16c4a4262f19a3a27f262b03","src/sync/tests/loom_rwlock.rs":"80ec00bdcac838806d4d9f711cb154e02f22913ba68711855c39ca92028d3e4e","src/sync/tests/loom_semaphore_batch.rs":"c6f69b8d5b2e6842287ed34638a9045095d9f94c86ba6bb84c1224bbe10026ff","src/sync/tests/loom_watch.rs":"558ad9bab3f18b79a0d46548aff24288f1c6c5d0581e51559cc2a82cccd0696c","src/sync/tests/mod.rs":"1ef2026ac3dfbb70a437b8be441deca4b7b5e72638b71daf753b89808cd3c9ee","src/sync/tests/notify.rs":"7691da277f53c23174781d2623e43e536fdda5fbbe9a337c1dd606eaebb67de3","src/sync/tests/semaphore_batch.rs":"a2eda9631a34c1c12dc39cfb584c4135b7da5b1ce3a00751c6e51ef81ef81e2b","src/sync/watch.rs":"099c7224563a26dceebd19d5eaabe29b341652f6e55ecf5b1a02612e841b060c","src/task/blocking.rs":"3fa940d88199467b8b80227f4ffd9c9e19364f29b8b0c198ebec5d12ea35209f","src/task/builder.rs":"b3e5c1a8e786519189ef05d3e26c64549370464ba6ca9aef0a7e684d1c35ae76","src/task/local.rs":"cc435e184f0c9f411d0b8044a43e9cf71adb9b7a59ae7881efede1c7eca388f1","src/task/mod.rs":"d80b80f4a0d0525f105cd8fd0f36d4c504220eefb5d3b27aa2a40943c87788a0","src/task/spawn.rs":"66956015042a64c671a6e9ff67c0fbfe5cd10889decb681511d3a6df3d27e2bb","src/task/task_local.rs":"9b6b1785410072cfc32ee9546a09109e6c96a31623c926db37e4516fa3b93c53","src/task/unconstrained.rs":"a39131550205cbc0b0ad5e4cdc1f3326ab243774a31fc986cc4ab0f27f356459","src/task/yield_now.rs":"c15d0d94091532afa9bfe52bce73ca76f9ba6ef3fa5ed570ceecbc568611afc3","src/time/clock.rs":"5a653de458a61c1c6343167b5fb30dafdb5fcf29d1103869a03cbc228d6b15c2","src/time/driver/entry.rs":"34e6a34f2c629215f6d923619994f880ce7894ae0a2952de2e5d6c48d04c338a","src/time/driver/handle.rs":"7dff6bf815eab2c34309cb23fab0a6fcd3a5d0ef0bf28a6edc8e841167d66600","src/time/driver/mod.rs":"dcdf7b31e69bb37ceca152114d722aa8a3a852e2d8048e881e7f1eef22cc7996","src/time/driver/sleep.rs":"1c6002d99fd4ef26b9bd621140959101838e4816fbbda0fe0b16bccfbe918961","src/time/driver/tests/mod.rs":"b56e40615bc2a83c1d313256a2a8007e467256bed242eeeaac54e225df6718c4","src/time/driver/wheel/level.rs":"798f3531be93d40926fb8f5e9105935898e669549ebe217b040c8279614f978b","src/time/driver/wheel/mod.rs":"138edd95c6a095d2edb53754bbc40bc719ae3a8bb10b4d4fa2daf67c27f6a508","src/time/driver/wheel/stack.rs":"3adb5316b814656d6b271c85b99ecf2f23431e966ab4cfff26ba999ebdd8915e","src/time/error.rs":"2ca1e032254ee67087aa15255d9434067c65ef84d143cbd01280f037bea8c19c","src/time/instant.rs":"97e61118c22eebecce9ab493975398d5c239836870f7e6948cb390159a44835e","src/time/interval.rs":"1e22203e16e96aa1c6418b26237ccd3049f6031a52e69d802d2d595eee676423","src/time/mod.rs":"e1602cbfa9a93479b580fb1e205751e0551a0233140390dcfe5177b2cca252ee","src/time/tests/mod.rs":"d5a5971423d84c60593baa494e71bec40655266afcd532545d70a680fc014cbc","src/time/tests/test_sleep.rs":"78c97ec7816ef02b89749b0c0384e2bb2f34a3e5f5daa1480729fee91e69bec7","src/time/timeout.rs":"986b36b96f6063d0c6f3d4f1801360546546f54375a05b16ab8df301aef3ab7d","src/util/bit.rs":"ad3117c9a8b1e312114a72e9b315c37137af61da51ea458832d46d2c1b88879b","src/util/error.rs":"d13d6f901192c38f4f3656ff0f2fe81b82d37ffc2a10644ea9ac4c2b0d2119b2","src/util/linked_list.rs":"0bd3baeae28231964112b1020b34091ded17df362542af4bc8169009ec8f431d","src/util/mod.rs":"1a9a123fa8b5f12f629c465f1b30595ab3717d1b1744e76dc829eb4c89b2d540","src/util/pad.rs":"5dc99dbb3d3d16fecd6228fd2e2f67e5301b2d426e6149f79f93c1af1b4d1d90","src/util/rand.rs":"85d46431198a8c07d08c969e3556245f66ab7062552e3717d100c6d6769408f8","src/util/slab.rs":"4c9124f44da1c2001fb156b26fa3653fe61c8b69ef5ca66910e1bc0fbe435da7","src/util/sync_wrapper.rs":"8f1ab76280171c33c0bafaec9c1cb1d48cfb0d19a1ab2b768cdf7d7e40f07d00","src/util/trace.rs":"a74e0631d4b2171595bd97d5092168820863c192c5b801dd5d00256a1d896718","src/util/try_lock.rs":"c4ee49e1751ee0a7df1a8cbd4f8d36ea1d7355e3ac584fdb8697a94cd7a7a8f8","src/util/vec_deque_cell.rs":"ff7d49cc4f660f55cb6ece97d1660bc5c36dee1eeb42643187ded07a33a0a6f0","src/util/wake.rs":"61131e69b7d52e745491a6e714454b2063eaa163f9e311df2ad4c0c1f6df5655","src/util/wake_list.rs":"c3443e695fd0b5c41c06d66cab96549064e9b645043559d01f82f365dcc4ff6a","tests/_require_full.rs":"a7d828d85aee8507a0292fe74ced5f4e75b0aaf3a2789cf0bddd276e9fa12dca","tests/async_send_sync.rs":"01aecf6ddc7d6187e200cb133d49d5fb2e65bc7fd5c4840b57cee1e66d997810","tests/buffered.rs":"3ca857823d8073fecd4175dcb886558a3c6f3aec81803a90c5f786fc3edb4a96","tests/fs.rs":"b4902aaff2c28ef4d2676462381b04559fb4f7cdc0ecf46c46bccbb6276feb5d","tests/fs_copy.rs":"83448b19bdc332ec315024d4903b0a2ae81221895725a8b750025b47a43b0e79","tests/fs_dir.rs":"d9a837aacc072620c621e7e9799261b44873feea51cc6d25770bd3ff93abac00","tests/fs_file.rs":"d5ce8931976a6909eb656f90a3f9721a9788fa1e4965d7400bf196372925d1cc","tests/fs_link.rs":"01689c5c69aaa33543399164e2036ed96ae6e09b006c8dbe8af59df8c63df47e","tests/io_async_fd.rs":"ed56435564501e1cadd284f180dddfbd747df72e74c4b7b7a77bc166383bab04","tests/io_async_read.rs":"a590efe9bb01986f067118640a3b55f6760186e554f8e8f2404231d4e96f61b9","tests/io_buf_reader.rs":"f5a322dea6fe9f40c18a085a865919c1bbfe8653203b37d1e18b77d259c6211d","tests/io_buf_writer.rs":"4327940f81c0591e5c7b4a2583af1d42169c9427bcdeb88327d9a351f02d43fb","tests/io_chain.rs":"f5d3ddc9f6e8152ceb08b5dda2ca3168b174f1f67ff28a4c5983bcbad69d8af6","tests/io_copy.rs":"0683dee400710c1696a6634ecee64c39e7027344e66bfdd6b2a78de8ca913555","tests/io_copy_bidirectional.rs":"8ec51c37395f273de8ace88e7203ce78af2c4acf00b33fd968239a644d28a8cc","tests/io_driver.rs":"76db3259c69f66ac07e5b8bcdb1e2e46d42e06e202831d8ccbee835b2dfc9714","tests/io_driver_drop.rs":"31e7002a20ab65b6a91904b4784047bdf17b8cfa134edef04b394430a43573eb","tests/io_fill_buf.rs":"a520725811d266e8833dbfb62999d4a32ad8aefc6403e12a51f8b0fd62530436","tests/io_lines.rs":"f5b1599ffff44819e269519ff0a08635ea1c5d7c541293e63ee33d98f25f0e3b","tests/io_mem_stream.rs":"d1a9397ddecace3172021c212637a3644be6a6ea366fd1fc36dbcf04b485c156","tests/io_poll_aio.rs":"165f80ebc81e8ccb4d335c9b9a89d960f097de9b17e92bc964effa3c76ce5f98","tests/io_read.rs":"528a2146495c53b271af460c0dcba28d54cc71821811002a7f8de213b4cbb385","tests/io_read_buf.rs":"3c1a7820fc5e486fe34c6fb61b3e1bf8d18587790a4897a732f325bdd438721d","tests/io_read_exact.rs":"b6387dbeb0baceb7a1f74a9a3a8b4a654894465368be27c3bbf4352b79fc4314","tests/io_read_line.rs":"8296624b4f5e162c79024f3beab2f561f4195a244cfd4c53e4d06282f56a31bf","tests/io_read_to_end.rs":"b5478431bf61dd66cedeb8e0ef588ed8ecd6d9e0feea3655512019b4abe9d451","tests/io_read_to_string.rs":"c9ebfee5cb262d822119c2881ea1cc0c73598b13c517c297663e35bb120a089d","tests/io_read_until.rs":"b6c0df9e4852766910ec68affcd92fbfbc280018b7f9c16cf5f4830f9b8389f0","tests/io_split.rs":"b1253c9f3e733e6bd1b6e7e4a1515606902992e15e57c8dd2ef28ccfcb7618d5","tests/io_take.rs":"8f4bfc9182539335704b6370a66998ef2a75f508fcdb73a7f8aa50baf0f4aea6","tests/io_write.rs":"98668a8c8feae0f85714df1dfecfcd94fba4ba347bdc3d8aaa4ea8b175055c69","tests/io_write_all.rs":"e171af1ecab45a439b384c3bae7198959c3f5e2e998967dbd9296760b52951b7","tests/io_write_all_buf.rs":"2c037f07ac464eaa4e0b87e4e4968b28a0f2f1b1d1e218546c9d5dac7a75d145","tests/io_write_buf.rs":"331d3b54c7664386bb87585f39910d1fe31bfbdfa012a2dc2120e535dcdac329","tests/io_write_int.rs":"3f4b50345f7d7d558e71ac7f2a8c1c4b7b771dad09fe2e1fbf9a17d4fb93c001","tests/macros_join.rs":"107e8b96a8654ed1e3ec1d9c7f41f44f2542f802c6324e993f0fbd6679912d87","tests/macros_pin.rs":"572d65b3894858ad8c2491b6a5f8ffdb3b37ec71d2996831b2ad929c4e47d067","tests/macros_select.rs":"ca09dfa0e44ec7bffefe75c661db149d20a34b757069fdad523e044d303989e6","tests/macros_test.rs":"d60b2877efca41d2dd1d108d3641dc895cf60424f6bde38bce50cc7042a91115","tests/macros_try_join.rs":"3b60eacc2afa5d39a2e447e96d5ae2d4bf0ea71e213a249bc0db3b8d234a80a1","tests/named_pipe.rs":"fba6c0d454a78ff938056d1573f07ebcf1844de386f7331c6750681ce16feeca","tests/net_bind_resource.rs":"3abdf9457ebc9f8262c03fa5834f1ceb6312d4a1573b6bdd4e2f584e3cf76b66","tests/net_lookup_host.rs":"fa43c0127277dd0cf750b17157fdc1d438a8009dd890458f9c566b3a1302a461","tests/no_rt.rs":"5f8f611b369e016dfdee970fd64462167dfd7c1861ddac9ec00aba665694a872","tests/process_arg0.rs":"785d801cf281230e3208512820e7d71b4d8362b8cf33fc72235da370e10983a8","tests/process_issue_2174.rs":"66c56d8dfda4e1723928da713dddea8d15774d6730398effadf0ec28f4c6f1e1","tests/process_issue_42.rs":"26043f8246b00046137551f7a9f638652c70f527f10b4d91e4286643120ca41d","tests/process_kill_on_drop.rs":"56d908ccead7fd23d1f73976524cbd0b0f05806d342818095f2c6803469cc3ad","tests/process_raw_handle.rs":"54498de544b61e95d75bf6e92779fbd9b805a434ffcd1ea18496a1c5cd7c7522","tests/process_smoke.rs":"3554f4a8c8b76ec0a3b79f4ae0b5900edd34255dd3adc561e8e9a77f217b1956","tests/rt_basic.rs":"37592e784bdd939b27f18d4f822bcd2d19798e6689c78e3e7624128665ab1e39","tests/rt_common.rs":"f09915824604a33c8e21098c84c648ec09cf4e26ccb3a8e43fda7f58df10f31b","tests/rt_handle_block_on.rs":"858d9a6a1eae28ff2d59c5f4c52d1b21eb7e2996b0f909dcaed11e525443d2dc","tests/rt_threaded.rs":"3d2c1de53267c043495a779c52947ae266080afafcc30bcc9ba5317b83c733d2","tests/signal_ctrl_c.rs":"9b53065781b37f3db5f7c67938239b0f3b0ebbc5938c14a5b730ad7ec07415d2","tests/signal_drop_recv.rs":"d1ec97213d9c6fd9fb25ea8c2b015c9e9ee1a62fe0853fc558bc8801e5a3a841","tests/signal_drop_rt.rs":"f968c1154262a4427b5aad2d9fb36d3b7d47084312d0b5527a8eb3d589381d8b","tests/signal_drop_signal.rs":"041940550863250f359630dc67ef133874d809ddaf0a6c1238cee1565a19efec","tests/signal_multi_rt.rs":"a1c50c25f4707fda7665da61b3317dd61fc32c63c61db2bbdb56065bd9c591ce","tests/signal_no_rt.rs":"99714bf488a26b6b394d93e61639c4b6807f9d756c8d5836f31111a30d42609b","tests/signal_notify_both.rs":"bf0b9def20f530d146ee865305833d8e9bee07a0515e66573d7ff30e2c631123","tests/signal_twice.rs":"bce33093eed151955d13c334d6d8a5bc5ca67cf5b37c246e435a24c15bc166a0","tests/signal_usr1.rs":"86ad07594b09d35e71011d1e12a1fa2c477bfbc4a2a36df1421b6594a0930074","tests/support/io_vec.rs":"9b3001e120138ead4a63720019c669ff00f8455a74dea2fb231633b3b58c9b09","tests/support/mpsc_stream.rs":"00d48122fa2ccbf1fe0b110ce3cf22590eda54b3ddec0134b1f9376eb1169645","tests/support/signal.rs":"83531afa2e8e71cfd90cd4e1fc821490ffa824f0f9f0c9c4a027c08fed6b8712","tests/sync_barrier.rs":"7771f9e75ecf24d1a8ff0a8731a6bfced34cc129aba0e6f7b9b73d6a1d6df999","tests/sync_broadcast.rs":"c30999b68cd763592abed2b0a6b25407b3362f5c7b9521d766c5ad8fd1e94f37","tests/sync_errors.rs":"d75d041f946ef8b0a726f4fcb3da29d7248485b5a28f0fd68adcffadd8852549","tests/sync_mpsc.rs":"5d16bce9b53b3139199bf3877671524156f11602c057b264e6c2007278ae00d6","tests/sync_mutex.rs":"ee69e10e779effd59339f39fe739848c87d6440723ce7e5666df772f9e755970","tests/sync_mutex_owned.rs":"76e339388f5d288fad70f384bc35ea74dea2fa233de39ea164bd4ca3b611d5f4","tests/sync_notify.rs":"022e6ac31214bfbf8cccbd8f9d12811818889dfe9744059346eddc44e8f0691e","tests/sync_once_cell.rs":"639d55248775f2cba0709919a3b2ff4317e70f081e09444d0a67791d65dfb3fa","tests/sync_oneshot.rs":"f6074fe14f6143dc82986847d8886bdc6631c79e532a74aadc6934db25742190","tests/sync_rwlock.rs":"145d5ac0750df83523b252c8f58857a6cc5fc190ad965a2fdf2d52d11ec49fab","tests/sync_semaphore.rs":"f0613025f27c78ec86af1ed86bbd3085423babaf682b8a3f53baded758dcef8e","tests/sync_semaphore_owned.rs":"6d746b7caa4a5894d15c600659f7c10e078c2189e670d00b89474765900c2270","tests/sync_watch.rs":"09216b5e6f101a2a46a9913c3966771191c896c9b89a5f0b532f8da4b9b316d1","tests/task_abort.rs":"a12920188752719d557a77c96586b1ef5917c424eb2b1237f90e017f01d51e25","tests/task_blocking.rs":"241574dfc0793008f80d64c3f6da64842fd1d46cc88964b59380e6796e0b116b","tests/task_builder.rs":"9f0212ae4d7071f2e491effca992ed8884b2ef2e3493a6d7ee3fa659cc926338","tests/task_local.rs":"c42b99a64a3e195bed08c3065f179bf20d9fd15e02c42cb54b9bac7e1e60319e","tests/task_local_set.rs":"dfeb90355de7ffd59aa567bbae5539f859b55d64255e6c71785118364c9da8d3","tests/tcp_accept.rs":"a17b374e8bf590633d5c3ba434ca0a8545ad96d8c01e140bb8418be968bd8cc1","tests/tcp_connect.rs":"3e457719e2ecc877090e039465d492706c9d0318f483c70fc325866ef84108f5","tests/tcp_echo.rs":"68d67368f1d9f9dffbaa9fb1a0ef71e4f3700a76aa5a2c3714c8cf7aedb0f1bc","tests/tcp_into_split.rs":"9636970f8450139462d7b88a4994ffb6c4d77c92f89750ad9a479ee70b0ed5ce","tests/tcp_into_std.rs":"9fab18181788d46e787e87fcdbbb2d1a24c1a60bbe8bcb1bb1e63cf43326c643","tests/tcp_peek.rs":"ea904d05f9684e6108a698bdbbd856c9849c1a51eb334cf5bd45ef74c8fe585c","tests/tcp_shutdown.rs":"68f3a5b9d166064f63819a53bd07bd1c0988c1c84832ac4a35ac9b1ad6f447f4","tests/tcp_socket.rs":"92a1bc2920d678f27ccb796367ec3c2b81494de287a8d5f7a5cc6e967d3dce07","tests/tcp_split.rs":"e967b01bb90e2081e5e08e8cfd619cbaf0d1dcd08c4e77dbd5bae893698cae85","tests/tcp_stream.rs":"0b597cfb53d00e2af278b64d74b7de6a1436b36b3a9a4966de3976c52d6f37e1","tests/test_clock.rs":"d5c9bf7bb5d926e2b29b43e47b5bb051b0f761bfe44d5fef349ed442ea7b416f","tests/time_interval.rs":"ea31a95eb0a422e76ea1c97e58f11ec79c2bf209ecfda78bc9db65f6b2154668","tests/time_pause.rs":"aadbea51adba2f437bffb3a01f444e634f629651b1bdd89134354e5ae4782ba8","tests/time_rt.rs":"2981f4a4c276b306c4d4bf5684bafbaffb0789ce7bf8d2db3556e5208bab52df","tests/time_sleep.rs":"dfbf5f7f53d8f1abadc2b6b15eb2893638a845d491d116251224a738df901540","tests/time_timeout.rs":"60d13e4647254849fb1535b12645b108fefa4248cee3990d871e3776ed1df207","tests/udp.rs":"ad6dfeda7a4721b7bd00692a05c9d668013c7f5e86714e6ed1005b99eacabaab","tests/uds_cred.rs":"146c6e9bdbb82a268f178b03575f94a40db81ef67a740dd16ead5b9e4a447f1b","tests/uds_datagram.rs":"06964ba9c88e49296da2e27dc8ae0d2bc85a55875a31f3875cfcf11f55ae6851","tests/uds_split.rs":"79d54d6ce35e5d15138299091871ecbdb6492ae6863fe406021fd7359f1ed7fd","tests/uds_stream.rs":"d672ed046b6e6ad9e2fd118be91c788680972e3f5271e91857f29c2e25d1b9d8"},"package":"70e992e41e0d2fb9f755b37446f20900f64446ef54874f40a60c78f021ac6144"} -\ No newline at end of file -+{"files":{"CHANGELOG.md":"2df658c0698b831c12d3d54981fd33bca1b767d17ba2a704c034c9fd2906766d","Cargo.toml":"271348dee3d77ab1838b074d2009cd4671217412eb134d6fb44b00e820bc9a5d","LICENSE":"1a594f153f129c2de7b15f3262394bdca3dcc2da40058e3ea435c8473eb1f3a0","README.md":"b9907ed688999a322164818659c83b48208c97c633ced7b09ad926aa010a25ed","build.rs":"24a1a8aae38051a322efa9f0e858bf0e76b2f062d7cef536cb6390d1530b9c51","docs/reactor-refactor.md":"24d4f3ec6d8828bb96afe0084df9e7739bbdf1995283dbd2cd76740311485b75","external-types.toml":"d808de4bbff94d5ea56f1b1783497b0c6cd107534853aca8c79ee8404d8c2399","src/blocking.rs":"8e62b2cdc512fedbca4b4c4f983629af035afea4ee7e918bb1a3e9851c8e034e","src/doc/mod.rs":"f54f0d17974e68bd93035137a36b216dad05402cd4f3f64ea7e0008e7c309858","src/doc/os.rs":"727a5e3dfd3b57609f6054c32965d6825949d5e7a5c751f14b50dac3b7ca065b","src/fs/canonicalize.rs":"93c64b72abdca17877d6ab61d50a43765d6aef9e0a9f7aaf41b6b0b7d9a8a380","src/fs/copy.rs":"262180fadc66e5ac2bf1e8389628fdd039f14788e66a4f8b10e10633e7310f20","src/fs/create_dir.rs":"233cbab2579a787614aeee88845a57f1578e9c2e064a3456c799f61430e911ad","src/fs/create_dir_all.rs":"56081d541caadca0fc59e84d55e78e702fe9373679598016224ad0b072b189a7","src/fs/dir_builder.rs":"b5b21229c7bf15e2074afab1accfbc392f3c69e546c7b652cfdc8e90d5a4a301","src/fs/file.rs":"29878fe127e8e192945b8fc0ce564ae1a613c793e389fa568c95bc26f803be79","src/fs/file/tests.rs":"014b0bd871a58d42d8b97cf2d860f83693294f935c808f1406f4b26e5d09afa2","src/fs/hard_link.rs":"98cccbbb3719baee11c232e79723ab1cb3d6c8056bddb109c4990fe2c236c1fb","src/fs/metadata.rs":"782a1a5dbc2cd6c40e928579fbfcf39e5f1de28def78781590c0280acdf02960","src/fs/mocks.rs":"d3718127d1d0362253bc7c7ca4d6abd21548fe69296291d1ae12a97ccf7fc196","src/fs/mod.rs":"8743addab538366cbe90b43cb233c54e1be524c173b9e659fda4fe9fd78060b2","src/fs/open_options.rs":"cd8acd3deaa339f38cbe14b1537ca4b07b9830105d3b385d965585330c824304","src/fs/open_options/mock_open_options.rs":"60ebc4bea76d742ead8fc5b5f4079450eb2450ecfed5f83d7d89cfe148f4ca54","src/fs/read.rs":"055ae8b6ae96ebae2d05f8780e7592bb587a742506c6df8ee8b380fc7d2820ef","src/fs/read_dir.rs":"4eff5170cb89a9ecfa9745c66d400124045b1b4f3dd30597cdfe49027a13b4d7","src/fs/read_link.rs":"93c104a21253372fef7056ab82e6065b0a1a8fc9be8b7329dfd5a8dd07c618b0","src/fs/read_to_string.rs":"9e5b2d476a6084e32a92c5421a8abc9d4f335f4ec677beec4bf8bfa109d7d106","src/fs/remove_dir.rs":"96475771e9c52678768288d8df6814216e0801bebc848481597ad34e829a5854","src/fs/remove_dir_all.rs":"b85abd05c7ab64ee8dc6cf5663a11e713aa51b357759ef660ef3cae3365ccc42","src/fs/remove_file.rs":"1cdf8bf16b3a164c594dac8773b7d1f9ebb28de169343184d34d6aac3b3a7eaa","src/fs/rename.rs":"a97875e92626fa46e23fece7b8698c9c4cea2bae8f1be8726f30ae6fe80ae0c7","src/fs/set_permissions.rs":"8adccafa475dcfc1bc3989af73374d90683c1be4953ef812e5fd606f968d7b7a","src/fs/symlink.rs":"32cf3e906531d30ebe6d8be7ee3bfe049949759b566015b56d0851f51abcff50","src/fs/symlink_dir.rs":"66a6655f5306854a7b6ed3748598bbe737055da9635bded715a04c3abfacda7c","src/fs/symlink_file.rs":"ec5816344f8c0b79c4d84e0ef2a987d753c719afd3bbc0d0a739224477a9edd2","src/fs/symlink_metadata.rs":"f5ce1e05f137da995e3e0d9582bae0a5f7ef4251285c64e912b0eedbb068b395","src/fs/try_exists.rs":"c666196690c4d45991374b03b27f0838b33e98d0be2838638d4de4ff856894b7","src/fs/write.rs":"1ffb734d31748bd879ad398b0fe99bdec569782b42677022957db2cae95c4d2d","src/future/block_on.rs":"30bad79b005a1ba7f696bec5639a5886b1f653a152b8948ae5fcd287c05ab8db","src/future/maybe_done.rs":"9042619f2a907e81763ac6082c080faa28af5d571dd49e82b60f3f14d58598f3","src/future/mod.rs":"6f28857347c50cd6467f1ca7d1b1028b633de7d142c3f3ca710a8693d1e839f9","src/future/poll_fn.rs":"b3c0eaeb442991d3fe27f53f2c2849f5f40b0f974035036c26661bcdaffa09df","src/future/trace.rs":"c42712a8d372922eba7e05cd21382fe5df5eec02cbcc870062100b59ab99654f","src/future/try_join.rs":"0ea5a069b17a34bbc091acbd74b9d51794a55a85dfa63fe2404d5ee91a4f0038","src/fuzz.rs":"db998767c729f35320b1d489f43f4d7788e989c8d16c0793188a2868207d8e25","src/io/async_buf_read.rs":"b37caa8f6c974b3c97327c635218803e573c531d4197950840549aa794357c99","src/io/async_fd.rs":"2ff1f92471e43f9445ff9dd6700180e6e5053bc46f7da66b6adbfe78cfd46732","src/io/async_read.rs":"f52c8d2f4a283c0dc8d06dc974484749973125b0b691bc0c3d100972ac67cb92","src/io/async_seek.rs":"a9a0df389ff2be3d79208ec475fcfede46a86f6ea0b822b1a4ce8273ec714b0b","src/io/async_write.rs":"198ed6a475b6f093fd2ff15e618d816d7e33cb8bc28d2e2299533e5df0bd78d6","src/io/blocking.rs":"b94dcac1e0ca315b356e7a71e5d71696e79363b92480603e699051e390b62873","src/io/bsd/poll_aio.rs":"45e818a201c8dce93f612c7856ba4259724d2c9fcf341001eb9833f821f16f3f","src/io/interest.rs":"2ca39d709d4ccbcff2101f977b2f6fa1ce3ccab9e5383280789cbc0dbfedf0d2","src/io/mod.rs":"b0ba3446cce66a7c51654e22e7386ce6242e4109f994c9af4cdae7890ff30b8e","src/io/poll_evented.rs":"5af0873f5b643444670b958c159202236ba4108a5d09fe6de5a997c710d785a3","src/io/read_buf.rs":"14f82f701d5056d1d5581c70aec98f7c6d287899df45e4b2e82388e7c97cca57","src/io/ready.rs":"1aef67e24da20fe76e3b9468d23c18af1ce1a94eed1a44084f4aa91da1e62f29","src/io/seek.rs":"e9e346fc926c3360601b80a8319a25fd0567dd6f77fab666694e9787deaef633","src/io/split.rs":"a8cde1b7b2dacccf31647183db475d34e15b000978f7d0207f34ced2506167c8","src/io/stderr.rs":"76cfb4eea6ba478ab158fa269c11ec56ac5ba91d2813417cf0b7a838a45599af","src/io/stdin.rs":"54b989a7a057fb784950fff882b331f7860326cf5adb1b66748df98bc93ab08e","src/io/stdio_common.rs":"f8c72bddf74e48af264676b36470636c16e227b46740c46d44f6b21b2a44bef8","src/io/stdout.rs":"ba7468285659fce3105fd3e02fc8f2ec63a83e01e3081520b6912534614756e9","src/io/util/async_buf_read_ext.rs":"7f7fde910ecd9e526bb85882a318f457dedf6ccc2cdbc693112562186dfb78de","src/io/util/async_read_ext.rs":"f70825f0be7ebecce5473c53c716cc57f1123e5818f7b917444c3892639a5e2c","src/io/util/async_seek_ext.rs":"0535ec6139be7ea68becafc0d374aaf9d996ce9cbe5dca0b8e70b133a661c1ea","src/io/util/async_write_ext.rs":"b8ef64cd0b8b57036297cc90f66aeab6d97ba20f33dda0cab9dd364b4509c123","src/io/util/buf_reader.rs":"670a58f404e5689daf1f2b3070b0b9e95fef96ad19f0e8487f294e8a2afe558d","src/io/util/buf_stream.rs":"2246fe71b707c15d7168c5da5ee158cec6e854d4fd11b685531c16a9c3cf2c6a","src/io/util/buf_writer.rs":"f9c3e018c9f9177fb6d910096503caee727bebd3c36f5f67dca2c4c55044408a","src/io/util/chain.rs":"5cd8df2cc7bbcd18ca2336a78507fa8009c0a9e595f81730a8c16cadb8f731a2","src/io/util/copy.rs":"f4c7d59736f9a6d8a1efdabf9685dce2ccc3053c5f9578d3b3aab4be58dd5c8b","src/io/util/copy_bidirectional.rs":"89a5fb3f77e9863c9496c02afc2613fce039f47a1b2322e6221dccda8323f80f","src/io/util/copy_buf.rs":"9d83771a6edcc6d0d32f066072e375634e21a13517968ec9b21a4edddbcc2605","src/io/util/empty.rs":"4d82f3995cde9295c5d2201b1ea975fcd4ee44c466505f189bcb4f2a7798a66b","src/io/util/fill_buf.rs":"223725d828071e923f25d2d49a0f6e470c411a6d9ba225700f2dd8d5793601bb","src/io/util/flush.rs":"fe3b4ff226e294843b8cbea9dc4e02d581582b78ddaafce137c96e290699c718","src/io/util/lines.rs":"1d9f9b99567111c911e72a4caa2abb19b277f2cdd0ca3268ac5ca6df5276259f","src/io/util/mem.rs":"84f1b4205bfff05c89aa3274628c7449cd7398bdd632a5fa8790a85f4cf13064","src/io/util/mod.rs":"6a9012d78fe2bed8240e7a628e9421cbef45433551522624065fdcbb329f3594","src/io/util/read.rs":"58988c3fbcf5ede633dc224d7df5a372495c4485757dec9bdbd825138bb7f5d4","src/io/util/read_buf.rs":"a87be2d115c09a6782ec8cadeafc92fb1fbe534580e71540087c3298a03bfca2","src/io/util/read_exact.rs":"4a8650fd7a885963a0fef2bec24c17046c5624e4dd7fe229ab3f33c4a92fc66c","src/io/util/read_int.rs":"49da230796335df584832cd7deb8370b4d1e0350d743046389a9d9ae17dbd94f","src/io/util/read_line.rs":"9cdb2d778b81bc50098a6851981ed9f541bd0c7896c0763b811971b5a598b7e8","src/io/util/read_to_end.rs":"1c061665818a4ca9632403aa95955bc435f4438c6d6317370ca728fb47acdbc5","src/io/util/read_to_string.rs":"fafb5463b013cc8f76def3a505dbebd179afc95bde0e2ca9388e428265788924","src/io/util/read_until.rs":"d9a932dfb5ef3d0d5e8faa72a2b3b9d1765c85599f3bc77741f69e7fe9c0d037","src/io/util/repeat.rs":"d4effcd81338831eb373cf2db972a99218b8379b91066940a732edcf4524c7c2","src/io/util/shutdown.rs":"971454342b4636fbd68e123d59d87017d81f72afb410c385846069b11def8efe","src/io/util/sink.rs":"0dcb794e48ca9b1c28e5f9f2051073ea0951a54c9c7dfc903ce9e5489d3d8cd7","src/io/util/split.rs":"03a59adccda29608886e38a1f484fbd4d6a6019180c4cfa851372d250796aa5a","src/io/util/take.rs":"ef080ce27d23cc23b9f99fe14ddd56349a3cb1442aba18f8405c30d20017b074","src/io/util/vec_with_initialized.rs":"f8673705967021b5a3cb819d672df89ec81eb5baabb48de7bb598d53352b62f8","src/io/util/write.rs":"20d14ee545ab1f67732915522e97808d1ddde13d151505c1289b596be519f7c8","src/io/util/write_all.rs":"906ff3fb24c6a979b104598f9a8229421bcaf2a4218c28069504b34a218241f6","src/io/util/write_all_buf.rs":"5911bf673ef89097938f4e2e38d9012865b28a0ce5ebb217ebe0e2507de6c1e3","src/io/util/write_buf.rs":"ab51d6174de24cbb729ce77dbaeea27e16059b8253e4830d8243ec5f08a08a8c","src/io/util/write_int.rs":"f321e69b0c7c01728b079e9fdeedb96c26475667e8b259d0c5f4a83d060990d1","src/io/util/write_vectored.rs":"7a335a9f796daa048fa9708dc44d32d2567b36461a6d88f07893eb31f304b69d","src/lib.rs":"190603ce38ec5e623af3e6bc75502bd4791df612026b3da43f340925eab57b68","src/loom/mocked.rs":"f0322f61b997ed86bd5f729a55cd862d56ec7602af711772094fb4005c7268f8","src/loom/mod.rs":"b14b9333a7a21bd125a4ae82f01e5ea9c9ed2f78d7d1ad49a13d9b176f1fe8ab","src/loom/std/atomic_u16.rs":"5aba33a798e8a95129e3fd039e4412322e25880003ba782031df9faac3dc93e1","src/loom/std/atomic_u32.rs":"7fbaa448621371cbb9b8dd882701236b41bed599d69eeeb0a1e25b2a9a4645ad","src/loom/std/atomic_u64.rs":"2d98d1608058f3248d79b1e9c96118627fef6362ccfefa77047be2e5617d7571","src/loom/std/atomic_u64_as_mutex.rs":"1a6b9f8417e968a78dcddd8c7c320c447b9f27d5f84245cae86c3ef68425c749","src/loom/std/atomic_u64_native.rs":"559e6fd21e678b904f5a905f2756a4a8e32ca68a8c7a9b4344af86979373cfa0","src/loom/std/atomic_u64_static_const_new.rs":"a1c0e7d2ea28904ae76227baa7da5da33b68257f4c1a7a456f8d3171529bd934","src/loom/std/atomic_u64_static_once_cell.rs":"92a25654dd8232f6c02c8ec58d4f706030db442fb2a5ba07f1aec09149559725","src/loom/std/atomic_usize.rs":"698c0a65ea4d1ad05d49770cef2614cee643794be4b6208ee071a3e381201349","src/loom/std/mod.rs":"8cb8ccb02d572c3c3d4a90bff632b9991a6b75f8ca64fac3ff4d54f8d53dcc3f","src/loom/std/mutex.rs":"0899bdc1302f1406aedf96ba8b1a890abf743188b442d242b1667d998952d17f","src/loom/std/parking_lot.rs":"e29739d7894c61a005ba29b0ea88dcf34ba24d9ea8fcf5f19b9e009d81095952","src/loom/std/unsafe_cell.rs":"05e2b4d8e78b0435650c6da6239ce8c53b4de2573e64ba098354b049f23429ec","src/macros/addr_of.rs":"cbd020a07ffba2b1c608856081499645cf606cb45444dc53d94457381a94bc33","src/macros/cfg.rs":"e4020c3839a84f3f9d0ce6b79d525990feea33c900117acb7f98956e1b72b1a5","src/macros/join.rs":"076dbeed1cbbb292e39012d18c0d1c97848bce48c4609b23f327025989b34a8e","src/macros/loom.rs":"80d2e4af9fc50d0bda1b20b95f8873b2f59c3c0e70f2e812a6207855df76204e","src/macros/mod.rs":"f180dc5f281e57fb08491f9283dd14c7a72525d2726ce68aeff0125f3f18e830","src/macros/pin.rs":"294e5644061e41801dcee5494b7334439e09af0b6219ce164090feb624864631","src/macros/ready.rs":"6efd4c866c4718c3a9a7b5564b435e2d13e9c1ae91fd98b1313d5e7c182942d6","src/macros/scoped_tls.rs":"ae431d108aa75645e68ce07dd8782bd7321b95ac66e30517f8b535adf70be7b8","src/macros/select.rs":"4d9588dd514cf9f25b8c3c76ab08ad141d8f7ed1acdd856c6418946edd08f055","src/macros/support.rs":"da976befe4ba4d29e96f0de24cafe6e1f7f97364274e240556a01f2af77314de","src/macros/thread_local.rs":"5e759658d18035af5aaf907237d399c05d967f94c71c7bb33f36f78ca768cf78","src/macros/trace.rs":"33befd4533a3b2b4b22e246033f2bea8930174a7da58adaa57dbf20931275bcd","src/macros/try_join.rs":"2233cb76a6ce35d020ebbb8a0b0d713f01c0b6fd20fd878442bcca688c97ed6a","src/net/addr.rs":"0ed3d72ef6679e3ad76c6830143713c611d357ca4ece88c3ee5ceb2787217224","src/net/lookup_host.rs":"c7a21d735225e316253d822f6b11a17107e6a8db004f947a54d8bc12ec782baf","src/net/mod.rs":"301307d5a5f8c783418646ef9f7712414226a73061a691b468e0e3ebb7eb4df9","src/net/tcp/listener.rs":"76dc043e1272d040a8a338ad23f3e27e27d7a47030a708bff538e0b21c1f8d59","src/net/tcp/mod.rs":"347182e4f0381896bf3b7ab578c4564f1730ae25a108076ec65b8e855683fbf6","src/net/tcp/socket.rs":"32010f5193c5aecd32b08636af6a8bca8e9e27aa3619103fcec089a5044fafd6","src/net/tcp/split.rs":"75d1f6c4afa23397164a30c4409a73c8d3df022c780aa4f91fabfa90549cc606","src/net/tcp/split_owned.rs":"0c5a9f48e7e49c257c25e138f74c0c5d3402edf447a860cbfc1a36439d997295","src/net/tcp/stream.rs":"2397ef910c6d04af277de6064ab70c20aa0abb7c131c3850bf9bbd354e33c066","src/net/udp.rs":"c2a5319f3e02eb515d1980083effba2545c25820e4bb6c5fba5fa328a3cd4ec7","src/net/unix/datagram/mod.rs":"fc48924e5d1e551405b0708a2d122473cdafeeee802a5722f64b4cf41a1c01da","src/net/unix/datagram/socket.rs":"15426207e557135fb6714eb2a80beed8cdab825ee982d9184709f5a57c52b084","src/net/unix/listener.rs":"08cc3b4f8a3b1e8e21f123dcd3b51a768cdb525d4d0351aa53ed609cfbebf3fb","src/net/unix/mod.rs":"72008ca5352432de2203321244da5377afe5779ac15f5f6a577998c037e7e4ae","src/net/unix/pipe.rs":"0881edb516df3443f190d5dc84d6b40b31b517775cca1bf0393f2e473e15ea8f","src/net/unix/socketaddr.rs":"66bf18321a81baeb394a7094567632b113e44e12d2643109b6a97c89d919bf3a","src/net/unix/split.rs":"bd0388de8b6035b8cce2a34989ff56304697ed6864615ae13474f4e9c504faa0","src/net/unix/split_owned.rs":"5eccba5c1d589af4e5b52d17410c2290c289db5583676cf016de93ccabdace9e","src/net/unix/stream.rs":"70242303f54add35b533d0de299af0c7d06fc15b2dc8c2e5bafd90310bc6b7e0","src/net/unix/ucred.rs":"81b16f5f56029c90de166aac21a9a27f906bbd8abcdb0c7202f19f9b801868b9","src/net/windows/mod.rs":"a1525f35c1acb92b15bec788a625b76acb42f9424f392074db697102ce79760d","src/net/windows/named_pipe.rs":"d607bdada51daada04c863d39d16e2e66f63bc141cdb017e2457573aa34cc048","src/process/kill.rs":"2f98bd1bd28ab37bedc34ab7b737760407ab5315420538acbd18da31d2662d94","src/process/mod.rs":"1bc72d2ce45447da99ba7b7f9f7bab9ef7493e06e1cb1e0825bd5b166cc89101","src/process/unix/mod.rs":"09112d79de5d25fc1d1a2c32435199ba480ce186d8516d5d1fc6bdb09b80f439","src/process/unix/orphan.rs":"d641d9dcf41b0ce26a3ccc38e2e8d3cd505c060a87a137fa761132e2290bd886","src/process/unix/reap.rs":"62868319849b8482d8d927dcd00cc8a74b9af61fd47494b39bd41fe2f4dcf0b6","src/process/windows.rs":"bf98b7c716c03c07b3341f124ceab93de45fd595af8fd061b1b0f3f4782e8d50","src/runtime/blocking/mod.rs":"3a1e04d2fc5590c7c0a19c85ecbd893108f9a81b197162378c525133c3bbc7aa","src/runtime/blocking/pool.rs":"b50454e68d2e60e5360c4aa5fe1f8289d21fbfa2f6e77b176931f9d370301af3","src/runtime/blocking/schedule.rs":"206f8a9972dfd2c1c18d29c8b8129a7d7165f5df898946015f6d4dc72c61a777","src/runtime/blocking/shutdown.rs":"6eaf2a1418b885bcc1ce3f257b99382de9c16f848ed53d9e00dc97389bb6b816","src/runtime/blocking/task.rs":"08571bce8a99dd6296ba7099c1f6da8c832d13a8c43db22044c683470147d7d4","src/runtime/builder.rs":"1907ae6a58a02ac9d1a9d911b15762f62c2996997f9930cd3c0e1f115d2f2404","src/runtime/config.rs":"ae0640322226c4af2eae61ecc58073b2926ada7eb885742f561d26659c552ddf","src/runtime/context.rs":"19bc97ba83ca4a52ca9abacad3d282798b65ccc556e87e96b1191ba68c3ed5e0","src/runtime/coop.rs":"2831dcaad3493519134ddbabef95e5046e3e306938d37de820634ee35a14a0f9","src/runtime/defer.rs":"2cfce0930b3ba32309417c504b93a7baaf9be6852ce3c6942789322712eb23b1","src/runtime/driver.rs":"00c9e7f1a33119612ab122cbd0ec12d4d4264fbbf03d69ea40ad44a530a305d0","src/runtime/handle.rs":"4301e3f41eb2acffd6380206210f58862b3881f66699191fa4381fcca6ddc39e","src/runtime/io/metrics.rs":"e711c65da155ef73e567125c0c9db33b2f511982a0c0a6b4f3b37c2d87c791a6","src/runtime/io/mod.rs":"701062f27786a23b4e477417f9a710ebd0403d27054e1a1eb6a44087b5ef0d68","src/runtime/io/platform.rs":"023acd3f2703d241b3e91ab6e4d4c0bc5ccc3451655fffd9f37938224f915494","src/runtime/io/registration.rs":"e00250aa1c88768c6cf269972c0e94627bfd82379e4911da7ab659e72e2379f3","src/runtime/io/scheduled_io.rs":"39f12635cb1ea028bd82040982ecfc38d31daa106c9dce0a39d81b326c84e163","src/runtime/metrics/batch.rs":"5bfbb8a576c73f4b053bb215dd4e69fe2f6ecb811be26a0386834215005232cb","src/runtime/metrics/io.rs":"960f44573cd16e2ec43ed872f235ece09db9f4c87e217002ae0d180e20ce9838","src/runtime/metrics/mock.rs":"abbab34d95a020f2ca054e97e81ba41ecb40cc2f42de7cee06506963c2c829df","src/runtime/metrics/mod.rs":"81dcffd01a0969399eefb539af6b1961a64ab01fe35d4bbfd080d0077e1a62ba","src/runtime/metrics/runtime.rs":"c64717569224a4e4b925be47c75d4137e853ca32a9a25f3818cdec23f2e525e7","src/runtime/metrics/scheduler.rs":"997ba0339af84ef878881fdb6f35d8f6b39dc81e8f0b5cafce94476d50675c91","src/runtime/metrics/worker.rs":"372feede369e277f3166ad60d3fcaf073b6f3ebd8ccb427e2063d852b49818fd","src/runtime/mod.rs":"dd087588973ec27334a1c1cb457d9d083bf44341284abc22961e4b853becef91","src/runtime/park.rs":"f140f940681f911da2d0741be4bfce1e8f025dcb2e12ea62c6992514adf61eba","src/runtime/process.rs":"f40854b46e5851d7f5ee10f50d839aac933343c2178508f419c8e41dc60557db","src/runtime/runtime.rs":"cf7ef7f63adad9759a9249df08bdefd089fb3a19dd8ea9a1d6d7d29417d7114b","src/runtime/scheduler/current_thread.rs":"ffcb1cc2ab32e2f179194d1c742308c54becad504a501c3b67b2b877a1fcfcf2","src/runtime/scheduler/mod.rs":"a8e975d0869b63bc3ee0839d504013e5ea64df86c1c221d0ca68e4b28a5e6c75","src/runtime/scheduler/multi_thread/handle.rs":"173d23f6a2457c47d4e47e9726e8f1aca743e8ce62e54e05be29acd39f4ba7a7","src/runtime/scheduler/multi_thread/idle.rs":"b048a6ed70ddfe08670b0f99535566be7eacafd75df9c3a9447ad14c835ca326","src/runtime/scheduler/multi_thread/mod.rs":"ac56be970e65e41441ebf168e682e7e6f4715b3855cad0bdf4d229d89ac8356e","src/runtime/scheduler/multi_thread/park.rs":"7703c126166a412963f0cde2f36be5de519b01c49daa75fb191256b3c100d7a2","src/runtime/scheduler/multi_thread/queue.rs":"81702cce0341a9c7daf3bac2458556e03aa6d21082edbddc5736d3f51be75ac2","src/runtime/scheduler/multi_thread/worker.rs":"1518b1ba4d681d0653254aacc98c5d2245cb1e9a2995d7bebd46cf64702085d1","src/runtime/signal/mod.rs":"1498f18f55e730270f8c92906857d856de5ae264d80a96699c8b8b2f9439b77f","src/runtime/task/abort.rs":"81004b45834ab44f1b673b31379d37c68c5ce8acb7d223ea58207f412745d3d5","src/runtime/task/core.rs":"dfc18195bd5ad056be461382d593279e7490298cb0964bf2e7b528a0b3d0c066","src/runtime/task/error.rs":"0367095439c51ce94f53b13aa64404e13e85b114f77cdcd7315d4cb3d4fb9344","src/runtime/task/harness.rs":"996330140acc964d5bf31398b994283d997a9dc5390a7c6983b0a38723d3f1f6","src/runtime/task/id.rs":"4cade5f2c02e5d3a0c516625aa8def2da110db3b83d13a6d9e26f2a1ad8b31c5","src/runtime/task/inject.rs":"34cd85d0d9d241ad1bc34d710bac708ee2f3fbe43bb68732123a30ed99ca2e36","src/runtime/task/join.rs":"3bdbab71e0c85376441a8b316ff13145e602850c29da41d154b1066c56a43661","src/runtime/task/list.rs":"190e96672f2bb869e7fd2678bc7020a101facb231b9b63a35e4afeda769974fc","src/runtime/task/mod.rs":"4545d974392f39b7a85d0a81255acd2f053187de34d52bfdc4b3f865208948bd","src/runtime/task/raw.rs":"ca4a33aa99dcca702912649c30e4d361a2894a8b38d64b2088dbcbf9521f20d8","src/runtime/task/state.rs":"447706ec30fb87598fb7e4d0564bdf825b060d9c343512ce1a8cd67fbb60656d","src/runtime/task/waker.rs":"784f7f251df481b7b7390561a6601e4b8e7fc26a2fc4207873519462185ad5cb","src/runtime/tests/loom_blocking.rs":"fb4bf871ae59cd567ae4a2cb568d7cba31ad92579bea17c598d273a3a749f74a","src/runtime/tests/loom_current_thread_scheduler.rs":"9ec324867d9d123bf93c8f1c9feba8f9b57689122a1efa784adff425962b2d65","src/runtime/tests/loom_join_set.rs":"d6612a19c695907a8bb41b24df3b404cb521cae6f30226f2449dc32f18700b69","src/runtime/tests/loom_local.rs":"69cf7fa67da9e3efe3eee722791f811efb395dcf821780051e62842654de09e3","src/runtime/tests/loom_oneshot.rs":"cb0cb66e1014708a10a2236c2dbbac9441b6a6e36a49c419fa3a51af62b054ce","src/runtime/tests/loom_pool.rs":"30ea07a942c39bf1eff70cc6d7ae10cc5f0162c0389029ef0bf8b14ebaf4533d","src/runtime/tests/loom_queue.rs":"522e1a44b6fb0cb379b6a45173cf16c62b4f85aa4ebe44e14b07f34ff69c21c1","src/runtime/tests/loom_shutdown_join.rs":"2f48626eb0a4135d480aa5bf72e514c4abf39aa17711c96d3829f93c03758557","src/runtime/tests/loom_yield.rs":"fac610e464660c196a35ce15a46c9ebf537d3f3475cfc633e58c76c25eb558fe","src/runtime/tests/mod.rs":"bdd3a189f9f07ff73cd0961e570aa9e0412d5c9acc096cb4f5cc9be8b2a73a99","src/runtime/tests/queue.rs":"fa642730c60770a3fa376e0ff27639ad992e72a683f8dffc34a3b18ce0ed5a86","src/runtime/tests/task.rs":"e98f94f976cee07f9722f82f11e9d9486e978310a5314367fcb9580564f613c8","src/runtime/tests/task_combinations.rs":"0ebf6682728fc5ede9374b6353a8fe5d0cb1d27e511f338e779607d8fcaebcf6","src/runtime/thread_id.rs":"ad85f1057b2c61838620f1323fa8a710e140bf448fb2aa1d9d1f87a7fad5f01d","src/runtime/time/entry.rs":"9f2ddadad4ab925dc59d682d9f4ba9dc42b2299df5f5b10e36afdab1c0608417","src/runtime/time/handle.rs":"1ecbebdc070477d61b782b2f4d3a5b9b5cc06dbe447188f23eef3257fd16ea8b","src/runtime/time/mod.rs":"a3652d26292aa0a6730acc86de911516723bcfdde965163b75da55e89127c50b","src/runtime/time/source.rs":"117b2504449177056447251da3d50791f291f32d91a027697f5e7504ef7e11f5","src/runtime/time/tests/mod.rs":"5be4c9b935df11411670c4bb59e071a513f4488dfed78f48ef20371cecee1d07","src/runtime/time/wheel/level.rs":"974a230b26f6d4fc9f4046741f1e8ef90acd2d53132f135515bc37914afc276e","src/runtime/time/wheel/mod.rs":"1104133c6d50ea708c5733f7bf05b2ad1f027608a7495d18e649c9b97f31204c","src/signal/ctrl_c.rs":"3e1d98df851b9ea1418f607c260434e906ada4e3d6c14cdfa5c81a0c4d55cdd3","src/signal/mod.rs":"4da598cb028d5716628bcfc06c0fb0bb8fb8f0f0986c6a328a655e76979cd85d","src/signal/registry.rs":"c9e9d1df123c6069c2ad80824162a5de8c0163a9c63714d26ba2128538e34cfa","src/signal/reusable_box.rs":"3d3b710b1794d9f8f5463e9ca380ece60c426b58786a5cb5f40add627da01aeb","src/signal/unix.rs":"0504cf52a28e9e8e528fab0ccd4e9c3dc86fdcfb807ecc9506fb6adca186c531","src/signal/windows.rs":"826a2a16fc9ff37ecaf7eef88f09d8b5f57adb6095dc10b981a4c0bb67b70a2d","src/signal/windows/stub.rs":"a6d3b11aa3a7247f7a8365c3241857bcde48d8c390d569e6bc9529c9b1f8ecd1","src/signal/windows/sys.rs":"3e4882762ac424cb3b3caf71d5a69f571fbe14e6b298889ccb227c58b213c257","src/sync/barrier.rs":"b64cc6a840a287f5f0d36ef024abb805e36fe1f5f801f121bfdf4fe4ee0f86fd","src/sync/batch_semaphore.rs":"539f6dd787baa3950b634aa6f07ca038ceef7ee06bba6072b199c77d1bb95ea7","src/sync/broadcast.rs":"1afe6e9db02b5ce8b479d8f481db73eeda2b6f805008e0dd6a2b55e120a14119","src/sync/mod.rs":"bd94e0b941f6c61623bf9ed6317c545c5a076d3431471f014f0448984c2bb82c","src/sync/mpsc/block.rs":"70a034a62ea88a95e970352a7a3e004c2755c75afa34d71f3653537389e6e2d6","src/sync/mpsc/bounded.rs":"eef3724210e603beab5646739ea936853cc5972e1921b2a8000ce369badc6285","src/sync/mpsc/chan.rs":"f7a863fcbc6e45daa96b3d18d6c79c4b4606e942357f7c39c90f72c611e5fa3a","src/sync/mpsc/error.rs":"a2968482264bc4b75cac19774bc33c7bfea5e96eff171d167bab407f4ace8c52","src/sync/mpsc/list.rs":"2c99cec4d3d179f6e668b8de37e58525477be3f069a9a748f7f8ed2f8a40f817","src/sync/mpsc/mod.rs":"3699ff2b4c5315f0a1cde40a1d3a45bc312febe1cb612cd68c6176ed7590bf1f","src/sync/mpsc/unbounded.rs":"5cd0694dbd4a2f33d44756a382c02780e1951dae19d246fe1af3e026ad6da5ca","src/sync/mutex.rs":"00dc461a5a60d7b9372999f86ea682837cfb1052487609fd1bb0b86c6eec1b66","src/sync/notify.rs":"c36eb8fcd4f640d5ccead4100abb123a9b634d9ec273312657fe6d934ad6b0f4","src/sync/once_cell.rs":"8a8ed3b6c5fc5e417dc3d3eafe5175292f4d4dedb56cb34ce0da213379a6bf73","src/sync/oneshot.rs":"33c19ca2f4d7c5417104e990e589d48d4b476825f87c9ff7f7d78af9b97ae37a","src/sync/rwlock.rs":"a89b7a8ffed53c9f91d07a9dff966544567fd90da9219e9099d81393970edee0","src/sync/rwlock/owned_read_guard.rs":"135d81271f0028263ce99c3246cd335a08912b50a43f125b3e8f7739ca353cfb","src/sync/rwlock/owned_write_guard.rs":"ef56443fac210bc3d0c2b66beda8436154c2ab726f1dc208758b54b2b087762d","src/sync/rwlock/owned_write_guard_mapped.rs":"3038187dc3a791a89505621230d3edd8629287ec11490ff37f2c624b593c5325","src/sync/rwlock/read_guard.rs":"0f7e52adacad0fb1529a453eb14f8207a8caabd8f5fca4aeb2031a9e9b0981f1","src/sync/rwlock/write_guard.rs":"f3855cdd09940c86a9bd10b91d3ebb37b2219b60c727a3bed377404ef2483c35","src/sync/rwlock/write_guard_mapped.rs":"8c839c4ac4b73faa1c1fc697753e23fce113ba6e576d2abc022ddadb98a34af4","src/sync/semaphore.rs":"dbf73a633a65a4fca9a6b7b5f0ba5d0a2d7432cac257e328ac76e936601a6881","src/sync/task/atomic_waker.rs":"41e9e05522254afbacec9895390d6f95498e413a61d8f654f9c421c808e7f83f","src/sync/task/mod.rs":"f5e38105c7f8a942c0e49b973bad0a8c2a1df81deea19f3c5228edc4896c1725","src/sync/tests/atomic_waker.rs":"34b1bfa8fa3b392b89bad36fc4a2a17e42d84c60635c6e7727b428cfb693feae","src/sync/tests/loom_atomic_waker.rs":"984b52699c47383b9b62e6c4ff93fd458bbe64cb4ca836463adbaf94d27c38ee","src/sync/tests/loom_broadcast.rs":"b2c6f138707fc389ee7d91109bc38093af9060b3465e68d3543cb652e0070406","src/sync/tests/loom_list.rs":"f0ce15a0f965fe558a21bca24863c712156eaeb10feb8ef91031a6d6e3cc5dba","src/sync/tests/loom_mpsc.rs":"4883352b9d75a81c878609613545ae14910eca4f2e7f3718053dfdb792aa0760","src/sync/tests/loom_notify.rs":"cd401c73084df551043b7d96b9f2c51e9c1929a9038eb899381bd4ecafe04ec8","src/sync/tests/loom_oneshot.rs":"c3596c15692b16e7cb8cd6957362adb3a98b3d7f16c4a4262f19a3a27f262b03","src/sync/tests/loom_rwlock.rs":"80ec00bdcac838806d4d9f711cb154e02f22913ba68711855c39ca92028d3e4e","src/sync/tests/loom_semaphore_batch.rs":"c6f69b8d5b2e6842287ed34638a9045095d9f94c86ba6bb84c1224bbe10026ff","src/sync/tests/loom_watch.rs":"d451c914e94c5a672abec3232e58aff6218581f0c0b1802434ddbe771b1be6a1","src/sync/tests/mod.rs":"1ef2026ac3dfbb70a437b8be441deca4b7b5e72638b71daf753b89808cd3c9ee","src/sync/tests/notify.rs":"cdbdc080eb9e653fbd56501a9897b9dcc6298ef81f7a88390976f9fb5deb034f","src/sync/tests/semaphore_batch.rs":"291d6c615058aa28a26ef17260cf5f27be286b20da9dba36ec95ca3a7d895ea9","src/sync/watch.rs":"7dcbb38d03f797455f9e811dd96abc005adcb07285057af56efbb4fdcea99627","src/task/blocking.rs":"54b262efd4e267adfabdd722588088d9a689bc5845ebb68acf36f8081209d777","src/task/builder.rs":"b70f082246ae16c0e60b17f5a0eeb5fa3394dcb087b7d17f796ece1a8afa8771","src/task/consume_budget.rs":"44f1e3c3f89e1919c664100bb5ee291537a46d4aa6695aceebecdff3d6711782","src/task/join_set.rs":"2287223f4510deac498484018b64c2f56591a7623143b15d355538620fd73b26","src/task/local.rs":"05226ad9b9951d3da30a55c75cad171798978ec6b247755b72bc8740b4dc1558","src/task/mod.rs":"68c4e77221655cc3cd208e20fd9f8b3035d5f6176e30a90c5ec67423f8ff8ec4","src/task/spawn.rs":"2955f56ea26fabe7f5db823ac00be4df5b8a5e865595a4106d1dab48ea69aa00","src/task/task_local.rs":"7c641f039786cbfd5542cd03674d399994960c5162a756122d8fbf71c4923d02","src/task/unconstrained.rs":"8e75239ae694f296136fbacadb232ae0a255b0b2013e1eb0390bfbb82af36692","src/task/yield_now.rs":"ce00e76a94f8e33c72fcc3346b21f7b91ac889c28e37b3982e95f5136c3d4a06","src/time/clock.rs":"839139149402a4ab18f3144a36249f57d36536ca44a646de0bd6eba374a71ef9","src/time/error.rs":"de761055f6596528fa158eb2179aa662fb1510d93aaa2102f8de3192c6a6d1ae","src/time/instant.rs":"164ee00dabfa6bb9fe4c9854f937ee92ae454eeaaeaa7a447e09434ea95bf722","src/time/interval.rs":"595e285196ec241d0f08e21cd3605795d0ac93967f63b7248400161416a1627e","src/time/mod.rs":"c790bbe9356ceb56fd20e762c9002906aa4eee1d1d297fa0c520130f72d3be3a","src/time/sleep.rs":"f817fe523ce00874dc918caee18180f112c9b19f50219451cf6306c103e1777b","src/time/timeout.rs":"67f5396cad468dac3381b323734739914052a0f72c3df018eeab14a855f6c8d8","src/util/atomic_cell.rs":"6e156b730f69c698cece358ff5b206e8dd88083230fd49b2fc4a66a539b92553","src/util/bit.rs":"ad3117c9a8b1e312114a72e9b315c37137af61da51ea458832d46d2c1b88879b","src/util/error.rs":"de1a0d662e9359da3e19739125b1450f571abadf30e34f50f085b23d8da28d80","src/util/idle_notified_set.rs":"8934660090fafad344f1718c9c06295878948ad1875c23f8e8b79f45192631e7","src/util/linked_list.rs":"bc0401c94f58fb99d9ba797fff951657aa8244e5f4157ec4e64d3ea8d3289750","src/util/memchr.rs":"8cb5e0a0da9b7d94d29a994dd4e725e547ce31f87b5bf24a1a9b53b0ae65cc08","src/util/mod.rs":"8ebc9c11dc8e5498e5ea68c35a3cda15a22502fcab3848b4bc2cb523e5acfcfb","src/util/once_cell.rs":"bafbbff82e595a0b8f41f3d5273dcfcacd282c51a24f14666105391a456c5db7","src/util/rand.rs":"d83761f4d10d48ec5a127e573661984932e27f0f3be1ac0ce5fa0ce457e17dd9","src/util/rc_cell.rs":"362a7a7b776389688299628a4678378fa02f88fbc6ed7f9fe006054d9b62643a","src/util/slab.rs":"fd21a2927f658c3fa7bad377e964702c4a85b5d995f44b90740101c19d820b97","src/util/sync_wrapper.rs":"8f1ab76280171c33c0bafaec9c1cb1d48cfb0d19a1ab2b768cdf7d7e40f07d00","src/util/trace.rs":"3b4e7ed40a16f9806a40f56268ec5daa519565c899216ab08a64c2f152f85c84","src/util/try_lock.rs":"c4ee49e1751ee0a7df1a8cbd4f8d36ea1d7355e3ac584fdb8697a94cd7a7a8f8","src/util/wake.rs":"27046cb8116d4aef4b9296024d1a9b822121c0813b8390acca45878c9a13c85e","src/util/wake_list.rs":"c3443e695fd0b5c41c06d66cab96549064e9b645043559d01f82f365dcc4ff6a","tests/_require_full.rs":"869a93f914df3d1c941b5787ab52dc55440d8d9d78dcaa0354b8d2a1d30119c9","tests/async_send_sync.rs":"da4a98c98c5879f39aa6d50d31d60f135593452f426f7aa0cc1c6256b24f0580","tests/buffered.rs":"b953415c67c406677816332e66d46ed677fdd504119d9a1ac4b5df15acd168db","tests/fs.rs":"da61358e4dfaa8bdf499fd453f68b26276ba50a721e79fd1e472b9eea889f58c","tests/fs_canonicalize_dir.rs":"c39e85391dc738db31ef5c7607956a97dc32cabdf09e5dc0bd4edd3a6e354aa3","tests/fs_copy.rs":"b28a67ea4722ed346eb4c035bb03c2785ed94c796191c1eafb29975bf1f66781","tests/fs_dir.rs":"e519be77200d54984f6088dfd1ab0e61c8284be54a4fd8c41060e1743533b4f4","tests/fs_file.rs":"61df8af26212e38ed0de9a8377a3b44a51871c52f9232ab2e130a12a70c7ee4c","tests/fs_link.rs":"ab0f68b65101b9e1d26216179d11bb637d968a81322e96721136881ec4796287","tests/fs_open_options.rs":"039a58348ca9d94dae8bc42e0e85f4c79f25f0ef07102e904564273ce2cd8ece","tests/fs_open_options_windows.rs":"1561afac0671988ee0bf4bb1a34dcc485e53fdeb11e75a87a6166a8f49a6a392","tests/fs_remove_dir_all.rs":"2b5294d43fa608a412d2d6a3c2d843fa1164524e680d86c6c216d62066da54e5","tests/fs_remove_file.rs":"da32874c72fa6b031176ffd4e8102faa19dbb9c92b3a43c1348fd9bb206ab801","tests/fs_rename.rs":"ec78709cae9e6d5afd7422b06303a192946845e8f5f78465eac8b3b7ddb8480e","tests/fs_symlink_dir_windows.rs":"5622869c393f27bd20ae44e7e38748a6d466844228c2c25038b9d1171c85b72b","tests/fs_symlink_file_windows.rs":"bee0d4b180d9edf7ff98a688e68b05e012ce78eff7d7af82c27c2ee63a5ebecf","tests/fs_try_exists.rs":"8ed69037a876312bc3d0a0ffe3e970349a3827369db5fe60d8123315f99fefae","tests/io_async_fd.rs":"ed56435564501e1cadd284f180dddfbd747df72e74c4b7b7a77bc166383bab04","tests/io_async_read.rs":"a590efe9bb01986f067118640a3b55f6760186e554f8e8f2404231d4e96f61b9","tests/io_buf_reader.rs":"f5a322dea6fe9f40c18a085a865919c1bbfe8653203b37d1e18b77d259c6211d","tests/io_buf_writer.rs":"3bdabe9ac26f3189929ab3e8957150f5262d5b426fd3cb6c4761a45014b1c1fa","tests/io_chain.rs":"f5d3ddc9f6e8152ceb08b5dda2ca3168b174f1f67ff28a4c5983bcbad69d8af6","tests/io_copy.rs":"0683dee400710c1696a6634ecee64c39e7027344e66bfdd6b2a78de8ca913555","tests/io_copy_bidirectional.rs":"855f720881c624562897c7e8f9cc15ef11498ddd11dbd803f21fd587c84eb2bd","tests/io_driver.rs":"01b89cded4f482dfcaf5cf1715a493c932aa0c72eb0563950b4b5fcdadf86ce2","tests/io_driver_drop.rs":"d25d432740f5eef3f214fff6d30646ffa6a3dba77658c76c1fd2172f32a0169a","tests/io_fill_buf.rs":"82a83d0d4d5a60bc312f2d77722607a8bd28d465fdeec3fd072815cd0cb4ee70","tests/io_lines.rs":"f5b1599ffff44819e269519ff0a08635ea1c5d7c541293e63ee33d98f25f0e3b","tests/io_mem_stream.rs":"7b20d86c02c8a868cfa3aa4d228519090d156fdd9a8a19a3be263f264fc9d33c","tests/io_panic.rs":"48f3f842f55afefa04824cee79383639c9d9465c8a6641c9eb8850f1c47d3bc7","tests/io_poll_aio.rs":"165f80ebc81e8ccb4d335c9b9a89d960f097de9b17e92bc964effa3c76ce5f98","tests/io_read.rs":"4ce62e123e687f38efb09a14246be86018c4772b10d492f9e512c99bbb5f0818","tests/io_read_buf.rs":"6dc454751af0e9cccb44fdfb12b9f0311fa8afa482886aa56e3e15d49ae1e06c","tests/io_read_exact.rs":"b6387dbeb0baceb7a1f74a9a3a8b4a654894465368be27c3bbf4352b79fc4314","tests/io_read_line.rs":"8296624b4f5e162c79024f3beab2f561f4195a244cfd4c53e4d06282f56a31bf","tests/io_read_to_end.rs":"722e2922a40080d391a83b4903f47823779740090624a98ac30e9f164b20a3bb","tests/io_read_to_string.rs":"c9ebfee5cb262d822119c2881ea1cc0c73598b13c517c297663e35bb120a089d","tests/io_read_until.rs":"b6c0df9e4852766910ec68affcd92fbfbc280018b7f9c16cf5f4830f9b8389f0","tests/io_split.rs":"a3228f84142732d624e062bc933ac26267a10f71202123b3a9d5eebaba82eb96","tests/io_take.rs":"8790584a344102da70e669d07b9aa39b94d5d76fd87ded8a684971b06d5e7367","tests/io_util_empty.rs":"32dff601a78e46e12339bf1577463c7ce1070d71d78a2fb33318112a111dc120","tests/io_write.rs":"98668a8c8feae0f85714df1dfecfcd94fba4ba347bdc3d8aaa4ea8b175055c69","tests/io_write_all.rs":"e171af1ecab45a439b384c3bae7198959c3f5e2e998967dbd9296760b52951b7","tests/io_write_all_buf.rs":"2c037f07ac464eaa4e0b87e4e4968b28a0f2f1b1d1e218546c9d5dac7a75d145","tests/io_write_buf.rs":"331d3b54c7664386bb87585f39910d1fe31bfbdfa012a2dc2120e535dcdac329","tests/io_write_int.rs":"3f4b50345f7d7d558e71ac7f2a8c1c4b7b771dad09fe2e1fbf9a17d4fb93c001","tests/join_handle_panic.rs":"5f81436d1e7c18847392c744c25c14518c41f24558861584f5ff759b147ce4eb","tests/macros_join.rs":"d91b865047afe490c2db84112c2fce1c953e1bf26f80c82d9c8dd5b73769c693","tests/macros_pin.rs":"6162681c8b31c35ea6d88d09187b77e1fcc96ca56a1304b5cb39b4051f601f3d","tests/macros_rename_test.rs":"c478f11266527a166bd8f7ca3446db94c7e7a1bcfa0e74b6597b6087e5749436","tests/macros_select.rs":"20044ec9cb0d92c04bb08e0636ecad749b06dccc9e8ccd09905f88fe7dcfa63b","tests/macros_test.rs":"dd28c1f90676230285ed2aad7e760e43d7df38d18ebba3fc8c7c7957d309fd72","tests/macros_try_join.rs":"08d723892038e36c39291b112a4eb16e4c1d021522cdee569c1209e02f1f4b44","tests/net_bind_resource.rs":"3fb8060945e26c6b38d28115a984ed17ec89e8313568e88014d3bb3dbad60bb9","tests/net_lookup_host.rs":"a1ba4c6100584f3ec706810c9a4313875e8cd0bca13531bc7759d8ecdf0189fa","tests/net_named_pipe.rs":"dfb791caa5a4ed1bae0605da27ef599abd8cbe745c2fa95a31853bd46465b042","tests/net_panic.rs":"e7382fd76c8e1f9744e9f2e442ef259cc9cb801429998ec3b00126cd8739911e","tests/net_unix_pipe.rs":"6b6956dd7d584fa18309fc8c86a74f5270c9fc2faed2f5c3b722c11e93419abe","tests/no_rt.rs":"228964501f3a7b0eb3ff12adb29dbf6296006d05d04fd2f418fb1f1f015dfe54","tests/process_arg0.rs":"785d801cf281230e3208512820e7d71b4d8362b8cf33fc72235da370e10983a8","tests/process_issue_2174.rs":"66c56d8dfda4e1723928da713dddea8d15774d6730398effadf0ec28f4c6f1e1","tests/process_issue_42.rs":"26043f8246b00046137551f7a9f638652c70f527f10b4d91e4286643120ca41d","tests/process_kill_on_drop.rs":"9b4bf8a73769fb268ef3687141e8df6122814855d3bbc4e63295c66b0ee6cff7","tests/process_raw_handle.rs":"aaf0dc242ce69f1a8c614e04515c41584f7e213f84ebf23238521eb881e0a6de","tests/process_smoke.rs":"61cfdea779ea749df9a30d136543874e0f1b979b85931728c75a44b70c55658e","tests/rt_basic.rs":"6e40762f7b772f4aede9197b9e82261282ec3fc6e0b55bc473a535104f99669f","tests/rt_common.rs":"b9f54f00f6893923c656389d6dd6a04d1834bffa31aa11cf07d332c8f235cf80","tests/rt_handle_block_on.rs":"2afa6806468f070c5b38d47bf51dd51d25e75d3f9098cdc804a7c2ca533199fa","tests/rt_metrics.rs":"2b4296183063778bca986392698fe096d416432992db62f8e382ff26ee84c6d1","tests/rt_panic.rs":"d7f54f60d0305b344b2c30b940662cb75f9f000c2ecfed58c6e8b427e936e787","tests/rt_threaded.rs":"700844adb42b6d2e2e0b935d85c33729222567cc0a48b8b339477e7e6a9b3eae","tests/rt_time_start_paused.rs":"76549719f16e9cbdd9a84b9d97929ed7c8ca95b8d4d715608eb99f950cdda7a3","tests/signal_ctrl_c.rs":"9b53065781b37f3db5f7c67938239b0f3b0ebbc5938c14a5b730ad7ec07415d2","tests/signal_drop_recv.rs":"d1ec97213d9c6fd9fb25ea8c2b015c9e9ee1a62fe0853fc558bc8801e5a3a841","tests/signal_drop_rt.rs":"f968c1154262a4427b5aad2d9fb36d3b7d47084312d0b5527a8eb3d589381d8b","tests/signal_drop_signal.rs":"041940550863250f359630dc67ef133874d809ddaf0a6c1238cee1565a19efec","tests/signal_multi_rt.rs":"a1c50c25f4707fda7665da61b3317dd61fc32c63c61db2bbdb56065bd9c591ce","tests/signal_no_rt.rs":"55b9d96355e1c4177c047ea01b78a5514c34e1eb75e67d8d99b65605c2df206c","tests/signal_notify_both.rs":"bf0b9def20f530d146ee865305833d8e9bee07a0515e66573d7ff30e2c631123","tests/signal_panic.rs":"0b26845bbc7f388346e0fe3af98a2257dbfd0eb84168368994a0857e06a42398","tests/signal_twice.rs":"bce33093eed151955d13c334d6d8a5bc5ca67cf5b37c246e435a24c15bc166a0","tests/signal_usr1.rs":"86ad07594b09d35e71011d1e12a1fa2c477bfbc4a2a36df1421b6594a0930074","tests/support/io_vec.rs":"9b3001e120138ead4a63720019c669ff00f8455a74dea2fb231633b3b58c9b09","tests/support/leaked_buffers.rs":"85ddbce3ff6b0c5cc8cb30449dd37e5bfedc94f8357e741ec88ff04462bc60c3","tests/support/mpsc_stream.rs":"00d48122fa2ccbf1fe0b110ce3cf22590eda54b3ddec0134b1f9376eb1169645","tests/support/panic.rs":"7bcaf8ea2d249b5c1acb3c1b769cbe479834630dc71b3ce1114b8b46277f44da","tests/support/signal.rs":"83531afa2e8e71cfd90cd4e1fc821490ffa824f0f9f0c9c4a027c08fed6b8712","tests/sync_barrier.rs":"e6d44e5c2da6e055598513781bdee6a42261e3f7ff538c925e07a52866662bd0","tests/sync_broadcast.rs":"eae02f0ad50141c36590a01113be82de382592273a55584a545ffd1eeb431533","tests/sync_errors.rs":"40c3ff2413dae2efc7abca7e84eed5023f2919108a5ab96bee1bc46b98b42449","tests/sync_mpsc.rs":"754ae8ad77f38fae2478ac016239c4c9b6e64e68e4764ab721f6a513dcf17482","tests/sync_mpsc_weak.rs":"868efe2c82c8c3232c1686bad41101486bc74a552bc7dd0b32e1633f272526d0","tests/sync_mutex.rs":"4355a738f2868f09ba0b376a82dbf0e8ab9a83225bd21e80e16ea7c34392fae8","tests/sync_mutex_owned.rs":"38ee9abc16c71a9c9eee5b74a17bcda588e93cb17a60dfa9a4d7fa6e93c8700a","tests/sync_notify.rs":"f2b6077a47bba8fe285970fc3e11b46fb9be1024bd3ba5b152b9c199c2da905f","tests/sync_once_cell.rs":"dc68e3643ab6a95f37e12dad9e8eca757dd3f2448e74e5463686c9a7e8b981bd","tests/sync_oneshot.rs":"93cdd67891fe501c2b86c1f7f1814b6f0b3f16b2877778af2e36cac141ec99ce","tests/sync_panic.rs":"5d0b4515bde6bae58131ea3f7c792b1faec7284924161918acf4ceb768bf4917","tests/sync_rwlock.rs":"f06683b9a95f3f9f12be06afefabc7cb0de790d9d79b4a1d7f3f7967aef1bade","tests/sync_semaphore.rs":"ac9102c51d2bfedb7afabe5a751ea58895ba35816639ec977f82a26f3d9ae56d","tests/sync_semaphore_owned.rs":"98547cb4b4e33409b7cf30e9db0c30e06377e77463dd31d03d3d3fe35f9a662f","tests/sync_watch.rs":"6718eedd56bc3107b1c7bc01ea059197800a6cebe1a61e74bafb0c450d137e7a","tests/task_abort.rs":"dc10ad424d4be12a86722ca181c3e2d93cdc41ffb7f27c1615f1c93ac1b11e94","tests/task_blocking.rs":"307bf3c4764936712b456c271f15b9c527001fdebee58822e74744c8f3e951dd","tests/task_builder.rs":"784830b868e9fd7b0d9413cbd7719eea7606c62dffaaf59986ed3e7902e9a3e5","tests/task_id.rs":"118bde53222009e4277fe4747ffde18f5acb3db17db3036b4d793200fa8f2a18","tests/task_join_set.rs":"f5a5708d4ef3bbf291b1de41ff54c30f37d7479b6087089a6c3a463e841828e1","tests/task_local.rs":"60cf924729be40a7f281def7911f6f6969c349af3a8a10c22fa4c94dd60b7e86","tests/task_local_set.rs":"5ee1c2fb426b69ad682567d91110c6ba43f04ebc6665a03ba4fb84a21c6c7a70","tests/task_panic.rs":"f4867fdde7918312ee493d263ae809ae3903c8c73a7e0ca6b8f9951ad55ef23f","tests/tcp_accept.rs":"5d91dbca6d78e176d62a316bd40818efa37e73e6253d1c9c31d5620ddc3b33df","tests/tcp_connect.rs":"a592530fd995ae5d119ffbf16c488875c944518c2c7b8c6ba7356ccd9d9963b5","tests/tcp_echo.rs":"5263afeb2499f4ed80e05bb19a68c9c407b798686715d53595c10beac6229193","tests/tcp_into_split.rs":"78df4144ed605dc65d20737281e6de10c9d4b750cd51ca8d4b03ef4d5aaef7e7","tests/tcp_into_std.rs":"3dd28d2a7ccfaa1eb74e321b08c05e1ce5d015d3f05f22a95f949b3acc5280ba","tests/tcp_peek.rs":"fa7868cee7ab85e5fd657c8b8fa1d947f63cce0e328d40c36ce6e5e450a13bc8","tests/tcp_shutdown.rs":"ddcae943626b44b74739f66f409092b05d303154041580c1bab319e02ecbb051","tests/tcp_socket.rs":"0c42454cf4246557daaef5d56e396aa6066cd4cd91ebb1cbc84be740f371bc0a","tests/tcp_split.rs":"691d578e4ee527674a6b800246dd48b12f1145a478b5e07f12f91c4a00c3ad2e","tests/tcp_stream.rs":"417cda921374da15359d7097daa24e8d32df2417efab2cce58f0705979a95a29","tests/test_clock.rs":"d5c9bf7bb5d926e2b29b43e47b5bb051b0f761bfe44d5fef349ed442ea7b416f","tests/time_interval.rs":"5e36011d97bdd27aad7c9c3a3da59190197f290543f0bb91cde331ffa67047b5","tests/time_panic.rs":"86430db173ddedd858bc77abd8d2a1394fdc74dde01beca7ecaa95f1f4274af9","tests/time_pause.rs":"457913a8b3d801291a516db1a6a31ea83e54cc89628b08fa7e49f7ffc5df7836","tests/time_rt.rs":"1687c1635695791fdcc4b536fa7b69410c4e82675b693f486ad48909f8f55b67","tests/time_sleep.rs":"810a7cd44c6116278f77ff3dfd16532b07361d655ddb067107e03507430db135","tests/time_timeout.rs":"1c1b44da8e8483f5df2e85892f3e88b075674a956ce91ea7a637772b8e6ac8e7","tests/udp.rs":"af5c73e42205aa9c5ecfc32a0c9923b8d92bb9735b5b100f6654150569a0a835","tests/uds_cred.rs":"146c6e9bdbb82a268f178b03575f94a40db81ef67a740dd16ead5b9e4a447f1b","tests/uds_datagram.rs":"f8d886adc6c3947960991392cd8540a0b4a7f7b0110a24d10805237b385b49f0","tests/uds_split.rs":"79d54d6ce35e5d15138299091871ecbdb6492ae6863fe406021fd7359f1ed7fd","tests/uds_stream.rs":"287b7d5e297df3e326488d98f9645ebfcf8be0205ba6a8e5ddaadac58240e113","tests/unwindsafe.rs":"86b71da9e70b53df8be1b80188b38cea4693f96f2a3006c0143c03555a5ff12a"},"package":"c3c786bf8134e5a3a166db9b29ab8f48134739014a3eca7bc6bfa95d673b136f"} -\ No newline at end of file -diff --git a/KubeOS-Rust/vendor/tokio/CHANGELOG.md b/KubeOS-Rust/vendor/tokio/CHANGELOG.md -index afa8bf0c..e51ad14d 100644 ---- a/KubeOS-Rust/vendor/tokio/CHANGELOG.md -+++ b/KubeOS-Rust/vendor/tokio/CHANGELOG.md -@@ -1,3 +1,940 @@ -+# 1.28.0 (April 25th, 2023) -+ -+### Added -+ -+- io: add `AsyncFd::async_io` ([#5542]) -+- io: impl BufMut for ReadBuf ([#5590]) -+- net: add `recv_buf` for `UdpSocket` and `UnixDatagram` ([#5583]) -+- sync: add `OwnedSemaphorePermit::semaphore` ([#5618]) -+- sync: add `same_channel` to broadcast channel ([#5607]) -+- sync: add `watch::Receiver::wait_for` ([#5611]) -+- task: add `JoinSet::spawn_blocking` and `JoinSet::spawn_blocking_on` ([#5612]) -+ -+### Changed -+ -+- deps: update windows-sys to 0.48 ([#5591]) -+- io: make `read_to_end` not grow unnecessarily ([#5610]) -+- macros: make entrypoints more efficient ([#5621]) -+- sync: improve Debug impl for `RwLock` ([#5647]) -+- sync: reduce contention in `Notify` ([#5503]) -+ -+### Fixed -+ -+- net: support `get_peer_cred` on AIX ([#5065]) -+- sync: avoid deadlocks in `broadcast` with custom wakers ([#5578]) -+ -+### Documented -+ -+- sync: fix typo in `Semaphore::MAX_PERMITS` ([#5645]) -+- sync: fix typo in `tokio::sync::watch::Sender` docs ([#5587]) -+ -+[#5065]: https://github.com/tokio-rs/tokio/pull/5065 -+[#5503]: https://github.com/tokio-rs/tokio/pull/5503 -+[#5542]: https://github.com/tokio-rs/tokio/pull/5542 -+[#5578]: https://github.com/tokio-rs/tokio/pull/5578 -+[#5583]: https://github.com/tokio-rs/tokio/pull/5583 -+[#5587]: https://github.com/tokio-rs/tokio/pull/5587 -+[#5590]: https://github.com/tokio-rs/tokio/pull/5590 -+[#5591]: https://github.com/tokio-rs/tokio/pull/5591 -+[#5607]: https://github.com/tokio-rs/tokio/pull/5607 -+[#5610]: https://github.com/tokio-rs/tokio/pull/5610 -+[#5611]: https://github.com/tokio-rs/tokio/pull/5611 -+[#5612]: https://github.com/tokio-rs/tokio/pull/5612 -+[#5618]: https://github.com/tokio-rs/tokio/pull/5618 -+[#5621]: https://github.com/tokio-rs/tokio/pull/5621 -+[#5645]: https://github.com/tokio-rs/tokio/pull/5645 -+[#5647]: https://github.com/tokio-rs/tokio/pull/5647 -+ -+# 1.27.0 (March 27th, 2023) -+ -+This release bumps the MSRV of Tokio to 1.56. ([#5559]) -+ -+### Added -+ -+- io: add `async_io` helper method to sockets ([#5512]) -+- io: add implementations of `AsFd`/`AsHandle`/`AsSocket` ([#5514], [#5540]) -+- net: add `UdpSocket::peek_sender()` ([#5520]) -+- sync: add `RwLockWriteGuard::{downgrade_map, try_downgrade_map}` ([#5527]) -+- task: add `JoinHandle::abort_handle` ([#5543]) -+ -+### Changed -+ -+- io: use `memchr` from `libc` ([#5558]) -+- macros: accept path as crate rename in `#[tokio::main]` ([#5557]) -+- macros: update to syn 2.0.0 ([#5572]) -+- time: don't register for a wakeup when `Interval` returns `Ready` ([#5553]) -+ -+### Fixed -+ -+- fs: fuse std iterator in `ReadDir` ([#5555]) -+- tracing: fix `spawn_blocking` location fields ([#5573]) -+- time: clean up redundant check in `Wheel::poll()` ([#5574]) -+ -+### Documented -+ -+- macros: define cancellation safety ([#5525]) -+- io: add details to docs of `tokio::io::copy[_buf]` ([#5575]) -+- io: refer to `ReaderStream` and `StreamReader` in module docs ([#5576]) -+ -+[#5512]: https://github.com/tokio-rs/tokio/pull/5512 -+[#5514]: https://github.com/tokio-rs/tokio/pull/5514 -+[#5520]: https://github.com/tokio-rs/tokio/pull/5520 -+[#5525]: https://github.com/tokio-rs/tokio/pull/5525 -+[#5527]: https://github.com/tokio-rs/tokio/pull/5527 -+[#5540]: https://github.com/tokio-rs/tokio/pull/5540 -+[#5543]: https://github.com/tokio-rs/tokio/pull/5543 -+[#5553]: https://github.com/tokio-rs/tokio/pull/5553 -+[#5555]: https://github.com/tokio-rs/tokio/pull/5555 -+[#5557]: https://github.com/tokio-rs/tokio/pull/5557 -+[#5558]: https://github.com/tokio-rs/tokio/pull/5558 -+[#5559]: https://github.com/tokio-rs/tokio/pull/5559 -+[#5572]: https://github.com/tokio-rs/tokio/pull/5572 -+[#5573]: https://github.com/tokio-rs/tokio/pull/5573 -+[#5574]: https://github.com/tokio-rs/tokio/pull/5574 -+[#5575]: https://github.com/tokio-rs/tokio/pull/5575 -+[#5576]: https://github.com/tokio-rs/tokio/pull/5576 -+ -+# 1.26.0 (March 1st, 2023) -+ -+### Fixed -+ -+- macros: fix empty `join!` and `try_join!` ([#5504]) -+- sync: don't leak tracing spans in mutex guards ([#5469]) -+- sync: drop wakers after unlocking the mutex in Notify ([#5471]) -+- sync: drop wakers outside lock in semaphore ([#5475]) -+ -+### Added -+ -+- fs: add `fs::try_exists` ([#4299]) -+- net: add types for named unix pipes ([#5351]) -+- sync: add `MappedOwnedMutexGuard` ([#5474]) -+ -+### Changed -+ -+- chore: update windows-sys to 0.45 ([#5386]) -+- net: use Message Read Mode for named pipes ([#5350]) -+- sync: mark lock guards with `#[clippy::has_significant_drop]` ([#5422]) -+- sync: reduce contention in watch channel ([#5464]) -+- time: remove cache padding in timer entries ([#5468]) -+- time: Improve `Instant::now()` perf with test-util ([#5513]) -+ -+### Internal Changes -+ -+- io: use `poll_fn` in `copy_bidirectional` ([#5486]) -+- net: refactor named pipe builders to not use bitfields ([#5477]) -+- rt: remove Arc from Clock ([#5434]) -+- sync: make `notify_waiters` calls atomic ([#5458]) -+- time: don't store deadline twice in sleep entries ([#5410]) -+ -+### Unstable -+ -+- metrics: add a new metric for budget exhaustion yields ([#5517]) -+ -+### Documented -+ -+- io: improve AsyncFd example ([#5481]) -+- runtime: document the nature of the main future ([#5494]) -+- runtime: remove extra period in docs ([#5511]) -+- signal: updated Documentation for Signals ([#5459]) -+- sync: add doc aliases for `blocking_*` methods ([#5448]) -+- sync: fix docs for Send/Sync bounds in broadcast ([#5480]) -+- sync: document drop behavior for channels ([#5497]) -+- task: clarify what happens to spawned work during runtime shutdown ([#5394]) -+- task: clarify `process::Command` docs ([#5413]) -+- task: fix wording with 'unsend' ([#5452]) -+- time: document immediate completion guarantee for timeouts ([#5509]) -+- tokio: document supported platforms ([#5483]) -+ -+[#4299]: https://github.com/tokio-rs/tokio/pull/4299 -+[#5350]: https://github.com/tokio-rs/tokio/pull/5350 -+[#5351]: https://github.com/tokio-rs/tokio/pull/5351 -+[#5386]: https://github.com/tokio-rs/tokio/pull/5386 -+[#5394]: https://github.com/tokio-rs/tokio/pull/5394 -+[#5410]: https://github.com/tokio-rs/tokio/pull/5410 -+[#5413]: https://github.com/tokio-rs/tokio/pull/5413 -+[#5422]: https://github.com/tokio-rs/tokio/pull/5422 -+[#5434]: https://github.com/tokio-rs/tokio/pull/5434 -+[#5448]: https://github.com/tokio-rs/tokio/pull/5448 -+[#5452]: https://github.com/tokio-rs/tokio/pull/5452 -+[#5458]: https://github.com/tokio-rs/tokio/pull/5458 -+[#5459]: https://github.com/tokio-rs/tokio/pull/5459 -+[#5464]: https://github.com/tokio-rs/tokio/pull/5464 -+[#5468]: https://github.com/tokio-rs/tokio/pull/5468 -+[#5469]: https://github.com/tokio-rs/tokio/pull/5469 -+[#5471]: https://github.com/tokio-rs/tokio/pull/5471 -+[#5474]: https://github.com/tokio-rs/tokio/pull/5474 -+[#5475]: https://github.com/tokio-rs/tokio/pull/5475 -+[#5477]: https://github.com/tokio-rs/tokio/pull/5477 -+[#5480]: https://github.com/tokio-rs/tokio/pull/5480 -+[#5481]: https://github.com/tokio-rs/tokio/pull/5481 -+[#5483]: https://github.com/tokio-rs/tokio/pull/5483 -+[#5486]: https://github.com/tokio-rs/tokio/pull/5486 -+[#5494]: https://github.com/tokio-rs/tokio/pull/5494 -+[#5497]: https://github.com/tokio-rs/tokio/pull/5497 -+[#5504]: https://github.com/tokio-rs/tokio/pull/5504 -+[#5509]: https://github.com/tokio-rs/tokio/pull/5509 -+[#5511]: https://github.com/tokio-rs/tokio/pull/5511 -+[#5513]: https://github.com/tokio-rs/tokio/pull/5513 -+[#5517]: https://github.com/tokio-rs/tokio/pull/5517 -+ -+# 1.25.0 (January 28, 2023) -+ -+### Fixed -+ -+- rt: fix runtime metrics reporting ([#5330]) -+ -+### Added -+ -+- sync: add `broadcast::Sender::len` ([#5343]) -+ -+### Changed -+ -+- fs: increase maximum read buffer size to 2MiB ([#5397]) -+ -+[#5330]: https://github.com/tokio-rs/tokio/pull/5330 -+[#5343]: https://github.com/tokio-rs/tokio/pull/5343 -+[#5397]: https://github.com/tokio-rs/tokio/pull/5397 -+ -+# 1.24.2 (January 17, 2023) -+ -+Forward ports 1.18.5 changes. -+ -+### Fixed -+ -+- io: fix unsoundness in `ReadHalf::unsplit` ([#5375]) -+ -+[#5375]: https://github.com/tokio-rs/tokio/pull/5375 -+ -+# 1.24.1 (January 6, 2022) -+ -+This release fixes a compilation failure on targets without `AtomicU64` when using rustc older than 1.63. ([#5356]) -+ -+[#5356]: https://github.com/tokio-rs/tokio/pull/5356 -+ -+# 1.24.0 (January 5, 2022) -+ -+### Fixed -+ - rt: improve native `AtomicU64` support detection ([#5284]) -+ -+### Added -+ - rt: add configuration option for max number of I/O events polled from the OS -+ per tick ([#5186]) -+ - rt: add an environment variable for configuring the default number of worker -+ threads per runtime instance ([#4250]) -+ -+### Changed -+ - sync: reduce MPSC channel stack usage ([#5294]) -+ - io: reduce lock contention in I/O operations ([#5300]) -+ - fs: speed up `read_dir()` by chunking operations ([#5309]) -+ - rt: use internal `ThreadId` implementation ([#5329]) -+ - test: don't auto-advance time when a `spawn_blocking` task is running ([#5115]) -+ -+[#5186]: https://github.com/tokio-rs/tokio/pull/5186 -+[#5294]: https://github.com/tokio-rs/tokio/pull/5294 -+[#5284]: https://github.com/tokio-rs/tokio/pull/5284 -+[#4250]: https://github.com/tokio-rs/tokio/pull/4250 -+[#5300]: https://github.com/tokio-rs/tokio/pull/5300 -+[#5329]: https://github.com/tokio-rs/tokio/pull/5329 -+[#5115]: https://github.com/tokio-rs/tokio/pull/5115 -+[#5309]: https://github.com/tokio-rs/tokio/pull/5309 -+ -+# 1.23.1 (January 4, 2022) -+ -+This release forward ports changes from 1.18.4. -+ -+### Fixed -+ -+- net: fix Windows named pipe server builder to maintain option when toggling -+ pipe mode ([#5336]). -+ -+[#5336]: https://github.com/tokio-rs/tokio/pull/5336 -+ -+# 1.23.0 (December 5, 2022) -+ -+### Fixed -+ -+ - net: fix Windows named pipe connect ([#5208]) -+ - io: support vectored writes for `ChildStdin` ([#5216]) -+ - io: fix `async fn ready()` false positive for OS-specific events ([#5231]) -+ -+ ### Changed -+ - runtime: `yield_now` defers task until after driver poll ([#5223]) -+ - runtime: reduce amount of codegen needed per spawned task ([#5213]) -+ - windows: replace `winapi` dependency with `windows-sys` ([#5204]) -+ -+ [#5208]: https://github.com/tokio-rs/tokio/pull/5208 -+ [#5216]: https://github.com/tokio-rs/tokio/pull/5216 -+ [#5213]: https://github.com/tokio-rs/tokio/pull/5213 -+ [#5204]: https://github.com/tokio-rs/tokio/pull/5204 -+ [#5223]: https://github.com/tokio-rs/tokio/pull/5223 -+ [#5231]: https://github.com/tokio-rs/tokio/pull/5231 -+ -+# 1.22.0 (November 17, 2022) -+ -+### Added -+ - runtime: add `Handle::runtime_flavor` ([#5138]) -+ - sync: add `Mutex::blocking_lock_owned` ([#5130]) -+ - sync: add `Semaphore::MAX_PERMITS` ([#5144]) -+ - sync: add `merge()` to semaphore permits ([#4948]) -+ - sync: add `mpsc::WeakUnboundedSender` ([#5189]) -+ -+### Added (unstable) -+ -+ - process: add `Command::process_group` ([#5114]) -+ - runtime: export metrics about the blocking thread pool ([#5161]) -+ - task: add `task::id()` and `task::try_id()` ([#5171]) -+ -+### Fixed -+ - macros: don't take ownership of futures in macros ([#5087]) -+ - runtime: fix Stacked Borrows violation in `LocalOwnedTasks` ([#5099]) -+ - runtime: mitigate ABA with 32-bit queue indices when possible ([#5042]) -+ - task: wake local tasks to the local queue when woken by the same thread ([#5095]) -+ - time: panic in release mode when `mark_pending` called illegally ([#5093]) -+ - runtime: fix typo in expect message ([#5169]) -+ - runtime: fix `unsync_load` on atomic types ([#5175]) -+ - task: elaborate safety comments in task deallocation ([#5172]) -+ - runtime: fix `LocalSet` drop in thread local ([#5179]) -+ - net: remove libc type leakage in a public API ([#5191]) -+ - runtime: update the alignment of `CachePadded` ([#5106]) -+ -+### Changed -+ - io: make `tokio::io::copy` continue filling the buffer when writer stalls ([#5066]) -+ - runtime: remove `coop::budget` from `LocalSet::run_until` ([#5155]) -+ - sync: make `Notify` panic safe ([#5154]) -+ -+### Documented -+ - io: fix doc for `write_i8` to use signed integers ([#5040]) -+ - net: fix doc typos for TCP and UDP `set_tos` methods ([#5073]) -+ - net: fix function name in `UdpSocket::recv` documentation ([#5150]) -+ - sync: typo in `TryLockError` for `RwLock::try_write` ([#5160]) -+ - task: document that spawned tasks execute immediately ([#5117]) -+ - time: document return type of `timeout` ([#5118]) -+ - time: document that `timeout` checks only before poll ([#5126]) -+ - sync: specify return type of `oneshot::Receiver` in docs ([#5198]) -+ -+### Internal changes -+ - runtime: use const `Mutex::new` for globals ([#5061]) -+ - runtime: remove `Option` around `mio::Events` in io driver ([#5078]) -+ - runtime: remove a conditional compilation clause ([#5104]) -+ - runtime: remove a reference to internal time handle ([#5107]) -+ - runtime: misc time driver cleanup ([#5120]) -+ - runtime: move signal driver to runtime module ([#5121]) -+ - runtime: signal driver now uses I/O driver directly ([#5125]) -+ - runtime: start decoupling I/O driver and I/O handle ([#5127]) -+ - runtime: switch `io::handle` refs with scheduler:Handle ([#5128]) -+ - runtime: remove Arc from I/O driver ([#5134]) -+ - runtime: use signal driver handle via `scheduler::Handle` ([#5135]) -+ - runtime: move internal clock fns out of context ([#5139]) -+ - runtime: remove `runtime::context` module ([#5140]) -+ - runtime: keep driver cfgs in `driver.rs` ([#5141]) -+ - runtime: add `runtime::context` to unify thread-locals ([#5143]) -+ - runtime: rename some confusing internal variables/fns ([#5151]) -+ - runtime: move `coop` mod into `runtime` ([#5152]) -+ - runtime: move budget state to context thread-local ([#5157]) -+ - runtime: move park logic into runtime module ([#5158]) -+ - runtime: move `Runtime` into its own file ([#5159]) -+ - runtime: unify entering a runtime with `Handle::enter` ([#5163]) -+ - runtime: remove handle reference from each scheduler ([#5166]) -+ - runtime: move `enter` into `context` ([#5167]) -+ - runtime: combine context and entered thread-locals ([#5168]) -+ - runtime: fix accidental unsetting of current handle ([#5178]) -+ - runtime: move `CoreStage` methods to `Core` ([#5182]) -+ - sync: name mpsc semaphore types ([#5146]) -+ -+[#4948]: https://github.com/tokio-rs/tokio/pull/4948 -+[#5040]: https://github.com/tokio-rs/tokio/pull/5040 -+[#5042]: https://github.com/tokio-rs/tokio/pull/5042 -+[#5061]: https://github.com/tokio-rs/tokio/pull/5061 -+[#5066]: https://github.com/tokio-rs/tokio/pull/5066 -+[#5073]: https://github.com/tokio-rs/tokio/pull/5073 -+[#5078]: https://github.com/tokio-rs/tokio/pull/5078 -+[#5087]: https://github.com/tokio-rs/tokio/pull/5087 -+[#5093]: https://github.com/tokio-rs/tokio/pull/5093 -+[#5095]: https://github.com/tokio-rs/tokio/pull/5095 -+[#5099]: https://github.com/tokio-rs/tokio/pull/5099 -+[#5104]: https://github.com/tokio-rs/tokio/pull/5104 -+[#5106]: https://github.com/tokio-rs/tokio/pull/5106 -+[#5107]: https://github.com/tokio-rs/tokio/pull/5107 -+[#5114]: https://github.com/tokio-rs/tokio/pull/5114 -+[#5117]: https://github.com/tokio-rs/tokio/pull/5117 -+[#5118]: https://github.com/tokio-rs/tokio/pull/5118 -+[#5120]: https://github.com/tokio-rs/tokio/pull/5120 -+[#5121]: https://github.com/tokio-rs/tokio/pull/5121 -+[#5125]: https://github.com/tokio-rs/tokio/pull/5125 -+[#5126]: https://github.com/tokio-rs/tokio/pull/5126 -+[#5127]: https://github.com/tokio-rs/tokio/pull/5127 -+[#5128]: https://github.com/tokio-rs/tokio/pull/5128 -+[#5130]: https://github.com/tokio-rs/tokio/pull/5130 -+[#5134]: https://github.com/tokio-rs/tokio/pull/5134 -+[#5135]: https://github.com/tokio-rs/tokio/pull/5135 -+[#5138]: https://github.com/tokio-rs/tokio/pull/5138 -+[#5138]: https://github.com/tokio-rs/tokio/pull/5138 -+[#5139]: https://github.com/tokio-rs/tokio/pull/5139 -+[#5140]: https://github.com/tokio-rs/tokio/pull/5140 -+[#5141]: https://github.com/tokio-rs/tokio/pull/5141 -+[#5143]: https://github.com/tokio-rs/tokio/pull/5143 -+[#5144]: https://github.com/tokio-rs/tokio/pull/5144 -+[#5144]: https://github.com/tokio-rs/tokio/pull/5144 -+[#5146]: https://github.com/tokio-rs/tokio/pull/5146 -+[#5150]: https://github.com/tokio-rs/tokio/pull/5150 -+[#5151]: https://github.com/tokio-rs/tokio/pull/5151 -+[#5152]: https://github.com/tokio-rs/tokio/pull/5152 -+[#5154]: https://github.com/tokio-rs/tokio/pull/5154 -+[#5155]: https://github.com/tokio-rs/tokio/pull/5155 -+[#5157]: https://github.com/tokio-rs/tokio/pull/5157 -+[#5158]: https://github.com/tokio-rs/tokio/pull/5158 -+[#5159]: https://github.com/tokio-rs/tokio/pull/5159 -+[#5160]: https://github.com/tokio-rs/tokio/pull/5160 -+[#5161]: https://github.com/tokio-rs/tokio/pull/5161 -+[#5163]: https://github.com/tokio-rs/tokio/pull/5163 -+[#5166]: https://github.com/tokio-rs/tokio/pull/5166 -+[#5167]: https://github.com/tokio-rs/tokio/pull/5167 -+[#5168]: https://github.com/tokio-rs/tokio/pull/5168 -+[#5169]: https://github.com/tokio-rs/tokio/pull/5169 -+[#5171]: https://github.com/tokio-rs/tokio/pull/5171 -+[#5172]: https://github.com/tokio-rs/tokio/pull/5172 -+[#5175]: https://github.com/tokio-rs/tokio/pull/5175 -+[#5178]: https://github.com/tokio-rs/tokio/pull/5178 -+[#5179]: https://github.com/tokio-rs/tokio/pull/5179 -+[#5182]: https://github.com/tokio-rs/tokio/pull/5182 -+[#5189]: https://github.com/tokio-rs/tokio/pull/5189 -+[#5191]: https://github.com/tokio-rs/tokio/pull/5191 -+[#5198]: https://github.com/tokio-rs/tokio/pull/5198 -+ -+# 1.21.2 (September 27, 2022) -+ -+This release removes the dependency on the `once_cell` crate to restore the MSRV -+of 1.21.x, which is the latest minor version at the time of release. ([#5048]) -+ -+[#5048]: https://github.com/tokio-rs/tokio/pull/5048 -+ -+# 1.21.1 (September 13, 2022) -+ -+### Fixed -+ -+- net: fix dependency resolution for socket2 ([#5000]) -+- task: ignore failure to set TLS in `LocalSet` Drop ([#4976]) -+ -+[#4976]: https://github.com/tokio-rs/tokio/pull/4976 -+[#5000]: https://github.com/tokio-rs/tokio/pull/5000 -+ -+# 1.21.0 (September 2, 2022) -+ -+This release is the first release of Tokio to intentionally support WASM. The -+`sync,macros,io-util,rt,time` features are stabilized on WASM. Additionally the -+wasm32-wasi target is given unstable support for the `net` feature. -+ -+### Added -+ -+- net: add `device` and `bind_device` methods to TCP/UDP sockets ([#4882]) -+- net: add `tos` and `set_tos` methods to TCP and UDP sockets ([#4877]) -+- net: add security flags to named pipe `ServerOptions` ([#4845]) -+- signal: add more windows signal handlers ([#4924]) -+- sync: add `mpsc::Sender::max_capacity` method ([#4904]) -+- sync: implement Weak version of `mpsc::Sender` ([#4595]) -+- task: add `LocalSet::enter` ([#4765]) -+- task: stabilize `JoinSet` and `AbortHandle` ([#4920]) -+- tokio: add `track_caller` to public APIs ([#4805], [#4848], [#4852]) -+- wasm: initial support for `wasm32-wasi` target ([#4716]) -+ -+### Fixed -+ -+- miri: improve miri compatibility by avoiding temporary references in `linked_list::Link` impls ([#4841]) -+- signal: don't register write interest on signal pipe ([#4898]) -+- sync: add `#[must_use]` to lock guards ([#4886]) -+- sync: fix hang when calling `recv` on closed and reopened broadcast channel ([#4867]) -+- task: propagate attributes on task-locals ([#4837]) -+ -+### Changed -+ -+- fs: change panic to error in `File::start_seek` ([#4897]) -+- io: reduce syscalls in `poll_read` ([#4840]) -+- process: use blocking threadpool for child stdio I/O ([#4824]) -+- signal: make `SignalKind` methods const ([#4956]) -+ -+### Internal changes -+ -+- rt: extract `basic_scheduler::Config` ([#4935]) -+- rt: move I/O driver into `runtime` module ([#4942]) -+- rt: rename internal scheduler types ([#4945]) -+ -+### Documented -+ -+- chore: fix typos and grammar ([#4858], [#4894], [#4928]) -+- io: fix typo in `AsyncSeekExt::rewind` docs ([#4893]) -+- net: add documentation to `try_read()` for zero-length buffers ([#4937]) -+- runtime: remove incorrect panic section for `Builder::worker_threads` ([#4849]) -+- sync: doc of `watch::Sender::send` improved ([#4959]) -+- task: add cancel safety docs to `JoinHandle` ([#4901]) -+- task: expand on cancellation of `spawn_blocking` ([#4811]) -+- time: clarify that the first tick of `Interval::tick` happens immediately ([#4951]) -+ -+### Unstable -+ -+- rt: add unstable option to disable the LIFO slot ([#4936]) -+- task: fix incorrect signature in `Builder::spawn_on` ([#4953]) -+- task: make `task::Builder::spawn*` methods fallible ([#4823]) -+ -+[#4595]: https://github.com/tokio-rs/tokio/pull/4595 -+[#4716]: https://github.com/tokio-rs/tokio/pull/4716 -+[#4765]: https://github.com/tokio-rs/tokio/pull/4765 -+[#4805]: https://github.com/tokio-rs/tokio/pull/4805 -+[#4811]: https://github.com/tokio-rs/tokio/pull/4811 -+[#4823]: https://github.com/tokio-rs/tokio/pull/4823 -+[#4824]: https://github.com/tokio-rs/tokio/pull/4824 -+[#4837]: https://github.com/tokio-rs/tokio/pull/4837 -+[#4840]: https://github.com/tokio-rs/tokio/pull/4840 -+[#4841]: https://github.com/tokio-rs/tokio/pull/4841 -+[#4845]: https://github.com/tokio-rs/tokio/pull/4845 -+[#4848]: https://github.com/tokio-rs/tokio/pull/4848 -+[#4849]: https://github.com/tokio-rs/tokio/pull/4849 -+[#4852]: https://github.com/tokio-rs/tokio/pull/4852 -+[#4858]: https://github.com/tokio-rs/tokio/pull/4858 -+[#4867]: https://github.com/tokio-rs/tokio/pull/4867 -+[#4877]: https://github.com/tokio-rs/tokio/pull/4877 -+[#4882]: https://github.com/tokio-rs/tokio/pull/4882 -+[#4886]: https://github.com/tokio-rs/tokio/pull/4886 -+[#4893]: https://github.com/tokio-rs/tokio/pull/4893 -+[#4894]: https://github.com/tokio-rs/tokio/pull/4894 -+[#4897]: https://github.com/tokio-rs/tokio/pull/4897 -+[#4898]: https://github.com/tokio-rs/tokio/pull/4898 -+[#4901]: https://github.com/tokio-rs/tokio/pull/4901 -+[#4904]: https://github.com/tokio-rs/tokio/pull/4904 -+[#4920]: https://github.com/tokio-rs/tokio/pull/4920 -+[#4924]: https://github.com/tokio-rs/tokio/pull/4924 -+[#4928]: https://github.com/tokio-rs/tokio/pull/4928 -+[#4935]: https://github.com/tokio-rs/tokio/pull/4935 -+[#4936]: https://github.com/tokio-rs/tokio/pull/4936 -+[#4937]: https://github.com/tokio-rs/tokio/pull/4937 -+[#4942]: https://github.com/tokio-rs/tokio/pull/4942 -+[#4945]: https://github.com/tokio-rs/tokio/pull/4945 -+[#4951]: https://github.com/tokio-rs/tokio/pull/4951 -+[#4953]: https://github.com/tokio-rs/tokio/pull/4953 -+[#4956]: https://github.com/tokio-rs/tokio/pull/4956 -+[#4959]: https://github.com/tokio-rs/tokio/pull/4959 -+ -+# 1.20.4 (January 17, 2023) -+ -+Forward ports 1.18.5 changes. -+ -+### Fixed -+ -+- io: fix unsoundness in `ReadHalf::unsplit` ([#5375]) -+ -+[#5375]: https://github.com/tokio-rs/tokio/pull/5375 -+ -+# 1.20.3 (January 3, 2022) -+ -+This release forward ports changes from 1.18.4. -+ -+### Fixed -+ -+- net: fix Windows named pipe server builder to maintain option when toggling -+ pipe mode ([#5336]). -+ -+[#5336]: https://github.com/tokio-rs/tokio/pull/5336 -+ -+# 1.20.2 (September 27, 2022) -+ -+This release removes the dependency on the `once_cell` crate to restore the MSRV -+of the 1.20.x LTS release. ([#5048]) -+ -+[#5048]: https://github.com/tokio-rs/tokio/pull/5048 -+ -+# 1.20.1 (July 25, 2022) -+ -+### Fixed -+ -+- chore: fix version detection in build script ([#4860]) -+ -+[#4860]: https://github.com/tokio-rs/tokio/pull/4860 -+ -+# 1.20.0 (July 12, 2022) -+ -+### Added -+- tokio: add `track_caller` to public APIs ([#4772], [#4791], [#4793], [#4806], [#4808]) -+- sync: Add `has_changed` method to `watch::Ref` ([#4758]) -+ -+### Changed -+ -+- time: remove `src/time/driver/wheel/stack.rs` ([#4766]) -+- rt: clean up arguments passed to basic scheduler ([#4767]) -+- net: be more specific about winapi features ([#4764]) -+- tokio: use const initialized thread locals where possible ([#4677]) -+- task: various small improvements to LocalKey ([#4795]) -+ -+### Documented -+ -+- fs: warn about performance pitfall ([#4762]) -+- chore: fix spelling ([#4769]) -+- sync: document spurious failures in oneshot ([#4777]) -+- sync: add warning for watch in non-Send futures ([#4741]) -+- chore: fix typo ([#4798]) -+ -+### Unstable -+ -+- joinset: rename `join_one` to `join_next` ([#4755]) -+- rt: unhandled panic config for current thread rt ([#4770]) -+ -+[#4677]: https://github.com/tokio-rs/tokio/pull/4677 -+[#4741]: https://github.com/tokio-rs/tokio/pull/4741 -+[#4755]: https://github.com/tokio-rs/tokio/pull/4755 -+[#4758]: https://github.com/tokio-rs/tokio/pull/4758 -+[#4762]: https://github.com/tokio-rs/tokio/pull/4762 -+[#4764]: https://github.com/tokio-rs/tokio/pull/4764 -+[#4766]: https://github.com/tokio-rs/tokio/pull/4766 -+[#4767]: https://github.com/tokio-rs/tokio/pull/4767 -+[#4769]: https://github.com/tokio-rs/tokio/pull/4769 -+[#4770]: https://github.com/tokio-rs/tokio/pull/4770 -+[#4772]: https://github.com/tokio-rs/tokio/pull/4772 -+[#4777]: https://github.com/tokio-rs/tokio/pull/4777 -+[#4791]: https://github.com/tokio-rs/tokio/pull/4791 -+[#4793]: https://github.com/tokio-rs/tokio/pull/4793 -+[#4795]: https://github.com/tokio-rs/tokio/pull/4795 -+[#4798]: https://github.com/tokio-rs/tokio/pull/4798 -+[#4806]: https://github.com/tokio-rs/tokio/pull/4806 -+[#4808]: https://github.com/tokio-rs/tokio/pull/4808 -+ -+# 1.19.2 (June 6, 2022) -+ -+This release fixes another bug in `Notified::enable`. ([#4751]) -+ -+[#4751]: https://github.com/tokio-rs/tokio/pull/4751 -+ -+# 1.19.1 (June 5, 2022) -+ -+This release fixes a bug in `Notified::enable`. ([#4747]) -+ -+[#4747]: https://github.com/tokio-rs/tokio/pull/4747 -+ -+# 1.19.0 (June 3, 2022) -+ -+### Added -+ -+- runtime: add `is_finished` method for `JoinHandle` and `AbortHandle` ([#4709]) -+- runtime: make global queue and event polling intervals configurable ([#4671]) -+- sync: add `Notified::enable` ([#4705]) -+- sync: add `watch::Sender::send_if_modified` ([#4591]) -+- sync: add resubscribe method to broadcast::Receiver ([#4607]) -+- net: add `take_error` to `TcpSocket` and `TcpStream` ([#4739]) -+ -+### Changed -+ -+- io: refactor out usage of Weak in the io handle ([#4656]) -+ -+### Fixed -+ -+- macros: avoid starvation in `join!` and `try_join!` ([#4624]) -+ -+### Documented -+ -+- runtime: clarify semantics of tasks outliving `block_on` ([#4729]) -+- time: fix example for `MissedTickBehavior::Burst` ([#4713]) -+ -+### Unstable -+ -+- metrics: correctly update atomics in `IoDriverMetrics` ([#4725]) -+- metrics: fix compilation with unstable, process, and rt, but without net ([#4682]) -+- task: add `#[track_caller]` to `JoinSet`/`JoinMap` ([#4697]) -+- task: add `Builder::{spawn_on, spawn_local_on, spawn_blocking_on}` ([#4683]) -+- task: add `consume_budget` for cooperative scheduling ([#4498]) -+- task: add `join_set::Builder` for configuring `JoinSet` tasks ([#4687]) -+- task: update return value of `JoinSet::join_one` ([#4726]) -+ -+[#4498]: https://github.com/tokio-rs/tokio/pull/4498 -+[#4591]: https://github.com/tokio-rs/tokio/pull/4591 -+[#4607]: https://github.com/tokio-rs/tokio/pull/4607 -+[#4624]: https://github.com/tokio-rs/tokio/pull/4624 -+[#4656]: https://github.com/tokio-rs/tokio/pull/4656 -+[#4671]: https://github.com/tokio-rs/tokio/pull/4671 -+[#4682]: https://github.com/tokio-rs/tokio/pull/4682 -+[#4683]: https://github.com/tokio-rs/tokio/pull/4683 -+[#4687]: https://github.com/tokio-rs/tokio/pull/4687 -+[#4697]: https://github.com/tokio-rs/tokio/pull/4697 -+[#4705]: https://github.com/tokio-rs/tokio/pull/4705 -+[#4709]: https://github.com/tokio-rs/tokio/pull/4709 -+[#4713]: https://github.com/tokio-rs/tokio/pull/4713 -+[#4725]: https://github.com/tokio-rs/tokio/pull/4725 -+[#4726]: https://github.com/tokio-rs/tokio/pull/4726 -+[#4729]: https://github.com/tokio-rs/tokio/pull/4729 -+[#4739]: https://github.com/tokio-rs/tokio/pull/4739 -+ -+# 1.18.5 (January 17, 2023) -+ -+### Fixed -+ -+- io: fix unsoundness in `ReadHalf::unsplit` ([#5375]) -+ -+[#5375]: https://github.com/tokio-rs/tokio/pull/5375 -+ -+# 1.18.4 (January 3, 2022) -+ -+### Fixed -+ -+- net: fix Windows named pipe server builder to maintain option when toggling -+ pipe mode ([#5336]). -+ -+[#5336]: https://github.com/tokio-rs/tokio/pull/5336 -+ -+# 1.18.3 (September 27, 2022) -+ -+This release removes the dependency on the `once_cell` crate to restore the MSRV -+of the 1.18.x LTS release. ([#5048]) -+ -+[#5048]: https://github.com/tokio-rs/tokio/pull/5048 -+ -+# 1.18.2 (May 5, 2022) -+ -+Add missing features for the `winapi` dependency. ([#4663]) -+ -+[#4663]: https://github.com/tokio-rs/tokio/pull/4663 -+ -+# 1.18.1 (May 2, 2022) -+ -+The 1.18.0 release broke the build for targets without 64-bit atomics when -+building with `tokio_unstable`. This release fixes that. ([#4649]) -+ -+[#4649]: https://github.com/tokio-rs/tokio/pull/4649 -+ -+# 1.18.0 (April 27, 2022) -+ -+This release adds a number of new APIs in `tokio::net`, `tokio::signal`, and -+`tokio::sync`. In addition, it adds new unstable APIs to `tokio::task` (`Id`s -+for uniquely identifying a task, and `AbortHandle` for remotely cancelling a -+task), as well as a number of bugfixes. -+ -+### Fixed -+ -+- blocking: add missing `#[track_caller]` for `spawn_blocking` ([#4616]) -+- macros: fix `select` macro to process 64 branches ([#4519]) -+- net: fix `try_io` methods not calling Mio's `try_io` internally ([#4582]) -+- runtime: recover when OS fails to spawn a new thread ([#4485]) -+ -+### Added -+ -+- net: add `UdpSocket::peer_addr` ([#4611]) -+- net: add `try_read_buf` method for named pipes ([#4626]) -+- signal: add `SignalKind` `Hash`/`Eq` impls and `c_int` conversion ([#4540]) -+- signal: add support for signals up to `SIGRTMAX` ([#4555]) -+- sync: add `watch::Sender::send_modify` method ([#4310]) -+- sync: add `broadcast::Receiver::len` method ([#4542]) -+- sync: add `watch::Receiver::same_channel` method ([#4581]) -+- sync: implement `Clone` for `RecvError` types ([#4560]) -+ -+### Changed -+ -+- update `mio` to 0.8.1 ([#4582]) -+- macros: rename `tokio::select!`'s internal `util` module ([#4543]) -+- runtime: use `Vec::with_capacity` when building runtime ([#4553]) -+ -+### Documented -+ -+- improve docs for `tokio_unstable` ([#4524]) -+- runtime: include more documentation for thread_pool/worker ([#4511]) -+- runtime: update `Handle::current`'s docs to mention `EnterGuard` ([#4567]) -+- time: clarify platform specific timer resolution ([#4474]) -+- signal: document that `Signal::recv` is cancel-safe ([#4634]) -+- sync: `UnboundedReceiver` close docs ([#4548]) -+ -+### Unstable -+ -+The following changes only apply when building with `--cfg tokio_unstable`: -+ -+- task: add `task::Id` type ([#4630]) -+- task: add `AbortHandle` type for cancelling tasks in a `JoinSet` ([#4530], -+ [#4640]) -+- task: fix missing `doc(cfg(...))` attributes for `JoinSet` ([#4531]) -+- task: fix broken link in `AbortHandle` RustDoc ([#4545]) -+- metrics: add initial IO driver metrics ([#4507]) -+ -+ -+[#4616]: https://github.com/tokio-rs/tokio/pull/4616 -+[#4519]: https://github.com/tokio-rs/tokio/pull/4519 -+[#4582]: https://github.com/tokio-rs/tokio/pull/4582 -+[#4485]: https://github.com/tokio-rs/tokio/pull/4485 -+[#4613]: https://github.com/tokio-rs/tokio/pull/4613 -+[#4611]: https://github.com/tokio-rs/tokio/pull/4611 -+[#4626]: https://github.com/tokio-rs/tokio/pull/4626 -+[#4540]: https://github.com/tokio-rs/tokio/pull/4540 -+[#4555]: https://github.com/tokio-rs/tokio/pull/4555 -+[#4310]: https://github.com/tokio-rs/tokio/pull/4310 -+[#4542]: https://github.com/tokio-rs/tokio/pull/4542 -+[#4581]: https://github.com/tokio-rs/tokio/pull/4581 -+[#4560]: https://github.com/tokio-rs/tokio/pull/4560 -+[#4631]: https://github.com/tokio-rs/tokio/pull/4631 -+[#4582]: https://github.com/tokio-rs/tokio/pull/4582 -+[#4543]: https://github.com/tokio-rs/tokio/pull/4543 -+[#4553]: https://github.com/tokio-rs/tokio/pull/4553 -+[#4524]: https://github.com/tokio-rs/tokio/pull/4524 -+[#4511]: https://github.com/tokio-rs/tokio/pull/4511 -+[#4567]: https://github.com/tokio-rs/tokio/pull/4567 -+[#4474]: https://github.com/tokio-rs/tokio/pull/4474 -+[#4634]: https://github.com/tokio-rs/tokio/pull/4634 -+[#4548]: https://github.com/tokio-rs/tokio/pull/4548 -+[#4630]: https://github.com/tokio-rs/tokio/pull/4630 -+[#4530]: https://github.com/tokio-rs/tokio/pull/4530 -+[#4640]: https://github.com/tokio-rs/tokio/pull/4640 -+[#4531]: https://github.com/tokio-rs/tokio/pull/4531 -+[#4545]: https://github.com/tokio-rs/tokio/pull/4545 -+[#4507]: https://github.com/tokio-rs/tokio/pull/4507 -+ -+# 1.17.0 (February 16, 2022) -+ -+This release updates the minimum supported Rust version (MSRV) to 1.49, the -+`mio` dependency to v0.8, and the (optional) `parking_lot` dependency to v0.12. -+Additionally, it contains several bug fixes, as well as internal refactoring and -+performance improvements. -+ -+### Fixed -+ -+- time: prevent panicking in `sleep` with large durations ([#4495]) -+- time: eliminate potential panics in `Instant` arithmetic on platforms where -+ `Instant::now` is not monotonic ([#4461]) -+- io: fix `DuplexStream` not participating in cooperative yielding ([#4478]) -+- rt: fix potential double panic when dropping a `JoinHandle` ([#4430]) -+ -+### Changed -+ -+- update minimum supported Rust version to 1.49 ([#4457]) -+- update `parking_lot` dependency to v0.12.0 ([#4459]) -+- update `mio` dependency to v0.8 ([#4449]) -+- rt: remove an unnecessary lock in the blocking pool ([#4436]) -+- rt: remove an unnecessary enum in the basic scheduler ([#4462]) -+- time: use bit manipulation instead of modulo to improve performance ([#4480]) -+- net: use `std::future::Ready` instead of our own `Ready` future ([#4271]) -+- replace deprecated `atomic::spin_loop_hint` with `hint::spin_loop` ([#4491]) -+- fix miri failures in intrusive linked lists ([#4397]) -+ -+### Documented -+ -+- io: add an example for `tokio::process::ChildStdin` ([#4479]) -+ -+### Unstable -+ -+The following changes only apply when building with `--cfg tokio_unstable`: -+ -+- task: fix missing location information in `tracing` spans generated by -+ `spawn_local` ([#4483]) -+- task: add `JoinSet` for managing sets of tasks ([#4335]) -+- metrics: fix compilation error on MIPS ([#4475]) -+- metrics: fix compilation error on arm32v7 ([#4453]) -+ -+[#4495]: https://github.com/tokio-rs/tokio/pull/4495 -+[#4461]: https://github.com/tokio-rs/tokio/pull/4461 -+[#4478]: https://github.com/tokio-rs/tokio/pull/4478 -+[#4430]: https://github.com/tokio-rs/tokio/pull/4430 -+[#4457]: https://github.com/tokio-rs/tokio/pull/4457 -+[#4459]: https://github.com/tokio-rs/tokio/pull/4459 -+[#4449]: https://github.com/tokio-rs/tokio/pull/4449 -+[#4462]: https://github.com/tokio-rs/tokio/pull/4462 -+[#4436]: https://github.com/tokio-rs/tokio/pull/4436 -+[#4480]: https://github.com/tokio-rs/tokio/pull/4480 -+[#4271]: https://github.com/tokio-rs/tokio/pull/4271 -+[#4491]: https://github.com/tokio-rs/tokio/pull/4491 -+[#4397]: https://github.com/tokio-rs/tokio/pull/4397 -+[#4479]: https://github.com/tokio-rs/tokio/pull/4479 -+[#4483]: https://github.com/tokio-rs/tokio/pull/4483 -+[#4335]: https://github.com/tokio-rs/tokio/pull/4335 -+[#4475]: https://github.com/tokio-rs/tokio/pull/4475 -+[#4453]: https://github.com/tokio-rs/tokio/pull/4453 -+ -+# 1.16.1 (January 28, 2022) -+ -+This release fixes a bug in [#4428] with the change [#4437]. -+ -+[#4428]: https://github.com/tokio-rs/tokio/pull/4428 -+[#4437]: https://github.com/tokio-rs/tokio/pull/4437 -+ -+# 1.16.0 (January 27, 2022) -+ -+Fixes a soundness bug in `io::Take` ([#4428]). The unsoundness is exposed when -+leaking memory in the given `AsyncRead` implementation and then overwriting the -+supplied buffer: -+ -+```rust -+impl AsyncRead for Buggy { -+ fn poll_read( -+ self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ buf: &mut ReadBuf<'_> -+ ) -> Poll> { -+ let new_buf = vec![0; 5].leak(); -+ *buf = ReadBuf::new(new_buf); -+ buf.put_slice(b"hello"); -+ Poll::Ready(Ok(())) -+ } -+} -+``` -+ -+Also, this release includes improvements to the multi-threaded scheduler that -+can increase throughput by up to 20% in some cases ([#4383]). -+ -+### Fixed -+ -+- io: **soundness** don't expose uninitialized memory when using `io::Take` in edge case ([#4428]) -+- fs: ensure `File::write` results in a `write` syscall when the runtime shuts down ([#4316]) -+- process: drop pipe after child exits in `wait_with_output` ([#4315]) -+- rt: improve error message when spawning a thread fails ([#4398]) -+- rt: reduce false-positive thread wakups in the multi-threaded scheduler ([#4383]) -+- sync: don't inherit `Send` from `parking_lot::*Guard` ([#4359]) -+ -+### Added -+ -+- net: `TcpSocket::linger()` and `set_linger()` ([#4324]) -+- net: impl `UnwindSafe` for socket types ([#4384]) -+- rt: impl `UnwindSafe` for `JoinHandle` ([#4418]) -+- sync: `watch::Receiver::has_changed()` ([#4342]) -+- sync: `oneshot::Receiver::blocking_recv()` ([#4334]) -+- sync: `RwLock` blocking operations ([#4425]) -+ -+### Unstable -+ -+The following changes only apply when building with `--cfg tokio_unstable` -+ -+- rt: **breaking change** overhaul runtime metrics API ([#4373]) -+ -+[#4428]: https://github.com/tokio-rs/tokio/pull/4428 -+[#4316]: https://github.com/tokio-rs/tokio/pull/4316 -+[#4315]: https://github.com/tokio-rs/tokio/pull/4315 -+[#4398]: https://github.com/tokio-rs/tokio/pull/4398 -+[#4383]: https://github.com/tokio-rs/tokio/pull/4383 -+[#4359]: https://github.com/tokio-rs/tokio/pull/4359 -+[#4324]: https://github.com/tokio-rs/tokio/pull/4324 -+[#4384]: https://github.com/tokio-rs/tokio/pull/4384 -+[#4418]: https://github.com/tokio-rs/tokio/pull/4418 -+[#4342]: https://github.com/tokio-rs/tokio/pull/4342 -+[#4334]: https://github.com/tokio-rs/tokio/pull/4334 -+[#4425]: https://github.com/tokio-rs/tokio/pull/4425 -+[#4373]: https://github.com/tokio-rs/tokio/pull/4373 -+ -+# 1.15.0 (December 15, 2021) -+ -+### Fixed -+ -+- io: add cooperative yielding support to `io::empty()` ([#4300]) -+- time: make timeout robust against budget-depleting tasks ([#4314]) -+ -+### Changed -+ -+- update minimum supported Rust version to 1.46. -+ -+### Added -+ -+- time: add `Interval::reset()` ([#4248]) -+- io: add explicit lifetimes to `AsyncFdReadyGuard` ([#4267]) -+- process: add `Command::as_std()` ([#4295]) -+ -+### Added (unstable) -+ -+- tracing: instrument `tokio::sync` types ([#4302]) -+ -+[#4302]: https://github.com/tokio-rs/tokio/pull/4302 -+[#4300]: https://github.com/tokio-rs/tokio/pull/4300 -+[#4295]: https://github.com/tokio-rs/tokio/pull/4295 -+[#4267]: https://github.com/tokio-rs/tokio/pull/4267 -+[#4248]: https://github.com/tokio-rs/tokio/pull/4248 -+[#4314]: https://github.com/tokio-rs/tokio/pull/4314 -+ - # 1.14.0 (November 15, 2021) - - ### Fixed -@@ -919,7 +1856,7 @@ Biggest changes are: - - Feature flags are simplified - - `rt-core` and `rt-util` are combined to `rt` - - `rt-threaded` is renamed to `rt-multi-thread` to match builder API -- - `tcp`, `udp`, `uds`, `dns` are combied to `net`. -+ - `tcp`, `udp`, `uds`, `dns` are combined to `net`. - - `parking_lot` is included with `full` - - ### Changes -@@ -1417,7 +2354,7 @@ Biggest changes are: - - `net::lookup_host` maps a `T: ToSocketAddrs` to a stream of `SocketAddrs` ([#1870]). - - `process::Child` fields are made public to match `std` ([#2014]). - - impl `Stream` for `sync::broadcast::Receiver` ([#2012]). --- `sync::RwLock` provides an asynchonous read-write lock ([#1699]). -+- `sync::RwLock` provides an asynchronous read-write lock ([#1699]). - - `runtime::Handle::current` returns the handle for the current runtime ([#2040]). - - `StreamExt::filter` filters stream values according to a predicate ([#2001]). - - `StreamExt::filter_map` simultaneously filter and map stream values ([#2001]). -@@ -1526,7 +2463,7 @@ Biggest changes are: - ### Fixes - - - calling `spawn_blocking` after runtime shutdown ([#1875]). --- `LocalSet` drop inifinite loop ([#1892]). -+- `LocalSet` drop infinite loop ([#1892]). - - `LocalSet` hang under load ([#1905]). - - improved documentation ([#1865], [#1866], [#1868], [#1874], [#1876], [#1911]). - -diff --git a/KubeOS-Rust/vendor/tokio/Cargo.toml b/KubeOS-Rust/vendor/tokio/Cargo.toml -index ec9b335d..ea23c9b1 100644 ---- a/KubeOS-Rust/vendor/tokio/Cargo.toml -+++ b/KubeOS-Rust/vendor/tokio/Cargo.toml -@@ -10,54 +10,73 @@ - # See Cargo.toml.orig for the original contents. - - [package] --edition = "2018" -+edition = "2021" -+rust-version = "1.56" - name = "tokio" --version = "1.14.0" -+version = "1.28.0" - authors = ["Tokio Contributors "] --description = "An event-driven, non-blocking I/O platform for writing asynchronous I/O\nbacked applications.\n" -+description = """ -+An event-driven, non-blocking I/O platform for writing asynchronous I/O -+backed applications. -+""" - homepage = "https://tokio.rs" --documentation = "https://docs.rs/tokio/1.14.0/tokio/" - readme = "README.md" --keywords = ["io", "async", "non-blocking", "futures"] --categories = ["asynchronous", "network-programming"] -+keywords = [ -+ "io", -+ "async", -+ "non-blocking", -+ "futures", -+] -+categories = [ -+ "asynchronous", -+ "network-programming", -+] - license = "MIT" - repository = "https://github.com/tokio-rs/tokio" -+resolver = "1" -+ - [package.metadata.docs.rs] - all-features = true --rustdoc-args = ["--cfg", "docsrs"] -+rustc-args = [ -+ "--cfg", -+ "tokio_unstable", -+] -+rustdoc-args = [ -+ "--cfg", -+ "docsrs", -+ "--cfg", -+ "tokio_unstable", -+] - - [package.metadata.playground] --features = ["full", "test-util"] -+features = [ -+ "full", -+ "test-util", -+] -+ - [dependencies.bytes] - version = "1.0.0" - optional = true - --[dependencies.memchr] --version = "2.2" --optional = true -- - [dependencies.mio] --version = "0.7.6" -+version = "0.8.4" - optional = true - - [dependencies.num_cpus] - version = "1.8.0" - optional = true - --[dependencies.once_cell] --version = "1.5.2" --optional = true -- - [dependencies.parking_lot] --version = "0.11.0" -+version = "0.12.0" - optional = true - - [dependencies.pin-project-lite] - version = "0.2.0" - - [dependencies.tokio-macros] --version = "1.6.0" -+version = "~2.1.0" - optional = true -+ - [dev-dependencies.async-stream] - version = "0.3" - -@@ -66,55 +85,124 @@ version = "0.3.0" - features = ["async-await"] - - [dev-dependencies.mockall] --version = "0.10.2" -- --[dev-dependencies.proptest] --version = "1" -- --[dev-dependencies.rand] --version = "0.8.0" -- --[dev-dependencies.socket2] --version = "0.4" -- --[dev-dependencies.tempfile] --version = "3.1.0" -+version = "0.11.1" - - [dev-dependencies.tokio-stream] - version = "0.1" - - [dev-dependencies.tokio-test] - version = "0.4.0" -+ - [build-dependencies.autocfg] --version = "1" -+version = "1.1" - - [features] - default = [] - fs = [] --full = ["fs", "io-util", "io-std", "macros", "net", "parking_lot", "process", "rt", "rt-multi-thread", "signal", "sync", "time"] -+full = [ -+ "fs", -+ "io-util", -+ "io-std", -+ "macros", -+ "net", -+ "parking_lot", -+ "process", -+ "rt", -+ "rt-multi-thread", -+ "signal", -+ "sync", -+ "time", -+] - io-std = [] --io-util = ["memchr", "bytes"] -+io-util = ["bytes"] - macros = ["tokio-macros"] --net = ["libc", "mio/os-poll", "mio/os-util", "mio/tcp", "mio/udp", "mio/uds", "winapi/namedpipeapi"] --process = ["bytes", "once_cell", "libc", "mio/os-poll", "mio/os-util", "mio/uds", "signal-hook-registry", "winapi/threadpoollegacyapiset"] -+net = [ -+ "libc", -+ "mio/os-poll", -+ "mio/os-ext", -+ "mio/net", -+ "socket2", -+ "windows-sys/Win32_Foundation", -+ "windows-sys/Win32_Security", -+ "windows-sys/Win32_Storage_FileSystem", -+ "windows-sys/Win32_System_Pipes", -+ "windows-sys/Win32_System_SystemServices", -+] -+process = [ -+ "bytes", -+ "libc", -+ "mio/os-poll", -+ "mio/os-ext", -+ "mio/net", -+ "signal-hook-registry", -+ "windows-sys/Win32_Foundation", -+ "windows-sys/Win32_System_Threading", -+ "windows-sys/Win32_System_WindowsProgramming", -+] - rt = [] --rt-multi-thread = ["num_cpus", "rt"] --signal = ["once_cell", "libc", "mio/os-poll", "mio/uds", "mio/os-util", "signal-hook-registry", "winapi/consoleapi"] -+rt-multi-thread = [ -+ "num_cpus", -+ "rt", -+] -+signal = [ -+ "libc", -+ "mio/os-poll", -+ "mio/net", -+ "mio/os-ext", -+ "signal-hook-registry", -+ "windows-sys/Win32_Foundation", -+ "windows-sys/Win32_System_Console", -+] - stats = [] - sync = [] --test-util = ["rt", "sync", "time"] -+test-util = [ -+ "rt", -+ "sync", -+ "time", -+] - time = [] -+ -+[target."cfg(all(any(target_arch = \"wasm32\", target_arch = \"wasm64\"), not(target_os = \"wasi\")))".dev-dependencies.wasm-bindgen-test] -+version = "0.3.0" -+ -+[target."cfg(docsrs)".dependencies.windows-sys] -+version = "0.48" -+features = [ -+ "Win32_Foundation", -+ "Win32_Security_Authorization", -+] -+ - [target."cfg(loom)".dev-dependencies.loom] --version = "0.5" --features = ["futures", "checkpoint"] -+version = "0.5.2" -+features = [ -+ "futures", -+ "checkpoint", -+] -+ -+[target."cfg(not(all(any(target_arch = \"wasm32\", target_arch = \"wasm64\"), target_os = \"unknown\")))".dev-dependencies.rand] -+version = "0.8.0" -+ -+[target."cfg(not(any(target_arch = \"wasm32\", target_arch = \"wasm64\")))".dependencies.socket2] -+version = "0.4.9" -+features = ["all"] -+optional = true -+ -+[target."cfg(not(any(target_arch = \"wasm32\", target_arch = \"wasm64\")))".dev-dependencies.socket2] -+version = "0.4.9" -+ -+[target."cfg(not(any(target_arch = \"wasm32\", target_arch = \"wasm64\")))".dev-dependencies.tempfile] -+version = "3.1.0" -+ - [target."cfg(target_os = \"freebsd\")".dev-dependencies.mio-aio] --version = "0.6.0" -+version = "0.7.0" - features = ["tokio"] -+ - [target."cfg(tokio_unstable)".dependencies.tracing] - version = "0.1.25" - features = ["std"] - optional = true - default-features = false -+ - [target."cfg(unix)".dependencies.libc] - version = "0.2.42" - optional = true -@@ -122,14 +210,18 @@ optional = true - [target."cfg(unix)".dependencies.signal-hook-registry] - version = "1.1.1" - optional = true -+ - [target."cfg(unix)".dev-dependencies.libc] - version = "0.2.42" - - [target."cfg(unix)".dev-dependencies.nix] --version = "0.22.0" --[target."cfg(windows)".dependencies.winapi] --version = "0.3.8" --optional = true -+version = "0.26" -+features = [ -+ "fs", -+ "socket", -+] - default-features = false --[target."cfg(windows)".dev-dependencies.ntapi] --version = "0.3.6" -+ -+[target."cfg(windows)".dependencies.windows-sys] -+version = "0.48" -+optional = true -diff --git a/KubeOS-Rust/vendor/tokio/LICENSE b/KubeOS-Rust/vendor/tokio/LICENSE -index ffa38bb6..8bdf6bd6 100644 ---- a/KubeOS-Rust/vendor/tokio/LICENSE -+++ b/KubeOS-Rust/vendor/tokio/LICENSE -@@ -1,4 +1,4 @@ --Copyright (c) 2021 Tokio Contributors -+Copyright (c) 2023 Tokio Contributors - - Permission is hereby granted, free of charge, to any - person obtaining a copy of this software and associated -diff --git a/KubeOS-Rust/vendor/tokio/README.md b/KubeOS-Rust/vendor/tokio/README.md -index 19f049cb..145ae4c8 100644 ---- a/KubeOS-Rust/vendor/tokio/README.md -+++ b/KubeOS-Rust/vendor/tokio/README.md -@@ -56,7 +56,7 @@ Make sure you activated the full features of the tokio crate on Cargo.toml: - - ```toml - [dependencies] --tokio = { version = "1.14.0", features = ["full"] } -+tokio = { version = "1.28.0", features = ["full"] } - ``` - Then, on your main.rs: - -@@ -161,11 +161,46 @@ several other libraries, including: - [`mio`]: https://github.com/tokio-rs/mio - [`bytes`]: https://github.com/tokio-rs/bytes - -+## Changelog -+ -+The Tokio repository contains multiple crates. Each crate has its own changelog. -+ -+ * `tokio` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio/CHANGELOG.md) -+ * `tokio-util` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio-util/CHANGELOG.md) -+ * `tokio-stream` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio-stream/CHANGELOG.md) -+ * `tokio-macros` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio-macros/CHANGELOG.md) -+ * `tokio-test` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio-test/CHANGELOG.md) -+ - ## Supported Rust Versions - --Tokio is built against the latest stable release. The minimum supported version --is 1.45. The current Tokio version is not guaranteed to build on Rust versions --earlier than the minimum supported version. -+ -+ -+Tokio will keep a rolling MSRV (minimum supported rust version) policy of **at -+least** 6 months. When increasing the MSRV, the new Rust version must have been -+released at least six months ago. The current MSRV is 1.56.0. -+ -+Note that the MSRV is not increased automatically, and only as part of a minor -+release. The MSRV history for past minor releases can be found below: -+ -+ * 1.27 to now - Rust 1.56 -+ * 1.17 to 1.26 - Rust 1.49 -+ * 1.15 to 1.16 - Rust 1.46 -+ * 1.0 to 1.14 - Rust 1.45 -+ -+Note that although we try to avoid the situation where a dependency transitively -+increases the MSRV of Tokio, we do not guarantee that this does not happen. -+However, every minor release will have some set of versions of dependencies that -+works with the MSRV of that minor release. - - ## Release schedule - -@@ -180,17 +215,19 @@ warrants a patch release with a fix for the bug, it will be backported and - released as a new patch release for each LTS minor version. Our current LTS - releases are: - -- * `1.8.x` - LTS release until February 2022. -+ * `1.18.x` - LTS release until June 2023. (MSRV 1.49) -+ * `1.20.x` - LTS release until September 2023. (MSRV 1.49) -+ * `1.25.x` - LTS release until March 2024. (MSRV 1.49) - --Each LTS release will continue to receive backported fixes for at least half a --year. If you wish to use a fixed minor release in your project, we recommend --that you use an LTS release. -+Each LTS release will continue to receive backported fixes for at least a year. -+If you wish to use a fixed minor release in your project, we recommend that you -+use an LTS release. - - To use a fixed minor version, you can specify the version with a tilde. For --example, to specify that you wish to use the newest `1.8.x` patch release, you -+example, to specify that you wish to use the newest `1.18.x` patch release, you - can use the following dependency specification: - ```text --tokio = { version = "~1.8", features = [...] } -+tokio = { version = "~1.18", features = [...] } - ``` - - ## License -diff --git a/KubeOS-Rust/vendor/tokio/build.rs b/KubeOS-Rust/vendor/tokio/build.rs -index fe5c8300..2d2ec564 100644 ---- a/KubeOS-Rust/vendor/tokio/build.rs -+++ b/KubeOS-Rust/vendor/tokio/build.rs -@@ -1,11 +1,127 @@ - use autocfg::AutoCfg; - -+const CONST_THREAD_LOCAL_PROBE: &str = r#" -+{ -+ thread_local! { -+ static MY_PROBE: usize = const { 10 }; -+ } -+ -+ MY_PROBE.with(|val| *val) -+} -+"#; -+ -+const CONST_MUTEX_NEW_PROBE: &str = r#" -+{ -+ static MY_MUTEX: ::std::sync::Mutex = ::std::sync::Mutex::new(1); -+ *MY_MUTEX.lock().unwrap() -+} -+"#; -+ -+const AS_FD_PROBE: &str = r#" -+{ -+ #![allow(unused_imports)] -+ -+ #[cfg(unix)] -+ use std::os::unix::prelude::AsFd as _; -+ #[cfg(windows)] -+ use std::os::windows::prelude::AsSocket as _; -+ #[cfg(target = "wasm32-wasi")] -+ use std::os::wasi::prelude::AsFd as _; -+} -+"#; -+ -+const TARGET_HAS_ATOMIC_PROBE: &str = r#" -+{ -+ #[cfg(target_has_atomic = "ptr")] -+ let _ = (); -+} -+"#; -+ -+const TARGET_ATOMIC_U64_PROBE: &str = r#" -+{ -+ #[allow(unused_imports)] -+ use std::sync::atomic::AtomicU64 as _; -+} -+"#; -+ - fn main() { -+ let mut enable_const_thread_local = false; -+ let mut enable_target_has_atomic = false; -+ let mut enable_const_mutex_new = false; -+ let mut enable_as_fd = false; -+ let mut target_needs_atomic_u64_fallback = false; -+ - match AutoCfg::new() { - Ok(ac) => { -- // The #[track_caller] attribute was stabilized in rustc 1.46.0. -- if ac.probe_rustc_version(1, 46) { -- autocfg::emit("tokio_track_caller") -+ // These checks prefer to call only `probe_rustc_version` if that is -+ // enough to determine whether the feature is supported. This is -+ // because the `probe_expression` call involves a call to rustc, -+ // which the `probe_rustc_version` call avoids. -+ -+ // Const-initialized thread locals were stabilized in 1.59. -+ if ac.probe_rustc_version(1, 60) { -+ enable_const_thread_local = true; -+ } else if ac.probe_rustc_version(1, 59) { -+ // This compiler claims to be 1.59, but there are some nightly -+ // compilers that claim to be 1.59 without supporting the -+ // feature. Explicitly probe to check if code using them -+ // compiles. -+ // -+ // The oldest nightly that supports the feature is 2021-12-06. -+ if ac.probe_expression(CONST_THREAD_LOCAL_PROBE) { -+ enable_const_thread_local = true; -+ } -+ } -+ -+ // The `target_has_atomic` cfg was stabilized in 1.60. -+ if ac.probe_rustc_version(1, 61) { -+ enable_target_has_atomic = true; -+ } else if ac.probe_rustc_version(1, 60) { -+ // This compiler claims to be 1.60, but there are some nightly -+ // compilers that claim to be 1.60 without supporting the -+ // feature. Explicitly probe to check if code using them -+ // compiles. -+ // -+ // The oldest nightly that supports the feature is 2022-02-11. -+ if ac.probe_expression(TARGET_HAS_ATOMIC_PROBE) { -+ enable_target_has_atomic = true; -+ } -+ } -+ -+ // If we can't tell using `target_has_atomic`, tell if the target -+ // has `AtomicU64` by trying to use it. -+ if !enable_target_has_atomic && !ac.probe_expression(TARGET_ATOMIC_U64_PROBE) { -+ target_needs_atomic_u64_fallback = true; -+ } -+ -+ // The `Mutex::new` method was made const in 1.63. -+ if ac.probe_rustc_version(1, 64) { -+ enable_const_mutex_new = true; -+ } else if ac.probe_rustc_version(1, 63) { -+ // This compiler claims to be 1.63, but there are some nightly -+ // compilers that claim to be 1.63 without supporting the -+ // feature. Explicitly probe to check if code using them -+ // compiles. -+ // -+ // The oldest nightly that supports the feature is 2022-06-20. -+ if ac.probe_expression(CONST_MUTEX_NEW_PROBE) { -+ enable_const_mutex_new = true; -+ } -+ } -+ -+ // The `AsFd` family of traits were made stable in 1.63. -+ if ac.probe_rustc_version(1, 64) { -+ enable_as_fd = true; -+ } else if ac.probe_rustc_version(1, 63) { -+ // This compiler claims to be 1.63, but there are some nightly -+ // compilers that claim to be 1.63 without supporting the -+ // feature. Explicitly probe to check if code using them -+ // compiles. -+ // -+ // The oldest nightly that supports the feature is 2022-06-16. -+ if ac.probe_expression(AS_FD_PROBE) { -+ enable_as_fd = true; -+ } - } - } - -@@ -19,4 +135,57 @@ fn main() { - ); - } - } -+ -+ if !enable_const_thread_local { -+ // To disable this feature on compilers that support it, you can -+ // explicitly pass this flag with the following environment variable: -+ // -+ // RUSTFLAGS="--cfg tokio_no_const_thread_local" -+ autocfg::emit("tokio_no_const_thread_local") -+ } -+ -+ if !enable_target_has_atomic { -+ // To disable this feature on compilers that support it, you can -+ // explicitly pass this flag with the following environment variable: -+ // -+ // RUSTFLAGS="--cfg tokio_no_target_has_atomic" -+ autocfg::emit("tokio_no_target_has_atomic") -+ } -+ -+ if !enable_const_mutex_new { -+ // To disable this feature on compilers that support it, you can -+ // explicitly pass this flag with the following environment variable: -+ // -+ // RUSTFLAGS="--cfg tokio_no_const_mutex_new" -+ autocfg::emit("tokio_no_const_mutex_new") -+ } -+ -+ if !enable_as_fd { -+ // To disable this feature on compilers that support it, you can -+ // explicitly pass this flag with the following environment variable: -+ // -+ // RUSTFLAGS="--cfg tokio_no_as_fd" -+ autocfg::emit("tokio_no_as_fd"); -+ } -+ -+ if target_needs_atomic_u64_fallback { -+ // To disable this feature on compilers that support it, you can -+ // explicitly pass this flag with the following environment variable: -+ // -+ // RUSTFLAGS="--cfg tokio_no_atomic_u64" -+ autocfg::emit("tokio_no_atomic_u64") -+ } -+ -+ let target = ::std::env::var("TARGET").unwrap_or_default(); -+ -+ // We emit cfgs instead of using `target_family = "wasm"` that requires Rust 1.54. -+ // Note that these cfgs are unavailable in `Cargo.toml`. -+ if target.starts_with("wasm") { -+ autocfg::emit("tokio_wasm"); -+ if target.contains("wasi") { -+ autocfg::emit("tokio_wasi"); -+ } else { -+ autocfg::emit("tokio_wasm_not_wasi"); -+ } -+ } - } -diff --git a/KubeOS-Rust/vendor/tokio/docs/reactor-refactor.md b/KubeOS-Rust/vendor/tokio/docs/reactor-refactor.md -index 1c9ace15..77e64f4d 100644 ---- a/KubeOS-Rust/vendor/tokio/docs/reactor-refactor.md -+++ b/KubeOS-Rust/vendor/tokio/docs/reactor-refactor.md -@@ -188,12 +188,12 @@ readiness, the driver's tick is packed into the atomic `usize`. - The `ScheduledIo` readiness `AtomicUsize` is structured as: - - ``` --| reserved | generation | driver tick | readinesss | --|----------+------------+--------------+------------| --| 1 bit | 7 bits + 8 bits + 16 bits | -+| shutdown | generation | driver tick | readiness | -+|----------+------------+--------------+-----------| -+| 1 bit | 7 bits + 8 bits + 16 bits | - ``` - --The `reserved` and `generation` components exist today. -+The `shutdown` and `generation` components exist today. - - The `readiness()` function returns a `ReadyEvent` value. This value includes the - `tick` component read with the resource's readiness value. When -diff --git a/KubeOS-Rust/vendor/tokio/external-types.toml b/KubeOS-Rust/vendor/tokio/external-types.toml -new file mode 100644 -index 00000000..a5bde8ed ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/external-types.toml -@@ -0,0 +1,11 @@ -+# This config file is for the `cargo-check-external-types` tool that is run in CI. -+ -+# The following are types that are allowed to be exposed in Tokio's public API. -+# The standard library is allowed by default. -+allowed_external_types = [ -+ "bytes::buf::buf_impl::Buf", -+ "bytes::buf::buf_mut::BufMut", -+ -+ "tokio_macros::*", -+] -+ -diff --git a/KubeOS-Rust/vendor/tokio/src/blocking.rs b/KubeOS-Rust/vendor/tokio/src/blocking.rs -index f88b1db1..f172399d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/blocking.rs -+++ b/KubeOS-Rust/vendor/tokio/src/blocking.rs -@@ -1,5 +1,11 @@ - cfg_rt! { - pub(crate) use crate::runtime::spawn_blocking; -+ -+ cfg_fs! { -+ #[allow(unused_imports)] -+ pub(crate) use crate::runtime::spawn_mandatory_blocking; -+ } -+ - pub(crate) use crate::task::JoinHandle; - } - -@@ -16,7 +22,16 @@ cfg_not_rt! { - { - assert_send_sync::>>(); - panic!("requires the `rt` Tokio feature flag") -+ } - -+ cfg_fs! { -+ pub(crate) fn spawn_mandatory_blocking(_f: F) -> Option> -+ where -+ F: FnOnce() -> R + Send + 'static, -+ R: Send + 'static, -+ { -+ panic!("requires the `rt` Tokio feature flag") -+ } - } - - pub(crate) struct JoinHandle { -diff --git a/KubeOS-Rust/vendor/tokio/src/doc/mod.rs b/KubeOS-Rust/vendor/tokio/src/doc/mod.rs -index 3a949344..7992fc6b 100644 ---- a/KubeOS-Rust/vendor/tokio/src/doc/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/doc/mod.rs -@@ -21,4 +21,3 @@ - pub enum NotDefinedHere {} - - pub mod os; --pub mod winapi; -diff --git a/KubeOS-Rust/vendor/tokio/src/doc/os.rs b/KubeOS-Rust/vendor/tokio/src/doc/os.rs -index 0ddf8695..9404d449 100644 ---- a/KubeOS-Rust/vendor/tokio/src/doc/os.rs -+++ b/KubeOS-Rust/vendor/tokio/src/doc/os.rs -@@ -13,7 +13,7 @@ pub mod windows { - - /// See [std::os::windows::io::AsRawHandle](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawHandle.html) - pub trait AsRawHandle { -- /// See [std::os::windows::io::FromRawHandle::from_raw_handle](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawHandle.html#tymethod.as_raw_handle) -+ /// See [std::os::windows::io::AsRawHandle::as_raw_handle](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawHandle.html#tymethod.as_raw_handle) - fn as_raw_handle(&self) -> RawHandle; - } - -@@ -22,5 +22,44 @@ pub mod windows { - /// See [std::os::windows::io::FromRawHandle::from_raw_handle](https://doc.rust-lang.org/std/os/windows/io/trait.FromRawHandle.html#tymethod.from_raw_handle) - unsafe fn from_raw_handle(handle: RawHandle) -> Self; - } -+ -+ /// See [std::os::windows::io::RawSocket](https://doc.rust-lang.org/std/os/windows/io/type.RawSocket.html) -+ pub type RawSocket = crate::doc::NotDefinedHere; -+ -+ /// See [std::os::windows::io::AsRawSocket](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawSocket.html) -+ pub trait AsRawSocket { -+ /// See [std::os::windows::io::AsRawSocket::as_raw_socket](https://doc.rust-lang.org/std/os/windows/io/trait.AsRawSocket.html#tymethod.as_raw_socket) -+ fn as_raw_socket(&self) -> RawSocket; -+ } -+ -+ /// See [std::os::windows::io::FromRawSocket](https://doc.rust-lang.org/std/os/windows/io/trait.FromRawSocket.html) -+ pub trait FromRawSocket { -+ /// See [std::os::windows::io::FromRawSocket::from_raw_socket](https://doc.rust-lang.org/std/os/windows/io/trait.FromRawSocket.html#tymethod.from_raw_socket) -+ unsafe fn from_raw_socket(sock: RawSocket) -> Self; -+ } -+ -+ /// See [std::os::windows::io::IntoRawSocket](https://doc.rust-lang.org/std/os/windows/io/trait.IntoRawSocket.html) -+ pub trait IntoRawSocket { -+ /// See [std::os::windows::io::IntoRawSocket::into_raw_socket](https://doc.rust-lang.org/std/os/windows/io/trait.IntoRawSocket.html#tymethod.into_raw_socket) -+ fn into_raw_socket(self) -> RawSocket; -+ } -+ -+ /// See [std::os::windows::io::BorrowedHandle](https://doc.rust-lang.org/std/os/windows/io/struct.BorrowedHandle.html) -+ pub type BorrowedHandle<'handle> = crate::doc::NotDefinedHere; -+ -+ /// See [std::os::windows::io::AsHandle](https://doc.rust-lang.org/std/os/windows/io/trait.AsHandle.html) -+ pub trait AsHandle { -+ /// See [std::os::windows::io::AsHandle::as_handle](https://doc.rust-lang.org/std/os/windows/io/trait.AsHandle.html#tymethod.as_handle) -+ fn as_handle(&self) -> BorrowedHandle<'_>; -+ } -+ -+ /// See [std::os::windows::io::BorrowedSocket](https://doc.rust-lang.org/std/os/windows/io/struct.BorrowedSocket.html) -+ pub type BorrowedSocket<'socket> = crate::doc::NotDefinedHere; -+ -+ /// See [std::os::windows::io::AsSocket](https://doc.rust-lang.org/std/os/windows/io/trait.AsSocket.html) -+ pub trait AsSocket { -+ /// See [std::os::windows::io::AsSocket::as_socket](https://doc.rust-lang.org/std/os/windows/io/trait.AsSocket.html#tymethod.as_socket) -+ fn as_socket(&self) -> BorrowedSocket<'_>; -+ } - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/doc/winapi.rs b/KubeOS-Rust/vendor/tokio/src/doc/winapi.rs -deleted file mode 100644 -index be68749e..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/doc/winapi.rs -+++ /dev/null -@@ -1,66 +0,0 @@ --//! See [winapi]. --//! --//! [winapi]: https://docs.rs/winapi -- --/// See [winapi::shared](https://docs.rs/winapi/*/winapi/shared/index.html). --pub mod shared { -- /// See [winapi::shared::winerror](https://docs.rs/winapi/*/winapi/shared/winerror/index.html). -- #[allow(non_camel_case_types)] -- pub mod winerror { -- /// See [winapi::shared::winerror::ERROR_ACCESS_DENIED][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/shared/winerror/constant.ERROR_ACCESS_DENIED.html -- pub type ERROR_ACCESS_DENIED = crate::doc::NotDefinedHere; -- -- /// See [winapi::shared::winerror::ERROR_PIPE_BUSY][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/shared/winerror/constant.ERROR_PIPE_BUSY.html -- pub type ERROR_PIPE_BUSY = crate::doc::NotDefinedHere; -- -- /// See [winapi::shared::winerror::ERROR_MORE_DATA][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/shared/winerror/constant.ERROR_MORE_DATA.html -- pub type ERROR_MORE_DATA = crate::doc::NotDefinedHere; -- } --} -- --/// See [winapi::um](https://docs.rs/winapi/*/winapi/um/index.html). --pub mod um { -- /// See [winapi::um::winbase](https://docs.rs/winapi/*/winapi/um/winbase/index.html). -- #[allow(non_camel_case_types)] -- pub mod winbase { -- /// See [winapi::um::winbase::PIPE_TYPE_MESSAGE][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.PIPE_TYPE_MESSAGE.html -- pub type PIPE_TYPE_MESSAGE = crate::doc::NotDefinedHere; -- -- /// See [winapi::um::winbase::PIPE_TYPE_BYTE][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.PIPE_TYPE_BYTE.html -- pub type PIPE_TYPE_BYTE = crate::doc::NotDefinedHere; -- -- /// See [winapi::um::winbase::PIPE_CLIENT_END][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.PIPE_CLIENT_END.html -- pub type PIPE_CLIENT_END = crate::doc::NotDefinedHere; -- -- /// See [winapi::um::winbase::PIPE_SERVER_END][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.PIPE_SERVER_END.html -- pub type PIPE_SERVER_END = crate::doc::NotDefinedHere; -- -- /// See [winapi::um::winbase::SECURITY_IDENTIFICATION][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.SECURITY_IDENTIFICATION.html -- pub type SECURITY_IDENTIFICATION = crate::doc::NotDefinedHere; -- } -- -- /// See [winapi::um::minwinbase](https://docs.rs/winapi/*/winapi/um/minwinbase/index.html). -- #[allow(non_camel_case_types)] -- pub mod minwinbase { -- /// See [winapi::um::minwinbase::SECURITY_ATTRIBUTES][winapi] -- /// -- /// [winapi]: https://docs.rs/winapi/*/winapi/um/minwinbase/constant.SECURITY_ATTRIBUTES.html -- pub type SECURITY_ATTRIBUTES = crate::doc::NotDefinedHere; -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/file.rs b/KubeOS-Rust/vendor/tokio/src/fs/file.rs -index 61071cf6..795a38f7 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/file.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/file.rs -@@ -19,17 +19,17 @@ use std::task::Context; - use std::task::Poll; - use std::task::Poll::*; - --#[cfg(test)] --use super::mocks::spawn_blocking; - #[cfg(test)] - use super::mocks::JoinHandle; - #[cfg(test)] - use super::mocks::MockFile as StdFile; --#[cfg(not(test))] --use crate::blocking::spawn_blocking; -+#[cfg(test)] -+use super::mocks::{spawn_blocking, spawn_mandatory_blocking}; - #[cfg(not(test))] - use crate::blocking::JoinHandle; - #[cfg(not(test))] -+use crate::blocking::{spawn_blocking, spawn_mandatory_blocking}; -+#[cfg(not(test))] - use std::fs::File as StdFile; - - /// A reference to an open file on the filesystem. -@@ -565,29 +565,30 @@ impl AsyncSeek for File { - let me = self.get_mut(); - let inner = me.inner.get_mut(); - -- loop { -- match inner.state { -- Busy(_) => panic!("must wait for poll_complete before calling start_seek"), -- Idle(ref mut buf_cell) => { -- let mut buf = buf_cell.take().unwrap(); -+ match inner.state { -+ Busy(_) => Err(io::Error::new( -+ io::ErrorKind::Other, -+ "other file operation is pending, call poll_complete before start_seek", -+ )), -+ Idle(ref mut buf_cell) => { -+ let mut buf = buf_cell.take().unwrap(); - -- // Factor in any unread data from the buf -- if !buf.is_empty() { -- let n = buf.discard_read(); -+ // Factor in any unread data from the buf -+ if !buf.is_empty() { -+ let n = buf.discard_read(); - -- if let SeekFrom::Current(ref mut offset) = pos { -- *offset += n; -- } -+ if let SeekFrom::Current(ref mut offset) = pos { -+ *offset += n; - } -+ } - -- let std = me.std.clone(); -+ let std = me.std.clone(); - -- inner.state = Busy(spawn_blocking(move || { -- let res = (&*std).seek(pos); -- (Operation::Seek(res), buf) -- })); -- return Ok(()); -- } -+ inner.state = Busy(spawn_blocking(move || { -+ let res = (&*std).seek(pos); -+ (Operation::Seek(res), buf) -+ })); -+ Ok(()) - } - } - } -@@ -649,7 +650,7 @@ impl AsyncWrite for File { - let n = buf.copy_from(src); - let std = me.std.clone(); - -- inner.state = Busy(spawn_blocking(move || { -+ let blocking_task_join_handle = spawn_mandatory_blocking(move || { - let res = if let Some(seek) = seek { - (&*std).seek(seek).and_then(|_| buf.write_to(&mut &*std)) - } else { -@@ -657,7 +658,12 @@ impl AsyncWrite for File { - }; - - (Operation::Write(res), buf) -- })); -+ }) -+ .ok_or_else(|| { -+ io::Error::new(io::ErrorKind::Other, "background task failed") -+ })?; -+ -+ inner.state = Busy(blocking_task_join_handle); - - return Ready(Ok(n)); - } -@@ -719,6 +725,15 @@ impl std::os::unix::io::AsRawFd for File { - } - } - -+#[cfg(all(unix, not(tokio_no_as_fd)))] -+impl std::os::unix::io::AsFd for File { -+ fn as_fd(&self) -> std::os::unix::io::BorrowedFd<'_> { -+ unsafe { -+ std::os::unix::io::BorrowedFd::borrow_raw(std::os::unix::io::AsRawFd::as_raw_fd(self)) -+ } -+ } -+} -+ - #[cfg(unix)] - impl std::os::unix::io::FromRawFd for File { - unsafe fn from_raw_fd(fd: std::os::unix::io::RawFd) -> Self { -@@ -726,17 +741,32 @@ impl std::os::unix::io::FromRawFd for File { - } - } - --#[cfg(windows)] --impl std::os::windows::io::AsRawHandle for File { -- fn as_raw_handle(&self) -> std::os::windows::io::RawHandle { -- self.std.as_raw_handle() -+cfg_windows! { -+ use crate::os::windows::io::{AsRawHandle, FromRawHandle, RawHandle}; -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsHandle, BorrowedHandle}; -+ -+ impl AsRawHandle for File { -+ fn as_raw_handle(&self) -> RawHandle { -+ self.std.as_raw_handle() -+ } - } --} - --#[cfg(windows)] --impl std::os::windows::io::FromRawHandle for File { -- unsafe fn from_raw_handle(handle: std::os::windows::io::RawHandle) -> Self { -- StdFile::from_raw_handle(handle).into() -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsHandle for File { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { -+ BorrowedHandle::borrow_raw( -+ AsRawHandle::as_raw_handle(self), -+ ) -+ } -+ } -+ } -+ -+ impl FromRawHandle for File { -+ unsafe fn from_raw_handle(handle: RawHandle) -> Self { -+ StdFile::from_raw_handle(handle).into() -+ } - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/file/tests.rs b/KubeOS-Rust/vendor/tokio/src/fs/file/tests.rs -index 28b5ffe7..7c61b3c4 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/file/tests.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/file/tests.rs -@@ -228,14 +228,15 @@ fn flush_while_idle() { - } - - #[test] -+#[cfg_attr(miri, ignore)] // takes a really long time with miri - fn read_with_buffer_larger_than_max() { - // Chunks -- let chunk_a = 16 * 1024; -+ let chunk_a = crate::io::blocking::MAX_BUF; - let chunk_b = chunk_a * 2; - let chunk_c = chunk_a * 3; - let chunk_d = chunk_a * 4; - -- assert_eq!(chunk_d / 1024, 64); -+ assert_eq!(chunk_d / 1024 / 1024, 8); - - let mut data = vec![]; - for i in 0..(chunk_d - 1) { -@@ -299,14 +300,15 @@ fn read_with_buffer_larger_than_max() { - } - - #[test] -+#[cfg_attr(miri, ignore)] // takes a really long time with miri - fn write_with_buffer_larger_than_max() { - // Chunks -- let chunk_a = 16 * 1024; -+ let chunk_a = crate::io::blocking::MAX_BUF; - let chunk_b = chunk_a * 2; - let chunk_c = chunk_a * 3; - let chunk_d = chunk_a * 4; - -- assert_eq!(chunk_d / 1024, 64); -+ assert_eq!(chunk_d / 1024 / 1024, 8); - - let mut data = vec![]; - for i in 0..(chunk_d - 1) { -@@ -953,3 +955,24 @@ fn partial_read_set_len_ok() { - assert_eq!(n, FOO.len()); - assert_eq!(&buf[..n], FOO); - } -+ -+#[test] -+fn busy_file_seek_error() { -+ let mut file = MockFile::default(); -+ let mut seq = Sequence::new(); -+ file.expect_inner_write() -+ .once() -+ .in_sequence(&mut seq) -+ .returning(|_| Err(io::ErrorKind::Other.into())); -+ -+ let mut file = crate::io::BufReader::new(File::from_std(file)); -+ { -+ let mut t = task::spawn(file.write(HELLO)); -+ assert_ready_ok!(t.poll()); -+ } -+ -+ pool::run_one(); -+ -+ let mut t = task::spawn(file.seek(SeekFrom::Start(0))); -+ assert_ready_err!(t.poll()); -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/mocks.rs b/KubeOS-Rust/vendor/tokio/src/fs/mocks.rs -index 68ef4f3a..aa01e247 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/mocks.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/mocks.rs -@@ -81,7 +81,7 @@ impl Write for &'_ MockFile { - } - } - --thread_local! { -+tokio_thread_local! { - static QUEUE: RefCell>> = RefCell::new(VecDeque::new()) - } - -@@ -105,6 +105,21 @@ where - JoinHandle { rx } - } - -+pub(super) fn spawn_mandatory_blocking(f: F) -> Option> -+where -+ F: FnOnce() -> R + Send + 'static, -+ R: Send + 'static, -+{ -+ let (tx, rx) = oneshot::channel(); -+ let task = Box::new(move || { -+ let _ = tx.send(f()); -+ }); -+ -+ QUEUE.with(|cell| cell.borrow_mut().push_back(task)); -+ -+ Some(JoinHandle { rx }) -+} -+ - impl Future for JoinHandle { - type Output = Result; - -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/mod.rs b/KubeOS-Rust/vendor/tokio/src/fs/mod.rs -index ca0264b3..f6d9605f 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/mod.rs -@@ -22,6 +22,24 @@ - //! `std::io::ErrorKind::WouldBlock` if a *worker* thread can not be converted - //! to a *backup* thread immediately. - //! -+//! **Warning**: These adapters may create a large number of temporary tasks, -+//! especially when reading large files. When performing a lot of operations -+//! in one batch, it may be significantly faster to use [`spawn_blocking`] -+//! directly: -+//! -+//! ``` -+//! use tokio::fs::File; -+//! use std::io::{BufReader, BufRead}; -+//! async fn count_lines(file: File) -> Result { -+//! let file = file.into_std().await; -+//! tokio::task::spawn_blocking(move || { -+//! let line_count = BufReader::new(file).lines().count(); -+//! Ok(line_count) -+//! }).await? -+//! } -+//! ``` -+//! -+//! [`spawn_blocking`]: fn@crate::task::spawn_blocking - //! [`AsyncRead`]: trait@crate::io::AsyncRead - - mod canonicalize; -@@ -84,6 +102,9 @@ pub use self::write::write; - mod copy; - pub use self::copy::copy; - -+mod try_exists; -+pub use self::try_exists::try_exists; -+ - #[cfg(test)] - mod mocks; - -@@ -94,9 +115,7 @@ feature! { - pub use self::symlink::symlink; - } - --feature! { -- #![windows] -- -+cfg_windows! { - mod symlink_dir; - pub use self::symlink_dir::symlink_dir; - -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/open_options.rs b/KubeOS-Rust/vendor/tokio/src/fs/open_options.rs -index f3b46547..10351025 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/open_options.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/open_options.rs -@@ -10,6 +10,11 @@ use mock_open_options::MockOpenOptions as StdOpenOptions; - #[cfg(not(test))] - use std::fs::OpenOptions as StdOpenOptions; - -+#[cfg(unix)] -+use std::os::unix::fs::OpenOptionsExt; -+#[cfg(windows)] -+use std::os::windows::fs::OpenOptionsExt; -+ - /// Options and flags which can be used to configure how a file is opened. - /// - /// This builder exposes the ability to configure how a [`File`] is opened and -@@ -399,8 +404,6 @@ impl OpenOptions { - feature! { - #![unix] - -- use std::os::unix::fs::OpenOptionsExt; -- - impl OpenOptions { - /// Sets the mode bits that a new file will be created with. - /// -@@ -464,11 +467,7 @@ feature! { - } - } - --feature! { -- #![windows] -- -- use std::os::windows::fs::OpenOptionsExt; -- -+cfg_windows! { - impl OpenOptions { - /// Overrides the `dwDesiredAccess` argument to the call to [`CreateFile`] - /// with the specified value. -@@ -542,7 +541,7 @@ feature! { - /// # Examples - /// - /// ```no_run -- /// use winapi::um::winbase::FILE_FLAG_DELETE_ON_CLOSE; -+ /// use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_DELETE_ON_CLOSE; - /// use tokio::fs::OpenOptions; - /// - /// # #[tokio::main] -@@ -581,7 +580,7 @@ feature! { - /// # Examples - /// - /// ```no_run -- /// use winapi::um::winnt::FILE_ATTRIBUTE_HIDDEN; -+ /// use windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_HIDDEN; - /// use tokio::fs::OpenOptions; - /// - /// # #[tokio::main] -@@ -624,7 +623,7 @@ feature! { - /// # Examples - /// - /// ```no_run -- /// use winapi::um::winbase::SECURITY_IDENTIFICATION; -+ /// use windows_sys::Win32::Storage::FileSystem::SECURITY_IDENTIFICATION; - /// use tokio::fs::OpenOptions; - /// - /// # #[tokio::main] -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/open_options/mock_open_options.rs b/KubeOS-Rust/vendor/tokio/src/fs/open_options/mock_open_options.rs -index cbbda0ec..17b4a486 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/open_options/mock_open_options.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/open_options/mock_open_options.rs -@@ -1,3 +1,4 @@ -+#![allow(unreachable_pub)] - //! Mock version of std::fs::OpenOptions; - use mockall::mock; - -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/read_dir.rs b/KubeOS-Rust/vendor/tokio/src/fs/read_dir.rs -index 281ea4cd..3b30eb0a 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/read_dir.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/read_dir.rs -@@ -1,5 +1,6 @@ - use crate::fs::asyncify; - -+use std::collections::VecDeque; - use std::ffi::OsString; - use std::fs::{FileType, Metadata}; - use std::future::Future; -@@ -19,6 +20,8 @@ use crate::blocking::spawn_blocking; - #[cfg(not(test))] - use crate::blocking::JoinHandle; - -+const CHUNK_SIZE: usize = 32; -+ - /// Returns a stream over the entries within a directory. - /// - /// This is an async version of [`std::fs::read_dir`](std::fs::read_dir) -@@ -29,12 +32,17 @@ use crate::blocking::JoinHandle; - /// [`spawn_blocking`]: crate::task::spawn_blocking - pub async fn read_dir(path: impl AsRef) -> io::Result { - let path = path.as_ref().to_owned(); -- let std = asyncify(|| std::fs::read_dir(path)).await?; -+ asyncify(|| -> io::Result { -+ let mut std = std::fs::read_dir(path)?.fuse(); -+ let mut buf = VecDeque::with_capacity(CHUNK_SIZE); -+ ReadDir::next_chunk(&mut buf, &mut std); - -- Ok(ReadDir(State::Idle(Some(std)))) -+ Ok(ReadDir(State::Idle(Some((buf, std))))) -+ }) -+ .await - } - --/// Reads the the entries in a directory. -+/// Reads the entries in a directory. - /// - /// This struct is returned from the [`read_dir`] function of this module and - /// will yield instances of [`DirEntry`]. Through a [`DirEntry`] information -@@ -56,10 +64,12 @@ pub async fn read_dir(path: impl AsRef) -> io::Result { - #[must_use = "streams do nothing unless polled"] - pub struct ReadDir(State); - -+type StdReadDir = std::iter::Fuse; -+ - #[derive(Debug)] - enum State { -- Idle(Option), -- Pending(JoinHandle<(Option>, std::fs::ReadDir)>), -+ Idle(Option<(VecDeque>, StdReadDir)>), -+ Pending(JoinHandle<(VecDeque>, StdReadDir)>), - } - - impl ReadDir { -@@ -94,29 +104,57 @@ impl ReadDir { - pub fn poll_next_entry(&mut self, cx: &mut Context<'_>) -> Poll>> { - loop { - match self.0 { -- State::Idle(ref mut std) => { -- let mut std = std.take().unwrap(); -+ State::Idle(ref mut data) => { -+ let (buf, _) = data.as_mut().unwrap(); -+ -+ if let Some(ent) = buf.pop_front() { -+ return Poll::Ready(ent.map(Some)); -+ }; -+ -+ let (mut buf, mut std) = data.take().unwrap(); - - self.0 = State::Pending(spawn_blocking(move || { -- let ret = std.next(); -- (ret, std) -+ ReadDir::next_chunk(&mut buf, &mut std); -+ (buf, std) - })); - } - State::Pending(ref mut rx) => { -- let (ret, std) = ready!(Pin::new(rx).poll(cx))?; -- self.0 = State::Idle(Some(std)); -+ let (mut buf, std) = ready!(Pin::new(rx).poll(cx))?; - -- let ret = match ret { -- Some(Ok(std)) => Ok(Some(DirEntry(Arc::new(std)))), -+ let ret = match buf.pop_front() { -+ Some(Ok(x)) => Ok(Some(x)), - Some(Err(e)) => Err(e), - None => Ok(None), - }; - -+ self.0 = State::Idle(Some((buf, std))); -+ - return Poll::Ready(ret); - } - } - } - } -+ -+ fn next_chunk(buf: &mut VecDeque>, std: &mut StdReadDir) { -+ for ret in std.by_ref().take(CHUNK_SIZE) { -+ let success = ret.is_ok(); -+ -+ buf.push_back(ret.map(|std| DirEntry { -+ #[cfg(not(any( -+ target_os = "solaris", -+ target_os = "illumos", -+ target_os = "haiku", -+ target_os = "vxworks" -+ )))] -+ file_type: std.file_type().ok(), -+ std: Arc::new(std), -+ })); -+ -+ if !success { -+ break; -+ } -+ } -+ } - } - - feature! { -@@ -160,7 +198,16 @@ feature! { - /// filesystem. Each entry can be inspected via methods to learn about the full - /// path or possibly other metadata through per-platform extension traits. - #[derive(Debug)] --pub struct DirEntry(Arc); -+pub struct DirEntry { -+ #[cfg(not(any( -+ target_os = "solaris", -+ target_os = "illumos", -+ target_os = "haiku", -+ target_os = "vxworks" -+ )))] -+ file_type: Option, -+ std: Arc, -+} - - impl DirEntry { - /// Returns the full path to the file that this entry represents. -@@ -193,7 +240,7 @@ impl DirEntry { - /// - /// The exact text, of course, depends on what files you have in `.`. - pub fn path(&self) -> PathBuf { -- self.0.path() -+ self.std.path() - } - - /// Returns the bare file name of this directory entry without any other -@@ -214,7 +261,7 @@ impl DirEntry { - /// # } - /// ``` - pub fn file_name(&self) -> OsString { -- self.0.file_name() -+ self.std.file_name() - } - - /// Returns the metadata for the file that this entry points at. -@@ -248,7 +295,7 @@ impl DirEntry { - /// # } - /// ``` - pub async fn metadata(&self) -> io::Result { -- let std = self.0.clone(); -+ let std = self.std.clone(); - asyncify(move || std.metadata()).await - } - -@@ -283,13 +330,23 @@ impl DirEntry { - /// # } - /// ``` - pub async fn file_type(&self) -> io::Result { -- let std = self.0.clone(); -+ #[cfg(not(any( -+ target_os = "solaris", -+ target_os = "illumos", -+ target_os = "haiku", -+ target_os = "vxworks" -+ )))] -+ if let Some(file_type) = self.file_type { -+ return Ok(file_type); -+ } -+ -+ let std = self.std.clone(); - asyncify(move || std.file_type()).await - } - - /// Returns a reference to the underlying `std::fs::DirEntry`. - #[cfg(unix)] - pub(super) fn as_inner(&self) -> &std::fs::DirEntry { -- &self.0 -+ &self.std - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/symlink_dir.rs b/KubeOS-Rust/vendor/tokio/src/fs/symlink_dir.rs -index 736e762b..6753c25e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/symlink_dir.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/symlink_dir.rs -@@ -10,7 +10,7 @@ use std::path::Path; - /// - /// This is an async version of [`std::os::windows::fs::symlink_dir`][std] - /// --/// [std]: std::os::windows::fs::symlink_dir -+/// [std]: https://doc.rust-lang.org/std/os/windows/fs/fn.symlink_dir.html - pub async fn symlink_dir(src: impl AsRef, dst: impl AsRef) -> io::Result<()> { - let src = src.as_ref().to_owned(); - let dst = dst.as_ref().to_owned(); -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/symlink_file.rs b/KubeOS-Rust/vendor/tokio/src/fs/symlink_file.rs -index 07d8e604..623352a1 100644 ---- a/KubeOS-Rust/vendor/tokio/src/fs/symlink_file.rs -+++ b/KubeOS-Rust/vendor/tokio/src/fs/symlink_file.rs -@@ -10,7 +10,7 @@ use std::path::Path; - /// - /// This is an async version of [`std::os::windows::fs::symlink_file`][std] - /// --/// [std]: std::os::windows::fs::symlink_file -+/// [std]: https://doc.rust-lang.org/std/os/windows/fs/fn.symlink_file.html - pub async fn symlink_file(src: impl AsRef, dst: impl AsRef) -> io::Result<()> { - let src = src.as_ref().to_owned(); - let dst = dst.as_ref().to_owned(); -diff --git a/KubeOS-Rust/vendor/tokio/src/fs/try_exists.rs b/KubeOS-Rust/vendor/tokio/src/fs/try_exists.rs -new file mode 100644 -index 00000000..069518bf ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/fs/try_exists.rs -@@ -0,0 +1,34 @@ -+use crate::fs::asyncify; -+ -+use std::io; -+use std::path::Path; -+ -+/// Returns `Ok(true)` if the path points at an existing entity. -+/// -+/// This function will traverse symbolic links to query information about the -+/// destination file. In case of broken symbolic links this will return `Ok(false)`. -+/// -+/// This is the async equivalent of [`std::path::Path::try_exists`][std]. -+/// -+/// [std]: fn@std::path::Path::try_exists -+/// -+/// # Examples -+/// -+/// ```no_run -+/// use tokio::fs; -+/// -+/// # async fn dox() -> std::io::Result<()> { -+/// fs::try_exists("foo.txt").await?; -+/// # Ok(()) -+/// # } -+/// ``` -+pub async fn try_exists(path: impl AsRef) -> io::Result { -+ let path = path.as_ref().to_owned(); -+ // std's Path::try_exists is not available for current Rust min supported version. -+ // Current implementation is based on its internal implementation instead. -+ match asyncify(move || std::fs::metadata(path)).await { -+ Ok(_) => Ok(true), -+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(false), -+ Err(error) => Err(error), -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/future/block_on.rs b/KubeOS-Rust/vendor/tokio/src/future/block_on.rs -index 91f9cc00..2c2ab373 100644 ---- a/KubeOS-Rust/vendor/tokio/src/future/block_on.rs -+++ b/KubeOS-Rust/vendor/tokio/src/future/block_on.rs -@@ -1,15 +1,22 @@ - use std::future::Future; - - cfg_rt! { -+ #[track_caller] - pub(crate) fn block_on(f: F) -> F::Output { -- let mut e = crate::runtime::enter::enter(false); -+ let mut e = crate::runtime::context::try_enter_blocking_region().expect( -+ "Cannot block the current thread from within a runtime. This \ -+ happens because a function attempted to block the current \ -+ thread while the thread is being used to drive asynchronous \ -+ tasks." -+ ); - e.block_on(f).unwrap() - } - } - - cfg_not_rt! { -+ #[track_caller] - pub(crate) fn block_on(f: F) -> F::Output { -- let mut park = crate::park::thread::CachedParkThread::new(); -+ let mut park = crate::runtime::park::CachedParkThread::new(); - park.block_on(f).unwrap() - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/future/mod.rs b/KubeOS-Rust/vendor/tokio/src/future/mod.rs -index 96483acd..084ddc57 100644 ---- a/KubeOS-Rust/vendor/tokio/src/future/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/future/mod.rs -@@ -8,11 +8,6 @@ pub(crate) mod maybe_done; - mod poll_fn; - pub use poll_fn::poll_fn; - --cfg_not_loom! { -- mod ready; -- pub(crate) use ready::{ok, Ready}; --} -- - cfg_process! { - mod try_join; - pub(crate) use try_join::try_join3; -diff --git a/KubeOS-Rust/vendor/tokio/src/future/poll_fn.rs b/KubeOS-Rust/vendor/tokio/src/future/poll_fn.rs -index d82ce896..074d9438 100644 ---- a/KubeOS-Rust/vendor/tokio/src/future/poll_fn.rs -+++ b/KubeOS-Rust/vendor/tokio/src/future/poll_fn.rs -@@ -7,13 +7,23 @@ use std::future::Future; - use std::pin::Pin; - use std::task::{Context, Poll}; - -+// This struct is intentionally `!Unpin` when `F` is `!Unpin`. This is to -+// mitigate the issue where rust puts noalias on mutable references to the -+// `PollFn` type if it is `Unpin`. If the closure has ownership of a future, -+// then this "leaks" and the future is affected by noalias too, which we don't -+// want. -+// -+// See this thread for more information: -+// -+// -+// The fact that `PollFn` is not `Unpin` when it shouldn't be is tested in -+// `tests/async_send_sync.rs`. -+ - /// Future for the [`poll_fn`] function. - pub struct PollFn { - f: F, - } - --impl Unpin for PollFn {} -- - /// Creates a new future wrapping around a function returning [`Poll`]. - pub fn poll_fn(f: F) -> PollFn - where -@@ -34,7 +44,17 @@ where - { - type Output = T; - -- fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -- (&mut self.f)(cx) -+ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -+ // Safety: We never construct a `Pin<&mut F>` anywhere, so accessing `f` -+ // mutably in an unpinned way is sound. -+ // -+ // This use of unsafe cannot be replaced with the pin-project macro -+ // because: -+ // * If we put `#[pin]` on the field, then it gives us a `Pin<&mut F>`, -+ // which we can't use to call the closure. -+ // * If we don't put `#[pin]` on the field, then it makes `PollFn` be -+ // unconditionally `Unpin`, which we also don't want. -+ let me = unsafe { Pin::into_inner_unchecked(self) }; -+ (me.f)(cx) - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/future/ready.rs b/KubeOS-Rust/vendor/tokio/src/future/ready.rs -deleted file mode 100644 -index de2d60c1..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/future/ready.rs -+++ /dev/null -@@ -1,27 +0,0 @@ --use std::future::Future; --use std::pin::Pin; --use std::task::{Context, Poll}; -- --/// Future for the [`ok`](ok()) function. --/// --/// `pub` in order to use the future as an associated type in a sealed trait. --#[derive(Debug)] --// Used as an associated type in a "sealed" trait. --#[allow(unreachable_pub)] --pub struct Ready(Option); -- --impl Unpin for Ready {} -- --impl Future for Ready { -- type Output = T; -- -- #[inline] -- fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll { -- Poll::Ready(self.0.take().unwrap()) -- } --} -- --/// Creates a future that is immediately ready with a success value. --pub(crate) fn ok(t: T) -> Ready> { -- Ready(Some(Ok(t))) --} -diff --git a/KubeOS-Rust/vendor/tokio/src/fuzz.rs b/KubeOS-Rust/vendor/tokio/src/fuzz.rs -new file mode 100644 -index 00000000..d89718f0 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/fuzz.rs -@@ -0,0 +1 @@ -+pub use crate::util::linked_list::tests::fuzz_linked_list; -diff --git a/KubeOS-Rust/vendor/tokio/src/io/async_fd.rs b/KubeOS-Rust/vendor/tokio/src/io/async_fd.rs -index 9ec5b7f2..e1e8a95c 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/async_fd.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/async_fd.rs -@@ -1,4 +1,6 @@ --use crate::io::driver::{Handle, Interest, ReadyEvent, Registration}; -+use crate::io::Interest; -+use crate::runtime::io::{ReadyEvent, Registration}; -+use crate::runtime::scheduler; - - use mio::unix::SourceFd; - use std::io; -@@ -63,8 +65,8 @@ use std::{task::Context, task::Poll}; - /// # Examples - /// - /// This example shows how to turn [`std::net::TcpStream`] asynchronous using --/// `AsyncFd`. It implements `read` as an async fn, and `AsyncWrite` as a trait --/// to show how to implement both approaches. -+/// `AsyncFd`. It implements the read/write operations both as an `async fn` -+/// and using the IO traits [`AsyncRead`] and [`AsyncWrite`]. - /// - /// ```no_run - /// use futures::ready; -@@ -72,7 +74,7 @@ use std::{task::Context, task::Poll}; - /// use std::net::TcpStream; - /// use std::pin::Pin; - /// use std::task::{Context, Poll}; --/// use tokio::io::AsyncWrite; -+/// use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; - /// use tokio::io::unix::AsyncFd; - /// - /// pub struct AsyncTcpStream { -@@ -81,6 +83,7 @@ use std::{task::Context, task::Poll}; - /// - /// impl AsyncTcpStream { - /// pub fn new(tcp: TcpStream) -> io::Result { -+/// tcp.set_nonblocking(true)?; - /// Ok(Self { - /// inner: AsyncFd::new(tcp)?, - /// }) -@@ -96,6 +99,39 @@ use std::{task::Context, task::Poll}; - /// } - /// } - /// } -+/// -+/// pub async fn write(&self, buf: &[u8]) -> io::Result { -+/// loop { -+/// let mut guard = self.inner.writable().await?; -+/// -+/// match guard.try_io(|inner| inner.get_ref().write(buf)) { -+/// Ok(result) => return result, -+/// Err(_would_block) => continue, -+/// } -+/// } -+/// } -+/// } -+/// -+/// impl AsyncRead for AsyncTcpStream { -+/// fn poll_read( -+/// self: Pin<&mut Self>, -+/// cx: &mut Context<'_>, -+/// buf: &mut ReadBuf<'_> -+/// ) -> Poll> { -+/// loop { -+/// let mut guard = ready!(self.inner.poll_read_ready(cx))?; -+/// -+/// let unfilled = buf.initialize_unfilled(); -+/// match guard.try_io(|inner| inner.get_ref().read(unfilled)) { -+/// Ok(Ok(len)) => { -+/// buf.advance(len); -+/// return Poll::Ready(Ok(())); -+/// }, -+/// Ok(Err(err)) => return Poll::Ready(Err(err)), -+/// Err(_would_block) => continue, -+/// } -+/// } -+/// } - /// } - /// - /// impl AsyncWrite for AsyncTcpStream { -@@ -136,6 +172,8 @@ use std::{task::Context, task::Poll}; - /// [`writable`]: method@Self::writable - /// [`AsyncFdReadyGuard`]: struct@self::AsyncFdReadyGuard - /// [`TcpStream::poll_read_ready`]: struct@crate::net::TcpStream -+/// [`AsyncRead`]: trait@crate::io::AsyncRead -+/// [`AsyncWrite`]: trait@crate::io::AsyncWrite - pub struct AsyncFd { - registration: Registration, - inner: Option, -@@ -166,12 +204,18 @@ pub struct AsyncFdReadyMutGuard<'a, T: AsRawFd> { - const ALL_INTEREST: Interest = Interest::READABLE.add(Interest::WRITABLE); - - impl AsyncFd { -- #[inline] - /// Creates an AsyncFd backed by (and taking ownership of) an object - /// implementing [`AsRawFd`]. The backing file descriptor is cached at the - /// time of creation. - /// - /// This method must be called in the context of a tokio runtime. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if there is no current reactor set, or if the `rt` -+ /// feature flag is not enabled. -+ #[inline] -+ #[track_caller] - pub fn new(inner: T) -> io::Result - where - T: AsRawFd, -@@ -179,19 +223,26 @@ impl AsyncFd { - Self::with_interest(inner, ALL_INTEREST) - } - -- #[inline] - /// Creates new instance as `new` with additional ability to customize interest, - /// allowing to specify whether file descriptor will be polled for read, write or both. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if there is no current reactor set, or if the `rt` -+ /// feature flag is not enabled. -+ #[inline] -+ #[track_caller] - pub fn with_interest(inner: T, interest: Interest) -> io::Result - where - T: AsRawFd, - { -- Self::new_with_handle_and_interest(inner, Handle::current(), interest) -+ Self::new_with_handle_and_interest(inner, scheduler::Handle::current(), interest) - } - -+ #[track_caller] - pub(crate) fn new_with_handle_and_interest( - inner: T, -- handle: Handle, -+ handle: scheduler::Handle, - interest: Interest, - ) -> io::Result { - let fd = inner.as_raw_fd(); -@@ -457,6 +508,109 @@ impl AsyncFd { - pub async fn writable_mut<'a>(&'a mut self) -> io::Result> { - self.readiness_mut(Interest::WRITABLE).await - } -+ -+ /// Reads or writes from the file descriptor using a user-provided IO operation. -+ /// -+ /// The `async_io` method is a convenience utility that waits for the file -+ /// descriptor to become ready, and then executes the provided IO operation. -+ /// Since file descriptors may be marked ready spuriously, the closure will -+ /// be called repeatedly until it returns something other than a -+ /// [`WouldBlock`] error. This is done using the following loop: -+ /// -+ /// ```no_run -+ /// # use std::io::{self, Result}; -+ /// # struct Dox { inner: T } -+ /// # impl Dox { -+ /// # async fn writable(&self) -> Result<&Self> { -+ /// # Ok(self) -+ /// # } -+ /// # fn try_io(&self, _: impl FnMut(&T) -> Result) -> Result> { -+ /// # panic!() -+ /// # } -+ /// async fn async_io(&self, mut f: impl FnMut(&T) -> io::Result) -> io::Result { -+ /// loop { -+ /// // or `readable` if called with the read interest. -+ /// let guard = self.writable().await?; -+ /// -+ /// match guard.try_io(&mut f) { -+ /// Ok(result) => return result, -+ /// Err(_would_block) => continue, -+ /// } -+ /// } -+ /// } -+ /// # } -+ /// ``` -+ /// -+ /// The closure should only return a [`WouldBlock`] error if it has performed -+ /// an IO operation on the file descriptor that failed due to the file descriptor not being -+ /// ready. Returning a [`WouldBlock`] error in any other situation will -+ /// incorrectly clear the readiness flag, which can cause the file descriptor to -+ /// behave incorrectly. -+ /// -+ /// The closure should not perform the IO operation using any of the methods -+ /// defined on the Tokio [`AsyncFd`] type, as this will mess with the -+ /// readiness flag and can cause the file descriptor to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ /// -+ /// # Examples -+ /// -+ /// This example sends some bytes on the inner [`std::net::UdpSocket`]. The `async_io` -+ /// method waits for readiness, and retries if the send operation does block. This example -+ /// is equivalent to the one given for [`try_io`]. -+ /// -+ /// ```no_run -+ /// use tokio::io::{Interest, unix::AsyncFd}; -+ /// -+ /// use std::io; -+ /// use std::net::UdpSocket; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// let socket = UdpSocket::bind("0.0.0.0:8080")?; -+ /// socket.set_nonblocking(true)?; -+ /// let async_fd = AsyncFd::new(socket)?; -+ /// -+ /// let written = async_fd -+ /// .async_io(Interest::WRITABLE, |inner| inner.send(&[1, 2])) -+ /// .await?; -+ /// -+ /// println!("wrote {written} bytes"); -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ /// -+ /// [`try_io`]: AsyncFdReadyGuard::try_io -+ /// [`WouldBlock`]: std::io::ErrorKind::WouldBlock -+ pub async fn async_io( -+ &self, -+ interest: Interest, -+ mut f: impl FnMut(&T) -> io::Result, -+ ) -> io::Result { -+ self.registration -+ .async_io(interest, || f(self.get_ref())) -+ .await -+ } -+ -+ /// Reads or writes from the file descriptor using a user-provided IO operation. -+ /// -+ /// The behavior is the same as [`async_io`], except that the closure can mutate the inner -+ /// value of the [`AsyncFd`]. -+ /// -+ /// [`async_io`]: AsyncFd::async_io -+ pub async fn async_io_mut( -+ &mut self, -+ interest: Interest, -+ mut f: impl FnMut(&mut T) -> io::Result, -+ ) -> io::Result { -+ self.registration -+ .async_io(interest, || f(self.inner.as_mut().unwrap())) -+ .await -+ } - } - - impl AsRawFd for AsyncFd { -@@ -465,6 +619,13 @@ impl AsRawFd for AsyncFd { - } - } - -+#[cfg(not(tokio_no_as_fd))] -+impl std::os::unix::io::AsFd for AsyncFd { -+ fn as_fd(&self) -> std::os::unix::io::BorrowedFd<'_> { -+ unsafe { std::os::unix::io::BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -+ - impl std::fmt::Debug for AsyncFd { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("AsyncFd") -@@ -520,12 +681,49 @@ impl<'a, Inner: AsRawFd> AsyncFdReadyGuard<'a, Inner> { - /// `AsyncFdReadyGuard` no longer expresses the readiness state that was queried to - /// create this `AsyncFdReadyGuard`. - /// -+ /// # Examples -+ /// -+ /// This example sends some bytes to the inner [`std::net::UdpSocket`]. Waiting -+ /// for write-readiness and retrying when the send operation does block are explicit. -+ /// This example can be written more succinctly using [`AsyncFd::async_io`]. -+ /// -+ /// ```no_run -+ /// use tokio::io::unix::AsyncFd; -+ /// -+ /// use std::io; -+ /// use std::net::UdpSocket; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// let socket = UdpSocket::bind("0.0.0.0:8080")?; -+ /// socket.set_nonblocking(true)?; -+ /// let async_fd = AsyncFd::new(socket)?; -+ /// -+ /// let written = loop { -+ /// let mut guard = async_fd.writable().await?; -+ /// match guard.try_io(|inner| inner.get_ref().send(&[1, 2])) { -+ /// Ok(result) => { -+ /// break result?; -+ /// } -+ /// Err(_would_block) => { -+ /// // try_io already cleared the file descriptor's readiness state -+ /// continue; -+ /// } -+ /// } -+ /// }; -+ /// -+ /// println!("wrote {written} bytes"); -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ /// - /// [`WouldBlock`]: std::io::ErrorKind::WouldBlock - // Alias for old name in 0.x - #[cfg_attr(docsrs, doc(alias = "with_io"))] - pub fn try_io( - &mut self, -- f: impl FnOnce(&AsyncFd) -> io::Result, -+ f: impl FnOnce(&'a AsyncFd) -> io::Result, - ) -> Result, TryIoError> { - let result = f(self.async_fd); - -@@ -542,12 +740,12 @@ impl<'a, Inner: AsRawFd> AsyncFdReadyGuard<'a, Inner> { - } - - /// Returns a shared reference to the inner [`AsyncFd`]. -- pub fn get_ref(&self) -> &AsyncFd { -+ pub fn get_ref(&self) -> &'a AsyncFd { - self.async_fd - } - - /// Returns a shared reference to the backing object of the inner [`AsyncFd`]. -- pub fn get_inner(&self) -> &Inner { -+ pub fn get_inner(&self) -> &'a Inner { - self.get_ref().get_ref() - } - } -@@ -598,7 +796,7 @@ impl<'a, Inner: AsRawFd> AsyncFdReadyMutGuard<'a, Inner> { - &mut self, - f: impl FnOnce(&mut AsyncFd) -> io::Result, - ) -> Result, TryIoError> { -- let result = f(&mut self.async_fd); -+ let result = f(self.async_fd); - - if let Err(e) = result.as_ref() { - if e.kind() == io::ErrorKind::WouldBlock { -diff --git a/KubeOS-Rust/vendor/tokio/src/io/blocking.rs b/KubeOS-Rust/vendor/tokio/src/io/blocking.rs -index 1d79ee7a..416573e9 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/blocking.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/blocking.rs -@@ -26,7 +26,7 @@ pub(crate) struct Buf { - pos: usize, - } - --pub(crate) const MAX_BUF: usize = 16 * 1024; -+pub(crate) const MAX_BUF: usize = 2 * 1024 * 1024; - - #[derive(Debug)] - enum State { -@@ -34,8 +34,9 @@ enum State { - Busy(sys::Blocking<(io::Result, Buf, T)>), - } - --cfg_io_std! { -+cfg_io_blocking! { - impl Blocking { -+ #[cfg_attr(feature = "fs", allow(dead_code))] - pub(crate) fn new(inner: T) -> Blocking { - Blocking { - inner: Some(inner), -diff --git a/KubeOS-Rust/vendor/tokio/src/io/bsd/poll_aio.rs b/KubeOS-Rust/vendor/tokio/src/io/bsd/poll_aio.rs -index f1ac4b2d..6ac9e288 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/bsd/poll_aio.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/bsd/poll_aio.rs -@@ -1,6 +1,8 @@ - //! Use POSIX AIO futures with Tokio. - --use crate::io::driver::{Handle, Interest, ReadyEvent, Registration}; -+use crate::io::interest::Interest; -+use crate::runtime::io::{ReadyEvent, Registration}; -+use crate::runtime::scheduler; - use mio::event::Source; - use mio::Registry; - use mio::Token; -@@ -117,7 +119,7 @@ impl Aio { - - fn new_with_interest(io: E, interest: Interest) -> io::Result { - let mut io = MioSource(io); -- let handle = Handle::current(); -+ let handle = scheduler::Handle::current(); - let registration = Registration::new_with_interest_and_handle(&mut io, interest, handle)?; - Ok(Self { io, registration }) - } -diff --git a/KubeOS-Rust/vendor/tokio/src/io/driver/interest.rs b/KubeOS-Rust/vendor/tokio/src/io/interest.rs -similarity index 98% -rename from KubeOS-Rust/vendor/tokio/src/io/driver/interest.rs -rename to KubeOS-Rust/vendor/tokio/src/io/interest.rs -index d6b46dfb..013c1140 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/driver/interest.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/interest.rs -@@ -1,6 +1,6 @@ - #![cfg_attr(not(feature = "net"), allow(dead_code, unreachable_pub))] - --use crate::io::driver::Ready; -+use crate::io::ready::Ready; - - use std::fmt; - use std::ops; -@@ -100,7 +100,7 @@ impl Interest { - self.0 - } - -- pub(super) fn mask(self) -> Ready { -+ pub(crate) fn mask(self) -> Ready { - match self { - Interest::READABLE => Ready::READABLE | Ready::READ_CLOSED, - Interest::WRITABLE => Ready::WRITABLE | Ready::WRITE_CLOSED, -diff --git a/KubeOS-Rust/vendor/tokio/src/io/mod.rs b/KubeOS-Rust/vendor/tokio/src/io/mod.rs -index cfdda61f..666d69cb 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/mod.rs -@@ -1,5 +1,3 @@ --#![cfg_attr(loom, allow(dead_code, unreachable_pub))] -- - //! Traits, helpers, and type definitions for asynchronous I/O functionality. - //! - //! This module is the asynchronous version of `std::io`. Primarily, it -@@ -132,19 +130,23 @@ - //! other words, these types must never block the thread, and instead the - //! current task is notified when the I/O resource is ready. - //! --//! ## Conversion to and from Sink/Stream -+//! ## Conversion to and from Stream/Sink -+//! -+//! It is often convenient to encapsulate the reading and writing of bytes in a -+//! [`Stream`] or [`Sink`] of data. -+//! -+//! Tokio provides simple wrappers for converting [`AsyncRead`] to [`Stream`] -+//! and vice-versa in the [tokio-util] crate, see [`ReaderStream`] and -+//! [`StreamReader`]. - //! --//! It is often convenient to encapsulate the reading and writing of --//! bytes and instead work with a [`Sink`] or [`Stream`] of some data --//! type that is encoded as bytes and/or decoded from bytes. Tokio --//! provides some utility traits in the [tokio-util] crate that --//! abstract the asynchronous buffering that is required and allows --//! you to write [`Encoder`] and [`Decoder`] functions working with a --//! buffer of bytes, and then use that ["codec"] to transform anything --//! that implements [`AsyncRead`] and [`AsyncWrite`] into a `Sink`/`Stream` of --//! your structured data. -+//! There are also utility traits that abstract the asynchronous buffering -+//! necessary to write your own adaptors for encoding and decoding bytes to/from -+//! your structured data, allowing to transform something that implements -+//! [`AsyncRead`]/[`AsyncWrite`] into a [`Stream`]/[`Sink`], see [`Decoder`] and -+//! [`Encoder`] in the [tokio-util::codec] module. - //! --//! [tokio-util]: https://docs.rs/tokio-util/0.6/tokio_util/codec/index.html -+//! [tokio-util]: https://docs.rs/tokio-util -+//! [tokio-util::codec]: https://docs.rs/tokio-util/latest/tokio_util/codec/index.html - //! - //! # Standard input and output - //! -@@ -169,9 +171,11 @@ - //! [`AsyncWrite`]: trait@AsyncWrite - //! [`AsyncReadExt`]: trait@AsyncReadExt - //! [`AsyncWriteExt`]: trait@AsyncWriteExt --//! ["codec"]: https://docs.rs/tokio-util/0.6/tokio_util/codec/index.html --//! [`Encoder`]: https://docs.rs/tokio-util/0.6/tokio_util/codec/trait.Encoder.html --//! [`Decoder`]: https://docs.rs/tokio-util/0.6/tokio_util/codec/trait.Decoder.html -+//! ["codec"]: https://docs.rs/tokio-util/latest/tokio_util/codec/index.html -+//! [`Encoder`]: https://docs.rs/tokio-util/latest/tokio_util/codec/trait.Encoder.html -+//! [`Decoder`]: https://docs.rs/tokio-util/latest/tokio_util/codec/trait.Decoder.html -+//! [`ReaderStream`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.ReaderStream.html -+//! [`StreamReader`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.StreamReader.html - //! [`Error`]: struct@Error - //! [`ErrorKind`]: enum@ErrorKind - //! [`Result`]: type@Result -@@ -180,6 +184,12 @@ - //! [`Sink`]: https://docs.rs/futures/0.3/futures/sink/trait.Sink.html - //! [`Stream`]: https://docs.rs/futures/0.3/futures/stream/trait.Stream.html - //! [`Write`]: std::io::Write -+ -+#![cfg_attr( -+ not(all(feature = "rt", feature = "net")), -+ allow(dead_code, unused_imports) -+)] -+ - cfg_io_blocking! { - pub(crate) mod blocking; - } -@@ -205,15 +215,19 @@ pub use self::read_buf::ReadBuf; - pub use std::io::{Error, ErrorKind, Result, SeekFrom}; - - cfg_io_driver_impl! { -- pub(crate) mod driver; -+ pub(crate) mod interest; -+ pub(crate) mod ready; - - cfg_net! { -- pub use driver::{Interest, Ready}; -+ pub use interest::Interest; -+ pub use ready::Ready; - } - -+ #[cfg_attr(tokio_wasi, allow(unused_imports))] - mod poll_evented; - - #[cfg(not(loom))] -+ #[cfg_attr(tokio_wasi, allow(unused_imports))] - pub(crate) use poll_evented::PollEvented; - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/io/poll_evented.rs b/KubeOS-Rust/vendor/tokio/src/io/poll_evented.rs -index 44e68a2a..dfe9ae34 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/poll_evented.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/poll_evented.rs -@@ -1,16 +1,19 @@ --use crate::io::driver::{Handle, Interest, Registration}; -+use crate::io::interest::Interest; -+use crate::runtime::io::Registration; -+use crate::runtime::scheduler; - - use mio::event::Source; - use std::fmt; - use std::io; - use std::ops::Deref; -+use std::panic::{RefUnwindSafe, UnwindSafe}; - - cfg_io_driver! { - /// Associates an I/O resource that implements the [`std::io::Read`] and/or - /// [`std::io::Write`] traits with the reactor that drives it. - /// - /// `PollEvented` uses [`Registration`] internally to take a type that -- /// implements [`mio::event::Source`] as well as [`std::io::Read`] and or -+ /// implements [`mio::event::Source`] as well as [`std::io::Read`] and/or - /// [`std::io::Write`] and associate it with a reactor that will drive it. - /// - /// Once the [`mio::event::Source`] type is wrapped by `PollEvented`, it can be -@@ -40,12 +43,12 @@ cfg_io_driver! { - /// [`poll_read_ready`] again will also indicate read readiness. - /// - /// When the operation is attempted and is unable to succeed due to the I/O -- /// resource not being ready, the caller must call `clear_readiness`. -+ /// resource not being ready, the caller must call [`clear_readiness`]. - /// This clears the readiness state until a new readiness event is received. - /// - /// This allows the caller to implement additional functions. For example, - /// [`TcpListener`] implements poll_accept by using [`poll_read_ready`] and -- /// `clear_read_ready`. -+ /// [`clear_readiness`]. - /// - /// ## Platform-specific events - /// -@@ -56,6 +59,7 @@ cfg_io_driver! { - /// [`AsyncRead`]: crate::io::AsyncRead - /// [`AsyncWrite`]: crate::io::AsyncWrite - /// [`TcpListener`]: crate::net::TcpListener -+ /// [`clear_readiness`]: Registration::clear_readiness - /// [`poll_read_ready`]: Registration::poll_read_ready - /// [`poll_write_ready`]: Registration::poll_write_ready - pub(crate) struct PollEvented { -@@ -76,6 +80,7 @@ impl PollEvented { - /// The runtime is usually set implicitly when this function is called - /// from a future driven by a tokio runtime, otherwise runtime can be set - /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ #[track_caller] - #[cfg_attr(feature = "signal", allow(unused))] - pub(crate) fn new(io: E) -> io::Result { - PollEvented::new_with_interest(io, Interest::READABLE | Interest::WRITABLE) -@@ -96,15 +101,17 @@ impl PollEvented { - /// a future driven by a tokio runtime, otherwise runtime can be set - /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) - /// function. -+ #[track_caller] - #[cfg_attr(feature = "signal", allow(unused))] - pub(crate) fn new_with_interest(io: E, interest: Interest) -> io::Result { -- Self::new_with_interest_and_handle(io, interest, Handle::current()) -+ Self::new_with_interest_and_handle(io, interest, scheduler::Handle::current()) - } - -+ #[track_caller] - pub(crate) fn new_with_interest_and_handle( - mut io: E, - interest: Interest, -- handle: Handle, -+ handle: scheduler::Handle, - ) -> io::Result { - let registration = Registration::new_with_interest_and_handle(&mut io, interest, handle)?; - Ok(Self { -@@ -114,11 +121,7 @@ impl PollEvented { - } - - /// Returns a reference to the registration. -- #[cfg(any( -- feature = "net", -- all(unix, feature = "process"), -- all(unix, feature = "signal"), -- ))] -+ #[cfg(any(feature = "net"))] - pub(crate) fn registration(&self) -> &Registration { - &self.registration - } -@@ -133,7 +136,7 @@ impl PollEvented { - } - - feature! { -- #![any(feature = "net", feature = "process")] -+ #![any(feature = "net", all(unix, feature = "process"))] - - use crate::io::ReadBuf; - use std::task::{Context, Poll}; -@@ -150,16 +153,32 @@ feature! { - { - use std::io::Read; - -- let n = ready!(self.registration.poll_read_io(cx, || { -+ loop { -+ let evt = ready!(self.registration.poll_read_ready(cx))?; -+ - let b = &mut *(buf.unfilled_mut() as *mut [std::mem::MaybeUninit] as *mut [u8]); -- self.io.as_ref().unwrap().read(b) -- }))?; -- -- // Safety: We trust `TcpStream::read` to have filled up `n` bytes in the -- // buffer. -- buf.assume_init(n); -- buf.advance(n); -- Poll::Ready(Ok(())) -+ let len = b.len(); -+ -+ match self.io.as_ref().unwrap().read(b) { -+ Ok(n) => { -+ // if we read a partially full buffer, this is sufficient on unix to show -+ // that the socket buffer has been drained -+ if n > 0 && (!cfg!(windows) && n < len) { -+ self.registration.clear_readiness(evt); -+ } -+ -+ // Safety: We trust `TcpStream::read` to have filled up `n` bytes in the -+ // buffer. -+ buf.assume_init(n); -+ buf.advance(n); -+ return Poll::Ready(Ok(())); -+ }, -+ Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ self.registration.clear_readiness(evt); -+ } -+ Err(e) => return Poll::Ready(Err(e)), -+ } -+ } - } - - pub(crate) fn poll_write<'a>(&'a self, cx: &mut Context<'_>, buf: &[u8]) -> Poll> -@@ -167,10 +186,29 @@ feature! { - &'a E: io::Write + 'a, - { - use std::io::Write; -- self.registration.poll_write_io(cx, || self.io.as_ref().unwrap().write(buf)) -+ -+ loop { -+ let evt = ready!(self.registration.poll_write_ready(cx))?; -+ -+ match self.io.as_ref().unwrap().write(buf) { -+ Ok(n) => { -+ // if we write only part of our buffer, this is sufficient on unix to show -+ // that the socket buffer is full -+ if n > 0 && (!cfg!(windows) && n < buf.len()) { -+ self.registration.clear_readiness(evt); -+ } -+ -+ return Poll::Ready(Ok(n)); -+ }, -+ Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ self.registration.clear_readiness(evt); -+ } -+ Err(e) => return Poll::Ready(Err(e)), -+ } -+ } - } - -- #[cfg(feature = "net")] -+ #[cfg(any(feature = "net", feature = "process"))] - pub(crate) fn poll_write_vectored<'a>( - &'a self, - cx: &mut Context<'_>, -@@ -185,6 +223,10 @@ feature! { - } - } - -+impl UnwindSafe for PollEvented {} -+ -+impl RefUnwindSafe for PollEvented {} -+ - impl Deref for PollEvented { - type Target = E; - -diff --git a/KubeOS-Rust/vendor/tokio/src/io/read_buf.rs b/KubeOS-Rust/vendor/tokio/src/io/read_buf.rs -index ad58cbe7..283d96e3 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/read_buf.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/read_buf.rs -@@ -1,9 +1,5 @@ --// This lint claims ugly casting is somehow safer than transmute, but there's --// no evidence that is the case. Shush. --#![allow(clippy::transmute_ptr_to_ptr)] -- - use std::fmt; --use std::mem::{self, MaybeUninit}; -+use std::mem::MaybeUninit; - - /// A wrapper around a byte buffer that is incrementally filled and initialized. - /// -@@ -35,7 +31,7 @@ impl<'a> ReadBuf<'a> { - #[inline] - pub fn new(buf: &'a mut [u8]) -> ReadBuf<'a> { - let initialized = buf.len(); -- let buf = unsafe { mem::transmute::<&mut [u8], &mut [MaybeUninit]>(buf) }; -+ let buf = unsafe { slice_to_uninit_mut(buf) }; - ReadBuf { - buf, - filled: 0, -@@ -67,8 +63,7 @@ impl<'a> ReadBuf<'a> { - let slice = &self.buf[..self.filled]; - // safety: filled describes how far into the buffer that the - // user has filled with bytes, so it's been initialized. -- // TODO: This could use `MaybeUninit::slice_get_ref` when it is stable. -- unsafe { mem::transmute::<&[MaybeUninit], &[u8]>(slice) } -+ unsafe { slice_assume_init(slice) } - } - - /// Returns a mutable reference to the filled portion of the buffer. -@@ -77,8 +72,7 @@ impl<'a> ReadBuf<'a> { - let slice = &mut self.buf[..self.filled]; - // safety: filled describes how far into the buffer that the - // user has filled with bytes, so it's been initialized. -- // TODO: This could use `MaybeUninit::slice_get_mut` when it is stable. -- unsafe { mem::transmute::<&mut [MaybeUninit], &mut [u8]>(slice) } -+ unsafe { slice_assume_init_mut(slice) } - } - - /// Returns a new `ReadBuf` comprised of the unfilled section up to `n`. -@@ -97,8 +91,7 @@ impl<'a> ReadBuf<'a> { - let slice = &self.buf[..self.initialized]; - // safety: initialized describes how far into the buffer that the - // user has at some point initialized with bytes. -- // TODO: This could use `MaybeUninit::slice_get_ref` when it is stable. -- unsafe { mem::transmute::<&[MaybeUninit], &[u8]>(slice) } -+ unsafe { slice_assume_init(slice) } - } - - /// Returns a mutable reference to the initialized portion of the buffer. -@@ -109,15 +102,14 @@ impl<'a> ReadBuf<'a> { - let slice = &mut self.buf[..self.initialized]; - // safety: initialized describes how far into the buffer that the - // user has at some point initialized with bytes. -- // TODO: This could use `MaybeUninit::slice_get_mut` when it is stable. -- unsafe { mem::transmute::<&mut [MaybeUninit], &mut [u8]>(slice) } -+ unsafe { slice_assume_init_mut(slice) } - } - - /// Returns a mutable reference to the entire buffer, without ensuring that it has been fully - /// initialized. - /// - /// The elements between 0 and `self.filled().len()` are filled, and those between 0 and -- /// `self.initialized().len()` are initialized (and so can be transmuted to a `&mut [u8]`). -+ /// `self.initialized().len()` are initialized (and so can be converted to a `&mut [u8]`). - /// - /// The caller of this method must ensure that these invariants are upheld. For example, if the - /// caller initializes some of the uninitialized section of the buffer, it must call -@@ -160,6 +152,7 @@ impl<'a> ReadBuf<'a> { - /// - /// Panics if `self.remaining()` is less than `n`. - #[inline] -+ #[track_caller] - pub fn initialize_unfilled_to(&mut self, n: usize) -> &mut [u8] { - assert!(self.remaining() >= n, "n overflows remaining"); - -@@ -178,7 +171,7 @@ impl<'a> ReadBuf<'a> { - let slice = &mut self.buf[self.filled..end]; - // safety: just above, we checked that the end of the buf has - // been initialized to some value. -- unsafe { mem::transmute::<&mut [MaybeUninit], &mut [u8]>(slice) } -+ unsafe { slice_assume_init_mut(slice) } - } - - /// Returns the number of bytes at the end of the slice that have not yet been filled. -@@ -203,6 +196,7 @@ impl<'a> ReadBuf<'a> { - /// - /// Panics if the filled region of the buffer would become larger than the initialized region. - #[inline] -+ #[track_caller] - pub fn advance(&mut self, n: usize) { - let new = self.filled.checked_add(n).expect("filled overflow"); - self.set_filled(new); -@@ -219,6 +213,7 @@ impl<'a> ReadBuf<'a> { - /// - /// Panics if the filled region of the buffer would become larger than the initialized region. - #[inline] -+ #[track_caller] - pub fn set_filled(&mut self, n: usize) { - assert!( - n <= self.initialized, -@@ -249,6 +244,7 @@ impl<'a> ReadBuf<'a> { - /// - /// Panics if `self.remaining()` is less than `buf.len()`. - #[inline] -+ #[track_caller] - pub fn put_slice(&mut self, buf: &[u8]) { - assert!( - self.remaining() >= buf.len(), -@@ -274,6 +270,33 @@ impl<'a> ReadBuf<'a> { - } - } - -+#[cfg(feature = "io-util")] -+#[cfg_attr(docsrs, doc(cfg(feature = "io-util")))] -+unsafe impl<'a> bytes::BufMut for ReadBuf<'a> { -+ fn remaining_mut(&self) -> usize { -+ self.remaining() -+ } -+ -+ // SAFETY: The caller guarantees that at least `cnt` unfilled bytes have been initialized. -+ unsafe fn advance_mut(&mut self, cnt: usize) { -+ self.assume_init(cnt); -+ self.advance(cnt); -+ } -+ -+ fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice { -+ // SAFETY: No region of `unfilled` will be deinitialized because it is -+ // exposed as an `UninitSlice`, whose API guarantees that the memory is -+ // never deinitialized. -+ let unfilled = unsafe { self.unfilled_mut() }; -+ let len = unfilled.len(); -+ let ptr = unfilled.as_mut_ptr() as *mut u8; -+ -+ // SAFETY: The pointer is valid for `len` bytes because it comes from a -+ // slice of that length. -+ unsafe { bytes::buf::UninitSlice::from_raw_parts_mut(ptr, len) } -+ } -+} -+ - impl fmt::Debug for ReadBuf<'_> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("ReadBuf") -@@ -283,3 +306,17 @@ impl fmt::Debug for ReadBuf<'_> { - .finish() - } - } -+ -+unsafe fn slice_to_uninit_mut(slice: &mut [u8]) -> &mut [MaybeUninit] { -+ &mut *(slice as *mut [u8] as *mut [MaybeUninit]) -+} -+ -+// TODO: This could use `MaybeUninit::slice_assume_init` when it is stable. -+unsafe fn slice_assume_init(slice: &[MaybeUninit]) -> &[u8] { -+ &*(slice as *const [MaybeUninit] as *const [u8]) -+} -+ -+// TODO: This could use `MaybeUninit::slice_assume_init_mut` when it is stable. -+unsafe fn slice_assume_init_mut(slice: &mut [MaybeUninit]) -> &mut [u8] { -+ &mut *(slice as *mut [MaybeUninit] as *mut [u8]) -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/io/driver/ready.rs b/KubeOS-Rust/vendor/tokio/src/io/ready.rs -similarity index 99% -rename from KubeOS-Rust/vendor/tokio/src/io/driver/ready.rs -rename to KubeOS-Rust/vendor/tokio/src/io/ready.rs -index 2430d302..ef135c43 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/driver/ready.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/ready.rs -@@ -12,7 +12,7 @@ const WRITE_CLOSED: usize = 0b0_1000; - /// - /// `Ready` tracks which operation an I/O resource is ready to perform. - #[cfg_attr(docsrs, doc(cfg(feature = "net")))] --#[derive(Clone, Copy, PartialEq, PartialOrd)] -+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] - pub struct Ready(usize); - - impl Ready { -diff --git a/KubeOS-Rust/vendor/tokio/src/io/split.rs b/KubeOS-Rust/vendor/tokio/src/io/split.rs -index 8258a0f7..f067b65a 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/split.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/split.rs -@@ -74,7 +74,11 @@ impl ReadHalf { - /// same `split` operation this method will panic. - /// This can be checked ahead of time by comparing the stream ID - /// of the two halves. -- pub fn unsplit(self, wr: WriteHalf) -> T { -+ #[track_caller] -+ pub fn unsplit(self, wr: WriteHalf) -> T -+ where -+ T: Unpin, -+ { - if self.is_pair_of(&wr) { - drop(wr); - -diff --git a/KubeOS-Rust/vendor/tokio/src/io/stderr.rs b/KubeOS-Rust/vendor/tokio/src/io/stderr.rs -index 2f624fba..2119c6d6 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/stderr.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/stderr.rs -@@ -74,16 +74,43 @@ cfg_io_std! { - } - - #[cfg(unix)] --impl std::os::unix::io::AsRawFd for Stderr { -- fn as_raw_fd(&self) -> std::os::unix::io::RawFd { -- std::io::stderr().as_raw_fd() -+mod sys { -+ #[cfg(not(tokio_no_as_fd))] -+ use std::os::unix::io::{AsFd, BorrowedFd}; -+ use std::os::unix::io::{AsRawFd, RawFd}; -+ -+ use super::Stderr; -+ -+ impl AsRawFd for Stderr { -+ fn as_raw_fd(&self) -> RawFd { -+ std::io::stderr().as_raw_fd() -+ } -+ } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for Stderr { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } - } - } - --#[cfg(windows)] --impl std::os::windows::io::AsRawHandle for Stderr { -- fn as_raw_handle(&self) -> std::os::windows::io::RawHandle { -- std::io::stderr().as_raw_handle() -+cfg_windows! { -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsHandle, BorrowedHandle}; -+ use crate::os::windows::io::{AsRawHandle, RawHandle}; -+ -+ impl AsRawHandle for Stderr { -+ fn as_raw_handle(&self) -> RawHandle { -+ std::io::stderr().as_raw_handle() -+ } -+ } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsHandle for Stderr { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) } -+ } - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/io/stdin.rs b/KubeOS-Rust/vendor/tokio/src/io/stdin.rs -index c9578f17..04cced42 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/stdin.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/stdin.rs -@@ -49,16 +49,43 @@ cfg_io_std! { - } - - #[cfg(unix)] --impl std::os::unix::io::AsRawFd for Stdin { -- fn as_raw_fd(&self) -> std::os::unix::io::RawFd { -- std::io::stdin().as_raw_fd() -+mod sys { -+ #[cfg(not(tokio_no_as_fd))] -+ use std::os::unix::io::{AsFd, BorrowedFd}; -+ use std::os::unix::io::{AsRawFd, RawFd}; -+ -+ use super::Stdin; -+ -+ impl AsRawFd for Stdin { -+ fn as_raw_fd(&self) -> RawFd { -+ std::io::stdin().as_raw_fd() -+ } -+ } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for Stdin { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } - } - } - --#[cfg(windows)] --impl std::os::windows::io::AsRawHandle for Stdin { -- fn as_raw_handle(&self) -> std::os::windows::io::RawHandle { -- std::io::stdin().as_raw_handle() -+cfg_windows! { -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsHandle, BorrowedHandle}; -+ use crate::os::windows::io::{AsRawHandle, RawHandle}; -+ -+ impl AsRawHandle for Stdin { -+ fn as_raw_handle(&self) -> RawHandle { -+ std::io::stdin().as_raw_handle() -+ } -+ } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsHandle for Stdin { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) } -+ } - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/io/stdio_common.rs b/KubeOS-Rust/vendor/tokio/src/io/stdio_common.rs -index 7e4a198a..06da761b 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/stdio_common.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/stdio_common.rs -@@ -42,7 +42,7 @@ where - // for further code. Since `AsyncWrite` can always shrink - // buffer at its discretion, excessive (i.e. in tests) shrinking - // does not break correctness. -- // 2. If buffer is small, it will not be shrinked. -+ // 2. If buffer is small, it will not be shrunk. - // That's why, it's "textness" will not change, so we don't have - // to fixup it. - if cfg!(not(any(target_os = "windows", test))) || buf.len() <= crate::io::blocking::MAX_BUF -@@ -108,14 +108,13 @@ where - #[cfg(test)] - #[cfg(not(loom))] - mod tests { -+ use crate::io::blocking::MAX_BUF; - use crate::io::AsyncWriteExt; - use std::io; - use std::pin::Pin; - use std::task::Context; - use std::task::Poll; - -- const MAX_BUF: usize = 16 * 1024; -- - struct TextMockWriter; - - impl crate::io::AsyncWrite for TextMockWriter { -@@ -177,6 +176,7 @@ mod tests { - } - - #[test] -+ #[cfg_attr(miri, ignore)] - fn test_splitter() { - let data = str::repeat("█", MAX_BUF); - let mut wr = super::SplitByUtf8BoundaryIfWindows::new(TextMockWriter); -@@ -190,10 +190,11 @@ mod tests { - } - - #[test] -+ #[cfg_attr(miri, ignore)] - fn test_pseudo_text() { - // In this test we write a piece of binary data, whose beginning is - // text though. We then validate that even in this corner case buffer -- // was not shrinked too much. -+ // was not shrunk too much. - let checked_count = super::MAGIC_CONST * super::MAX_BYTES_PER_CHAR; - let mut data: Vec = str::repeat("a", checked_count).into(); - data.extend(std::iter::repeat(0b1010_1010).take(MAX_BUF - checked_count + 1)); -@@ -212,7 +213,7 @@ mod tests { - writer.write_history.iter().copied().sum::(), - data.len() - ); -- // Check that at most MAX_BYTES_PER_CHAR + 1 (i.e. 5) bytes were shrinked -+ // Check that at most MAX_BYTES_PER_CHAR + 1 (i.e. 5) bytes were shrunk - // from the buffer: one because it was outside of MAX_BUF boundary, and - // up to one "utf8 code point". - assert!(data.len() - writer.write_history[0] <= super::MAX_BYTES_PER_CHAR + 1); -diff --git a/KubeOS-Rust/vendor/tokio/src/io/stdout.rs b/KubeOS-Rust/vendor/tokio/src/io/stdout.rs -index a08ed01e..f52bf5a4 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/stdout.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/stdout.rs -@@ -73,16 +73,43 @@ cfg_io_std! { - } - - #[cfg(unix)] --impl std::os::unix::io::AsRawFd for Stdout { -- fn as_raw_fd(&self) -> std::os::unix::io::RawFd { -- std::io::stdout().as_raw_fd() -+mod sys { -+ #[cfg(not(tokio_no_as_fd))] -+ use std::os::unix::io::{AsFd, BorrowedFd}; -+ use std::os::unix::io::{AsRawFd, RawFd}; -+ -+ use super::Stdout; -+ -+ impl AsRawFd for Stdout { -+ fn as_raw_fd(&self) -> RawFd { -+ std::io::stdout().as_raw_fd() -+ } -+ } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for Stdout { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } - } - } - --#[cfg(windows)] --impl std::os::windows::io::AsRawHandle for Stdout { -- fn as_raw_handle(&self) -> std::os::windows::io::RawHandle { -- std::io::stdout().as_raw_handle() -+cfg_windows! { -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsHandle, BorrowedHandle}; -+ use crate::os::windows::io::{AsRawHandle, RawHandle}; -+ -+ impl AsRawHandle for Stdout { -+ fn as_raw_handle(&self) -> RawHandle { -+ std::io::stdout().as_raw_handle() -+ } -+ } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsHandle for Stdout { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) } -+ } - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/async_seek_ext.rs b/KubeOS-Rust/vendor/tokio/src/io/util/async_seek_ext.rs -index 46b3e6c0..aadf3a76 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/async_seek_ext.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/async_seek_ext.rs -@@ -69,7 +69,7 @@ cfg_io_util! { - - /// Creates a future which will rewind to the beginning of the stream. - /// -- /// This is convenience method, equivalent to to `self.seek(SeekFrom::Start(0))`. -+ /// This is convenience method, equivalent to `self.seek(SeekFrom::Start(0))`. - fn rewind(&mut self) -> Seek<'_, Self> - where - Self: Unpin, -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/async_write_ext.rs b/KubeOS-Rust/vendor/tokio/src/io/util/async_write_ext.rs -index 93a31831..dfdde82f 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/async_write_ext.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/async_write_ext.rs -@@ -406,7 +406,7 @@ cfg_io_util! { - /// ``` - fn write_u8(&mut self, n: u8) -> WriteU8; - -- /// Writes an unsigned 8-bit integer to the underlying writer. -+ /// Writes a signed 8-bit integer to the underlying writer. - /// - /// Equivalent to: - /// -@@ -425,7 +425,7 @@ cfg_io_util! { - /// - /// # Examples - /// -- /// Write unsigned 8 bit integers to a `AsyncWrite`: -+ /// Write signed 8 bit integers to a `AsyncWrite`: - /// - /// ```rust - /// use tokio::io::{self, AsyncWriteExt}; -@@ -434,10 +434,10 @@ cfg_io_util! { - /// async fn main() -> io::Result<()> { - /// let mut writer = Vec::new(); - /// -- /// writer.write_u8(2).await?; -- /// writer.write_u8(5).await?; -+ /// writer.write_i8(-2).await?; -+ /// writer.write_i8(126).await?; - /// -- /// assert_eq!(writer, b"\x02\x05"); -+ /// assert_eq!(writer, b"\xFE\x7E"); - /// Ok(()) - /// } - /// ``` -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/buf_reader.rs b/KubeOS-Rust/vendor/tokio/src/io/util/buf_reader.rs -index 7df610b1..60879c0f 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/buf_reader.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/buf_reader.rs -@@ -204,7 +204,6 @@ impl AsyncSeek for BufReader { - self.as_mut() - .get_pin_mut() - .start_seek(SeekFrom::Current(offset))?; -- self.as_mut().get_pin_mut().poll_complete(cx)? - } else { - // seek backwards by our remainder, and then by the offset - self.as_mut() -@@ -221,8 +220,8 @@ impl AsyncSeek for BufReader { - self.as_mut() - .get_pin_mut() - .start_seek(SeekFrom::Current(n))?; -- self.as_mut().get_pin_mut().poll_complete(cx)? - } -+ self.as_mut().get_pin_mut().poll_complete(cx)? - } - SeekState::PendingOverflowed(n) => { - if self.as_mut().get_pin_mut().poll_complete(cx)?.is_pending() { -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/copy.rs b/KubeOS-Rust/vendor/tokio/src/io/util/copy.rs -index d0ab7cb1..55861244 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/copy.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/copy.rs -@@ -27,6 +27,51 @@ impl CopyBuffer { - } - } - -+ fn poll_fill_buf( -+ &mut self, -+ cx: &mut Context<'_>, -+ reader: Pin<&mut R>, -+ ) -> Poll> -+ where -+ R: AsyncRead + ?Sized, -+ { -+ let me = &mut *self; -+ let mut buf = ReadBuf::new(&mut me.buf); -+ buf.set_filled(me.cap); -+ -+ let res = reader.poll_read(cx, &mut buf); -+ if let Poll::Ready(Ok(_)) = res { -+ let filled_len = buf.filled().len(); -+ me.read_done = me.cap == filled_len; -+ me.cap = filled_len; -+ } -+ res -+ } -+ -+ fn poll_write_buf( -+ &mut self, -+ cx: &mut Context<'_>, -+ mut reader: Pin<&mut R>, -+ mut writer: Pin<&mut W>, -+ ) -> Poll> -+ where -+ R: AsyncRead + ?Sized, -+ W: AsyncWrite + ?Sized, -+ { -+ let me = &mut *self; -+ match writer.as_mut().poll_write(cx, &me.buf[me.pos..me.cap]) { -+ Poll::Pending => { -+ // Top up the buffer towards full if we can read a bit more -+ // data - this should improve the chances of a large write -+ if !me.read_done && me.cap < me.buf.len() { -+ ready!(me.poll_fill_buf(cx, reader.as_mut()))?; -+ } -+ Poll::Pending -+ } -+ res => res, -+ } -+ } -+ - pub(super) fn poll_copy( - &mut self, - cx: &mut Context<'_>, -@@ -41,10 +86,10 @@ impl CopyBuffer { - // If our buffer is empty, then we need to read some data to - // continue. - if self.pos == self.cap && !self.read_done { -- let me = &mut *self; -- let mut buf = ReadBuf::new(&mut me.buf); -+ self.pos = 0; -+ self.cap = 0; - -- match reader.as_mut().poll_read(cx, &mut buf) { -+ match self.poll_fill_buf(cx, reader.as_mut()) { - Poll::Ready(Ok(_)) => (), - Poll::Ready(Err(err)) => return Poll::Ready(Err(err)), - Poll::Pending => { -@@ -58,20 +103,11 @@ impl CopyBuffer { - return Poll::Pending; - } - } -- -- let n = buf.filled().len(); -- if n == 0 { -- self.read_done = true; -- } else { -- self.pos = 0; -- self.cap = n; -- } - } - - // If our buffer has some data, let's write it out! - while self.pos < self.cap { -- let me = &mut *self; -- let i = ready!(writer.as_mut().poll_write(cx, &me.buf[me.pos..me.cap]))?; -+ let i = ready!(self.poll_write_buf(cx, reader.as_mut(), writer.as_mut()))?; - if i == 0 { - return Poll::Ready(Err(io::Error::new( - io::ErrorKind::WriteZero, -@@ -117,14 +153,22 @@ cfg_io_util! { - /// - /// This function returns a future that will continuously read data from - /// `reader` and then write it into `writer` in a streaming fashion until -- /// `reader` returns EOF. -+ /// `reader` returns EOF or fails. - /// - /// On success, the total number of bytes that were copied from `reader` to - /// `writer` is returned. - /// - /// This is an asynchronous version of [`std::io::copy`][std]. - /// -+ /// A heap-allocated copy buffer with 8 KB is created to take data from the -+ /// reader to the writer, check [`copy_buf`] if you want an alternative for -+ /// [`AsyncBufRead`]. You can use `copy_buf` with [`BufReader`] to change the -+ /// buffer capacity. -+ /// - /// [std]: std::io::copy -+ /// [`copy_buf`]: crate::io::copy_buf -+ /// [`AsyncBufRead`]: crate::io::AsyncBufRead -+ /// [`BufReader`]: crate::io::BufReader - /// - /// # Errors - /// -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/copy_bidirectional.rs b/KubeOS-Rust/vendor/tokio/src/io/util/copy_bidirectional.rs -index c93060b3..e1a7db12 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/copy_bidirectional.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/copy_bidirectional.rs -@@ -1,8 +1,8 @@ - use super::copy::CopyBuffer; - -+use crate::future::poll_fn; - use crate::io::{AsyncRead, AsyncWrite}; - --use std::future::Future; - use std::io; - use std::pin::Pin; - use std::task::{Context, Poll}; -@@ -13,13 +13,6 @@ enum TransferState { - Done(u64), - } - --struct CopyBidirectional<'a, A: ?Sized, B: ?Sized> { -- a: &'a mut A, -- b: &'a mut B, -- a_to_b: TransferState, -- b_to_a: TransferState, --} -- - fn transfer_one_direction( - cx: &mut Context<'_>, - state: &mut TransferState, -@@ -48,35 +41,6 @@ where - } - } - } -- --impl<'a, A, B> Future for CopyBidirectional<'a, A, B> --where -- A: AsyncRead + AsyncWrite + Unpin + ?Sized, -- B: AsyncRead + AsyncWrite + Unpin + ?Sized, --{ -- type Output = io::Result<(u64, u64)>; -- -- fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -- // Unpack self into mut refs to each field to avoid borrow check issues. -- let CopyBidirectional { -- a, -- b, -- a_to_b, -- b_to_a, -- } = &mut *self; -- -- let a_to_b = transfer_one_direction(cx, a_to_b, &mut *a, &mut *b)?; -- let b_to_a = transfer_one_direction(cx, b_to_a, &mut *b, &mut *a)?; -- -- // It is not a problem if ready! returns early because transfer_one_direction for the -- // other direction will keep returning TransferState::Done(count) in future calls to poll -- let a_to_b = ready!(a_to_b); -- let b_to_a = ready!(b_to_a); -- -- Poll::Ready(Ok((a_to_b, b_to_a))) -- } --} -- - /// Copies data in both directions between `a` and `b`. - /// - /// This function returns a future that will read from both streams, -@@ -110,11 +74,18 @@ where - A: AsyncRead + AsyncWrite + Unpin + ?Sized, - B: AsyncRead + AsyncWrite + Unpin + ?Sized, - { -- CopyBidirectional { -- a, -- b, -- a_to_b: TransferState::Running(CopyBuffer::new()), -- b_to_a: TransferState::Running(CopyBuffer::new()), -- } -+ let mut a_to_b = TransferState::Running(CopyBuffer::new()); -+ let mut b_to_a = TransferState::Running(CopyBuffer::new()); -+ poll_fn(|cx| { -+ let a_to_b = transfer_one_direction(cx, &mut a_to_b, a, b)?; -+ let b_to_a = transfer_one_direction(cx, &mut b_to_a, b, a)?; -+ -+ // It is not a problem if ready! returns early because transfer_one_direction for the -+ // other direction will keep returning TransferState::Done(count) in future calls to poll -+ let a_to_b = ready!(a_to_b); -+ let b_to_a = ready!(b_to_a); -+ -+ Poll::Ready(Ok((a_to_b, b_to_a))) -+ }) - .await - } -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/copy_buf.rs b/KubeOS-Rust/vendor/tokio/src/io/util/copy_buf.rs -index 6831580b..c23fc9a2 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/copy_buf.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/copy_buf.rs -@@ -24,11 +24,17 @@ cfg_io_util! { - /// - /// This function returns a future that will continuously read data from - /// `reader` and then write it into `writer` in a streaming fashion until -- /// `reader` returns EOF. -+ /// `reader` returns EOF or fails. - /// - /// On success, the total number of bytes that were copied from `reader` to - /// `writer` is returned. - /// -+ /// This is a [`tokio::io::copy`] alternative for [`AsyncBufRead`] readers -+ /// with no extra buffer allocation, since [`AsyncBufRead`] allow access -+ /// to the reader's inner buffer. -+ /// -+ /// [`tokio::io::copy`]: crate::io::copy -+ /// [`AsyncBufRead`]: crate::io::AsyncBufRead - /// - /// # Errors - /// -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/empty.rs b/KubeOS-Rust/vendor/tokio/src/io/util/empty.rs -index f964d18e..9e648f87 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/empty.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/empty.rs -@@ -50,16 +50,18 @@ impl AsyncRead for Empty { - #[inline] - fn poll_read( - self: Pin<&mut Self>, -- _: &mut Context<'_>, -+ cx: &mut Context<'_>, - _: &mut ReadBuf<'_>, - ) -> Poll> { -+ ready!(poll_proceed_and_make_progress(cx)); - Poll::Ready(Ok(())) - } - } - - impl AsyncBufRead for Empty { - #[inline] -- fn poll_fill_buf(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll> { -+ fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { -+ ready!(poll_proceed_and_make_progress(cx)); - Poll::Ready(Ok(&[])) - } - -@@ -73,6 +75,20 @@ impl fmt::Debug for Empty { - } - } - -+cfg_coop! { -+ fn poll_proceed_and_make_progress(cx: &mut Context<'_>) -> Poll<()> { -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); -+ coop.made_progress(); -+ Poll::Ready(()) -+ } -+} -+ -+cfg_not_coop! { -+ fn poll_proceed_and_make_progress(_: &mut Context<'_>) -> Poll<()> { -+ Poll::Ready(()) -+ } -+} -+ - #[cfg(test)] - mod tests { - use super::*; -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/fill_buf.rs b/KubeOS-Rust/vendor/tokio/src/io/util/fill_buf.rs -index 3655c015..bb07c766 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/fill_buf.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/fill_buf.rs -@@ -40,6 +40,12 @@ impl<'a, R: AsyncBufRead + ?Sized + Unpin> Future for FillBuf<'a, R> { - // Safety: This is necessary only due to a limitation in the - // borrow checker. Once Rust starts using the polonius borrow - // checker, this can be simplified. -+ // -+ // The safety of this transmute relies on the fact that the -+ // value of `reader` is `None` when we return in this branch. -+ // Otherwise the caller could poll us again after -+ // completion, and access the mutable reference while the -+ // returned immutable reference still exists. - let slice = std::mem::transmute::<&[u8], &'a [u8]>(slice); - Poll::Ready(Ok(slice)) - }, -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/mem.rs b/KubeOS-Rust/vendor/tokio/src/io/util/mem.rs -index 4eefe7b2..31884b39 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/mem.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/mem.rs -@@ -177,10 +177,8 @@ impl Pipe { - waker.wake(); - } - } --} - --impl AsyncRead for Pipe { -- fn poll_read( -+ fn poll_read_internal( - mut self: Pin<&mut Self>, - cx: &mut task::Context<'_>, - buf: &mut ReadBuf<'_>, -@@ -204,10 +202,8 @@ impl AsyncRead for Pipe { - Poll::Pending - } - } --} - --impl AsyncWrite for Pipe { -- fn poll_write( -+ fn poll_write_internal( - mut self: Pin<&mut Self>, - cx: &mut task::Context<'_>, - buf: &[u8], -@@ -228,6 +224,62 @@ impl AsyncWrite for Pipe { - } - Poll::Ready(Ok(len)) - } -+} -+ -+impl AsyncRead for Pipe { -+ cfg_coop! { -+ fn poll_read( -+ self: Pin<&mut Self>, -+ cx: &mut task::Context<'_>, -+ buf: &mut ReadBuf<'_>, -+ ) -> Poll> { -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); -+ -+ let ret = self.poll_read_internal(cx, buf); -+ if ret.is_ready() { -+ coop.made_progress(); -+ } -+ ret -+ } -+ } -+ -+ cfg_not_coop! { -+ fn poll_read( -+ self: Pin<&mut Self>, -+ cx: &mut task::Context<'_>, -+ buf: &mut ReadBuf<'_>, -+ ) -> Poll> { -+ self.poll_read_internal(cx, buf) -+ } -+ } -+} -+ -+impl AsyncWrite for Pipe { -+ cfg_coop! { -+ fn poll_write( -+ self: Pin<&mut Self>, -+ cx: &mut task::Context<'_>, -+ buf: &[u8], -+ ) -> Poll> { -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); -+ -+ let ret = self.poll_write_internal(cx, buf); -+ if ret.is_ready() { -+ coop.made_progress(); -+ } -+ ret -+ } -+ } -+ -+ cfg_not_coop! { -+ fn poll_write( -+ self: Pin<&mut Self>, -+ cx: &mut task::Context<'_>, -+ buf: &[u8], -+ ) -> Poll> { -+ self.poll_write_internal(cx, buf) -+ } -+ } - - fn poll_flush(self: Pin<&mut Self>, _: &mut task::Context<'_>) -> Poll> { - Poll::Ready(Ok(())) -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/read.rs b/KubeOS-Rust/vendor/tokio/src/io/util/read.rs -index edc9d5a9..a1f9c8a0 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/read.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/read.rs -@@ -48,7 +48,7 @@ where - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { - let me = self.project(); -- let mut buf = ReadBuf::new(*me.buf); -+ let mut buf = ReadBuf::new(me.buf); - ready!(Pin::new(me.reader).poll_read(cx, &mut buf))?; - Poll::Ready(Ok(buf.filled().len())) - } -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/read_exact.rs b/KubeOS-Rust/vendor/tokio/src/io/util/read_exact.rs -index 1e8150eb..dbdd58ba 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/read_exact.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/read_exact.rs -@@ -51,13 +51,13 @@ where - type Output = io::Result; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { -- let mut me = self.project(); -+ let me = self.project(); - - loop { - // if our buffer is empty, then we need to read some data to continue. - let rem = me.buf.remaining(); - if rem != 0 { -- ready!(Pin::new(&mut *me.reader).poll_read(cx, &mut me.buf))?; -+ ready!(Pin::new(&mut *me.reader).poll_read(cx, me.buf))?; - if me.buf.remaining() == rem { - return Err(eof()).into(); - } -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/read_to_end.rs b/KubeOS-Rust/vendor/tokio/src/io/util/read_to_end.rs -index f4a564d7..8edba2a1 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/read_to_end.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/read_to_end.rs -@@ -1,11 +1,11 @@ - use crate::io::util::vec_with_initialized::{into_read_buf_parts, VecU8, VecWithInitialized}; --use crate::io::AsyncRead; -+use crate::io::{AsyncRead, ReadBuf}; - - use pin_project_lite::pin_project; - use std::future::Future; - use std::io; - use std::marker::PhantomPinned; --use std::mem; -+use std::mem::{self, MaybeUninit}; - use std::pin::Pin; - use std::task::{Context, Poll}; - -@@ -67,16 +67,47 @@ fn poll_read_to_end( - // has 4 bytes while still making large reads if the reader does have a ton - // of data to return. Simply tacking on an extra DEFAULT_BUF_SIZE space every - // time is 4,500 times (!) slower than this if the reader has a very small -- // amount of data to return. -- buf.reserve(32); -+ // amount of data to return. When the vector is full with its starting -+ // capacity, we first try to read into a small buffer to see if we reached -+ // an EOF. This only happens when the starting capacity is >= NUM_BYTES, since -+ // we allocate at least NUM_BYTES each time. This avoids the unnecessary -+ // allocation that we attempt before reading into the vector. -+ -+ const NUM_BYTES: usize = 32; -+ let try_small_read = buf.try_small_read_first(NUM_BYTES); - - // Get a ReadBuf into the vector. -- let mut read_buf = buf.get_read_buf(); -+ let mut read_buf; -+ let poll_result; -+ -+ let n = if try_small_read { -+ // Read some bytes using a small read. -+ let mut small_buf: [MaybeUninit; NUM_BYTES] = [MaybeUninit::uninit(); NUM_BYTES]; -+ let mut small_read_buf = ReadBuf::uninit(&mut small_buf); -+ poll_result = read.poll_read(cx, &mut small_read_buf); -+ let to_write = small_read_buf.filled(); -+ -+ // Ensure we have enough space to fill our vector with what we read. -+ read_buf = buf.get_read_buf(); -+ if to_write.len() > read_buf.remaining() { -+ buf.reserve(NUM_BYTES); -+ read_buf = buf.get_read_buf(); -+ } -+ read_buf.put_slice(to_write); -+ -+ to_write.len() -+ } else { -+ // Ensure we have enough space for reading. -+ buf.reserve(NUM_BYTES); -+ read_buf = buf.get_read_buf(); -+ -+ // Read data directly into vector. -+ let filled_before = read_buf.filled().len(); -+ poll_result = read.poll_read(cx, &mut read_buf); - -- let filled_before = read_buf.filled().len(); -- let poll_result = read.poll_read(cx, &mut read_buf); -- let filled_after = read_buf.filled().len(); -- let n = filled_after - filled_before; -+ // Compute the number of bytes read. -+ read_buf.filled().len() - filled_before -+ }; - - // Update the length of the vector using the result of poll_read. - let read_buf_parts = into_read_buf_parts(read_buf); -@@ -87,11 +118,11 @@ fn poll_read_to_end( - // In this case, nothing should have been read. However we still - // update the vector in case the poll_read call initialized parts of - // the vector's unused capacity. -- debug_assert_eq!(filled_before, filled_after); -+ debug_assert_eq!(n, 0); - Poll::Pending - } - Poll::Ready(Err(err)) => { -- debug_assert_eq!(filled_before, filled_after); -+ debug_assert_eq!(n, 0); - Poll::Ready(Err(err)) - } - Poll::Ready(Ok(())) => Poll::Ready(Ok(n)), -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/read_until.rs b/KubeOS-Rust/vendor/tokio/src/io/util/read_until.rs -index 90a0e8a1..fb6fb22d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/read_until.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/read_until.rs -@@ -1,4 +1,5 @@ - use crate::io::AsyncBufRead; -+use crate::util::memchr; - - use pin_project_lite::pin_project; - use std::future::Future; -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/take.rs b/KubeOS-Rust/vendor/tokio/src/io/util/take.rs -index b5e90c93..df2f61b9 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/take.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/take.rs -@@ -86,7 +86,11 @@ impl AsyncRead for Take { - - let me = self.project(); - let mut b = buf.take(*me.limit_ as usize); -+ -+ let buf_ptr = b.filled().as_ptr(); - ready!(me.inner.poll_read(cx, &mut b))?; -+ assert_eq!(b.filled().as_ptr(), buf_ptr); -+ - let n = b.filled().len(); - - // We need to update the original ReadBuf -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/vec_with_initialized.rs b/KubeOS-Rust/vendor/tokio/src/io/util/vec_with_initialized.rs -index 208cc939..f527492d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/vec_with_initialized.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/vec_with_initialized.rs -@@ -1,19 +1,18 @@ - use crate::io::ReadBuf; - use std::mem::MaybeUninit; - --mod private { -- pub trait Sealed {} -- -- impl Sealed for Vec {} -- impl Sealed for &mut Vec {} --} -+/// Something that looks like a `Vec`. -+/// -+/// # Safety -+/// -+/// The implementor must guarantee that the vector returned by the -+/// `as_mut` and `as_mut` methods do not change from one call to -+/// another. -+pub(crate) unsafe trait VecU8: AsRef> + AsMut> {} - --/// A sealed trait that constrains the generic type parameter in `VecWithInitialized`. That struct's safety relies --/// on certain invariants upheld by `Vec`. --pub(crate) trait VecU8: AsMut> + private::Sealed {} -+unsafe impl VecU8 for Vec {} -+unsafe impl VecU8 for &mut Vec {} - --impl VecU8 for Vec {} --impl VecU8 for &mut Vec {} - /// This struct wraps a `Vec` or `&mut Vec`, combining it with a - /// `num_initialized`, which keeps track of the number of initialized bytes - /// in the unused capacity. -@@ -29,6 +28,7 @@ pub(crate) struct VecWithInitialized { - // The number of initialized bytes in the vector. - // Always between `vec.len()` and `vec.capacity()`. - num_initialized: usize, -+ starting_capacity: usize, - } - - impl VecWithInitialized> { -@@ -48,6 +48,7 @@ where - // to its length are initialized. - Self { - num_initialized: vec.as_mut().len(), -+ starting_capacity: vec.as_ref().capacity(), - vec, - } - } -@@ -64,8 +65,8 @@ where - } - - #[cfg(feature = "io-util")] -- pub(crate) fn is_empty(&mut self) -> bool { -- self.vec.as_mut().is_empty() -+ pub(crate) fn is_empty(&self) -> bool { -+ self.vec.as_ref().is_empty() - } - - pub(crate) fn get_read_buf<'a>(&'a mut self) -> ReadBuf<'a> { -@@ -112,6 +113,15 @@ where - vec.set_len(parts.len); - } - } -+ -+ // Returns a boolean telling the caller to try reading into a small local buffer first if true. -+ // Doing so would avoid overallocating when vec is filled to capacity and we reached EOF. -+ pub(crate) fn try_small_read_first(&self, num_bytes: usize) -> bool { -+ let vec = self.vec.as_ref(); -+ vec.capacity() - vec.len() < num_bytes -+ && self.starting_capacity == vec.capacity() -+ && self.starting_capacity >= num_bytes -+ } - } - - pub(crate) struct ReadBufParts { -diff --git a/KubeOS-Rust/vendor/tokio/src/io/util/write_all.rs b/KubeOS-Rust/vendor/tokio/src/io/util/write_all.rs -index e59d41e4..abd3e39d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/util/write_all.rs -+++ b/KubeOS-Rust/vendor/tokio/src/io/util/write_all.rs -@@ -42,7 +42,7 @@ where - while !me.buf.is_empty() { - let n = ready!(Pin::new(&mut *me.writer).poll_write(cx, me.buf))?; - { -- let (_, rest) = mem::replace(&mut *me.buf, &[]).split_at(n); -+ let (_, rest) = mem::take(&mut *me.buf).split_at(n); - *me.buf = rest; - } - if n == 0 { -diff --git a/KubeOS-Rust/vendor/tokio/src/lib.rs b/KubeOS-Rust/vendor/tokio/src/lib.rs -index 9821c1a6..96da4b77 100644 ---- a/KubeOS-Rust/vendor/tokio/src/lib.rs -+++ b/KubeOS-Rust/vendor/tokio/src/lib.rs -@@ -1,7 +1,9 @@ - #![allow( - clippy::cognitive_complexity, - clippy::large_enum_variant, -- clippy::needless_doctest_main -+ clippy::module_inception, -+ clippy::needless_doctest_main, -+ clippy::declare_interior_mutable_const - )] - #![warn( - missing_debug_implementations, -@@ -10,17 +12,13 @@ - unreachable_pub - )] - #![deny(unused_must_use)] --#![cfg_attr(docsrs, deny(rustdoc::broken_intra_doc_links))] - #![doc(test( - no_crate_inject, - attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables)) - ))] - #![cfg_attr(docsrs, feature(doc_cfg))] --#![cfg_attr(docsrs, feature(doc_cfg_hide))] --#![cfg_attr(docsrs, doc(cfg_hide(docsrs)))] --#![cfg_attr(docsrs, doc(cfg_hide(loom)))] --#![cfg_attr(docsrs, doc(cfg_hide(not(loom))))] - #![cfg_attr(docsrs, allow(unused_attributes))] -+#![cfg_attr(loom, allow(dead_code, unreachable_pub))] - - //! A runtime for writing reliable network applications without compromising speed. - //! -@@ -119,7 +117,7 @@ - //! The [`tokio::sync`] module contains synchronization primitives to use when - //! needing to communicate or share data. These include: - //! --//! * channels ([`oneshot`], [`mpsc`], and [`watch`]), for sending values -+//! * channels ([`oneshot`], [`mpsc`], [`watch`], and [`broadcast`]), for sending values - //! between tasks, - //! * a non-blocking [`Mutex`], for controlling access to a shared, mutable - //! value, -@@ -135,6 +133,7 @@ - //! [`oneshot`]: crate::sync::oneshot - //! [`mpsc`]: crate::sync::mpsc - //! [`watch`]: crate::sync::watch -+//! [`broadcast`]: crate::sync::broadcast - //! - //! The [`tokio::time`] module provides utilities for tracking time and - //! scheduling work. This includes functions for setting [timeouts][timeout] for -@@ -156,7 +155,7 @@ - //! provide the functionality you need. - //! - //! Using the runtime requires the "rt" or "rt-multi-thread" feature flags, to --//! enable the basic [single-threaded scheduler][rt] and the [thread-pool -+//! enable the current-thread [single-threaded scheduler][rt] and the [multi-thread - //! scheduler][rt-multi-thread], respectively. See the [`runtime` module - //! documentation][rt-features] for details. In addition, the "macros" feature - //! flag enables the `#[tokio::main]` and `#[tokio::test]` attributes. -@@ -175,12 +174,15 @@ - //! swapping the currently running task on each thread. However, this kind of - //! swapping can only happen at `.await` points, so code that spends a long time - //! without reaching an `.await` will prevent other tasks from running. To --//! combat this, Tokio provides two kinds of threads: Core threads and blocking --//! threads. The core threads are where all asynchronous code runs, and Tokio --//! will by default spawn one for each CPU core. The blocking threads are --//! spawned on demand, can be used to run blocking code that would otherwise --//! block other tasks from running and are kept alive when not used for a certain --//! amount of time which can be configured with [`thread_keep_alive`]. -+//! combat this, Tokio provides two kinds of threads: Core threads and blocking threads. -+//! -+//! The core threads are where all asynchronous code runs, and Tokio will by default -+//! spawn one for each CPU core. You can use the environment variable `TOKIO_WORKER_THREADS` -+//! to override the default value. -+//! -+//! The blocking threads are spawned on demand, can be used to run blocking code -+//! that would otherwise block other tasks from running and are kept alive when -+//! not used for a certain amount of time which can be configured with [`thread_keep_alive`]. - //! Since it is not possible for Tokio to swap out blocking tasks, like it - //! can do with asynchronous code, the upper limit on the number of blocking - //! threads is very large. These limits can be configured on the [`Builder`]. -@@ -312,8 +314,8 @@ - //! Beware though that this will pull in many extra dependencies that you may not - //! need. - //! --//! - `full`: Enables all Tokio public API features listed below except `test-util`. --//! - `rt`: Enables `tokio::spawn`, the basic (current thread) scheduler, -+//! - `full`: Enables all features listed below except `test-util` and `tracing`. -+//! - `rt`: Enables `tokio::spawn`, the current-thread scheduler, - //! and non-scheduler utilities. - //! - `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler. - //! - `io-util`: Enables the IO based `Ext` traits. -@@ -329,30 +331,117 @@ - //! - `signal`: Enables all `tokio::signal` types. - //! - `fs`: Enables `tokio::fs` types. - //! - `test-util`: Enables testing based infrastructure for the Tokio runtime. -+//! - `parking_lot`: As a potential optimization, use the _parking_lot_ crate's -+//! synchronization primitives internally. Also, this -+//! dependency is necessary to construct some of our primitives -+//! in a const context. MSRV may increase according to the -+//! _parking_lot_ release in use. - //! - //! _Note: `AsyncRead` and `AsyncWrite` traits do not require any features and are - //! always available._ - //! --//! ### Internal features -+//! ### Unstable features - //! --//! These features do not expose any new API, but influence internal --//! implementation aspects of Tokio, and can pull in additional --//! dependencies. -+//! Some feature flags are only available when specifying the `tokio_unstable` flag: - //! --//! - `parking_lot`: As a potential optimization, use the _parking_lot_ crate's --//! synchronization primitives internally. MSRV may increase according to the --//! _parking_lot_ release in use. -+//! - `tracing`: Enables tracing events. - //! --//! ### Unstable features -+//! Likewise, some parts of the API are only available with the same flag: - //! --//! These feature flags enable **unstable** features. The public API may break in 1.x --//! releases. To enable these features, the `--cfg tokio_unstable` must be passed to --//! `rustc` when compiling. This is easiest done using the `RUSTFLAGS` env variable: --//! `RUSTFLAGS="--cfg tokio_unstable"`. -+//! - [`task::Builder`] -+//! - Some methods on [`task::JoinSet`] -+//! - [`runtime::RuntimeMetrics`] -+//! - [`runtime::Builder::unhandled_panic`] -+//! - [`task::Id`] - //! --//! - `tracing`: Enables tracing events. -+//! This flag enables **unstable** features. The public API of these features -+//! may break in 1.x releases. To enable these features, the `--cfg -+//! tokio_unstable` argument must be passed to `rustc` when compiling. This -+//! serves to explicitly opt-in to features which may break semver conventions, -+//! since Cargo [does not yet directly support such opt-ins][unstable features]. -+//! -+//! You can specify it in your project's `.cargo/config.toml` file: -+//! -+//! ```toml -+//! [build] -+//! rustflags = ["--cfg", "tokio_unstable"] -+//! ``` - //! -+//! Alternatively, you can specify it with an environment variable: -+//! -+//! ```sh -+//! ## Many *nix shells: -+//! export RUSTFLAGS="--cfg tokio_unstable" -+//! cargo build -+//! ``` -+//! -+//! ```powershell -+//! ## Windows PowerShell: -+//! $Env:RUSTFLAGS="--cfg tokio_unstable" -+//! cargo build -+//! ``` -+//! -+//! [unstable features]: https://internals.rust-lang.org/t/feature-request-unstable-opt-in-non-transitive-crate-features/16193#why-not-a-crate-feature-2 - //! [feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section -+//! -+//! ## Supported platforms -+//! -+//! Tokio currently guarantees support for the following platforms: -+//! -+//! * Linux -+//! * Windows -+//! * Android (API level 21) -+//! * macOS -+//! * iOS -+//! * FreeBSD -+//! -+//! Tokio will continue to support these platforms in the future. However, -+//! future releases may change requirements such as the minimum required libc -+//! version on Linux, the API level on Android, or the supported FreeBSD -+//! release. -+//! -+//! Beyond the above platforms, Tokio is intended to work on all platforms -+//! supported by the mio crate. You can find a longer list [in mio's -+//! documentation][mio-supported]. However, these additional platforms may -+//! become unsupported in the future. -+//! -+//! Note that Wine is considered to be a different platform from Windows. See -+//! mio's documentation for more information on Wine support. -+//! -+//! [mio-supported]: https://crates.io/crates/mio#platforms -+//! -+//! ### WASM support -+//! -+//! Tokio has some limited support for the WASM platform. Without the -+//! `tokio_unstable` flag, the following features are supported: -+//! -+//! * `sync` -+//! * `macros` -+//! * `io-util` -+//! * `rt` -+//! * `time` -+//! -+//! Enabling any other feature (including `full`) will cause a compilation -+//! failure. -+//! -+//! The `time` module will only work on WASM platforms that have support for -+//! timers (e.g. wasm32-wasi). The timing functions will panic if used on a WASM -+//! platform that does not support timers. -+//! -+//! Note also that if the runtime becomes indefinitely idle, it will panic -+//! immediately instead of blocking forever. On platforms that don't support -+//! time, this means that the runtime can never be idle in any way. -+//! -+//! ### Unstable WASM support -+//! -+//! Tokio also has unstable support for some additional WASM features. This -+//! requires the use of the `tokio_unstable` flag. -+//! -+//! Using this flag enables the use of `tokio::net` on the wasm32-wasi target. -+//! However, not all methods are available on the networking types as WASI -+//! currently does not support the creation of new sockets from within WASM. -+//! Because of this, sockets must currently be created via the `FromRawFd` -+//! trait. - - // Test that pointer width is compatible. This asserts that e.g. usize is at - // least 32 bits, which a lot of components in Tokio currently assumes. -@@ -367,6 +456,37 @@ compile_error! { - "Tokio requires the platform pointer width to be 32, 64, or 128 bits" - } - -+// Ensure that our build script has correctly set cfg flags for wasm. -+// -+// Each condition is written all(a, not(b)). This should be read as -+// "if a, then we must also have b". -+#[cfg(any( -+ all(target_arch = "wasm32", not(tokio_wasm)), -+ all(target_arch = "wasm64", not(tokio_wasm)), -+ all(target_family = "wasm", not(tokio_wasm)), -+ all(target_os = "wasi", not(tokio_wasm)), -+ all(target_os = "wasi", not(tokio_wasi)), -+ all(target_os = "wasi", tokio_wasm_not_wasi), -+ all(tokio_wasm, not(any(target_arch = "wasm32", target_arch = "wasm64"))), -+ all(tokio_wasm_not_wasi, not(tokio_wasm)), -+ all(tokio_wasi, not(tokio_wasm)) -+))] -+compile_error!("Tokio's build script has incorrectly detected wasm."); -+ -+#[cfg(all( -+ not(tokio_unstable), -+ tokio_wasm, -+ any( -+ feature = "fs", -+ feature = "io-std", -+ feature = "net", -+ feature = "process", -+ feature = "rt-multi-thread", -+ feature = "signal" -+ ) -+))] -+compile_error!("Only features sync,macros,io-util,rt,time are supported on wasm."); -+ - // Includes re-exports used by macros. - // - // This module is not intended to be part of the public API. In general, any -@@ -385,20 +505,25 @@ pub mod io; - pub mod net; - - mod loom; --mod park; - - cfg_process! { - pub mod process; - } - --#[cfg(any(feature = "net", feature = "fs", feature = "io-std"))] -+#[cfg(any( -+ feature = "fs", -+ feature = "io-std", -+ feature = "net", -+ all(windows, feature = "process"), -+))] - mod blocking; - - cfg_rt! { - pub mod runtime; - } -- --pub(crate) mod coop; -+cfg_not_rt! { -+ pub(crate) mod runtime; -+} - - cfg_signal! { - pub mod signal; -@@ -482,14 +607,6 @@ pub(crate) use self::doc::os; - #[allow(unused)] - pub(crate) use std::os; - --#[cfg(docsrs)] --#[allow(unused)] --pub(crate) use self::doc::winapi; -- --#[cfg(all(not(docsrs), windows, feature = "net"))] --#[allow(unused)] --pub(crate) use ::winapi; -- - cfg_macros! { - /// Implementation detail of the `select!` macro. This macro is **not** - /// intended to be used as part of the public API and is permitted to -@@ -540,3 +657,7 @@ cfg_macros! { - #[cfg(feature = "io-util")] - #[cfg(test)] - fn is_unpin() {} -+ -+/// fuzz test (fuzz_linked_list) -+#[cfg(fuzzing)] -+pub mod fuzz; -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/mocked.rs b/KubeOS-Rust/vendor/tokio/src/loom/mocked.rs -index 367d59b4..56dc1a06 100644 ---- a/KubeOS-Rust/vendor/tokio/src/loom/mocked.rs -+++ b/KubeOS-Rust/vendor/tokio/src/loom/mocked.rs -@@ -25,6 +25,13 @@ pub(crate) mod sync { - } - } - pub(crate) use loom::sync::*; -+ -+ pub(crate) mod atomic { -+ pub(crate) use loom::sync::atomic::*; -+ -+ // TODO: implement a loom version -+ pub(crate) type StaticAtomicU64 = std::sync::atomic::AtomicU64; -+ } - } - - pub(crate) mod rand { -@@ -38,3 +45,8 @@ pub(crate) mod sys { - 2 - } - } -+ -+pub(crate) mod thread { -+ pub use loom::lazy_static::AccessError; -+ pub use loom::thread::*; -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_ptr.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_ptr.rs -deleted file mode 100644 -index 236645f0..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_ptr.rs -+++ /dev/null -@@ -1,34 +0,0 @@ --use std::fmt; --use std::ops::{Deref, DerefMut}; -- --/// `AtomicPtr` providing an additional `load_unsync` function. --pub(crate) struct AtomicPtr { -- inner: std::sync::atomic::AtomicPtr, --} -- --impl AtomicPtr { -- pub(crate) fn new(ptr: *mut T) -> AtomicPtr { -- let inner = std::sync::atomic::AtomicPtr::new(ptr); -- AtomicPtr { inner } -- } --} -- --impl Deref for AtomicPtr { -- type Target = std::sync::atomic::AtomicPtr; -- -- fn deref(&self) -> &Self::Target { -- &self.inner -- } --} -- --impl DerefMut for AtomicPtr { -- fn deref_mut(&mut self) -> &mut Self::Target { -- &mut self.inner -- } --} -- --impl fmt::Debug for AtomicPtr { -- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- self.deref().fmt(fmt) -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u16.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u16.rs -index c1c53120..c9e105c1 100644 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u16.rs -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u16.rs -@@ -2,7 +2,7 @@ use std::cell::UnsafeCell; - use std::fmt; - use std::ops::Deref; - --/// `AtomicU16` providing an additional `load_unsync` function. -+/// `AtomicU16` providing an additional `unsync_load` function. - pub(crate) struct AtomicU16 { - inner: UnsafeCell, - } -@@ -23,7 +23,7 @@ impl AtomicU16 { - /// All mutations must have happened before the unsynchronized load. - /// Additionally, there must be no concurrent mutations. - pub(crate) unsafe fn unsync_load(&self) -> u16 { -- *(*self.inner.get()).get_mut() -+ core::ptr::read(self.inner.get() as *const u16) - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u32.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u32.rs -index 61f95fb3..ee0d2d38 100644 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u32.rs -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u32.rs -@@ -2,7 +2,7 @@ use std::cell::UnsafeCell; - use std::fmt; - use std::ops::Deref; - --/// `AtomicU32` providing an additional `load_unsync` function. -+/// `AtomicU32` providing an additional `unsync_load` function. - pub(crate) struct AtomicU32 { - inner: UnsafeCell, - } -@@ -15,6 +15,16 @@ impl AtomicU32 { - let inner = UnsafeCell::new(std::sync::atomic::AtomicU32::new(val)); - AtomicU32 { inner } - } -+ -+ /// Performs an unsynchronized load. -+ /// -+ /// # Safety -+ /// -+ /// All mutations must have happened before the unsynchronized load. -+ /// Additionally, there must be no concurrent mutations. -+ pub(crate) unsafe fn unsync_load(&self) -> u32 { -+ core::ptr::read(self.inner.get() as *const u32) -+ } - } - - impl Deref for AtomicU32 { -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64.rs -index 8ea6bd40..ce391be3 100644 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64.rs -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64.rs -@@ -7,65 +7,13 @@ - // `#[cfg(target_has_atomic = "64")]`. - // Refs: https://github.com/rust-lang/rust/tree/master/src/librustc_target - cfg_has_atomic_u64! { -- pub(crate) use std::sync::atomic::AtomicU64; -+ #[path = "atomic_u64_native.rs"] -+ mod imp; - } - - cfg_not_has_atomic_u64! { -- use crate::loom::sync::Mutex; -- use std::sync::atomic::Ordering; -- -- #[derive(Debug)] -- pub(crate) struct AtomicU64 { -- inner: Mutex, -- } -- -- impl AtomicU64 { -- pub(crate) fn new(val: u64) -> Self { -- Self { -- inner: Mutex::new(val), -- } -- } -- -- pub(crate) fn load(&self, _: Ordering) -> u64 { -- *self.inner.lock() -- } -- -- pub(crate) fn store(&self, val: u64, _: Ordering) { -- *self.inner.lock() = val; -- } -- -- pub(crate) fn fetch_or(&self, val: u64, _: Ordering) -> u64 { -- let mut lock = self.inner.lock(); -- let prev = *lock; -- *lock = prev | val; -- prev -- } -- -- pub(crate) fn compare_exchange( -- &self, -- current: u64, -- new: u64, -- _success: Ordering, -- _failure: Ordering, -- ) -> Result { -- let mut lock = self.inner.lock(); -- -- if *lock == current { -- *lock = new; -- Ok(current) -- } else { -- Err(*lock) -- } -- } -- -- pub(crate) fn compare_exchange_weak( -- &self, -- current: u64, -- new: u64, -- success: Ordering, -- failure: Ordering, -- ) -> Result { -- self.compare_exchange(current, new, success, failure) -- } -- } -+ #[path = "atomic_u64_as_mutex.rs"] -+ mod imp; - } -+ -+pub(crate) use imp::{AtomicU64, StaticAtomicU64}; -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_as_mutex.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_as_mutex.rs -new file mode 100644 -index 00000000..9b3b6fac ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_as_mutex.rs -@@ -0,0 +1,76 @@ -+use crate::loom::sync::Mutex; -+use std::sync::atomic::Ordering; -+ -+cfg_has_const_mutex_new! { -+ #[path = "atomic_u64_static_const_new.rs"] -+ mod static_macro; -+} -+ -+cfg_not_has_const_mutex_new! { -+ #[path = "atomic_u64_static_once_cell.rs"] -+ mod static_macro; -+} -+ -+pub(crate) use static_macro::StaticAtomicU64; -+ -+#[derive(Debug)] -+pub(crate) struct AtomicU64 { -+ inner: Mutex, -+} -+ -+impl AtomicU64 { -+ pub(crate) fn load(&self, _: Ordering) -> u64 { -+ *self.inner.lock() -+ } -+ -+ pub(crate) fn store(&self, val: u64, _: Ordering) { -+ *self.inner.lock() = val; -+ } -+ -+ pub(crate) fn fetch_add(&self, val: u64, _: Ordering) -> u64 { -+ let mut lock = self.inner.lock(); -+ let prev = *lock; -+ *lock = prev + val; -+ prev -+ } -+ -+ pub(crate) fn fetch_or(&self, val: u64, _: Ordering) -> u64 { -+ let mut lock = self.inner.lock(); -+ let prev = *lock; -+ *lock = prev | val; -+ prev -+ } -+ -+ pub(crate) fn compare_exchange( -+ &self, -+ current: u64, -+ new: u64, -+ _success: Ordering, -+ _failure: Ordering, -+ ) -> Result { -+ let mut lock = self.inner.lock(); -+ -+ if *lock == current { -+ *lock = new; -+ Ok(current) -+ } else { -+ Err(*lock) -+ } -+ } -+ -+ pub(crate) fn compare_exchange_weak( -+ &self, -+ current: u64, -+ new: u64, -+ success: Ordering, -+ failure: Ordering, -+ ) -> Result { -+ self.compare_exchange(current, new, success, failure) -+ } -+} -+ -+impl Default for AtomicU64 { -+ fn default() -> AtomicU64 { -+ AtomicU64::new(u64::default()) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_native.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_native.rs -new file mode 100644 -index 00000000..08adb286 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_native.rs -@@ -0,0 +1,4 @@ -+pub(crate) use std::sync::atomic::{AtomicU64, Ordering}; -+ -+/// Alias `AtomicU64` to `StaticAtomicU64` -+pub(crate) type StaticAtomicU64 = AtomicU64; -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_static_const_new.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_static_const_new.rs -new file mode 100644 -index 00000000..a4215342 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_static_const_new.rs -@@ -0,0 +1,12 @@ -+use super::AtomicU64; -+use crate::loom::sync::Mutex; -+ -+pub(crate) type StaticAtomicU64 = AtomicU64; -+ -+impl AtomicU64 { -+ pub(crate) const fn new(val: u64) -> Self { -+ Self { -+ inner: Mutex::const_new(val), -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_static_once_cell.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_static_once_cell.rs -new file mode 100644 -index 00000000..40c6172a ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u64_static_once_cell.rs -@@ -0,0 +1,57 @@ -+use super::AtomicU64; -+use crate::loom::sync::{atomic::Ordering, Mutex}; -+use crate::util::once_cell::OnceCell; -+ -+pub(crate) struct StaticAtomicU64 { -+ init: u64, -+ cell: OnceCell>, -+} -+ -+impl AtomicU64 { -+ pub(crate) fn new(val: u64) -> Self { -+ Self { -+ inner: Mutex::new(val), -+ } -+ } -+} -+ -+impl StaticAtomicU64 { -+ pub(crate) const fn new(val: u64) -> StaticAtomicU64 { -+ StaticAtomicU64 { -+ init: val, -+ cell: OnceCell::new(), -+ } -+ } -+ -+ pub(crate) fn load(&self, order: Ordering) -> u64 { -+ *self.inner().lock() -+ } -+ -+ pub(crate) fn fetch_add(&self, val: u64, order: Ordering) -> u64 { -+ let mut lock = self.inner().lock(); -+ let prev = *lock; -+ *lock = prev + val; -+ prev -+ } -+ -+ pub(crate) fn compare_exchange_weak( -+ &self, -+ current: u64, -+ new: u64, -+ _success: Ordering, -+ _failure: Ordering, -+ ) -> Result { -+ let mut lock = self.inner().lock(); -+ -+ if *lock == current { -+ *lock = new; -+ Ok(current) -+ } else { -+ Err(*lock) -+ } -+ } -+ -+ fn inner(&self) -> &Mutex { -+ self.cell.get(|| Mutex::new(self.init)) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u8.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u8.rs -deleted file mode 100644 -index 408aea33..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_u8.rs -+++ /dev/null -@@ -1,34 +0,0 @@ --use std::cell::UnsafeCell; --use std::fmt; --use std::ops::Deref; -- --/// `AtomicU8` providing an additional `load_unsync` function. --pub(crate) struct AtomicU8 { -- inner: UnsafeCell, --} -- --unsafe impl Send for AtomicU8 {} --unsafe impl Sync for AtomicU8 {} -- --impl AtomicU8 { -- pub(crate) const fn new(val: u8) -> AtomicU8 { -- let inner = UnsafeCell::new(std::sync::atomic::AtomicU8::new(val)); -- AtomicU8 { inner } -- } --} -- --impl Deref for AtomicU8 { -- type Target = std::sync::atomic::AtomicU8; -- -- fn deref(&self) -> &Self::Target { -- // safety: it is always safe to access `&self` fns on the inner value as -- // we never perform unsafe mutations. -- unsafe { &*self.inner.get() } -- } --} -- --impl fmt::Debug for AtomicU8 { -- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- self.deref().fmt(fmt) -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_usize.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_usize.rs -index 0d5f36e4..c5503a2c 100644 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_usize.rs -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/atomic_usize.rs -@@ -2,7 +2,7 @@ use std::cell::UnsafeCell; - use std::fmt; - use std::ops; - --/// `AtomicUsize` providing an additional `load_unsync` function. -+/// `AtomicUsize` providing an additional `unsync_load` function. - pub(crate) struct AtomicUsize { - inner: UnsafeCell, - } -@@ -23,7 +23,7 @@ impl AtomicUsize { - /// All mutations must have happened before the unsynchronized load. - /// Additionally, there must be no concurrent mutations. - pub(crate) unsafe fn unsync_load(&self) -> usize { -- *(*self.inner.get()).get_mut() -+ core::ptr::read(self.inner.get() as *const usize) - } - - pub(crate) fn with_mut(&mut self, f: impl FnOnce(&mut usize) -> R) -> R { -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/mod.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/mod.rs -index 8b6e8bc1..6bd1ad93 100644 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/mod.rs -@@ -1,10 +1,8 @@ - #![cfg_attr(any(not(feature = "full"), loom), allow(unused_imports, dead_code))] - --mod atomic_ptr; - mod atomic_u16; - mod atomic_u32; - mod atomic_u64; --mod atomic_u8; - mod atomic_usize; - mod mutex; - #[cfg(feature = "parking_lot")] -@@ -25,6 +23,10 @@ pub(crate) mod future { - pub(crate) use crate::sync::AtomicWaker; - } - -+pub(crate) mod hint { -+ pub(crate) use std::hint::spin_loop; -+} -+ - pub(crate) mod rand { - use std::collections::hash_map::RandomState; - use std::hash::{BuildHasher, Hash, Hasher}; -@@ -67,24 +69,39 @@ pub(crate) mod sync { - pub(crate) use crate::loom::std::mutex::Mutex; - - pub(crate) mod atomic { -- pub(crate) use crate::loom::std::atomic_ptr::AtomicPtr; - pub(crate) use crate::loom::std::atomic_u16::AtomicU16; - pub(crate) use crate::loom::std::atomic_u32::AtomicU32; -- pub(crate) use crate::loom::std::atomic_u64::AtomicU64; -- pub(crate) use crate::loom::std::atomic_u8::AtomicU8; -+ pub(crate) use crate::loom::std::atomic_u64::{AtomicU64, StaticAtomicU64}; - pub(crate) use crate::loom::std::atomic_usize::AtomicUsize; - -- pub(crate) use std::sync::atomic::{fence, AtomicBool, Ordering}; -- // TODO: once we bump MSRV to 1.49+, use `hint::spin_loop` instead. -- #[allow(deprecated)] -- pub(crate) use std::sync::atomic::spin_loop_hint; -+ pub(crate) use std::sync::atomic::{fence, AtomicBool, AtomicPtr, AtomicU8, Ordering}; - } - } - - pub(crate) mod sys { - #[cfg(feature = "rt-multi-thread")] - pub(crate) fn num_cpus() -> usize { -- usize::max(1, num_cpus::get()) -+ const ENV_WORKER_THREADS: &str = "TOKIO_WORKER_THREADS"; -+ -+ match std::env::var(ENV_WORKER_THREADS) { -+ Ok(s) => { -+ let n = s.parse().unwrap_or_else(|e| { -+ panic!( -+ "\"{}\" must be usize, error: {}, value: {}", -+ ENV_WORKER_THREADS, e, s -+ ) -+ }); -+ assert!(n > 0, "\"{}\" cannot be set to 0", ENV_WORKER_THREADS); -+ n -+ } -+ Err(std::env::VarError::NotPresent) => usize::max(1, num_cpus::get()), -+ Err(std::env::VarError::NotUnicode(e)) => { -+ panic!( -+ "\"{}\" must be valid unicode, error: {:?}", -+ ENV_WORKER_THREADS, e -+ ) -+ } -+ } - } - - #[cfg(not(feature = "rt-multi-thread"))] -@@ -96,14 +113,12 @@ pub(crate) mod sys { - pub(crate) mod thread { - #[inline] - pub(crate) fn yield_now() { -- // TODO: once we bump MSRV to 1.49+, use `hint::spin_loop` instead. -- #[allow(deprecated)] -- std::sync::atomic::spin_loop_hint(); -+ std::hint::spin_loop(); - } - - #[allow(unused_imports)] - pub(crate) use std::thread::{ -- current, panicking, park, park_timeout, sleep, spawn, Builder, JoinHandle, LocalKey, -- Result, Thread, ThreadId, -+ current, panicking, park, park_timeout, sleep, spawn, AccessError, Builder, JoinHandle, -+ LocalKey, Result, Thread, ThreadId, - }; - } -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/mutex.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/mutex.rs -index 3f686e0a..076f7861 100644 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/mutex.rs -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/mutex.rs -@@ -12,6 +12,12 @@ impl Mutex { - Mutex(sync::Mutex::new(t)) - } - -+ #[inline] -+ #[cfg(not(tokio_no_const_mutex_new))] -+ pub(crate) const fn const_new(t: T) -> Mutex { -+ Mutex(sync::Mutex::new(t)) -+ } -+ - #[inline] - pub(crate) fn lock(&self) -> MutexGuard<'_, T> { - match self.0.lock() { -diff --git a/KubeOS-Rust/vendor/tokio/src/loom/std/parking_lot.rs b/KubeOS-Rust/vendor/tokio/src/loom/std/parking_lot.rs -index 8448bed5..e3af258d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/loom/std/parking_lot.rs -+++ b/KubeOS-Rust/vendor/tokio/src/loom/std/parking_lot.rs -@@ -3,83 +3,143 @@ - //! - //! This can be extended to additional types/methods as required. - -+use std::fmt; -+use std::marker::PhantomData; -+use std::ops::{Deref, DerefMut}; - use std::sync::LockResult; - use std::time::Duration; - -+// All types in this file are marked with PhantomData to ensure that -+// parking_lot's send_guard feature does not leak through and affect when Tokio -+// types are Send. -+// -+// See for more info. -+ - // Types that do not need wrapping --pub(crate) use parking_lot::{MutexGuard, RwLockReadGuard, RwLockWriteGuard, WaitTimeoutResult}; -+pub(crate) use parking_lot::WaitTimeoutResult; -+ -+#[derive(Debug)] -+pub(crate) struct Mutex(PhantomData>, parking_lot::Mutex); -+ -+#[derive(Debug)] -+pub(crate) struct RwLock(PhantomData>, parking_lot::RwLock); -+ -+#[derive(Debug)] -+pub(crate) struct Condvar(PhantomData, parking_lot::Condvar); - --/// Adapter for `parking_lot::Mutex` to the `std::sync::Mutex` interface. - #[derive(Debug)] --pub(crate) struct Mutex(parking_lot::Mutex); -+pub(crate) struct MutexGuard<'a, T: ?Sized>( -+ PhantomData>, -+ parking_lot::MutexGuard<'a, T>, -+); - - #[derive(Debug)] --pub(crate) struct RwLock(parking_lot::RwLock); -+pub(crate) struct RwLockReadGuard<'a, T: ?Sized>( -+ PhantomData>, -+ parking_lot::RwLockReadGuard<'a, T>, -+); - --/// Adapter for `parking_lot::Condvar` to the `std::sync::Condvar` interface. - #[derive(Debug)] --pub(crate) struct Condvar(parking_lot::Condvar); -+pub(crate) struct RwLockWriteGuard<'a, T: ?Sized>( -+ PhantomData>, -+ parking_lot::RwLockWriteGuard<'a, T>, -+); - - impl Mutex { - #[inline] - pub(crate) fn new(t: T) -> Mutex { -- Mutex(parking_lot::Mutex::new(t)) -+ Mutex(PhantomData, parking_lot::Mutex::new(t)) - } - - #[inline] -- #[cfg(all(feature = "parking_lot", not(all(loom, test)),))] -+ #[cfg(all(feature = "parking_lot", not(all(loom, test))))] - #[cfg_attr(docsrs, doc(cfg(all(feature = "parking_lot",))))] - pub(crate) const fn const_new(t: T) -> Mutex { -- Mutex(parking_lot::const_mutex(t)) -+ Mutex(PhantomData, parking_lot::const_mutex(t)) - } - - #[inline] - pub(crate) fn lock(&self) -> MutexGuard<'_, T> { -- self.0.lock() -+ MutexGuard(PhantomData, self.1.lock()) - } - - #[inline] - pub(crate) fn try_lock(&self) -> Option> { -- self.0.try_lock() -+ self.1 -+ .try_lock() -+ .map(|guard| MutexGuard(PhantomData, guard)) - } - - #[inline] - pub(crate) fn get_mut(&mut self) -> &mut T { -- self.0.get_mut() -+ self.1.get_mut() - } - - // Note: Additional methods `is_poisoned` and `into_inner`, can be - // provided here as needed. - } - -+impl<'a, T: ?Sized> Deref for MutexGuard<'a, T> { -+ type Target = T; -+ fn deref(&self) -> &T { -+ self.1.deref() -+ } -+} -+ -+impl<'a, T: ?Sized> DerefMut for MutexGuard<'a, T> { -+ fn deref_mut(&mut self) -> &mut T { -+ self.1.deref_mut() -+ } -+} -+ - impl RwLock { - pub(crate) fn new(t: T) -> RwLock { -- RwLock(parking_lot::RwLock::new(t)) -+ RwLock(PhantomData, parking_lot::RwLock::new(t)) - } - - pub(crate) fn read(&self) -> LockResult> { -- Ok(self.0.read()) -+ Ok(RwLockReadGuard(PhantomData, self.1.read())) - } - - pub(crate) fn write(&self) -> LockResult> { -- Ok(self.0.write()) -+ Ok(RwLockWriteGuard(PhantomData, self.1.write())) -+ } -+} -+ -+impl<'a, T: ?Sized> Deref for RwLockReadGuard<'a, T> { -+ type Target = T; -+ fn deref(&self) -> &T { -+ self.1.deref() -+ } -+} -+ -+impl<'a, T: ?Sized> Deref for RwLockWriteGuard<'a, T> { -+ type Target = T; -+ fn deref(&self) -> &T { -+ self.1.deref() -+ } -+} -+ -+impl<'a, T: ?Sized> DerefMut for RwLockWriteGuard<'a, T> { -+ fn deref_mut(&mut self) -> &mut T { -+ self.1.deref_mut() - } - } - - impl Condvar { - #[inline] - pub(crate) fn new() -> Condvar { -- Condvar(parking_lot::Condvar::new()) -+ Condvar(PhantomData, parking_lot::Condvar::new()) - } - - #[inline] - pub(crate) fn notify_one(&self) { -- self.0.notify_one(); -+ self.1.notify_one(); - } - - #[inline] - pub(crate) fn notify_all(&self) { -- self.0.notify_all(); -+ self.1.notify_all(); - } - - #[inline] -@@ -87,7 +147,7 @@ impl Condvar { - &self, - mut guard: MutexGuard<'a, T>, - ) -> LockResult> { -- self.0.wait(&mut guard); -+ self.1.wait(&mut guard.1); - Ok(guard) - } - -@@ -97,10 +157,28 @@ impl Condvar { - mut guard: MutexGuard<'a, T>, - timeout: Duration, - ) -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)> { -- let wtr = self.0.wait_for(&mut guard, timeout); -+ let wtr = self.1.wait_for(&mut guard.1, timeout); - Ok((guard, wtr)) - } - - // Note: Additional methods `wait_timeout_ms`, `wait_timeout_until`, - // `wait_until` can be provided here as needed. - } -+ -+impl<'a, T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'a, T> { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt::Display::fmt(&self.1, f) -+ } -+} -+ -+impl<'a, T: ?Sized + fmt::Display> fmt::Display for RwLockReadGuard<'a, T> { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt::Display::fmt(&self.1, f) -+ } -+} -+ -+impl<'a, T: ?Sized + fmt::Display> fmt::Display for RwLockWriteGuard<'a, T> { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt::Display::fmt(&self.1, f) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/addr_of.rs b/KubeOS-Rust/vendor/tokio/src/macros/addr_of.rs -new file mode 100644 -index 00000000..9d28158f ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/macros/addr_of.rs -@@ -0,0 +1,22 @@ -+//! This module defines a macro that lets you go from a raw pointer to a struct -+//! to a raw pointer to a field of the struct. -+ -+macro_rules! generate_addr_of_methods { -+ ( -+ impl<$($gen:ident)*> $struct_name:ty {$( -+ $(#[$attrs:meta])* -+ $vis:vis unsafe fn $fn_name:ident(self: NonNull) -> NonNull<$field_type:ty> { -+ &self$(.$field_name:tt)+ -+ } -+ )*} -+ ) => { -+ impl<$($gen)*> $struct_name {$( -+ $(#[$attrs])* -+ $vis unsafe fn $fn_name(me: ::core::ptr::NonNull) -> ::core::ptr::NonNull<$field_type> { -+ let me = me.as_ptr(); -+ let field = ::std::ptr::addr_of_mut!((*me) $(.$field_name)+ ); -+ ::core::ptr::NonNull::new_unchecked(field) -+ } -+ )*} -+ }; -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/cfg.rs b/KubeOS-Rust/vendor/tokio/src/macros/cfg.rs -index 606bce76..5c1c5c69 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/cfg.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/cfg.rs -@@ -13,6 +13,18 @@ macro_rules! feature { - } - } - -+/// Enables Windows-specific code. -+/// Use this macro instead of `cfg(windows)` to generate docs properly. -+macro_rules! cfg_windows { -+ ($($item:item)*) => { -+ $( -+ #[cfg(any(all(doc, docsrs), windows))] -+ #[cfg_attr(docsrs, doc(cfg(windows)))] -+ $item -+ )* -+ } -+} -+ - /// Enables enter::block_on. - macro_rules! cfg_block_on { - ($($item:item)*) => { -@@ -61,6 +73,7 @@ macro_rules! cfg_fs { - ($($item:item)*) => { - $( - #[cfg(feature = "fs")] -+ #[cfg(not(tokio_wasi))] - #[cfg_attr(docsrs, doc(cfg(feature = "fs")))] - $item - )* -@@ -69,7 +82,11 @@ macro_rules! cfg_fs { - - macro_rules! cfg_io_blocking { - ($($item:item)*) => { -- $( #[cfg(any(feature = "io-std", feature = "fs"))] $item )* -+ $( #[cfg(any( -+ feature = "io-std", -+ feature = "fs", -+ all(windows, feature = "process"), -+ ))] $item )* - } - } - -@@ -78,12 +95,12 @@ macro_rules! cfg_io_driver { - $( - #[cfg(any( - feature = "net", -- feature = "process", -+ all(unix, feature = "process"), - all(unix, feature = "signal"), - ))] - #[cfg_attr(docsrs, doc(cfg(any( - feature = "net", -- feature = "process", -+ all(unix, feature = "process"), - all(unix, feature = "signal"), - ))))] - $item -@@ -96,10 +113,9 @@ macro_rules! cfg_io_driver_impl { - $( - #[cfg(any( - feature = "net", -- feature = "process", -+ all(unix, feature = "process"), - all(unix, feature = "signal"), - ))] -- #[cfg_attr(docsrs, doc(cfg(all())))] - $item - )* - } -@@ -110,7 +126,7 @@ macro_rules! cfg_not_io_driver { - $( - #[cfg(not(any( - feature = "net", -- feature = "process", -+ all(unix, feature = "process"), - all(unix, feature = "signal"), - )))] - $item -@@ -175,20 +191,38 @@ macro_rules! cfg_macros { - } - } - --macro_rules! cfg_stats { -+macro_rules! cfg_metrics { -+ ($($item:item)*) => { -+ $( -+ // For now, metrics is only disabled in loom tests. -+ // When stabilized, it might have a dedicated feature flag. -+ #[cfg(all(tokio_unstable, not(loom)))] -+ #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))] -+ $item -+ )* -+ } -+} -+ -+macro_rules! cfg_not_metrics { - ($($item:item)*) => { - $( -- #[cfg(all(tokio_unstable, feature = "stats"))] -- #[cfg_attr(docsrs, doc(cfg(feature = "stats")))] -+ #[cfg(not(all(tokio_unstable, not(loom))))] - $item - )* - } - } - --macro_rules! cfg_not_stats { -+macro_rules! cfg_not_rt_and_metrics_and_net { -+ ($($item:item)*) => { -+ $( #[cfg(not(all(feature = "net", feature = "rt", all(tokio_unstable, not(loom)))))]$item )* -+ } -+} -+ -+macro_rules! cfg_net_or_process { - ($($item:item)*) => { - $( -- #[cfg(not(all(tokio_unstable, feature = "stats")))] -+ #[cfg(any(feature = "net", feature = "process"))] -+ #[cfg_attr(docsrs, doc(cfg(any(feature = "net", feature = "process"))))] - $item - )* - } -@@ -230,6 +264,7 @@ macro_rules! cfg_process { - #[cfg(feature = "process")] - #[cfg_attr(docsrs, doc(cfg(feature = "process")))] - #[cfg(not(loom))] -+ #[cfg(not(tokio_wasi))] - $item - )* - } -@@ -258,6 +293,7 @@ macro_rules! cfg_signal { - #[cfg(feature = "signal")] - #[cfg_attr(docsrs, doc(cfg(feature = "signal")))] - #[cfg(not(loom))] -+ #[cfg(not(tokio_wasi))] - $item - )* - } -@@ -273,6 +309,13 @@ macro_rules! cfg_signal_internal { - } - } - -+macro_rules! cfg_signal_internal_and_unix { -+ ($($item:item)*) => { -+ #[cfg(unix)] -+ cfg_signal_internal! { $($item)* } -+ } -+} -+ - macro_rules! cfg_not_signal_internal { - ($($item:item)*) => { - $( -@@ -317,7 +360,7 @@ macro_rules! cfg_not_rt { - macro_rules! cfg_rt_multi_thread { - ($($item:item)*) => { - $( -- #[cfg(feature = "rt-multi-thread")] -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] - #[cfg_attr(docsrs, doc(cfg(feature = "rt-multi-thread")))] - $item - )* -@@ -366,10 +409,20 @@ macro_rules! cfg_trace { - ($($item:item)*) => { - $( - #[cfg(all(tokio_unstable, feature = "tracing"))] -- #[cfg_attr(docsrs, doc(cfg(feature = "tracing")))] -+ #[cfg_attr(docsrs, doc(cfg(all(tokio_unstable, feature = "tracing"))))] - $item - )* -- } -+ }; -+} -+ -+macro_rules! cfg_unstable { -+ ($($item:item)*) => { -+ $( -+ #[cfg(tokio_unstable)] -+ #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))] -+ $item -+ )* -+ }; - } - - macro_rules! cfg_not_trace { -@@ -420,12 +473,14 @@ macro_rules! cfg_not_coop { - macro_rules! cfg_has_atomic_u64 { - ($($item:item)*) => { - $( -- #[cfg(not(any( -- target_arch = "arm", -- target_arch = "mips", -- target_arch = "powerpc", -- target_arch = "riscv32" -- )))] -+ #[cfg_attr( -+ not(tokio_no_target_has_atomic), -+ cfg(all(target_has_atomic = "64", not(tokio_no_atomic_u64)) -+ ))] -+ #[cfg_attr( -+ tokio_no_target_has_atomic, -+ cfg(not(tokio_no_atomic_u64)) -+ )] - $item - )* - } -@@ -434,12 +489,62 @@ macro_rules! cfg_has_atomic_u64 { - macro_rules! cfg_not_has_atomic_u64 { - ($($item:item)*) => { - $( -- #[cfg(any( -- target_arch = "arm", -- target_arch = "mips", -- target_arch = "powerpc", -- target_arch = "riscv32" -- ))] -+ #[cfg_attr( -+ not(tokio_no_target_has_atomic), -+ cfg(any(not(target_has_atomic = "64"), tokio_no_atomic_u64) -+ ))] -+ #[cfg_attr( -+ tokio_no_target_has_atomic, -+ cfg(tokio_no_atomic_u64) -+ )] -+ $item -+ )* -+ } -+} -+ -+macro_rules! cfg_has_const_mutex_new { -+ ($($item:item)*) => { -+ $( -+ #[cfg(all( -+ not(all(loom, test)), -+ any( -+ feature = "parking_lot", -+ not(tokio_no_const_mutex_new) -+ ) -+ ))] -+ $item -+ )* -+ } -+} -+ -+macro_rules! cfg_not_has_const_mutex_new { -+ ($($item:item)*) => { -+ $( -+ #[cfg(not(all( -+ not(all(loom, test)), -+ any( -+ feature = "parking_lot", -+ not(tokio_no_const_mutex_new) -+ ) -+ )))] -+ $item -+ )* -+ } -+} -+ -+macro_rules! cfg_not_wasi { -+ ($($item:item)*) => { -+ $( -+ #[cfg(not(tokio_wasi))] -+ $item -+ )* -+ } -+} -+ -+macro_rules! cfg_is_wasm_not_wasi { -+ ($($item:item)*) => { -+ $( -+ #[cfg(tokio_wasm_not_wasi)] - $item - )* - } -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/join.rs b/KubeOS-Rust/vendor/tokio/src/macros/join.rs -index f91b5f19..8a019860 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/join.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/join.rs -@@ -12,7 +12,7 @@ - /// for **all** branches complete regardless if any complete with `Err`. Use - /// [`try_join!`] to return early when `Err` is encountered. - /// --/// [`try_join!`]: macro@try_join -+/// [`try_join!`]: crate::try_join - /// - /// # Notes - /// -@@ -60,6 +60,9 @@ macro_rules! join { - // normalization is complete. - ( $($count:tt)* ) - -+ // The expression `0+1+1+ ... +1` equal to the number of branches. -+ ( $($total:tt)* ) -+ - // Normalized join! branches - $( ( $($skip:tt)* ) $e:expr, )* - -@@ -69,24 +72,66 @@ macro_rules! join { - - // Safety: nothing must be moved out of `futures`. This is to satisfy - // the requirement of `Pin::new_unchecked` called below. -+ // -+ // We can't use the `pin!` macro for this because `futures` is a tuple -+ // and the standard library provides no way to pin-project to the fields -+ // of a tuple. - let mut futures = ( $( maybe_done($e), )* ); - -+ // This assignment makes sure that the `poll_fn` closure only has a -+ // reference to the futures, instead of taking ownership of them. This -+ // mitigates the issue described in -+ // -+ let mut futures = &mut futures; -+ -+ // Each time the future created by poll_fn is polled, a different future will be polled first -+ // to ensure every future passed to join! gets a chance to make progress even if -+ // one of the futures consumes the whole budget. -+ // -+ // This is number of futures that will be skipped in the first loop -+ // iteration the next time. -+ let mut skip_next_time: u32 = 0; -+ - poll_fn(move |cx| { -+ const COUNT: u32 = $($total)*; -+ - let mut is_pending = false; - -+ let mut to_run = COUNT; -+ -+ // The number of futures that will be skipped in the first loop iteration. -+ let mut skip = skip_next_time; -+ -+ skip_next_time = if skip + 1 == COUNT { 0 } else { skip + 1 }; -+ -+ // This loop runs twice and the first `skip` futures -+ // are not polled in the first iteration. -+ loop { - $( -- // Extract the future for this branch from the tuple. -- let ( $($skip,)* fut, .. ) = &mut futures; -+ if skip == 0 { -+ if to_run == 0 { -+ // Every future has been polled -+ break; -+ } -+ to_run -= 1; - -- // Safety: future is stored on the stack above -- // and never moved. -- let mut fut = unsafe { Pin::new_unchecked(fut) }; -+ // Extract the future for this branch from the tuple. -+ let ( $($skip,)* fut, .. ) = &mut *futures; - -- // Try polling -- if fut.poll(cx).is_pending() { -- is_pending = true; -+ // Safety: future is stored on the stack above -+ // and never moved. -+ let mut fut = unsafe { Pin::new_unchecked(fut) }; -+ -+ // Try polling -+ if fut.poll(cx).is_pending() { -+ is_pending = true; -+ } -+ } else { -+ // Future skipped, one less future to skip in the next iteration -+ skip -= 1; - } - )* -+ } - - if is_pending { - Pending -@@ -107,13 +152,15 @@ macro_rules! join { - - // ===== Normalize ===== - -- (@ { ( $($s:tt)* ) $($t:tt)* } $e:expr, $($r:tt)* ) => { -- $crate::join!(@{ ($($s)* _) $($t)* ($($s)*) $e, } $($r)*) -+ (@ { ( $($s:tt)* ) ( $($n:tt)* ) $($t:tt)* } $e:expr, $($r:tt)* ) => { -+ $crate::join!(@{ ($($s)* _) ($($n)* + 1) $($t)* ($($s)*) $e, } $($r)*) - }; - - // ===== Entry point ===== - -- ( $($e:expr),* $(,)?) => { -- $crate::join!(@{ () } $($e,)*) -+ ( $($e:expr),+ $(,)?) => { -+ $crate::join!(@{ () (0) } $($e,)*) - }; -+ -+ () => { async {}.await } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/mod.rs b/KubeOS-Rust/vendor/tokio/src/macros/mod.rs -index a1839c83..57678c67 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/mod.rs -@@ -15,6 +15,9 @@ mod ready; - #[macro_use] - mod thread_local; - -+#[macro_use] -+mod addr_of; -+ - cfg_trace! { - #[macro_use] - mod trace; -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/scoped_tls.rs b/KubeOS-Rust/vendor/tokio/src/macros/scoped_tls.rs -index f2504cba..ed74b32d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/scoped_tls.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/scoped_tls.rs -@@ -10,7 +10,7 @@ macro_rules! scoped_thread_local { - $vis static $name: $crate::macros::scoped_tls::ScopedKey<$ty> - = $crate::macros::scoped_tls::ScopedKey { - inner: { -- thread_local!(static FOO: ::std::cell::Cell<*const ()> = { -+ tokio_thread_local!(static FOO: ::std::cell::Cell<*const ()> = const { - std::cell::Cell::new(::std::ptr::null()) - }); - &FOO -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/select.rs b/KubeOS-Rust/vendor/tokio/src/macros/select.rs -index 051f8cb7..31c9b3ac 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/select.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/select.rs -@@ -101,6 +101,7 @@ - /// * [`tokio::sync::watch::Receiver::changed`](crate::sync::watch::Receiver::changed) - /// * [`tokio::net::TcpListener::accept`](crate::net::TcpListener::accept) - /// * [`tokio::net::UnixListener::accept`](crate::net::UnixListener::accept) -+/// * [`tokio::signal::unix::Signal::recv`](crate::signal::unix::Signal::recv) - /// * [`tokio::io::AsyncReadExt::read`](crate::io::AsyncReadExt::read) on any `AsyncRead` - /// * [`tokio::io::AsyncReadExt::read_buf`](crate::io::AsyncReadExt::read_buf) on any `AsyncRead` - /// * [`tokio::io::AsyncWriteExt::write`](crate::io::AsyncWriteExt::write) on any `AsyncWrite` -@@ -130,6 +131,13 @@ - /// correctly even if it is restarted while waiting at an `.await`, then it is - /// cancellation safe. - /// -+/// Cancellation safety can be defined in the following way: If you have a -+/// future that has not yet completed, then it must be a no-op to drop that -+/// future and recreate it. This definition is motivated by the situation where -+/// a `select!` is used in a loop. Without this guarantee, you would lose your -+/// progress when another branch completes and you restart the `select!` by -+/// going around the loop. -+/// - /// Be aware that cancelling something that is not cancellation safe is not - /// necessarily wrong. For example, if you are cancelling a task because the - /// application is shutting down, then you probably don't care that partially -@@ -429,7 +437,8 @@ macro_rules! select { - // - // This module is defined within a scope and should not leak out of this - // macro. -- mod util { -+ #[doc(hidden)] -+ mod __tokio_select_util { - // Generate an enum with one variant per select branch - $crate::select_priv_declare_output_enum!( ( $($count)* ) ); - } -@@ -442,13 +451,13 @@ macro_rules! select { - - const BRANCHES: u32 = $crate::count!( $($count)* ); - -- let mut disabled: util::Mask = Default::default(); -+ let mut disabled: __tokio_select_util::Mask = Default::default(); - - // First, invoke all the pre-conditions. For any that return true, - // set the appropriate bit in `disabled`. - $( - if !$c { -- let mask: util::Mask = 1 << $crate::count!( $($skip)* ); -+ let mask: __tokio_select_util::Mask = 1 << $crate::count!( $($skip)* ); - disabled |= mask; - } - )* -@@ -458,8 +467,18 @@ macro_rules! select { - let mut output = { - // Safety: Nothing must be moved out of `futures`. This is to - // satisfy the requirement of `Pin::new_unchecked` called below. -+ // -+ // We can't use the `pin!` macro for this because `futures` is a -+ // tuple and the standard library provides no way to pin-project to -+ // the fields of a tuple. - let mut futures = ( $( $fut , )+ ); - -+ // This assignment makes sure that the `poll_fn` closure only has a -+ // reference to the futures, instead of taking ownership of them. -+ // This mitigates the issue described in -+ // -+ let mut futures = &mut futures; -+ - $crate::macros::support::poll_fn(|cx| { - // Track if any branch returns pending. If no branch completes - // **or** returns pending, this implies that all branches are -@@ -495,7 +514,7 @@ macro_rules! select { - - // Extract the future for this branch from the - // tuple -- let ( $($skip,)* fut, .. ) = &mut futures; -+ let ( $($skip,)* fut, .. ) = &mut *futures; - - // Safety: future is stored on the stack above - // and never moved. -@@ -525,7 +544,7 @@ macro_rules! select { - } - - // The select is complete, return the value -- return Ready($crate::select_variant!(util::Out, ($($skip)*))(out)); -+ return Ready($crate::select_variant!(__tokio_select_util::Out, ($($skip)*))(out)); - } - )* - _ => unreachable!("reaching this means there probably is an off by one bug"), -@@ -536,16 +555,16 @@ macro_rules! select { - Pending - } else { - // All branches have been disabled. -- Ready(util::Out::Disabled) -+ Ready(__tokio_select_util::Out::Disabled) - } - }).await - }; - - match output { - $( -- $crate::select_variant!(util::Out, ($($skip)*) ($bind)) => $handle, -+ $crate::select_variant!(__tokio_select_util::Out, ($($skip)*) ($bind)) => $handle, - )* -- util::Out::Disabled => $else, -+ __tokio_select_util::Out::Disabled => $else, - _ => unreachable!("failed to match bind"), - } - }}; -@@ -801,6 +820,9 @@ macro_rules! count { - (_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) => { - 63 - }; -+ (_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _) => { -+ 64 -+ }; - } - - #[macro_export] -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/support.rs b/KubeOS-Rust/vendor/tokio/src/macros/support.rs -index 7f11bc68..10526bcb 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/support.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/support.rs -@@ -1,7 +1,11 @@ - cfg_macros! { - pub use crate::future::poll_fn; - pub use crate::future::maybe_done::maybe_done; -- pub use crate::util::thread_rng_n; -+ -+ #[doc(hidden)] -+ pub fn thread_rng_n(n: u32) -> u32 { -+ crate::runtime::context::thread_rng_n(n) -+ } - } - - pub use std::future::Future; -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/thread_local.rs b/KubeOS-Rust/vendor/tokio/src/macros/thread_local.rs -index d8489473..74be99ab 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/thread_local.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/thread_local.rs -@@ -1,4 +1,32 @@ - #[cfg(all(loom, test))] --macro_rules! thread_local { -+macro_rules! tokio_thread_local { -+ ($(#[$attrs:meta])* $vis:vis static $name:ident: $ty:ty = const { $expr:expr } $(;)?) => { -+ loom::thread_local! { -+ $(#[$attrs])* -+ $vis static $name: $ty = $expr; -+ } -+ }; -+ - ($($tts:tt)+) => { loom::thread_local!{ $($tts)+ } } - } -+ -+#[cfg(not(tokio_no_const_thread_local))] -+#[cfg(not(all(loom, test)))] -+macro_rules! tokio_thread_local { -+ ($($tts:tt)+) => { -+ ::std::thread_local!{ $($tts)+ } -+ } -+} -+ -+#[cfg(tokio_no_const_thread_local)] -+#[cfg(not(all(loom, test)))] -+macro_rules! tokio_thread_local { -+ ($(#[$attrs:meta])* $vis:vis static $name:ident: $ty:ty = const { $expr:expr } $(;)?) => { -+ ::std::thread_local! { -+ $(#[$attrs])* -+ $vis static $name: $ty = $expr; -+ } -+ }; -+ -+ ($($tts:tt)+) => { ::std::thread_local!{ $($tts)+ } } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/trace.rs b/KubeOS-Rust/vendor/tokio/src/macros/trace.rs -index 31dde2f2..80a257e1 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/trace.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/trace.rs -@@ -1,9 +1,8 @@ - cfg_trace! { - macro_rules! trace_op { -- ($name:literal, $readiness:literal, $parent:expr) => { -+ ($name:expr, $readiness:literal) => { - tracing::trace!( - target: "runtime::resource::poll_op", -- parent: $parent, - op_name = $name, - is_ready = $readiness - ); -@@ -11,14 +10,14 @@ cfg_trace! { - } - - macro_rules! trace_poll_op { -- ($name:literal, $poll:expr, $parent:expr $(,)*) => { -+ ($name:expr, $poll:expr $(,)*) => { - match $poll { - std::task::Poll::Ready(t) => { -- trace_op!($name, true, $parent); -+ trace_op!($name, true); - std::task::Poll::Ready(t) - } - std::task::Poll::Pending => { -- trace_op!($name, false, $parent); -+ trace_op!($name, false); - return std::task::Poll::Pending; - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/macros/try_join.rs b/KubeOS-Rust/vendor/tokio/src/macros/try_join.rs -index 6d3a893b..7b123709 100644 ---- a/KubeOS-Rust/vendor/tokio/src/macros/try_join.rs -+++ b/KubeOS-Rust/vendor/tokio/src/macros/try_join.rs -@@ -106,6 +106,9 @@ macro_rules! try_join { - // normalization is complete. - ( $($count:tt)* ) - -+ // The expression `0+1+1+ ... +1` equal to the number of branches. -+ ( $($total:tt)* ) -+ - // Normalized try_join! branches - $( ( $($skip:tt)* ) $e:expr, )* - -@@ -115,26 +118,68 @@ macro_rules! try_join { - - // Safety: nothing must be moved out of `futures`. This is to satisfy - // the requirement of `Pin::new_unchecked` called below. -+ // -+ // We can't use the `pin!` macro for this because `futures` is a tuple -+ // and the standard library provides no way to pin-project to the fields -+ // of a tuple. - let mut futures = ( $( maybe_done($e), )* ); - -+ // This assignment makes sure that the `poll_fn` closure only has a -+ // reference to the futures, instead of taking ownership of them. This -+ // mitigates the issue described in -+ // -+ let mut futures = &mut futures; -+ -+ // Each time the future created by poll_fn is polled, a different future will be polled first -+ // to ensure every future passed to join! gets a chance to make progress even if -+ // one of the futures consumes the whole budget. -+ // -+ // This is number of futures that will be skipped in the first loop -+ // iteration the next time. -+ let mut skip_next_time: u32 = 0; -+ - poll_fn(move |cx| { -+ const COUNT: u32 = $($total)*; -+ - let mut is_pending = false; - -+ let mut to_run = COUNT; -+ -+ // The number of futures that will be skipped in the first loop iteration -+ let mut skip = skip_next_time; -+ -+ skip_next_time = if skip + 1 == COUNT { 0 } else { skip + 1 }; -+ -+ // This loop runs twice and the first `skip` futures -+ // are not polled in the first iteration. -+ loop { - $( -- // Extract the future for this branch from the tuple. -- let ( $($skip,)* fut, .. ) = &mut futures; -- -- // Safety: future is stored on the stack above -- // and never moved. -- let mut fut = unsafe { Pin::new_unchecked(fut) }; -- -- // Try polling -- if fut.as_mut().poll(cx).is_pending() { -- is_pending = true; -- } else if fut.as_mut().output_mut().expect("expected completed future").is_err() { -- return Ready(Err(fut.take_output().expect("expected completed future").err().unwrap())) -+ if skip == 0 { -+ if to_run == 0 { -+ // Every future has been polled -+ break; -+ } -+ to_run -= 1; -+ -+ // Extract the future for this branch from the tuple. -+ let ( $($skip,)* fut, .. ) = &mut *futures; -+ -+ // Safety: future is stored on the stack above -+ // and never moved. -+ let mut fut = unsafe { Pin::new_unchecked(fut) }; -+ -+ // Try polling -+ if fut.as_mut().poll(cx).is_pending() { -+ is_pending = true; -+ } else if fut.as_mut().output_mut().expect("expected completed future").is_err() { -+ return Ready(Err(fut.take_output().expect("expected completed future").err().unwrap())) -+ } -+ } else { -+ // Future skipped, one less future to skip in the next iteration -+ skip -= 1; - } - )* -+ } - - if is_pending { - Pending -@@ -159,13 +204,15 @@ macro_rules! try_join { - - // ===== Normalize ===== - -- (@ { ( $($s:tt)* ) $($t:tt)* } $e:expr, $($r:tt)* ) => { -- $crate::try_join!(@{ ($($s)* _) $($t)* ($($s)*) $e, } $($r)*) -+ (@ { ( $($s:tt)* ) ( $($n:tt)* ) $($t:tt)* } $e:expr, $($r:tt)* ) => { -+ $crate::try_join!(@{ ($($s)* _) ($($n)* + 1) $($t)* ($($s)*) $e, } $($r)*) - }; - - // ===== Entry point ===== - -- ( $($e:expr),* $(,)?) => { -- $crate::try_join!(@{ () } $($e,)*) -+ ( $($e:expr),+ $(,)?) => { -+ $crate::try_join!(@{ () (0) } $($e,)*) - }; -+ -+ () => { async { Ok(()) }.await } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/net/addr.rs b/KubeOS-Rust/vendor/tokio/src/net/addr.rs -index ec4fa198..fb8248fb 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/addr.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/addr.rs -@@ -1,5 +1,4 @@ --use crate::future; -- -+use std::future; - use std::io; - use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6}; - -@@ -56,7 +55,7 @@ impl sealed::ToSocketAddrsPriv for SocketAddr { - - fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future { - let iter = Some(*self).into_iter(); -- future::ok(iter) -+ future::ready(Ok(iter)) - } - } - -@@ -96,7 +95,7 @@ impl sealed::ToSocketAddrsPriv for (IpAddr, u16) { - - fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future { - let iter = Some(SocketAddr::from(*self)).into_iter(); -- future::ok(iter) -+ future::ready(Ok(iter)) - } - } - -@@ -137,8 +136,23 @@ impl sealed::ToSocketAddrsPriv for &[SocketAddr] { - type Future = ReadyFuture; - - fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future { -- let iter = self.to_vec().into_iter(); -- future::ok(iter) -+ #[inline] -+ fn slice_to_vec(addrs: &[SocketAddr]) -> Vec { -+ addrs.to_vec() -+ } -+ -+ // This uses a helper method because clippy doesn't like the `to_vec()` -+ // call here (it will allocate, whereas `self.iter().copied()` would -+ // not), but it's actually necessary in order to ensure that the -+ // returned iterator is valid for the `'static` lifetime, which the -+ // borrowed `slice::Iter` iterator would not be. -+ // -+ // Note that we can't actually add an `allow` attribute for -+ // `clippy::unnecessary_to_owned` here, as Tokio's CI runs clippy lints -+ // on Rust 1.52 to avoid breaking LTS releases of Tokio. Users of newer -+ // Rust versions who see this lint should just ignore it. -+ let iter = slice_to_vec(self).into_iter(); -+ future::ready(Ok(iter)) - } - } - -@@ -230,7 +244,7 @@ cfg_net! { - type Future = ::Future; - - fn to_socket_addrs(&self, _: sealed::Internal) -> Self::Future { -- (&self[..]).to_socket_addrs(sealed::Internal) -+ self[..].to_socket_addrs(sealed::Internal) - } - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/net/mod.rs b/KubeOS-Rust/vendor/tokio/src/net/mod.rs -index 0b8c1ecd..2d317a8a 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/mod.rs -@@ -23,8 +23,10 @@ - //! [`UnixDatagram`]: UnixDatagram - - mod addr; --#[cfg(feature = "net")] --pub(crate) use addr::to_socket_addrs; -+cfg_not_wasi! { -+ #[cfg(feature = "net")] -+ pub(crate) use addr::to_socket_addrs; -+} - pub use addr::ToSocketAddrs; - - cfg_net! { -@@ -33,11 +35,13 @@ cfg_net! { - - pub mod tcp; - pub use tcp::listener::TcpListener; -- pub use tcp::socket::TcpSocket; - pub use tcp::stream::TcpStream; -+ cfg_not_wasi! { -+ pub use tcp::socket::TcpSocket; - -- mod udp; -- pub use udp::UdpSocket; -+ mod udp; -+ pub use udp::UdpSocket; -+ } - } - - cfg_net_unix! { -diff --git a/KubeOS-Rust/vendor/tokio/src/net/tcp/listener.rs b/KubeOS-Rust/vendor/tokio/src/net/tcp/listener.rs -index 8aecb21a..34e393c8 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/tcp/listener.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/tcp/listener.rs -@@ -1,8 +1,10 @@ - use crate::io::{Interest, PollEvented}; - use crate::net::tcp::TcpStream; --use crate::net::{to_socket_addrs, ToSocketAddrs}; - --use std::convert::TryFrom; -+cfg_not_wasi! { -+ use crate::net::{to_socket_addrs, ToSocketAddrs}; -+} -+ - use std::fmt; - use std::io; - use std::net::{self, SocketAddr}; -@@ -55,68 +57,70 @@ cfg_net! { - } - - impl TcpListener { -- /// Creates a new TcpListener, which will be bound to the specified address. -- /// -- /// The returned listener is ready for accepting connections. -- /// -- /// Binding with a port number of 0 will request that the OS assigns a port -- /// to this listener. The port allocated can be queried via the `local_addr` -- /// method. -- /// -- /// The address type can be any implementor of the [`ToSocketAddrs`] trait. -- /// If `addr` yields multiple addresses, bind will be attempted with each of -- /// the addresses until one succeeds and returns the listener. If none of -- /// the addresses succeed in creating a listener, the error returned from -- /// the last attempt (the last address) is returned. -- /// -- /// This function sets the `SO_REUSEADDR` option on the socket. -- /// -- /// To configure the socket before binding, you can use the [`TcpSocket`] -- /// type. -- /// -- /// [`ToSocketAddrs`]: trait@crate::net::ToSocketAddrs -- /// [`TcpSocket`]: struct@crate::net::TcpSocket -- /// -- /// # Examples -- /// -- /// ```no_run -- /// use tokio::net::TcpListener; -- /// -- /// use std::io; -- /// -- /// #[tokio::main] -- /// async fn main() -> io::Result<()> { -- /// let listener = TcpListener::bind("127.0.0.1:2345").await?; -- /// -- /// // use the listener -- /// -- /// # let _ = listener; -- /// Ok(()) -- /// } -- /// ``` -- pub async fn bind(addr: A) -> io::Result { -- let addrs = to_socket_addrs(addr).await?; -+ cfg_not_wasi! { -+ /// Creates a new TcpListener, which will be bound to the specified address. -+ /// -+ /// The returned listener is ready for accepting connections. -+ /// -+ /// Binding with a port number of 0 will request that the OS assigns a port -+ /// to this listener. The port allocated can be queried via the `local_addr` -+ /// method. -+ /// -+ /// The address type can be any implementor of the [`ToSocketAddrs`] trait. -+ /// If `addr` yields multiple addresses, bind will be attempted with each of -+ /// the addresses until one succeeds and returns the listener. If none of -+ /// the addresses succeed in creating a listener, the error returned from -+ /// the last attempt (the last address) is returned. -+ /// -+ /// This function sets the `SO_REUSEADDR` option on the socket. -+ /// -+ /// To configure the socket before binding, you can use the [`TcpSocket`] -+ /// type. -+ /// -+ /// [`ToSocketAddrs`]: trait@crate::net::ToSocketAddrs -+ /// [`TcpSocket`]: struct@crate::net::TcpSocket -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::TcpListener; -+ /// -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// let listener = TcpListener::bind("127.0.0.1:2345").await?; -+ /// -+ /// // use the listener -+ /// -+ /// # let _ = listener; -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub async fn bind(addr: A) -> io::Result { -+ let addrs = to_socket_addrs(addr).await?; - -- let mut last_err = None; -+ let mut last_err = None; - -- for addr in addrs { -- match TcpListener::bind_addr(addr) { -- Ok(listener) => return Ok(listener), -- Err(e) => last_err = Some(e), -+ for addr in addrs { -+ match TcpListener::bind_addr(addr) { -+ Ok(listener) => return Ok(listener), -+ Err(e) => last_err = Some(e), -+ } - } -- } - -- Err(last_err.unwrap_or_else(|| { -- io::Error::new( -- io::ErrorKind::InvalidInput, -- "could not resolve to any address", -- ) -- })) -- } -+ Err(last_err.unwrap_or_else(|| { -+ io::Error::new( -+ io::ErrorKind::InvalidInput, -+ "could not resolve to any address", -+ ) -+ })) -+ } - -- fn bind_addr(addr: SocketAddr) -> io::Result { -- let listener = mio::net::TcpListener::bind(addr)?; -- TcpListener::new(listener) -+ fn bind_addr(addr: SocketAddr) -> io::Result { -+ let listener = mio::net::TcpListener::bind(addr)?; -+ TcpListener::new(listener) -+ } - } - - /// Accepts a new incoming connection from this listener. -@@ -190,15 +194,22 @@ impl TcpListener { - /// Creates new `TcpListener` from a `std::net::TcpListener`. - /// - /// This function is intended to be used to wrap a TCP listener from the -- /// standard library in the Tokio equivalent. The conversion assumes nothing -- /// about the underlying listener; it is left up to the user to set it in -- /// non-blocking mode. -+ /// standard library in the Tokio equivalent. - /// - /// This API is typically paired with the `socket2` crate and the `Socket` - /// type to build up and customize a listener before it's shipped off to the - /// backing event loop. This allows configuration of options like - /// `SO_REUSEPORT`, binding to multiple addresses, etc. - /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the listener is in -+ /// non-blocking mode. Otherwise all I/O operations on the listener -+ /// will block the thread, which will cause unexpected behavior. -+ /// Non-blocking mode can be set using [`set_nonblocking`]. -+ /// -+ /// [`set_nonblocking`]: std::net::TcpListener::set_nonblocking -+ /// - /// # Examples - /// - /// ```rust,no_run -@@ -216,11 +227,13 @@ impl TcpListener { - /// - /// # Panics - /// -- /// This function panics if thread-local runtime is not set. -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. - /// - /// The runtime is usually set implicitly when this function is called - /// from a future driven by a tokio runtime, otherwise runtime can be set - /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ #[track_caller] - pub fn from_std(listener: net::TcpListener) -> io::Result { - let io = mio::net::TcpListener::from_std(listener); - let io = PollEvented::new(io)?; -@@ -267,11 +280,22 @@ impl TcpListener { - .map(|io| io.into_raw_socket()) - .map(|raw_socket| unsafe { std::net::TcpListener::from_raw_socket(raw_socket) }) - } -+ -+ #[cfg(tokio_wasi)] -+ { -+ use std::os::wasi::io::{FromRawFd, IntoRawFd}; -+ self.io -+ .into_inner() -+ .map(|io| io.into_raw_fd()) -+ .map(|raw_fd| unsafe { std::net::TcpListener::from_raw_fd(raw_fd) }) -+ } - } - -- pub(crate) fn new(listener: mio::net::TcpListener) -> io::Result { -- let io = PollEvented::new(listener)?; -- Ok(TcpListener { io }) -+ cfg_not_wasi! { -+ pub(crate) fn new(listener: mio::net::TcpListener) -> io::Result { -+ let io = PollEvented::new(listener)?; -+ Ok(TcpListener { io }) -+ } - } - - /// Returns the local address that this listener is bound to. -@@ -382,16 +406,51 @@ mod sys { - self.io.as_raw_fd() - } - } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for TcpListener { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+ } - } - --#[cfg(windows)] --mod sys { -- use super::TcpListener; -- use std::os::windows::prelude::*; -+cfg_unstable! { -+ #[cfg(tokio_wasi)] -+ mod sys { -+ use super::TcpListener; -+ use std::os::wasi::prelude::*; -+ -+ impl AsRawFd for TcpListener { -+ fn as_raw_fd(&self) -> RawFd { -+ self.io.as_raw_fd() -+ } -+ } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for TcpListener { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+ } -+ } -+} -+ -+cfg_windows! { -+ use crate::os::windows::io::{AsRawSocket, RawSocket}; -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsSocket, BorrowedSocket}; - - impl AsRawSocket for TcpListener { - fn as_raw_socket(&self) -> RawSocket { - self.io.as_raw_socket() - } - } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsSocket for TcpListener { -+ fn as_socket(&self) -> BorrowedSocket<'_> { -+ unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) } -+ } -+ } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/net/tcp/mod.rs b/KubeOS-Rust/vendor/tokio/src/net/tcp/mod.rs -index cb8a8b23..734eabe6 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/tcp/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/tcp/mod.rs -@@ -2,7 +2,9 @@ - - pub(crate) mod listener; - --pub(crate) mod socket; -+cfg_not_wasi! { -+ pub(crate) mod socket; -+} - - mod split; - pub use split::{ReadHalf, WriteHalf}; -diff --git a/KubeOS-Rust/vendor/tokio/src/net/tcp/socket.rs b/KubeOS-Rust/vendor/tokio/src/net/tcp/socket.rs -index f54ff958..1c36d3a8 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/tcp/socket.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/tcp/socket.rs -@@ -4,10 +4,17 @@ use std::fmt; - use std::io; - use std::net::SocketAddr; - -+#[cfg(all(unix, not(tokio_no_as_fd)))] -+use std::os::unix::io::{AsFd, BorrowedFd}; - #[cfg(unix)] - use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; --#[cfg(windows)] --use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket}; -+use std::time::Duration; -+ -+cfg_windows! { -+ use crate::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket}; -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsSocket, BorrowedSocket}; -+} - - cfg_net! { - /// A TCP socket that has not yet been converted to a `TcpStream` or -@@ -81,8 +88,9 @@ cfg_net! { - /// [`AsRawFd`]: https://doc.rust-lang.org/std/os/unix/io/trait.AsRawFd.html - /// [`AsRawSocket`]: https://doc.rust-lang.org/std/os/windows/io/trait.AsRawSocket.html - /// [`socket2`]: https://docs.rs/socket2/ -+ #[cfg_attr(docsrs, doc(alias = "connect_std"))] - pub struct TcpSocket { -- inner: mio::net::TcpSocket, -+ inner: socket2::Socket, - } - } - -@@ -117,8 +125,7 @@ impl TcpSocket { - /// } - /// ``` - pub fn new_v4() -> io::Result { -- let inner = mio::net::TcpSocket::new_v4()?; -- Ok(TcpSocket { inner }) -+ TcpSocket::new(socket2::Domain::IPV4) - } - - /// Creates a new socket configured for IPv6. -@@ -151,7 +158,34 @@ impl TcpSocket { - /// } - /// ``` - pub fn new_v6() -> io::Result { -- let inner = mio::net::TcpSocket::new_v6()?; -+ TcpSocket::new(socket2::Domain::IPV6) -+ } -+ -+ fn new(domain: socket2::Domain) -> io::Result { -+ let ty = socket2::Type::STREAM; -+ #[cfg(any( -+ target_os = "android", -+ target_os = "dragonfly", -+ target_os = "freebsd", -+ target_os = "fuchsia", -+ target_os = "illumos", -+ target_os = "linux", -+ target_os = "netbsd", -+ target_os = "openbsd" -+ ))] -+ let ty = ty.nonblocking(); -+ let inner = socket2::Socket::new(domain, ty, Some(socket2::Protocol::TCP))?; -+ #[cfg(not(any( -+ target_os = "android", -+ target_os = "dragonfly", -+ target_os = "freebsd", -+ target_os = "fuchsia", -+ target_os = "illumos", -+ target_os = "linux", -+ target_os = "netbsd", -+ target_os = "openbsd" -+ )))] -+ inner.set_nonblocking(true)?; - Ok(TcpSocket { inner }) - } - -@@ -182,7 +216,7 @@ impl TcpSocket { - /// } - /// ``` - pub fn set_reuseaddr(&self, reuseaddr: bool) -> io::Result<()> { -- self.inner.set_reuseaddr(reuseaddr) -+ self.inner.set_reuse_address(reuseaddr) - } - - /// Retrieves the value set for `SO_REUSEADDR` on this socket. -@@ -208,7 +242,7 @@ impl TcpSocket { - /// } - /// ``` - pub fn reuseaddr(&self) -> io::Result { -- self.inner.get_reuseaddr() -+ self.inner.reuse_address() - } - - /// Allows the socket to bind to an in-use port. Only available for unix systems -@@ -242,7 +276,7 @@ impl TcpSocket { - doc(cfg(all(unix, not(target_os = "solaris"), not(target_os = "illumos")))) - )] - pub fn set_reuseport(&self, reuseport: bool) -> io::Result<()> { -- self.inner.set_reuseport(reuseport) -+ self.inner.set_reuse_port(reuseport) - } - - /// Allows the socket to bind to an in-use port. Only available for unix systems -@@ -277,14 +311,14 @@ impl TcpSocket { - doc(cfg(all(unix, not(target_os = "solaris"), not(target_os = "illumos")))) - )] - pub fn reuseport(&self) -> io::Result { -- self.inner.get_reuseport() -+ self.inner.reuse_port() - } - - /// Sets the size of the TCP send buffer on this socket. - /// - /// On most operating systems, this sets the `SO_SNDBUF` socket option. - pub fn set_send_buffer_size(&self, size: u32) -> io::Result<()> { -- self.inner.set_send_buffer_size(size) -+ self.inner.set_send_buffer_size(size as usize) - } - - /// Returns the size of the TCP send buffer for this socket. -@@ -311,14 +345,14 @@ impl TcpSocket { - /// - /// [`set_send_buffer_size`]: #method.set_send_buffer_size - pub fn send_buffer_size(&self) -> io::Result { -- self.inner.get_send_buffer_size() -+ self.inner.send_buffer_size().map(|n| n as u32) - } - - /// Sets the size of the TCP receive buffer on this socket. - /// - /// On most operating systems, this sets the `SO_RCVBUF` socket option. - pub fn set_recv_buffer_size(&self, size: u32) -> io::Result<()> { -- self.inner.set_recv_buffer_size(size) -+ self.inner.set_recv_buffer_size(size as usize) - } - - /// Returns the size of the TCP receive buffer for this socket. -@@ -345,7 +379,112 @@ impl TcpSocket { - /// - /// [`set_recv_buffer_size`]: #method.set_recv_buffer_size - pub fn recv_buffer_size(&self) -> io::Result { -- self.inner.get_recv_buffer_size() -+ self.inner.recv_buffer_size().map(|n| n as u32) -+ } -+ -+ /// Sets the linger duration of this socket by setting the SO_LINGER option. -+ /// -+ /// This option controls the action taken when a stream has unsent messages and the stream is -+ /// closed. If SO_LINGER is set, the system shall block the process until it can transmit the -+ /// data or until the time expires. -+ /// -+ /// If SO_LINGER is not specified, and the socket is closed, the system handles the call in a -+ /// way that allows the process to continue as quickly as possible. -+ pub fn set_linger(&self, dur: Option) -> io::Result<()> { -+ self.inner.set_linger(dur) -+ } -+ -+ /// Reads the linger duration for this socket by getting the `SO_LINGER` -+ /// option. -+ /// -+ /// For more information about this option, see [`set_linger`]. -+ /// -+ /// [`set_linger`]: TcpSocket::set_linger -+ pub fn linger(&self) -> io::Result> { -+ self.inner.linger() -+ } -+ -+ /// Gets the value of the `IP_TOS` option for this socket. -+ /// -+ /// For more information about this option, see [`set_tos`]. -+ /// -+ /// **NOTE:** On Windows, `IP_TOS` is only supported on [Windows 8+ or -+ /// Windows Server 2012+.](https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options) -+ /// -+ /// [`set_tos`]: Self::set_tos -+ // https://docs.rs/socket2/0.4.2/src/socket2/socket.rs.html#1178 -+ #[cfg(not(any( -+ target_os = "fuchsia", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "illumos", -+ )))] -+ #[cfg_attr( -+ docsrs, -+ doc(cfg(not(any( -+ target_os = "fuchsia", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "illumos", -+ )))) -+ )] -+ pub fn tos(&self) -> io::Result { -+ self.inner.tos() -+ } -+ -+ /// Sets the value for the `IP_TOS` option on this socket. -+ /// -+ /// This value sets the type-of-service field that is used in every packet -+ /// sent from this socket. -+ /// -+ /// **NOTE:** On Windows, `IP_TOS` is only supported on [Windows 8+ or -+ /// Windows Server 2012+.](https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options) -+ // https://docs.rs/socket2/0.4.2/src/socket2/socket.rs.html#1178 -+ #[cfg(not(any( -+ target_os = "fuchsia", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "illumos", -+ )))] -+ #[cfg_attr( -+ docsrs, -+ doc(cfg(not(any( -+ target_os = "fuchsia", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "illumos", -+ )))) -+ )] -+ pub fn set_tos(&self, tos: u32) -> io::Result<()> { -+ self.inner.set_tos(tos) -+ } -+ -+ /// Gets the value for the `SO_BINDTODEVICE` option on this socket -+ /// -+ /// This value gets the socket binded device's interface name. -+ #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux",))] -+ #[cfg_attr( -+ docsrs, -+ doc(cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux",))) -+ )] -+ pub fn device(&self) -> io::Result>> { -+ self.inner.device() -+ } -+ -+ /// Sets the value for the `SO_BINDTODEVICE` option on this socket -+ /// -+ /// If a socket is bound to an interface, only packets received from that -+ /// particular interface are processed by the socket. Note that this only -+ /// works for some socket types, particularly `AF_INET` sockets. -+ /// -+ /// If `interface` is `None` or an empty string it removes the binding. -+ #[cfg(all(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))] -+ #[cfg_attr( -+ docsrs, -+ doc(cfg(all(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))) -+ )] -+ pub fn bind_device(&self, interface: Option<&[u8]>) -> io::Result<()> { -+ self.inner.bind_device(interface) - } - - /// Gets the local address of this socket. -@@ -371,7 +510,12 @@ impl TcpSocket { - /// } - /// ``` - pub fn local_addr(&self) -> io::Result { -- self.inner.get_localaddr() -+ self.inner.local_addr().and_then(convert_address) -+ } -+ -+ /// Returns the value of the `SO_ERROR` option. -+ pub fn take_error(&self) -> io::Result> { -+ self.inner.take_error() - } - - /// Binds the socket to the given address. -@@ -403,7 +547,7 @@ impl TcpSocket { - /// } - /// ``` - pub fn bind(&self, addr: SocketAddr) -> io::Result<()> { -- self.inner.bind(addr) -+ self.inner.bind(&addr.into()) - } - - /// Establishes a TCP connection with a peer at the specified socket address. -@@ -439,7 +583,32 @@ impl TcpSocket { - /// } - /// ``` - pub async fn connect(self, addr: SocketAddr) -> io::Result { -- let mio = self.inner.connect(addr)?; -+ if let Err(err) = self.inner.connect(&addr.into()) { -+ #[cfg(unix)] -+ if err.raw_os_error() != Some(libc::EINPROGRESS) { -+ return Err(err); -+ } -+ #[cfg(windows)] -+ if err.kind() != io::ErrorKind::WouldBlock { -+ return Err(err); -+ } -+ } -+ #[cfg(unix)] -+ let mio = { -+ use std::os::unix::io::{FromRawFd, IntoRawFd}; -+ -+ let raw_fd = self.inner.into_raw_fd(); -+ unsafe { mio::net::TcpStream::from_raw_fd(raw_fd) } -+ }; -+ -+ #[cfg(windows)] -+ let mio = { -+ use std::os::windows::io::{FromRawSocket, IntoRawSocket}; -+ -+ let raw_socket = self.inner.into_raw_socket(); -+ unsafe { mio::net::TcpStream::from_raw_socket(raw_socket) } -+ }; -+ - TcpStream::connect_mio(mio).await - } - -@@ -479,7 +648,23 @@ impl TcpSocket { - /// } - /// ``` - pub fn listen(self, backlog: u32) -> io::Result { -- let mio = self.inner.listen(backlog)?; -+ self.inner.listen(backlog as i32)?; -+ #[cfg(unix)] -+ let mio = { -+ use std::os::unix::io::{FromRawFd, IntoRawFd}; -+ -+ let raw_fd = self.inner.into_raw_fd(); -+ unsafe { mio::net::TcpListener::from_raw_fd(raw_fd) } -+ }; -+ -+ #[cfg(windows)] -+ let mio = { -+ use std::os::windows::io::{FromRawSocket, IntoRawSocket}; -+ -+ let raw_socket = self.inner.into_raw_socket(); -+ unsafe { mio::net::TcpListener::from_raw_socket(raw_socket) } -+ }; -+ - TcpListener::new(mio) - } - -@@ -491,6 +676,15 @@ impl TcpSocket { - /// [`std::net::TcpStream`]: struct@std::net::TcpStream - /// [`socket2`]: https://docs.rs/socket2/ - /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the socket is in -+ /// non-blocking mode. Otherwise all I/O operations on the socket -+ /// will block the thread, which will cause unexpected behavior. -+ /// Non-blocking mode can be set using [`set_nonblocking`]. -+ /// -+ /// [`set_nonblocking`]: std::net::TcpStream::set_nonblocking -+ /// - /// # Examples - /// - /// ``` -@@ -499,8 +693,8 @@ impl TcpSocket { - /// - /// #[tokio::main] - /// async fn main() -> std::io::Result<()> { -- /// - /// let socket2_socket = Socket::new(Domain::IPV4, Type::STREAM, None)?; -+ /// socket2_socket.set_nonblocking(true)?; - /// - /// let socket = TcpSocket::from_std_stream(socket2_socket.into()); - /// -@@ -526,6 +720,16 @@ impl TcpSocket { - } - } - -+fn convert_address(address: socket2::SockAddr) -> io::Result { -+ match address.as_socket() { -+ Some(address) => Ok(address), -+ None => Err(io::Error::new( -+ io::ErrorKind::InvalidInput, -+ "invalid address family (not IPv4 or IPv6)", -+ )), -+ } -+} -+ - impl fmt::Debug for TcpSocket { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - self.inner.fmt(fmt) -@@ -539,6 +743,13 @@ impl AsRawFd for TcpSocket { - } - } - -+#[cfg(all(unix, not(tokio_no_as_fd)))] -+impl AsFd for TcpSocket { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -+ - #[cfg(unix)] - impl FromRawFd for TcpSocket { - /// Converts a `RawFd` to a `TcpSocket`. -@@ -548,7 +759,7 @@ impl FromRawFd for TcpSocket { - /// The caller is responsible for ensuring that the socket is in - /// non-blocking mode. - unsafe fn from_raw_fd(fd: RawFd) -> TcpSocket { -- let inner = mio::net::TcpSocket::from_raw_fd(fd); -+ let inner = socket2::Socket::from_raw_fd(fd); - TcpSocket { inner } - } - } -@@ -560,30 +771,36 @@ impl IntoRawFd for TcpSocket { - } - } - --#[cfg(windows)] --impl IntoRawSocket for TcpSocket { -- fn into_raw_socket(self) -> RawSocket { -- self.inner.into_raw_socket() -+cfg_windows! { -+ impl IntoRawSocket for TcpSocket { -+ fn into_raw_socket(self) -> RawSocket { -+ self.inner.into_raw_socket() -+ } - } --} - --#[cfg(windows)] --impl AsRawSocket for TcpSocket { -- fn as_raw_socket(&self) -> RawSocket { -- self.inner.as_raw_socket() -+ impl AsRawSocket for TcpSocket { -+ fn as_raw_socket(&self) -> RawSocket { -+ self.inner.as_raw_socket() -+ } - } --} - --#[cfg(windows)] --impl FromRawSocket for TcpSocket { -- /// Converts a `RawSocket` to a `TcpStream`. -- /// -- /// # Notes -- /// -- /// The caller is responsible for ensuring that the socket is in -- /// non-blocking mode. -- unsafe fn from_raw_socket(socket: RawSocket) -> TcpSocket { -- let inner = mio::net::TcpSocket::from_raw_socket(socket); -- TcpSocket { inner } -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsSocket for TcpSocket { -+ fn as_socket(&self) -> BorrowedSocket<'_> { -+ unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) } -+ } -+ } -+ -+ impl FromRawSocket for TcpSocket { -+ /// Converts a `RawSocket` to a `TcpStream`. -+ /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the socket is in -+ /// non-blocking mode. -+ unsafe fn from_raw_socket(socket: RawSocket) -> TcpSocket { -+ let inner = socket2::Socket::from_raw_socket(socket); -+ TcpSocket { inner } -+ } - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/net/tcp/split.rs b/KubeOS-Rust/vendor/tokio/src/net/tcp/split.rs -index 0e029284..1a1e2225 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/tcp/split.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/tcp/split.rs -@@ -141,12 +141,21 @@ impl ReadHalf<'_> { - - /// Waits for any of the requested ready states. - /// -- /// This function is usually paired with `try_read()` or `try_write()`. It -- /// can be used to concurrently read / write to the same socket on a single -- /// task without splitting the socket. -+ /// This function is usually paired with [`try_read()`]. It can be used instead -+ /// of [`readable()`] to check the returned ready set for [`Ready::READABLE`] -+ /// and [`Ready::READ_CLOSED`] events. -+ /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. - /// - /// This function is equivalent to [`TcpStream::ready`]. - /// -+ /// [`try_read()`]: Self::try_read -+ /// [`readable()`]: Self::readable -+ /// - /// # Cancel safety - /// - /// This method is cancel safe. Once a readiness event occurs, the method -@@ -190,8 +199,12 @@ impl ReadHalf<'_> { - /// # Return - /// - /// If data is successfully read, `Ok(n)` is returned, where `n` is the -- /// number of bytes read. `Ok(0)` indicates the stream's read half is closed -- /// and will no longer yield data. If the stream is not ready to read data -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The stream's read half is closed and will no longer yield data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the stream is not ready to read data, - /// `Err(io::ErrorKind::WouldBlock)` is returned. - pub fn try_read(&self, buf: &mut [u8]) -> io::Result { - self.0.try_read(buf) -@@ -265,12 +278,21 @@ impl ReadHalf<'_> { - impl WriteHalf<'_> { - /// Waits for any of the requested ready states. - /// -- /// This function is usually paired with `try_read()` or `try_write()`. It -- /// can be used to concurrently read / write to the same socket on a single -- /// task without splitting the socket. -+ /// This function is usually paired with [`try_write()`]. It can be used instead -+ /// of [`writable()`] to check the returned ready set for [`Ready::WRITABLE`] -+ /// and [`Ready::WRITE_CLOSED`] events. -+ /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. - /// - /// This function is equivalent to [`TcpStream::ready`]. - /// -+ /// [`try_write()`]: Self::try_write -+ /// [`writable()`]: Self::writable -+ /// - /// # Cancel safety - /// - /// This method is cancel safe. Once a readiness event occurs, the method -diff --git a/KubeOS-Rust/vendor/tokio/src/net/tcp/split_owned.rs b/KubeOS-Rust/vendor/tokio/src/net/tcp/split_owned.rs -index ef4e7b53..6771d649 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/tcp/split_owned.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/tcp/split_owned.rs -@@ -196,12 +196,21 @@ impl OwnedReadHalf { - - /// Waits for any of the requested ready states. - /// -- /// This function is usually paired with `try_read()` or `try_write()`. It -- /// can be used to concurrently read / write to the same socket on a single -- /// task without splitting the socket. -+ /// This function is usually paired with [`try_read()`]. It can be used instead -+ /// of [`readable()`] to check the returned ready set for [`Ready::READABLE`] -+ /// and [`Ready::READ_CLOSED`] events. -+ /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. - /// - /// This function is equivalent to [`TcpStream::ready`]. - /// -+ /// [`try_read()`]: Self::try_read -+ /// [`readable()`]: Self::readable -+ /// - /// # Cancel safety - /// - /// This method is cancel safe. Once a readiness event occurs, the method -@@ -245,8 +254,12 @@ impl OwnedReadHalf { - /// # Return - /// - /// If data is successfully read, `Ok(n)` is returned, where `n` is the -- /// number of bytes read. `Ok(0)` indicates the stream's read half is closed -- /// and will no longer yield data. If the stream is not ready to read data -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The stream's read half is closed and will no longer yield data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the stream is not ready to read data, - /// `Err(io::ErrorKind::WouldBlock)` is returned. - pub fn try_read(&self, buf: &mut [u8]) -> io::Result { - self.inner.try_read(buf) -@@ -347,12 +360,21 @@ impl OwnedWriteHalf { - - /// Waits for any of the requested ready states. - /// -- /// This function is usually paired with `try_read()` or `try_write()`. It -- /// can be used to concurrently read / write to the same socket on a single -- /// task without splitting the socket. -+ /// This function is usually paired with [`try_write()`]. It can be used instead -+ /// of [`writable()`] to check the returned ready set for [`Ready::WRITABLE`] -+ /// and [`Ready::WRITE_CLOSED`] events. -+ /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. - /// - /// This function is equivalent to [`TcpStream::ready`]. - /// -+ /// [`try_write()`]: Self::try_write -+ /// [`writable()`]: Self::writable -+ /// - /// # Cancel safety - /// - /// This method is cancel safe. Once a readiness event occurs, the method -@@ -474,12 +496,12 @@ impl AsyncWrite for OwnedWriteHalf { - - impl AsRef for OwnedReadHalf { - fn as_ref(&self) -> &TcpStream { -- &*self.inner -+ &self.inner - } - } - - impl AsRef for OwnedWriteHalf { - fn as_ref(&self) -> &TcpStream { -- &*self.inner -+ &self.inner - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/net/tcp/stream.rs b/KubeOS-Rust/vendor/tokio/src/net/tcp/stream.rs -index 60d20fd7..b7104d78 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/tcp/stream.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/tcp/stream.rs -@@ -1,16 +1,18 @@ --use crate::future::poll_fn; -+cfg_not_wasi! { -+ use crate::future::poll_fn; -+ use crate::net::{to_socket_addrs, ToSocketAddrs}; -+ use std::time::Duration; -+} -+ - use crate::io::{AsyncRead, AsyncWrite, Interest, PollEvented, ReadBuf, Ready}; - use crate::net::tcp::split::{split, ReadHalf, WriteHalf}; - use crate::net::tcp::split_owned::{split_owned, OwnedReadHalf, OwnedWriteHalf}; --use crate::net::{to_socket_addrs, ToSocketAddrs}; - --use std::convert::TryFrom; - use std::fmt; - use std::io; - use std::net::{Shutdown, SocketAddr}; - use std::pin::Pin; - use std::task::{Context, Poll}; --use std::time::Duration; - - cfg_io_util! { - use bytes::BufMut; -@@ -70,86 +72,88 @@ cfg_net! { - } - - impl TcpStream { -- /// Opens a TCP connection to a remote host. -- /// -- /// `addr` is an address of the remote host. Anything which implements the -- /// [`ToSocketAddrs`] trait can be supplied as the address. If `addr` -- /// yields multiple addresses, connect will be attempted with each of the -- /// addresses until a connection is successful. If none of the addresses -- /// result in a successful connection, the error returned from the last -- /// connection attempt (the last address) is returned. -- /// -- /// To configure the socket before connecting, you can use the [`TcpSocket`] -- /// type. -- /// -- /// [`ToSocketAddrs`]: trait@crate::net::ToSocketAddrs -- /// [`TcpSocket`]: struct@crate::net::TcpSocket -- /// -- /// # Examples -- /// -- /// ```no_run -- /// use tokio::net::TcpStream; -- /// use tokio::io::AsyncWriteExt; -- /// use std::error::Error; -- /// -- /// #[tokio::main] -- /// async fn main() -> Result<(), Box> { -- /// // Connect to a peer -- /// let mut stream = TcpStream::connect("127.0.0.1:8080").await?; -- /// -- /// // Write some data. -- /// stream.write_all(b"hello world!").await?; -- /// -- /// Ok(()) -- /// } -- /// ``` -- /// -- /// The [`write_all`] method is defined on the [`AsyncWriteExt`] trait. -- /// -- /// [`write_all`]: fn@crate::io::AsyncWriteExt::write_all -- /// [`AsyncWriteExt`]: trait@crate::io::AsyncWriteExt -- pub async fn connect(addr: A) -> io::Result { -- let addrs = to_socket_addrs(addr).await?; -+ cfg_not_wasi! { -+ /// Opens a TCP connection to a remote host. -+ /// -+ /// `addr` is an address of the remote host. Anything which implements the -+ /// [`ToSocketAddrs`] trait can be supplied as the address. If `addr` -+ /// yields multiple addresses, connect will be attempted with each of the -+ /// addresses until a connection is successful. If none of the addresses -+ /// result in a successful connection, the error returned from the last -+ /// connection attempt (the last address) is returned. -+ /// -+ /// To configure the socket before connecting, you can use the [`TcpSocket`] -+ /// type. -+ /// -+ /// [`ToSocketAddrs`]: trait@crate::net::ToSocketAddrs -+ /// [`TcpSocket`]: struct@crate::net::TcpSocket -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::TcpStream; -+ /// use tokio::io::AsyncWriteExt; -+ /// use std::error::Error; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> Result<(), Box> { -+ /// // Connect to a peer -+ /// let mut stream = TcpStream::connect("127.0.0.1:8080").await?; -+ /// -+ /// // Write some data. -+ /// stream.write_all(b"hello world!").await?; -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ /// -+ /// The [`write_all`] method is defined on the [`AsyncWriteExt`] trait. -+ /// -+ /// [`write_all`]: fn@crate::io::AsyncWriteExt::write_all -+ /// [`AsyncWriteExt`]: trait@crate::io::AsyncWriteExt -+ pub async fn connect(addr: A) -> io::Result { -+ let addrs = to_socket_addrs(addr).await?; - -- let mut last_err = None; -+ let mut last_err = None; - -- for addr in addrs { -- match TcpStream::connect_addr(addr).await { -- Ok(stream) => return Ok(stream), -- Err(e) => last_err = Some(e), -+ for addr in addrs { -+ match TcpStream::connect_addr(addr).await { -+ Ok(stream) => return Ok(stream), -+ Err(e) => last_err = Some(e), -+ } - } -+ -+ Err(last_err.unwrap_or_else(|| { -+ io::Error::new( -+ io::ErrorKind::InvalidInput, -+ "could not resolve to any address", -+ ) -+ })) - } - -- Err(last_err.unwrap_or_else(|| { -- io::Error::new( -- io::ErrorKind::InvalidInput, -- "could not resolve to any address", -- ) -- })) -- } -+ /// Establishes a connection to the specified `addr`. -+ async fn connect_addr(addr: SocketAddr) -> io::Result { -+ let sys = mio::net::TcpStream::connect(addr)?; -+ TcpStream::connect_mio(sys).await -+ } - -- /// Establishes a connection to the specified `addr`. -- async fn connect_addr(addr: SocketAddr) -> io::Result { -- let sys = mio::net::TcpStream::connect(addr)?; -- TcpStream::connect_mio(sys).await -- } -+ pub(crate) async fn connect_mio(sys: mio::net::TcpStream) -> io::Result { -+ let stream = TcpStream::new(sys)?; - -- pub(crate) async fn connect_mio(sys: mio::net::TcpStream) -> io::Result { -- let stream = TcpStream::new(sys)?; -+ // Once we've connected, wait for the stream to be writable as -+ // that's when the actual connection has been initiated. Once we're -+ // writable we check for `take_socket_error` to see if the connect -+ // actually hit an error or not. -+ // -+ // If all that succeeded then we ship everything on up. -+ poll_fn(|cx| stream.io.registration().poll_write_ready(cx)).await?; - -- // Once we've connected, wait for the stream to be writable as -- // that's when the actual connection has been initiated. Once we're -- // writable we check for `take_socket_error` to see if the connect -- // actually hit an error or not. -- // -- // If all that succeeded then we ship everything on up. -- poll_fn(|cx| stream.io.registration().poll_write_ready(cx)).await?; -+ if let Some(e) = stream.io.take_error()? { -+ return Err(e); -+ } - -- if let Some(e) = stream.io.take_error()? { -- return Err(e); -+ Ok(stream) - } -- -- Ok(stream) - } - - pub(crate) fn new(connected: mio::net::TcpStream) -> io::Result { -@@ -160,9 +164,16 @@ impl TcpStream { - /// Creates new `TcpStream` from a `std::net::TcpStream`. - /// - /// This function is intended to be used to wrap a TCP stream from the -- /// standard library in the Tokio equivalent. The conversion assumes nothing -- /// about the underlying stream; it is left up to the user to set it in -- /// non-blocking mode. -+ /// standard library in the Tokio equivalent. -+ /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the stream is in -+ /// non-blocking mode. Otherwise all I/O operations on the stream -+ /// will block the thread, which will cause unexpected behavior. -+ /// Non-blocking mode can be set using [`set_nonblocking`]. -+ /// -+ /// [`set_nonblocking`]: std::net::TcpStream::set_nonblocking - /// - /// # Examples - /// -@@ -181,11 +192,13 @@ impl TcpStream { - /// - /// # Panics - /// -- /// This function panics if thread-local runtime is not set. -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. - /// - /// The runtime is usually set implicitly when this function is called - /// from a future driven by a tokio runtime, otherwise runtime can be set - /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ #[track_caller] - pub fn from_std(stream: std::net::TcpStream) -> io::Result { - let io = mio::net::TcpStream::from_std(stream); - let io = PollEvented::new(io)?; -@@ -244,6 +257,15 @@ impl TcpStream { - .map(|io| io.into_raw_socket()) - .map(|raw_socket| unsafe { std::net::TcpStream::from_raw_socket(raw_socket) }) - } -+ -+ #[cfg(tokio_wasi)] -+ { -+ use std::os::wasi::io::{FromRawFd, IntoRawFd}; -+ self.io -+ .into_inner() -+ .map(|io| io.into_raw_fd()) -+ .map(|raw_fd| unsafe { std::net::TcpStream::from_raw_fd(raw_fd) }) -+ } - } - - /// Returns the local address that this stream is bound to. -@@ -264,6 +286,11 @@ impl TcpStream { - self.io.local_addr() - } - -+ /// Returns the value of the `SO_ERROR` option. -+ pub fn take_error(&self) -> io::Result> { -+ self.io.take_error() -+ } -+ - /// Returns the remote address that this stream is connected to. - /// - /// # Examples -@@ -356,6 +383,12 @@ impl TcpStream { - /// can be used to concurrently read / write to the same socket on a single - /// task without splitting the socket. - /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// - /// # Cancel safety - /// - /// This method is cancel safe. Once a readiness event occurs, the method -@@ -387,7 +420,7 @@ impl TcpStream { - /// // if the readiness event is a false positive. - /// match stream.try_read(&mut data) { - /// Ok(n) => { -- /// println!("read {} bytes", n); -+ /// println!("read {} bytes", n); - /// } - /// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { - /// continue; -@@ -526,8 +559,12 @@ impl TcpStream { - /// # Return - /// - /// If data is successfully read, `Ok(n)` is returned, where `n` is the -- /// number of bytes read. `Ok(0)` indicates the stream's read half is closed -- /// and will no longer yield data. If the stream is not ready to read data -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The stream's read half is closed and will no longer yield data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the stream is not ready to read data, - /// `Err(io::ErrorKind::WouldBlock)` is returned. - /// - /// # Examples -@@ -939,7 +976,7 @@ impl TcpStream { - /// Tries to read or write from the socket using a user-provided IO operation. - /// - /// If the socket is ready, the provided closure is called. The closure -- /// should attempt to perform IO operation from the socket by manually -+ /// should attempt to perform IO operation on the socket by manually - /// calling the appropriate syscall. If the operation fails because the - /// socket is not actually ready, then the closure should return a - /// `WouldBlock` error and the readiness flag is cleared. The return value -@@ -958,6 +995,11 @@ impl TcpStream { - /// defined on the Tokio `TcpStream` type, as this will mess with the - /// readiness flag and can cause the socket to behave incorrectly. - /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ /// - /// Usually, [`readable()`], [`writable()`] or [`ready()`] is used with this function. - /// - /// [`readable()`]: TcpStream::readable() -@@ -968,7 +1010,45 @@ impl TcpStream { - interest: Interest, - f: impl FnOnce() -> io::Result, - ) -> io::Result { -- self.io.registration().try_io(interest, f) -+ self.io -+ .registration() -+ .try_io(interest, || self.io.try_io(f)) -+ } -+ -+ /// Reads or writes from the socket using a user-provided IO operation. -+ /// -+ /// The readiness of the socket is awaited and when the socket is ready, -+ /// the provided closure is called. The closure should attempt to perform -+ /// IO operation on the socket by manually calling the appropriate syscall. -+ /// If the operation fails because the socket is not actually ready, -+ /// then the closure should return a `WouldBlock` error. In such case the -+ /// readiness flag is cleared and the socket readiness is awaited again. -+ /// This loop is repeated until the closure returns an `Ok` or an error -+ /// other than `WouldBlock`. -+ /// -+ /// The closure should only return a `WouldBlock` error if it has performed -+ /// an IO operation on the socket that failed due to the socket not being -+ /// ready. Returning a `WouldBlock` error in any other situation will -+ /// incorrectly clear the readiness flag, which can cause the socket to -+ /// behave incorrectly. -+ /// -+ /// The closure should not perform the IO operation using any of the methods -+ /// defined on the Tokio `TcpStream` type, as this will mess with the -+ /// readiness flag and can cause the socket to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ pub async fn async_io( -+ &self, -+ interest: Interest, -+ mut f: impl FnMut() -> io::Result, -+ ) -> io::Result { -+ self.io -+ .registration() -+ .async_io(interest, || self.io.try_io(&mut f)) -+ .await - } - - /// Receives data on the socket from the remote address to which it is -@@ -1070,69 +1150,53 @@ impl TcpStream { - self.io.set_nodelay(nodelay) - } - -- /// Reads the linger duration for this socket by getting the `SO_LINGER` -- /// option. -- /// -- /// For more information about this option, see [`set_linger`]. -- /// -- /// [`set_linger`]: TcpStream::set_linger -- /// -- /// # Examples -- /// -- /// ```no_run -- /// use tokio::net::TcpStream; -- /// -- /// # async fn dox() -> Result<(), Box> { -- /// let stream = TcpStream::connect("127.0.0.1:8080").await?; -- /// -- /// println!("{:?}", stream.linger()?); -- /// # Ok(()) -- /// # } -- /// ``` -- pub fn linger(&self) -> io::Result> { -- let mio_socket = std::mem::ManuallyDrop::new(self.to_mio()); -- -- mio_socket.get_linger() -- } -- -- /// Sets the linger duration of this socket by setting the SO_LINGER option. -- /// -- /// This option controls the action taken when a stream has unsent messages and the stream is -- /// closed. If SO_LINGER is set, the system shall block the process until it can transmit the -- /// data or until the time expires. -- /// -- /// If SO_LINGER is not specified, and the stream is closed, the system handles the call in a -- /// way that allows the process to continue as quickly as possible. -- /// -- /// # Examples -- /// -- /// ```no_run -- /// use tokio::net::TcpStream; -- /// -- /// # async fn dox() -> Result<(), Box> { -- /// let stream = TcpStream::connect("127.0.0.1:8080").await?; -- /// -- /// stream.set_linger(None)?; -- /// # Ok(()) -- /// # } -- /// ``` -- pub fn set_linger(&self, dur: Option) -> io::Result<()> { -- let mio_socket = std::mem::ManuallyDrop::new(self.to_mio()); -- -- mio_socket.set_linger(dur) -- } -- -- fn to_mio(&self) -> mio::net::TcpSocket { -- #[cfg(windows)] -- { -- use std::os::windows::io::{AsRawSocket, FromRawSocket}; -- unsafe { mio::net::TcpSocket::from_raw_socket(self.as_raw_socket()) } -+ cfg_not_wasi! { -+ /// Reads the linger duration for this socket by getting the `SO_LINGER` -+ /// option. -+ /// -+ /// For more information about this option, see [`set_linger`]. -+ /// -+ /// [`set_linger`]: TcpStream::set_linger -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::TcpStream; -+ /// -+ /// # async fn dox() -> Result<(), Box> { -+ /// let stream = TcpStream::connect("127.0.0.1:8080").await?; -+ /// -+ /// println!("{:?}", stream.linger()?); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn linger(&self) -> io::Result> { -+ socket2::SockRef::from(self).linger() - } - -- #[cfg(unix)] -- { -- use std::os::unix::io::{AsRawFd, FromRawFd}; -- unsafe { mio::net::TcpSocket::from_raw_fd(self.as_raw_fd()) } -+ /// Sets the linger duration of this socket by setting the SO_LINGER option. -+ /// -+ /// This option controls the action taken when a stream has unsent messages and the stream is -+ /// closed. If SO_LINGER is set, the system shall block the process until it can transmit the -+ /// data or until the time expires. -+ /// -+ /// If SO_LINGER is not specified, and the stream is closed, the system handles the call in a -+ /// way that allows the process to continue as quickly as possible. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::TcpStream; -+ /// -+ /// # async fn dox() -> Result<(), Box> { -+ /// let stream = TcpStream::connect("127.0.0.1:8080").await?; -+ /// -+ /// stream.set_linger(None)?; -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn set_linger(&self, dur: Option) -> io::Result<()> { -+ socket2::SockRef::from(self).set_linger(dur) - } - } - -@@ -1313,16 +1377,49 @@ mod sys { - self.io.as_raw_fd() - } - } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for TcpStream { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+ } - } - --#[cfg(windows)] --mod sys { -- use super::TcpStream; -- use std::os::windows::prelude::*; -+cfg_windows! { -+ use crate::os::windows::io::{AsRawSocket, RawSocket}; -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsSocket, BorrowedSocket}; - - impl AsRawSocket for TcpStream { - fn as_raw_socket(&self) -> RawSocket { - self.io.as_raw_socket() - } - } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsSocket for TcpStream { -+ fn as_socket(&self) -> BorrowedSocket<'_> { -+ unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) } -+ } -+ } -+} -+ -+#[cfg(all(tokio_unstable, tokio_wasi))] -+mod sys { -+ use super::TcpStream; -+ use std::os::wasi::prelude::*; -+ -+ impl AsRawFd for TcpStream { -+ fn as_raw_fd(&self) -> RawFd { -+ self.io.as_raw_fd() -+ } -+ } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for TcpStream { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+ } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/net/udp.rs b/KubeOS-Rust/vendor/tokio/src/net/udp.rs -index 504d74eb..8da377e1 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/udp.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/udp.rs -@@ -1,7 +1,6 @@ - use crate::io::{Interest, PollEvented, ReadBuf, Ready}; - use crate::net::{to_socket_addrs, ToSocketAddrs}; - --use std::convert::TryFrom; - use std::fmt; - use std::io; - use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; -@@ -128,6 +127,10 @@ impl UdpSocket { - /// This function will create a new UDP socket and attempt to bind it to - /// the `addr` provided. - /// -+ /// Binding with a port number of 0 will request that the OS assigns a port -+ /// to this listener. The port allocated can be queried via the `local_addr` -+ /// method. -+ /// - /// # Example - /// - /// ```no_run -@@ -166,6 +169,7 @@ impl UdpSocket { - UdpSocket::new(sys) - } - -+ #[track_caller] - fn new(socket: mio::net::UdpSocket) -> io::Result { - let io = PollEvented::new(socket)?; - Ok(UdpSocket { io }) -@@ -174,14 +178,21 @@ impl UdpSocket { - /// Creates new `UdpSocket` from a previously bound `std::net::UdpSocket`. - /// - /// This function is intended to be used to wrap a UDP socket from the -- /// standard library in the Tokio equivalent. The conversion assumes nothing -- /// about the underlying socket; it is left up to the user to set it in -- /// non-blocking mode. -+ /// standard library in the Tokio equivalent. - /// - /// This can be used in conjunction with socket2's `Socket` interface to - /// configure a socket before it's handed off, such as setting options like - /// `reuse_address` or binding to multiple addresses. - /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the socket is in -+ /// non-blocking mode. Otherwise all I/O operations on the socket -+ /// will block the thread, which will cause unexpected behavior. -+ /// Non-blocking mode can be set using [`set_nonblocking`]. -+ /// -+ /// [`set_nonblocking`]: std::net::UdpSocket::set_nonblocking -+ /// - /// # Panics - /// - /// This function panics if thread-local runtime is not set. -@@ -206,6 +217,7 @@ impl UdpSocket { - /// # Ok(()) - /// # } - /// ``` -+ #[track_caller] - pub fn from_std(socket: net::UdpSocket) -> io::Result { - let io = mio::net::UdpSocket::from_std(socket); - UdpSocket::new(io) -@@ -253,6 +265,10 @@ impl UdpSocket { - } - } - -+ fn as_socket(&self) -> socket2::SockRef<'_> { -+ socket2::SockRef::from(self) -+ } -+ - /// Returns the local address that this socket is bound to. - /// - /// # Example -@@ -274,6 +290,28 @@ impl UdpSocket { - self.io.local_addr() - } - -+ /// Returns the socket address of the remote peer this socket was connected to. -+ /// -+ /// # Example -+ /// -+ /// ``` -+ /// use tokio::net::UdpSocket; -+ /// -+ /// # use std::{io, net::SocketAddr}; -+ /// # #[tokio::main] -+ /// # async fn main() -> io::Result<()> { -+ /// let addr = "0.0.0.0:8080".parse::().unwrap(); -+ /// let peer = "127.0.0.1:11100".parse::().unwrap(); -+ /// let sock = UdpSocket::bind(addr).await?; -+ /// sock.connect(peer).await?; -+ /// assert_eq!(peer, sock.peer_addr()?); -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn peer_addr(&self) -> io::Result { -+ self.io.peer_addr() -+ } -+ - /// Connects the UDP socket setting the default destination for send() and - /// limiting packets that are read via recv from the address specified in - /// `addr`. -@@ -325,7 +363,9 @@ impl UdpSocket { - /// - /// The function may complete without the socket being ready. This is a - /// false-positive and attempting an operation will return with -- /// `io::ErrorKind::WouldBlock`. -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. - /// - /// # Cancel safety - /// -@@ -708,7 +748,7 @@ impl UdpSocket { - /// - /// # Cancel safety - /// -- /// This method is cancel safe. If `recv_from` is used as the event in a -+ /// This method is cancel safe. If `recv` is used as the event in a - /// [`tokio::select!`](crate::select) statement and some other branch - /// completes first, it is guaranteed that no messages were received on this - /// socket. -@@ -785,7 +825,7 @@ impl UdpSocket { - /// address to which it is connected. On success, returns the number of - /// bytes read. - /// -- /// The function must be called with valid byte array buf of sufficient size -+ /// This method must be called with valid byte array buf of sufficient size - /// to hold the message bytes. If a message is too long to fit in the - /// supplied buffer, excess bytes may be discarded. - /// -@@ -841,10 +881,12 @@ impl UdpSocket { - /// Tries to receive data from the stream into the provided buffer, advancing the - /// buffer's internal cursor, returning how many bytes were read. - /// -- /// The function must be called with valid byte array buf of sufficient size -+ /// This method must be called with valid byte array buf of sufficient size - /// to hold the message bytes. If a message is too long to fit in the - /// supplied buffer, excess bytes may be discarded. - /// -+ /// This method can be used even if `buf` is uninitialized. -+ /// - /// When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is - /// returned. This function is usually paired with `readable()`. - /// -@@ -891,10 +933,10 @@ impl UdpSocket { - let dst = - unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; - -+ let n = (*self.io).recv(dst)?; -+ - // Safety: We trust `UdpSocket::recv` to have filled up `n` bytes in the - // buffer. -- let n = (&*self.io).recv(dst)?; -- - unsafe { - buf.advance_mut(n); - } -@@ -903,16 +945,75 @@ impl UdpSocket { - }) - } - -+ /// Receives a single datagram message on the socket from the remote address -+ /// to which it is connected, advancing the buffer's internal cursor, -+ /// returning how many bytes were read. -+ /// -+ /// This method must be called with valid byte array buf of sufficient size -+ /// to hold the message bytes. If a message is too long to fit in the -+ /// supplied buffer, excess bytes may be discarded. -+ /// -+ /// This method can be used even if `buf` is uninitialized. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::UdpSocket; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Connect to a peer -+ /// let socket = UdpSocket::bind("127.0.0.1:8080").await?; -+ /// socket.connect("127.0.0.1:8081").await?; -+ /// -+ /// let mut buf = Vec::with_capacity(512); -+ /// let len = socket.recv_buf(&mut buf).await?; -+ /// -+ /// println!("received {} bytes {:?}", len, &buf[..len]); -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub async fn recv_buf(&self, buf: &mut B) -> io::Result { -+ self.io.registration().async_io(Interest::READABLE, || { -+ let dst = buf.chunk_mut(); -+ let dst = -+ unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; -+ -+ let n = (*self.io).recv(dst)?; -+ -+ // Safety: We trust `UdpSocket::recv` to have filled up `n` bytes in the -+ // buffer. -+ unsafe { -+ buf.advance_mut(n); -+ } -+ -+ Ok(n) -+ }).await -+ } -+ - /// Tries to receive a single datagram message on the socket. On success, - /// returns the number of bytes read and the origin. - /// -- /// The function must be called with valid byte array buf of sufficient size -+ /// This method must be called with valid byte array buf of sufficient size - /// to hold the message bytes. If a message is too long to fit in the - /// supplied buffer, excess bytes may be discarded. - /// -+ /// This method can be used even if `buf` is uninitialized. -+ /// - /// When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is - /// returned. This function is usually paired with `readable()`. - /// -+ /// # Notes -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection -+ /// - /// # Examples - /// - /// ```no_run -@@ -955,10 +1056,10 @@ impl UdpSocket { - let dst = - unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; - -+ let (n, addr) = (*self.io).recv_from(dst)?; -+ - // Safety: We trust `UdpSocket::recv_from` to have filled up `n` bytes in the - // buffer. -- let (n, addr) = (&*self.io).recv_from(dst)?; -- - unsafe { - buf.advance_mut(n); - } -@@ -966,6 +1067,62 @@ impl UdpSocket { - Ok((n, addr)) - }) - } -+ -+ /// Receives a single datagram message on the socket, advancing the -+ /// buffer's internal cursor, returning how many bytes were read and the origin. -+ /// -+ /// This method must be called with valid byte array buf of sufficient size -+ /// to hold the message bytes. If a message is too long to fit in the -+ /// supplied buffer, excess bytes may be discarded. -+ /// -+ /// This method can be used even if `buf` is uninitialized. -+ /// -+ /// # Notes -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::UdpSocket; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Connect to a peer -+ /// let socket = UdpSocket::bind("127.0.0.1:8080").await?; -+ /// socket.connect("127.0.0.1:8081").await?; -+ /// -+ /// let mut buf = Vec::with_capacity(512); -+ /// let (len, addr) = socket.recv_buf_from(&mut buf).await?; -+ /// -+ /// println!("received {:?} bytes from {:?}", len, addr); -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub async fn recv_buf_from(&self, buf: &mut B) -> io::Result<(usize, SocketAddr)> { -+ self.io.registration().async_io(Interest::READABLE, || { -+ let dst = buf.chunk_mut(); -+ let dst = -+ unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; -+ -+ let (n, addr) = (*self.io).recv_from(dst)?; -+ -+ // Safety: We trust `UdpSocket::recv_from` to have filled up `n` bytes in the -+ // buffer. -+ unsafe { -+ buf.advance_mut(n); -+ } -+ -+ Ok((n,addr)) -+ }).await -+ } - } - - /// Sends data on the socket to the given address. On success, returns the -@@ -1136,6 +1293,15 @@ impl UdpSocket { - /// Ok(()) - /// } - /// ``` -+ /// -+ /// # Notes -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection - pub async fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { - self.io - .registration() -@@ -1160,6 +1326,15 @@ impl UdpSocket { - /// # Errors - /// - /// This function may encounter any standard I/O error except `WouldBlock`. -+ /// -+ /// # Notes -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection - pub fn poll_recv_from( - &self, - cx: &mut Context<'_>, -@@ -1185,13 +1360,23 @@ impl UdpSocket { - /// Tries to receive a single datagram message on the socket. On success, - /// returns the number of bytes read and the origin. - /// -- /// The function must be called with valid byte array buf of sufficient size -+ /// This method must be called with valid byte array buf of sufficient size - /// to hold the message bytes. If a message is too long to fit in the - /// supplied buffer, excess bytes may be discarded. - /// - /// When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is - /// returned. This function is usually paired with `readable()`. - /// -+ /// # Notes -+ /// -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection -+ /// - /// # Examples - /// - /// ```no_run -@@ -1239,7 +1424,7 @@ impl UdpSocket { - /// Tries to read or write from the socket using a user-provided IO operation. - /// - /// If the socket is ready, the provided closure is called. The closure -- /// should attempt to perform IO operation from the socket by manually -+ /// should attempt to perform IO operation on the socket by manually - /// calling the appropriate syscall. If the operation fails because the - /// socket is not actually ready, then the closure should return a - /// `WouldBlock` error and the readiness flag is cleared. The return value -@@ -1258,6 +1443,11 @@ impl UdpSocket { - /// defined on the Tokio `UdpSocket` type, as this will mess with the - /// readiness flag and can cause the socket to behave incorrectly. - /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ /// - /// Usually, [`readable()`], [`writable()`] or [`ready()`] is used with this function. - /// - /// [`readable()`]: UdpSocket::readable() -@@ -1268,7 +1458,45 @@ impl UdpSocket { - interest: Interest, - f: impl FnOnce() -> io::Result, - ) -> io::Result { -- self.io.registration().try_io(interest, f) -+ self.io -+ .registration() -+ .try_io(interest, || self.io.try_io(f)) -+ } -+ -+ /// Reads or writes from the socket using a user-provided IO operation. -+ /// -+ /// The readiness of the socket is awaited and when the socket is ready, -+ /// the provided closure is called. The closure should attempt to perform -+ /// IO operation on the socket by manually calling the appropriate syscall. -+ /// If the operation fails because the socket is not actually ready, -+ /// then the closure should return a `WouldBlock` error. In such case the -+ /// readiness flag is cleared and the socket readiness is awaited again. -+ /// This loop is repeated until the closure returns an `Ok` or an error -+ /// other than `WouldBlock`. -+ /// -+ /// The closure should only return a `WouldBlock` error if it has performed -+ /// an IO operation on the socket that failed due to the socket not being -+ /// ready. Returning a `WouldBlock` error in any other situation will -+ /// incorrectly clear the readiness flag, which can cause the socket to -+ /// behave incorrectly. -+ /// -+ /// The closure should not perform the IO operation using any of the methods -+ /// defined on the Tokio `UdpSocket` type, as this will mess with the -+ /// readiness flag and can cause the socket to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ pub async fn async_io( -+ &self, -+ interest: Interest, -+ mut f: impl FnMut() -> io::Result, -+ ) -> io::Result { -+ self.io -+ .registration() -+ .async_io(interest, || self.io.try_io(&mut f)) -+ .await - } - - /// Receives data from the socket, without removing it from the input queue. -@@ -1283,6 +1511,17 @@ impl UdpSocket { - /// Make sure to always use a sufficiently large buffer to hold the - /// maximum UDP packet size, which can be up to 65536 bytes in size. - /// -+ /// MacOS will return an error if you pass a zero-sized buffer. -+ /// -+ /// If you're merely interested in learning the sender of the data at the head of the queue, -+ /// try [`peek_sender`]. -+ /// -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// - /// # Examples - /// - /// ```no_run -@@ -1301,6 +1540,9 @@ impl UdpSocket { - /// Ok(()) - /// } - /// ``` -+ /// -+ /// [`peek_sender`]: method@Self::peek_sender -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection - pub async fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { - self.io - .registration() -@@ -1309,7 +1551,7 @@ impl UdpSocket { - } - - /// Receives data from the socket, without removing it from the input queue. -- /// On success, returns the number of bytes read. -+ /// On success, returns the sending address of the datagram. - /// - /// # Notes - /// -@@ -1323,6 +1565,17 @@ impl UdpSocket { - /// Make sure to always use a sufficiently large buffer to hold the - /// maximum UDP packet size, which can be up to 65536 bytes in size. - /// -+ /// MacOS will return an error if you pass a zero-sized buffer. -+ /// -+ /// If you're merely interested in learning the sender of the data at the head of the queue, -+ /// try [`poll_peek_sender`]. -+ /// -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// - /// # Return value - /// - /// The function returns: -@@ -1334,6 +1587,9 @@ impl UdpSocket { - /// # Errors - /// - /// This function may encounter any standard I/O error except `WouldBlock`. -+ /// -+ /// [`poll_peek_sender`]: method@Self::poll_peek_sender -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection - pub fn poll_peek_from( - &self, - cx: &mut Context<'_>, -@@ -1356,6 +1612,117 @@ impl UdpSocket { - Poll::Ready(Ok(addr)) - } - -+ /// Tries to receive data on the socket without removing it from the input queue. -+ /// On success, returns the number of bytes read and the sending address of the -+ /// datagram. -+ /// -+ /// When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is -+ /// returned. This function is usually paired with `readable()`. -+ /// -+ /// # Notes -+ /// -+ /// On Windows, if the data is larger than the buffer specified, the buffer -+ /// is filled with the first part of the data, and peek returns the error -+ /// WSAEMSGSIZE(10040). The excess data is lost. -+ /// Make sure to always use a sufficiently large buffer to hold the -+ /// maximum UDP packet size, which can be up to 65536 bytes in size. -+ /// -+ /// MacOS will return an error if you pass a zero-sized buffer. -+ /// -+ /// If you're merely interested in learning the sender of the data at the head of the queue, -+ /// try [`try_peek_sender`]. -+ /// -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [`try_peek_sender`]: method@Self::try_peek_sender -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection -+ pub fn try_peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { -+ self.io -+ .registration() -+ .try_io(Interest::READABLE, || self.io.peek_from(buf)) -+ } -+ -+ /// Retrieve the sender of the data at the head of the input queue, waiting if empty. -+ /// -+ /// This is equivalent to calling [`peek_from`] with a zero-sized buffer, -+ /// but suppresses the `WSAEMSGSIZE` error on Windows and the "invalid argument" error on macOS. -+ /// -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [`peek_from`]: method@Self::peek_from -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection -+ pub async fn peek_sender(&self) -> io::Result { -+ self.io -+ .registration() -+ .async_io(Interest::READABLE, || self.peek_sender_inner()) -+ .await -+ } -+ -+ /// Retrieve the sender of the data at the head of the input queue, -+ /// scheduling a wakeup if empty. -+ /// -+ /// This is equivalent to calling [`poll_peek_from`] with a zero-sized buffer, -+ /// but suppresses the `WSAEMSGSIZE` error on Windows and the "invalid argument" error on macOS. -+ /// -+ /// # Notes -+ /// -+ /// Note that on multiple calls to a `poll_*` method in the recv direction, only the -+ /// `Waker` from the `Context` passed to the most recent call will be scheduled to -+ /// receive a wakeup. -+ /// -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [`poll_peek_from`]: method@Self::poll_peek_from -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection -+ pub fn poll_peek_sender(&self, cx: &mut Context<'_>) -> Poll> { -+ self.io -+ .registration() -+ .poll_read_io(cx, || self.peek_sender_inner()) -+ } -+ -+ /// Try to retrieve the sender of the data at the head of the input queue. -+ /// -+ /// When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is -+ /// returned. This function is usually paired with `readable()`. -+ /// -+ /// Note that the socket address **cannot** be implicitly trusted, because it is relatively -+ /// trivial to send a UDP datagram with a spoofed origin in a [packet injection attack]. -+ /// Because UDP is stateless and does not validate the origin of a packet, -+ /// the attacker does not need to be able to intercept traffic in order to interfere. -+ /// It is important to be aware of this when designing your application-level protocol. -+ /// -+ /// [packet injection attack]: https://en.wikipedia.org/wiki/Packet_injection -+ pub fn try_peek_sender(&self) -> io::Result { -+ self.io -+ .registration() -+ .try_io(Interest::READABLE, || self.peek_sender_inner()) -+ } -+ -+ #[inline] -+ fn peek_sender_inner(&self) -> io::Result { -+ self.io.try_io(|| { -+ self.as_socket() -+ .peek_sender()? -+ // May be `None` if the platform doesn't populate the sender for some reason. -+ // In testing, that only occurred on macOS if you pass a zero-sized buffer, -+ // but the implementation of `Socket::peek_sender()` covers that. -+ .as_socket() -+ .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "sender not available")) -+ }) -+ } -+ - /// Gets the value of the `SO_BROADCAST` option for this socket. - /// - /// For more information about this option, see [`set_broadcast`]. -@@ -1480,6 +1847,89 @@ impl UdpSocket { - self.io.set_ttl(ttl) - } - -+ /// Gets the value of the `IP_TOS` option for this socket. -+ /// -+ /// For more information about this option, see [`set_tos`]. -+ /// -+ /// **NOTE:** On Windows, `IP_TOS` is only supported on [Windows 8+ or -+ /// Windows Server 2012+.](https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options) -+ /// -+ /// [`set_tos`]: Self::set_tos -+ // https://docs.rs/socket2/0.4.2/src/socket2/socket.rs.html#1178 -+ #[cfg(not(any( -+ target_os = "fuchsia", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "illumos", -+ )))] -+ #[cfg_attr( -+ docsrs, -+ doc(cfg(not(any( -+ target_os = "fuchsia", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "illumos", -+ )))) -+ )] -+ pub fn tos(&self) -> io::Result { -+ self.as_socket().tos() -+ } -+ -+ /// Sets the value for the `IP_TOS` option on this socket. -+ /// -+ /// This value sets the type-of-service field that is used in every packet -+ /// sent from this socket. -+ /// -+ /// **NOTE:** On Windows, `IP_TOS` is only supported on [Windows 8+ or -+ /// Windows Server 2012+.](https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-ip-socket-options) -+ // https://docs.rs/socket2/0.4.2/src/socket2/socket.rs.html#1178 -+ #[cfg(not(any( -+ target_os = "fuchsia", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "illumos", -+ )))] -+ #[cfg_attr( -+ docsrs, -+ doc(cfg(not(any( -+ target_os = "fuchsia", -+ target_os = "redox", -+ target_os = "solaris", -+ target_os = "illumos", -+ )))) -+ )] -+ pub fn set_tos(&self, tos: u32) -> io::Result<()> { -+ self.as_socket().set_tos(tos) -+ } -+ -+ /// Gets the value for the `SO_BINDTODEVICE` option on this socket -+ /// -+ /// This value gets the socket-bound device's interface name. -+ #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux",))] -+ #[cfg_attr( -+ docsrs, -+ doc(cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux",))) -+ )] -+ pub fn device(&self) -> io::Result>> { -+ self.as_socket().device() -+ } -+ -+ /// Sets the value for the `SO_BINDTODEVICE` option on this socket -+ /// -+ /// If a socket is bound to an interface, only packets received from that -+ /// particular interface are processed by the socket. Note that this only -+ /// works for some socket types, particularly `AF_INET` sockets. -+ /// -+ /// If `interface` is `None` or an empty string it removes the binding. -+ #[cfg(all(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))] -+ #[cfg_attr( -+ docsrs, -+ doc(cfg(all(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))) -+ )] -+ pub fn bind_device(&self, interface: Option<&[u8]>) -> io::Result<()> { -+ self.as_socket().bind_device(interface) -+ } -+ - /// Executes an operation of the `IP_ADD_MEMBERSHIP` type. - /// - /// This function specifies a new multicast group for this socket to join. -@@ -1560,7 +2010,7 @@ impl fmt::Debug for UdpSocket { - } - } - --#[cfg(all(unix))] -+#[cfg(unix)] - mod sys { - use super::UdpSocket; - use std::os::unix::prelude::*; -@@ -1570,16 +2020,30 @@ mod sys { - self.io.as_raw_fd() - } - } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for UdpSocket { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+ } - } - --#[cfg(windows)] --mod sys { -- use super::UdpSocket; -- use std::os::windows::prelude::*; -+cfg_windows! { -+ use crate::os::windows::io::{AsRawSocket, RawSocket}; -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsSocket, BorrowedSocket}; - - impl AsRawSocket for UdpSocket { - fn as_raw_socket(&self) -> RawSocket { - self.io.as_raw_socket() - } - } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsSocket for UdpSocket { -+ fn as_socket(&self) -> BorrowedSocket<'_> { -+ unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) } -+ } -+ } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/net/unix/datagram/socket.rs b/KubeOS-Rust/vendor/tokio/src/net/unix/datagram/socket.rs -index d5b61866..bd16dd6e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/unix/datagram/socket.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/unix/datagram/socket.rs -@@ -1,10 +1,11 @@ - use crate::io::{Interest, PollEvented, ReadBuf, Ready}; - use crate::net::unix::SocketAddr; - --use std::convert::TryFrom; - use std::fmt; - use std::io; - use std::net::Shutdown; -+#[cfg(not(tokio_no_as_fd))] -+use std::os::unix::io::{AsFd, BorrowedFd}; - use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; - use std::os::unix::net; - use std::path::Path; -@@ -104,7 +105,9 @@ impl UnixDatagram { - /// - /// The function may complete without the socket being ready. This is a - /// false-positive and attempting an operation will return with -- /// `io::ErrorKind::WouldBlock`. -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. - /// - /// # Cancel safety - /// -@@ -424,13 +427,21 @@ impl UnixDatagram { - /// Creates new `UnixDatagram` from a `std::os::unix::net::UnixDatagram`. - /// - /// This function is intended to be used to wrap a UnixDatagram from the -- /// standard library in the Tokio equivalent. The conversion assumes -- /// nothing about the underlying datagram; it is left up to the user to set -- /// it in non-blocking mode. -+ /// standard library in the Tokio equivalent. -+ /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the socker is in -+ /// non-blocking mode. Otherwise all I/O operations on the socket -+ /// will block the thread, which will cause unexpected behavior. -+ /// Non-blocking mode can be set using [`set_nonblocking`]. -+ /// -+ /// [`set_nonblocking`]: std::os::unix::net::UnixDatagram::set_nonblocking - /// - /// # Panics - /// -- /// This function panics if thread-local runtime is not set. -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. - /// - /// The runtime is usually set implicitly when this function is called - /// from a future driven by a Tokio runtime, otherwise runtime can be set -@@ -457,6 +468,7 @@ impl UnixDatagram { - /// # Ok(()) - /// # } - /// ``` -+ #[track_caller] - pub fn from_std(datagram: net::UnixDatagram) -> io::Result { - let socket = mio::net::UnixDatagram::from_std(datagram); - let io = PollEvented::new(socket)?; -@@ -466,21 +478,19 @@ impl UnixDatagram { - /// Turns a [`tokio::net::UnixDatagram`] into a [`std::os::unix::net::UnixDatagram`]. - /// - /// The returned [`std::os::unix::net::UnixDatagram`] will have nonblocking -- /// mode set as `true`. Use [`set_nonblocking`] to change the blocking mode -+ /// mode set as `true`. Use [`set_nonblocking`] to change the blocking mode - /// if needed. - /// - /// # Examples - /// - /// ```rust,no_run -- /// use std::error::Error; -- /// -- /// #[tokio::main] -- /// async fn main() -> Result<(), Box> { -- /// let tokio_socket = tokio::net::UnixDatagram::bind("127.0.0.1:0")?; -- /// let std_socket = tokio_socket.into_std()?; -- /// std_socket.set_nonblocking(false)?; -- /// Ok(()) -- /// } -+ /// # use std::error::Error; -+ /// # async fn dox() -> Result<(), Box> { -+ /// let tokio_socket = tokio::net::UnixDatagram::bind("/path/to/the/socket")?; -+ /// let std_socket = tokio_socket.into_std()?; -+ /// std_socket.set_nonblocking(false)?; -+ /// # Ok(()) -+ /// # } - /// ``` - /// - /// [`tokio::net::UnixDatagram`]: UnixDatagram -@@ -797,6 +807,8 @@ impl UnixDatagram { - cfg_io_util! { - /// Tries to receive data from the socket without waiting. - /// -+ /// This method can be used even if `buf` is uninitialized. -+ /// - /// # Examples - /// - /// ```no_run -@@ -844,7 +856,7 @@ impl UnixDatagram { - - // Safety: We trust `UnixDatagram::recv_from` to have filled up `n` bytes in the - // buffer. -- let (n, addr) = (&*self.io).recv_from(dst)?; -+ let (n, addr) = (*self.io).recv_from(dst)?; - - unsafe { - buf.advance_mut(n); -@@ -856,9 +868,64 @@ impl UnixDatagram { - Ok((n, SocketAddr(addr))) - } - -+ /// Receives from the socket, advances the -+ /// buffer's internal cursor and returns how many bytes were read and the origin. -+ /// -+ /// This method can be used even if `buf` is uninitialized. -+ /// -+ /// # Examples -+ /// ``` -+ /// # use std::error::Error; -+ /// # #[tokio::main] -+ /// # async fn main() -> Result<(), Box> { -+ /// use tokio::net::UnixDatagram; -+ /// use tempfile::tempdir; -+ /// -+ /// // We use a temporary directory so that the socket -+ /// // files left by the bound sockets will get cleaned up. -+ /// let tmp = tempdir()?; -+ /// -+ /// // Bind each socket to a filesystem path -+ /// let tx_path = tmp.path().join("tx"); -+ /// let tx = UnixDatagram::bind(&tx_path)?; -+ /// let rx_path = tmp.path().join("rx"); -+ /// let rx = UnixDatagram::bind(&rx_path)?; -+ /// -+ /// let bytes = b"hello world"; -+ /// tx.send_to(bytes, &rx_path).await?; -+ /// -+ /// let mut buf = Vec::with_capacity(24); -+ /// let (size, addr) = rx.recv_buf_from(&mut buf).await?; -+ /// -+ /// let dgram = &buf[..size]; -+ /// assert_eq!(dgram, bytes); -+ /// assert_eq!(addr.as_pathname().unwrap(), &tx_path); -+ /// -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub async fn recv_buf_from(&self, buf: &mut B) -> io::Result<(usize, SocketAddr)> { -+ self.io.registration().async_io(Interest::READABLE, || { -+ let dst = buf.chunk_mut(); -+ let dst = -+ unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; -+ -+ // Safety: We trust `UnixDatagram::recv_from` to have filled up `n` bytes in the -+ // buffer. -+ let (n, addr) = (*self.io).recv_from(dst)?; -+ -+ unsafe { -+ buf.advance_mut(n); -+ } -+ Ok((n,SocketAddr(addr))) -+ }).await -+ } -+ - /// Tries to read data from the stream into the provided buffer, advancing the - /// buffer's internal cursor, returning how many bytes were read. - /// -+ /// This method can be used even if `buf` is uninitialized. -+ /// - /// # Examples - /// - /// ```no_run -@@ -907,7 +974,7 @@ impl UnixDatagram { - - // Safety: We trust `UnixDatagram::recv` to have filled up `n` bytes in the - // buffer. -- let n = (&*self.io).recv(dst)?; -+ let n = (*self.io).recv(dst)?; - - unsafe { - buf.advance_mut(n); -@@ -916,6 +983,52 @@ impl UnixDatagram { - Ok(n) - }) - } -+ -+ /// Receives data from the socket from the address to which it is connected, -+ /// advancing the buffer's internal cursor, returning how many bytes were read. -+ /// -+ /// This method can be used even if `buf` is uninitialized. -+ /// -+ /// # Examples -+ /// ``` -+ /// # use std::error::Error; -+ /// # #[tokio::main] -+ /// # async fn main() -> Result<(), Box> { -+ /// use tokio::net::UnixDatagram; -+ /// -+ /// // Create the pair of sockets -+ /// let (sock1, sock2) = UnixDatagram::pair()?; -+ /// -+ /// // Since the sockets are paired, the paired send/recv -+ /// // functions can be used -+ /// let bytes = b"hello world"; -+ /// sock1.send(bytes).await?; -+ /// -+ /// let mut buff = Vec::with_capacity(24); -+ /// let size = sock2.recv_buf(&mut buff).await?; -+ /// -+ /// let dgram = &buff[..size]; -+ /// assert_eq!(dgram, bytes); -+ /// -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub async fn recv_buf(&self, buf: &mut B) -> io::Result { -+ self.io.registration().async_io(Interest::READABLE, || { -+ let dst = buf.chunk_mut(); -+ let dst = -+ unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; -+ -+ // Safety: We trust `UnixDatagram::recv_from` to have filled up `n` bytes in the -+ // buffer. -+ let n = (*self.io).recv(dst)?; -+ -+ unsafe { -+ buf.advance_mut(n); -+ } -+ Ok(n) -+ }).await -+ } - } - - /// Sends data on the socket to the specified address. -@@ -1212,7 +1325,7 @@ impl UnixDatagram { - /// Tries to read or write from the socket using a user-provided IO operation. - /// - /// If the socket is ready, the provided closure is called. The closure -- /// should attempt to perform IO operation from the socket by manually -+ /// should attempt to perform IO operation on the socket by manually - /// calling the appropriate syscall. If the operation fails because the - /// socket is not actually ready, then the closure should return a - /// `WouldBlock` error and the readiness flag is cleared. The return value -@@ -1231,6 +1344,11 @@ impl UnixDatagram { - /// defined on the Tokio `UnixDatagram` type, as this will mess with the - /// readiness flag and can cause the socket to behave incorrectly. - /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ /// - /// Usually, [`readable()`], [`writable()`] or [`ready()`] is used with this function. - /// - /// [`readable()`]: UnixDatagram::readable() -@@ -1241,7 +1359,45 @@ impl UnixDatagram { - interest: Interest, - f: impl FnOnce() -> io::Result, - ) -> io::Result { -- self.io.registration().try_io(interest, f) -+ self.io -+ .registration() -+ .try_io(interest, || self.io.try_io(f)) -+ } -+ -+ /// Reads or writes from the socket using a user-provided IO operation. -+ /// -+ /// The readiness of the socket is awaited and when the socket is ready, -+ /// the provided closure is called. The closure should attempt to perform -+ /// IO operation on the socket by manually calling the appropriate syscall. -+ /// If the operation fails because the socket is not actually ready, -+ /// then the closure should return a `WouldBlock` error. In such case the -+ /// readiness flag is cleared and the socket readiness is awaited again. -+ /// This loop is repeated until the closure returns an `Ok` or an error -+ /// other than `WouldBlock`. -+ /// -+ /// The closure should only return a `WouldBlock` error if it has performed -+ /// an IO operation on the socket that failed due to the socket not being -+ /// ready. Returning a `WouldBlock` error in any other situation will -+ /// incorrectly clear the readiness flag, which can cause the socket to -+ /// behave incorrectly. -+ /// -+ /// The closure should not perform the IO operation using any of the methods -+ /// defined on the Tokio `UnixDatagram` type, as this will mess with the -+ /// readiness flag and can cause the socket to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ pub async fn async_io( -+ &self, -+ interest: Interest, -+ mut f: impl FnMut() -> io::Result, -+ ) -> io::Result { -+ self.io -+ .registration() -+ .async_io(interest, || self.io.try_io(&mut f)) -+ .await - } - - /// Returns the local address that this socket is bound to. -@@ -1420,3 +1576,10 @@ impl AsRawFd for UnixDatagram { - self.io.as_raw_fd() - } - } -+ -+#[cfg(not(tokio_no_as_fd))] -+impl AsFd for UnixDatagram { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/net/unix/listener.rs b/KubeOS-Rust/vendor/tokio/src/net/unix/listener.rs -index 1785f8b0..6a050f39 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/unix/listener.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/unix/listener.rs -@@ -1,9 +1,10 @@ - use crate::io::{Interest, PollEvented}; - use crate::net::unix::{SocketAddr, UnixStream}; - --use std::convert::TryFrom; - use std::fmt; - use std::io; -+#[cfg(not(tokio_no_as_fd))] -+use std::os::unix::io::{AsFd, BorrowedFd}; - use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; - use std::os::unix::net; - use std::path::Path; -@@ -54,11 +55,13 @@ impl UnixListener { - /// - /// # Panics - /// -- /// This function panics if thread-local runtime is not set. -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. - /// - /// The runtime is usually set implicitly when this function is called - /// from a future driven by a tokio runtime, otherwise runtime can be set - /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ #[track_caller] - pub fn bind

(path: P) -> io::Result - where - P: AsRef, -@@ -71,17 +74,41 @@ impl UnixListener { - /// Creates new `UnixListener` from a `std::os::unix::net::UnixListener `. - /// - /// This function is intended to be used to wrap a UnixListener from the -- /// standard library in the Tokio equivalent. The conversion assumes -- /// nothing about the underlying listener; it is left up to the user to set -- /// it in non-blocking mode. -+ /// standard library in the Tokio equivalent. -+ /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the listener is in -+ /// non-blocking mode. Otherwise all I/O operations on the listener -+ /// will block the thread, which will cause unexpected behavior. -+ /// Non-blocking mode can be set using [`set_nonblocking`]. -+ /// -+ /// [`set_nonblocking`]: std::os::unix::net::UnixListener::set_nonblocking -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::UnixListener; -+ /// use std::os::unix::net::UnixListener as StdUnixListener; -+ /// # use std::error::Error; -+ /// -+ /// # async fn dox() -> Result<(), Box> { -+ /// let std_listener = StdUnixListener::bind("/path/to/the/socket")?; -+ /// std_listener.set_nonblocking(true)?; -+ /// let listener = UnixListener::from_std(std_listener)?; -+ /// # Ok(()) -+ /// # } -+ /// ``` - /// - /// # Panics - /// -- /// This function panics if thread-local runtime is not set. -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. - /// - /// The runtime is usually set implicitly when this function is called - /// from a future driven by a tokio runtime, otherwise runtime can be set - /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ #[track_caller] - pub fn from_std(listener: net::UnixListener) -> io::Result { - let listener = mio::net::UnixListener::from_std(listener); - let io = PollEvented::new(listener)?; -@@ -91,20 +118,18 @@ impl UnixListener { - /// Turns a [`tokio::net::UnixListener`] into a [`std::os::unix::net::UnixListener`]. - /// - /// The returned [`std::os::unix::net::UnixListener`] will have nonblocking mode -- /// set as `true`. Use [`set_nonblocking`] to change the blocking mode if needed. -+ /// set as `true`. Use [`set_nonblocking`] to change the blocking mode if needed. - /// - /// # Examples - /// - /// ```rust,no_run -- /// use std::error::Error; -- /// -- /// #[tokio::main] -- /// async fn main() -> Result<(), Box> { -- /// let tokio_listener = tokio::net::UnixListener::bind("127.0.0.1:0")?; -- /// let std_listener = tokio_listener.into_std()?; -- /// std_listener.set_nonblocking(false)?; -- /// Ok(()) -- /// } -+ /// # use std::error::Error; -+ /// # async fn dox() -> Result<(), Box> { -+ /// let tokio_listener = tokio::net::UnixListener::bind("/path/to/the/socket")?; -+ /// let std_listener = tokio_listener.into_std()?; -+ /// std_listener.set_nonblocking(false)?; -+ /// # Ok(()) -+ /// # } - /// ``` - /// - /// [`tokio::net::UnixListener`]: UnixListener -@@ -184,3 +209,10 @@ impl AsRawFd for UnixListener { - self.io.as_raw_fd() - } - } -+ -+#[cfg(not(tokio_no_as_fd))] -+impl AsFd for UnixListener { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/net/unix/mod.rs b/KubeOS-Rust/vendor/tokio/src/net/unix/mod.rs -index 14cb4567..a49b70af 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/unix/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/unix/mod.rs -@@ -1,5 +1,4 @@ --//! Unix domain socket utility types. -- -+//! Unix specific network types. - // This module does not currently provide any public API, but it was - // unintentionally defined as a public module. Hide it from the documentation - // instead of changing it to a private module to avoid breakage. -@@ -22,3 +21,17 @@ pub(crate) use stream::UnixStream; - - mod ucred; - pub use ucred::UCred; -+ -+pub mod pipe; -+ -+/// A type representing process and process group IDs. -+#[allow(non_camel_case_types)] -+pub type uid_t = u32; -+ -+/// A type representing user ID. -+#[allow(non_camel_case_types)] -+pub type gid_t = u32; -+ -+/// A type representing group ID. -+#[allow(non_camel_case_types)] -+pub type pid_t = i32; -diff --git a/KubeOS-Rust/vendor/tokio/src/net/unix/pipe.rs b/KubeOS-Rust/vendor/tokio/src/net/unix/pipe.rs -new file mode 100644 -index 00000000..188ac68b ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/net/unix/pipe.rs -@@ -0,0 +1,1222 @@ -+//! Unix pipe types. -+ -+use crate::io::interest::Interest; -+use crate::io::{AsyncRead, AsyncWrite, PollEvented, ReadBuf, Ready}; -+ -+use mio::unix::pipe as mio_pipe; -+use std::fs::File; -+use std::io::{self, Read, Write}; -+use std::os::unix::fs::{FileTypeExt, OpenOptionsExt}; -+#[cfg(not(tokio_no_as_fd))] -+use std::os::unix::io::{AsFd, BorrowedFd}; -+use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; -+use std::path::Path; -+use std::pin::Pin; -+use std::task::{Context, Poll}; -+ -+cfg_io_util! { -+ use bytes::BufMut; -+} -+ -+/// Options and flags which can be used to configure how a FIFO file is opened. -+/// -+/// This builder allows configuring how to create a pipe end from a FIFO file. -+/// Generally speaking, when using `OpenOptions`, you'll first call [`new`], -+/// then chain calls to methods to set each option, then call either -+/// [`open_receiver`] or [`open_sender`], passing the path of the FIFO file you -+/// are trying to open. This will give you a [`io::Result`][result] with a pipe -+/// end inside that you can further operate on. -+/// -+/// [`new`]: OpenOptions::new -+/// [`open_receiver`]: OpenOptions::open_receiver -+/// [`open_sender`]: OpenOptions::open_sender -+/// [result]: std::io::Result -+/// -+/// # Examples -+/// -+/// Opening a pair of pipe ends from a FIFO file: -+/// -+/// ```no_run -+/// use tokio::net::unix::pipe; -+/// # use std::error::Error; -+/// -+/// const FIFO_NAME: &str = "path/to/a/fifo"; -+/// -+/// # async fn dox() -> Result<(), Box> { -+/// let rx = pipe::OpenOptions::new().open_receiver(FIFO_NAME)?; -+/// let tx = pipe::OpenOptions::new().open_sender(FIFO_NAME)?; -+/// # Ok(()) -+/// # } -+/// ``` -+/// -+/// Opening a [`Sender`] on Linux when you are sure the file is a FIFO: -+/// -+/// ```ignore -+/// use tokio::net::unix::pipe; -+/// use nix::{unistd::mkfifo, sys::stat::Mode}; -+/// # use std::error::Error; -+/// -+/// // Our program has exclusive access to this path. -+/// const FIFO_NAME: &str = "path/to/a/new/fifo"; -+/// -+/// # async fn dox() -> Result<(), Box> { -+/// mkfifo(FIFO_NAME, Mode::S_IRWXU)?; -+/// let tx = pipe::OpenOptions::new() -+/// .read_write(true) -+/// .unchecked(true) -+/// .open_sender(FIFO_NAME)?; -+/// # Ok(()) -+/// # } -+/// ``` -+#[derive(Clone, Debug)] -+pub struct OpenOptions { -+ #[cfg(target_os = "linux")] -+ read_write: bool, -+ unchecked: bool, -+} -+ -+impl OpenOptions { -+ /// Creates a blank new set of options ready for configuration. -+ /// -+ /// All options are initially set to `false`. -+ pub fn new() -> OpenOptions { -+ OpenOptions { -+ #[cfg(target_os = "linux")] -+ read_write: false, -+ unchecked: false, -+ } -+ } -+ -+ /// Sets the option for read-write access. -+ /// -+ /// This option, when true, will indicate that a FIFO file will be opened -+ /// in read-write access mode. This operation is not defined by the POSIX -+ /// standard and is only guaranteed to work on Linux. -+ /// -+ /// # Examples -+ /// -+ /// Opening a [`Sender`] even if there are no open reading ends: -+ /// -+ /// ```ignore -+ /// use tokio::net::unix::pipe; -+ /// -+ /// let tx = pipe::OpenOptions::new() -+ /// .read_write(true) -+ /// .open_sender("path/to/a/fifo"); -+ /// ``` -+ /// -+ /// Opening a resilient [`Receiver`] i.e. a reading pipe end which will not -+ /// fail with [`UnexpectedEof`] during reading if all writing ends of the -+ /// pipe close the FIFO file. -+ /// -+ /// [`UnexpectedEof`]: std::io::ErrorKind::UnexpectedEof -+ /// -+ /// ```ignore -+ /// use tokio::net::unix::pipe; -+ /// -+ /// let tx = pipe::OpenOptions::new() -+ /// .read_write(true) -+ /// .open_receiver("path/to/a/fifo"); -+ /// ``` -+ #[cfg(target_os = "linux")] -+ #[cfg_attr(docsrs, doc(cfg(target_os = "linux")))] -+ pub fn read_write(&mut self, value: bool) -> &mut Self { -+ self.read_write = value; -+ self -+ } -+ -+ /// Sets the option to skip the check for FIFO file type. -+ /// -+ /// By default, [`open_receiver`] and [`open_sender`] functions will check -+ /// if the opened file is a FIFO file. Set this option to `true` if you are -+ /// sure the file is a FIFO file. -+ /// -+ /// [`open_receiver`]: OpenOptions::open_receiver -+ /// [`open_sender`]: OpenOptions::open_sender -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use nix::{unistd::mkfifo, sys::stat::Mode}; -+ /// # use std::error::Error; -+ /// -+ /// // Our program has exclusive access to this path. -+ /// const FIFO_NAME: &str = "path/to/a/new/fifo"; -+ /// -+ /// # async fn dox() -> Result<(), Box> { -+ /// mkfifo(FIFO_NAME, Mode::S_IRWXU)?; -+ /// let rx = pipe::OpenOptions::new() -+ /// .unchecked(true) -+ /// .open_receiver(FIFO_NAME)?; -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ pub fn unchecked(&mut self, value: bool) -> &mut Self { -+ self.unchecked = value; -+ self -+ } -+ -+ /// Creates a [`Receiver`] from a FIFO file with the options specified by `self`. -+ /// -+ /// This function will open the FIFO file at the specified path, possibly -+ /// check if it is a pipe, and associate the pipe with the default event -+ /// loop for reading. -+ /// -+ /// # Errors -+ /// -+ /// If the file type check fails, this function will fail with `io::ErrorKind::InvalidInput`. -+ /// This function may also fail with other standard OS errors. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. -+ /// -+ /// The runtime is usually set implicitly when this function is called -+ /// from a future driven by a tokio runtime, otherwise runtime can be set -+ /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ pub fn open_receiver>(&self, path: P) -> io::Result { -+ let file = self.open(path.as_ref(), PipeEnd::Receiver)?; -+ Receiver::from_file_unchecked(file) -+ } -+ -+ /// Creates a [`Sender`] from a FIFO file with the options specified by `self`. -+ /// -+ /// This function will open the FIFO file at the specified path, possibly -+ /// check if it is a pipe, and associate the pipe with the default event -+ /// loop for writing. -+ /// -+ /// # Errors -+ /// -+ /// If the file type check fails, this function will fail with `io::ErrorKind::InvalidInput`. -+ /// If the file is not opened in read-write access mode and the file is not -+ /// currently open for reading, this function will fail with `ENXIO`. -+ /// This function may also fail with other standard OS errors. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. -+ /// -+ /// The runtime is usually set implicitly when this function is called -+ /// from a future driven by a tokio runtime, otherwise runtime can be set -+ /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ pub fn open_sender>(&self, path: P) -> io::Result { -+ let file = self.open(path.as_ref(), PipeEnd::Sender)?; -+ Sender::from_file_unchecked(file) -+ } -+ -+ fn open(&self, path: &Path, pipe_end: PipeEnd) -> io::Result { -+ let mut options = std::fs::OpenOptions::new(); -+ options -+ .read(pipe_end == PipeEnd::Receiver) -+ .write(pipe_end == PipeEnd::Sender) -+ .custom_flags(libc::O_NONBLOCK); -+ -+ #[cfg(target_os = "linux")] -+ if self.read_write { -+ options.read(true).write(true); -+ } -+ -+ let file = options.open(path)?; -+ -+ if !self.unchecked && !is_fifo(&file)? { -+ return Err(io::Error::new(io::ErrorKind::InvalidInput, "not a pipe")); -+ } -+ -+ Ok(file) -+ } -+} -+ -+impl Default for OpenOptions { -+ fn default() -> OpenOptions { -+ OpenOptions::new() -+ } -+} -+ -+#[derive(Clone, Copy, PartialEq, Eq, Debug)] -+enum PipeEnd { -+ Sender, -+ Receiver, -+} -+ -+/// Writing end of a Unix pipe. -+/// -+/// It can be constructed from a FIFO file with [`OpenOptions::open_sender`]. -+/// -+/// Opening a named pipe for writing involves a few steps. -+/// Call to [`OpenOptions::open_sender`] might fail with an error indicating -+/// different things: -+/// -+/// * [`io::ErrorKind::NotFound`] - There is no file at the specified path. -+/// * [`io::ErrorKind::InvalidInput`] - The file exists, but it is not a FIFO. -+/// * [`ENXIO`] - The file is a FIFO, but no process has it open for reading. -+/// Sleep for a while and try again. -+/// * Other OS errors not specific to opening FIFO files. -+/// -+/// Opening a `Sender` from a FIFO file should look like this: -+/// -+/// ```no_run -+/// use tokio::net::unix::pipe; -+/// use tokio::time::{self, Duration}; -+/// -+/// const FIFO_NAME: &str = "path/to/a/fifo"; -+/// -+/// # async fn dox() -> Result<(), Box> { -+/// // Wait for a reader to open the file. -+/// let tx = loop { -+/// match pipe::OpenOptions::new().open_sender(FIFO_NAME) { -+/// Ok(tx) => break tx, -+/// Err(e) if e.raw_os_error() == Some(libc::ENXIO) => {}, -+/// Err(e) => return Err(e.into()), -+/// } -+/// -+/// time::sleep(Duration::from_millis(50)).await; -+/// }; -+/// # Ok(()) -+/// # } -+/// ``` -+/// -+/// On Linux, it is possible to create a `Sender` without waiting in a sleeping -+/// loop. This is done by opening a named pipe in read-write access mode with -+/// `OpenOptions::read_write`. This way, a `Sender` can at the same time hold -+/// both a writing end and a reading end, and the latter allows to open a FIFO -+/// without [`ENXIO`] error since the pipe is open for reading as well. -+/// -+/// `Sender` cannot be used to read from a pipe, so in practice the read access -+/// is only used when a FIFO is opened. However, using a `Sender` in read-write -+/// mode **may lead to lost data**, because written data will be dropped by the -+/// system as soon as all pipe ends are closed. To avoid lost data you have to -+/// make sure that a reading end has been opened before dropping a `Sender`. -+/// -+/// Note that using read-write access mode with FIFO files is not defined by -+/// the POSIX standard and it is only guaranteed to work on Linux. -+/// -+/// ```ignore -+/// use tokio::io::AsyncWriteExt; -+/// use tokio::net::unix::pipe; -+/// -+/// const FIFO_NAME: &str = "path/to/a/fifo"; -+/// -+/// # async fn dox() -> Result<(), Box> { -+/// let mut tx = pipe::OpenOptions::new() -+/// .read_write(true) -+/// .open_sender(FIFO_NAME)?; -+/// -+/// // Asynchronously write to the pipe before a reader. -+/// tx.write_all(b"hello world").await?; -+/// # Ok(()) -+/// # } -+/// ``` -+/// -+/// [`ENXIO`]: https://docs.rs/libc/latest/libc/constant.ENXIO.html -+#[derive(Debug)] -+pub struct Sender { -+ io: PollEvented, -+} -+ -+impl Sender { -+ fn from_mio(mio_tx: mio_pipe::Sender) -> io::Result { -+ let io = PollEvented::new_with_interest(mio_tx, Interest::WRITABLE)?; -+ Ok(Sender { io }) -+ } -+ -+ /// Creates a new `Sender` from a [`File`]. -+ /// -+ /// This function is intended to construct a pipe from a [`File`] representing -+ /// a special FIFO file. It will check if the file is a pipe and has write access, -+ /// set it in non-blocking mode and perform the conversion. -+ /// -+ /// # Errors -+ /// -+ /// Fails with `io::ErrorKind::InvalidInput` if the file is not a pipe or it -+ /// does not have write access. Also fails with any standard OS error if it occurs. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. -+ /// -+ /// The runtime is usually set implicitly when this function is called -+ /// from a future driven by a tokio runtime, otherwise runtime can be set -+ /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ pub fn from_file(mut file: File) -> io::Result { -+ if !is_fifo(&file)? { -+ return Err(io::Error::new(io::ErrorKind::InvalidInput, "not a pipe")); -+ } -+ -+ let flags = get_file_flags(&file)?; -+ if has_write_access(flags) { -+ set_nonblocking(&mut file, flags)?; -+ Sender::from_file_unchecked(file) -+ } else { -+ Err(io::Error::new( -+ io::ErrorKind::InvalidInput, -+ "not in O_WRONLY or O_RDWR access mode", -+ )) -+ } -+ } -+ -+ /// Creates a new `Sender` from a [`File`] without checking pipe properties. -+ /// -+ /// This function is intended to construct a pipe from a File representing -+ /// a special FIFO file. The conversion assumes nothing about the underlying -+ /// file; it is left up to the user to make sure it is opened with write access, -+ /// represents a pipe and is set in non-blocking mode. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::fs::OpenOptions; -+ /// use std::os::unix::fs::{FileTypeExt, OpenOptionsExt}; -+ /// # use std::error::Error; -+ /// -+ /// const FIFO_NAME: &str = "path/to/a/fifo"; -+ /// -+ /// # async fn dox() -> Result<(), Box> { -+ /// let file = OpenOptions::new() -+ /// .write(true) -+ /// .custom_flags(libc::O_NONBLOCK) -+ /// .open(FIFO_NAME)?; -+ /// if file.metadata()?.file_type().is_fifo() { -+ /// let tx = pipe::Sender::from_file_unchecked(file)?; -+ /// /* use the Sender */ -+ /// } -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ /// -+ /// # Panics -+ /// -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. -+ /// -+ /// The runtime is usually set implicitly when this function is called -+ /// from a future driven by a tokio runtime, otherwise runtime can be set -+ /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ pub fn from_file_unchecked(file: File) -> io::Result { -+ let raw_fd = file.into_raw_fd(); -+ let mio_tx = unsafe { mio_pipe::Sender::from_raw_fd(raw_fd) }; -+ Sender::from_mio(mio_tx) -+ } -+ -+ /// Waits for any of the requested ready states. -+ /// -+ /// This function can be used instead of [`writable()`] to check the returned -+ /// ready set for [`Ready::WRITABLE`] and [`Ready::WRITE_CLOSED`] events. -+ /// -+ /// The function may complete without the pipe being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// -+ /// [`writable()`]: Self::writable -+ /// -+ /// # Cancel safety -+ /// -+ /// This method is cancel safe. Once a readiness event occurs, the method -+ /// will continue to return immediately until the readiness event is -+ /// consumed by an attempt to write that fails with `WouldBlock` or -+ /// `Poll::Pending`. -+ pub async fn ready(&self, interest: Interest) -> io::Result { -+ let event = self.io.registration().readiness(interest).await?; -+ Ok(event.ready) -+ } -+ -+ /// Waits for the pipe to become writable. -+ /// -+ /// This function is equivalent to `ready(Interest::WRITABLE)` and is usually -+ /// paired with [`try_write()`]. -+ /// -+ /// [`try_write()`]: Self::try_write -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Open a writing end of a fifo -+ /// let tx = pipe::OpenOptions::new().open_sender("path/to/a/fifo")?; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be writable -+ /// tx.writable().await?; -+ /// -+ /// // Try to write data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match tx.try_write(b"hello world") { -+ /// Ok(n) => { -+ /// break; -+ /// } -+ /// Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub async fn writable(&self) -> io::Result<()> { -+ self.ready(Interest::WRITABLE).await?; -+ Ok(()) -+ } -+ -+ /// Polls for write readiness. -+ /// -+ /// If the pipe is not currently ready for writing, this method will -+ /// store a clone of the `Waker` from the provided `Context`. When the pipe -+ /// becomes ready for writing, `Waker::wake` will be called on the waker. -+ /// -+ /// Note that on multiple calls to `poll_write_ready` or `poll_write`, only -+ /// the `Waker` from the `Context` passed to the most recent call is -+ /// scheduled to receive a wakeup. -+ /// -+ /// This function is intended for cases where creating and pinning a future -+ /// via [`writable`] is not feasible. Where possible, using [`writable`] is -+ /// preferred, as this supports polling from multiple tasks at once. -+ /// -+ /// [`writable`]: Self::writable -+ /// -+ /// # Return value -+ /// -+ /// The function returns: -+ /// -+ /// * `Poll::Pending` if the pipe is not ready for writing. -+ /// * `Poll::Ready(Ok(()))` if the pipe is ready for writing. -+ /// * `Poll::Ready(Err(e))` if an error is encountered. -+ /// -+ /// # Errors -+ /// -+ /// This function may encounter any standard I/O error except `WouldBlock`. -+ pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll> { -+ self.io.registration().poll_write_ready(cx).map_ok(|_| ()) -+ } -+ -+ /// Tries to write a buffer to the pipe, returning how many bytes were -+ /// written. -+ /// -+ /// The function will attempt to write the entire contents of `buf`, but -+ /// only part of the buffer may be written. If the length of `buf` is not -+ /// greater than `PIPE_BUF` (an OS constant, 4096 under Linux), then the -+ /// write is guaranteed to be atomic, i.e. either the entire content of -+ /// `buf` will be written or this method will fail with `WouldBlock`. There -+ /// is no such guarantee if `buf` is larger than `PIPE_BUF`. -+ /// -+ /// This function is usually paired with [`writable`]. -+ /// -+ /// [`writable`]: Self::writable -+ /// -+ /// # Return -+ /// -+ /// If data is successfully written, `Ok(n)` is returned, where `n` is the -+ /// number of bytes written. If the pipe is not ready to write data, -+ /// `Err(io::ErrorKind::WouldBlock)` is returned. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Open a writing end of a fifo -+ /// let tx = pipe::OpenOptions::new().open_sender("path/to/a/fifo")?; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be writable -+ /// tx.writable().await?; -+ /// -+ /// // Try to write data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match tx.try_write(b"hello world") { -+ /// Ok(n) => { -+ /// break; -+ /// } -+ /// Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub fn try_write(&self, buf: &[u8]) -> io::Result { -+ self.io -+ .registration() -+ .try_io(Interest::WRITABLE, || (&*self.io).write(buf)) -+ } -+ -+ /// Tries to write several buffers to the pipe, returning how many bytes -+ /// were written. -+ /// -+ /// Data is written from each buffer in order, with the final buffer read -+ /// from possible being only partially consumed. This method behaves -+ /// equivalently to a single call to [`try_write()`] with concatenated -+ /// buffers. -+ /// -+ /// If the total length of buffers is not greater than `PIPE_BUF` (an OS -+ /// constant, 4096 under Linux), then the write is guaranteed to be atomic, -+ /// i.e. either the entire contents of buffers will be written or this -+ /// method will fail with `WouldBlock`. There is no such guarantee if the -+ /// total length of buffers is greater than `PIPE_BUF`. -+ /// -+ /// This function is usually paired with [`writable`]. -+ /// -+ /// [`try_write()`]: Self::try_write() -+ /// [`writable`]: Self::writable -+ /// -+ /// # Return -+ /// -+ /// If data is successfully written, `Ok(n)` is returned, where `n` is the -+ /// number of bytes written. If the pipe is not ready to write data, -+ /// `Err(io::ErrorKind::WouldBlock)` is returned. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Open a writing end of a fifo -+ /// let tx = pipe::OpenOptions::new().open_sender("path/to/a/fifo")?; -+ /// -+ /// let bufs = [io::IoSlice::new(b"hello "), io::IoSlice::new(b"world")]; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be writable -+ /// tx.writable().await?; -+ /// -+ /// // Try to write data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match tx.try_write_vectored(&bufs) { -+ /// Ok(n) => { -+ /// break; -+ /// } -+ /// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub fn try_write_vectored(&self, buf: &[io::IoSlice<'_>]) -> io::Result { -+ self.io -+ .registration() -+ .try_io(Interest::WRITABLE, || (&*self.io).write_vectored(buf)) -+ } -+} -+ -+impl AsyncWrite for Sender { -+ fn poll_write( -+ self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ buf: &[u8], -+ ) -> Poll> { -+ self.io.poll_write(cx, buf) -+ } -+ -+ fn poll_write_vectored( -+ self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ bufs: &[io::IoSlice<'_>], -+ ) -> Poll> { -+ self.io.poll_write_vectored(cx, bufs) -+ } -+ -+ fn is_write_vectored(&self) -> bool { -+ true -+ } -+ -+ fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll> { -+ Poll::Ready(Ok(())) -+ } -+ -+ fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll> { -+ Poll::Ready(Ok(())) -+ } -+} -+ -+impl AsRawFd for Sender { -+ fn as_raw_fd(&self) -> RawFd { -+ self.io.as_raw_fd() -+ } -+} -+ -+#[cfg(not(tokio_no_as_fd))] -+impl AsFd for Sender { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -+ -+/// Reading end of a Unix pipe. -+/// -+/// It can be constructed from a FIFO file with [`OpenOptions::open_receiver`]. -+/// -+/// # Examples -+/// -+/// Receiving messages from a named pipe in a loop: -+/// -+/// ```no_run -+/// use tokio::net::unix::pipe; -+/// use tokio::io::{self, AsyncReadExt}; -+/// -+/// const FIFO_NAME: &str = "path/to/a/fifo"; -+/// -+/// # async fn dox() -> Result<(), Box> { -+/// let mut rx = pipe::OpenOptions::new().open_receiver(FIFO_NAME)?; -+/// loop { -+/// let mut msg = vec![0; 256]; -+/// match rx.read_exact(&mut msg).await { -+/// Ok(_) => { -+/// /* handle the message */ -+/// } -+/// Err(e) if e.kind() == io::ErrorKind::UnexpectedEof => { -+/// // Writing end has been closed, we should reopen the pipe. -+/// rx = pipe::OpenOptions::new().open_receiver(FIFO_NAME)?; -+/// } -+/// Err(e) => return Err(e.into()), -+/// } -+/// } -+/// # } -+/// ``` -+/// -+/// On Linux, you can use a `Receiver` in read-write access mode to implement -+/// resilient reading from a named pipe. Unlike `Receiver` opened in read-only -+/// mode, read from a pipe in read-write mode will not fail with `UnexpectedEof` -+/// when the writing end is closed. This way, a `Receiver` can asynchronously -+/// wait for the next writer to open the pipe. -+/// -+/// You should not use functions waiting for EOF such as [`read_to_end`] with -+/// a `Receiver` in read-write access mode, since it **may wait forever**. -+/// `Receiver` in this mode also holds an open writing end, which prevents -+/// receiving EOF. -+/// -+/// To set the read-write access mode you can use `OpenOptions::read_write`. -+/// Note that using read-write access mode with FIFO files is not defined by -+/// the POSIX standard and it is only guaranteed to work on Linux. -+/// -+/// ```ignore -+/// use tokio::net::unix::pipe; -+/// use tokio::io::AsyncReadExt; -+/// # use std::error::Error; -+/// -+/// const FIFO_NAME: &str = "path/to/a/fifo"; -+/// -+/// # async fn dox() -> Result<(), Box> { -+/// let mut rx = pipe::OpenOptions::new() -+/// .read_write(true) -+/// .open_receiver(FIFO_NAME)?; -+/// loop { -+/// let mut msg = vec![0; 256]; -+/// rx.read_exact(&mut msg).await?; -+/// /* handle the message */ -+/// } -+/// # } -+/// ``` -+/// -+/// [`read_to_end`]: crate::io::AsyncReadExt::read_to_end -+#[derive(Debug)] -+pub struct Receiver { -+ io: PollEvented, -+} -+ -+impl Receiver { -+ fn from_mio(mio_rx: mio_pipe::Receiver) -> io::Result { -+ let io = PollEvented::new_with_interest(mio_rx, Interest::READABLE)?; -+ Ok(Receiver { io }) -+ } -+ -+ /// Creates a new `Receiver` from a [`File`]. -+ /// -+ /// This function is intended to construct a pipe from a [`File`] representing -+ /// a special FIFO file. It will check if the file is a pipe and has read access, -+ /// set it in non-blocking mode and perform the conversion. -+ /// -+ /// # Errors -+ /// -+ /// Fails with `io::ErrorKind::InvalidInput` if the file is not a pipe or it -+ /// does not have read access. Also fails with any standard OS error if it occurs. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. -+ /// -+ /// The runtime is usually set implicitly when this function is called -+ /// from a future driven by a tokio runtime, otherwise runtime can be set -+ /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ pub fn from_file(mut file: File) -> io::Result { -+ if !is_fifo(&file)? { -+ return Err(io::Error::new(io::ErrorKind::InvalidInput, "not a pipe")); -+ } -+ -+ let flags = get_file_flags(&file)?; -+ if has_read_access(flags) { -+ set_nonblocking(&mut file, flags)?; -+ Receiver::from_file_unchecked(file) -+ } else { -+ Err(io::Error::new( -+ io::ErrorKind::InvalidInput, -+ "not in O_RDONLY or O_RDWR access mode", -+ )) -+ } -+ } -+ -+ /// Creates a new `Receiver` from a [`File`] without checking pipe properties. -+ /// -+ /// This function is intended to construct a pipe from a File representing -+ /// a special FIFO file. The conversion assumes nothing about the underlying -+ /// file; it is left up to the user to make sure it is opened with read access, -+ /// represents a pipe and is set in non-blocking mode. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::fs::OpenOptions; -+ /// use std::os::unix::fs::{FileTypeExt, OpenOptionsExt}; -+ /// # use std::error::Error; -+ /// -+ /// const FIFO_NAME: &str = "path/to/a/fifo"; -+ /// -+ /// # async fn dox() -> Result<(), Box> { -+ /// let file = OpenOptions::new() -+ /// .read(true) -+ /// .custom_flags(libc::O_NONBLOCK) -+ /// .open(FIFO_NAME)?; -+ /// if file.metadata()?.file_type().is_fifo() { -+ /// let rx = pipe::Receiver::from_file_unchecked(file)?; -+ /// /* use the Receiver */ -+ /// } -+ /// # Ok(()) -+ /// # } -+ /// ``` -+ /// -+ /// # Panics -+ /// -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. -+ /// -+ /// The runtime is usually set implicitly when this function is called -+ /// from a future driven by a tokio runtime, otherwise runtime can be set -+ /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ pub fn from_file_unchecked(file: File) -> io::Result { -+ let raw_fd = file.into_raw_fd(); -+ let mio_rx = unsafe { mio_pipe::Receiver::from_raw_fd(raw_fd) }; -+ Receiver::from_mio(mio_rx) -+ } -+ -+ /// Waits for any of the requested ready states. -+ /// -+ /// This function can be used instead of [`readable()`] to check the returned -+ /// ready set for [`Ready::READABLE`] and [`Ready::READ_CLOSED`] events. -+ /// -+ /// The function may complete without the pipe being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// -+ /// [`readable()`]: Self::readable -+ /// -+ /// # Cancel safety -+ /// -+ /// This method is cancel safe. Once a readiness event occurs, the method -+ /// will continue to return immediately until the readiness event is -+ /// consumed by an attempt to read that fails with `WouldBlock` or -+ /// `Poll::Pending`. -+ pub async fn ready(&self, interest: Interest) -> io::Result { -+ let event = self.io.registration().readiness(interest).await?; -+ Ok(event.ready) -+ } -+ -+ /// Waits for the pipe to become readable. -+ /// -+ /// This function is equivalent to `ready(Interest::READABLE)` and is usually -+ /// paired with [`try_read()`]. -+ /// -+ /// [`try_read()`]: Self::try_read() -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Open a reading end of a fifo -+ /// let rx = pipe::OpenOptions::new().open_receiver("path/to/a/fifo")?; -+ /// -+ /// let mut msg = vec![0; 1024]; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be readable -+ /// rx.readable().await?; -+ /// -+ /// // Try to read data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match rx.try_read(&mut msg) { -+ /// Ok(n) => { -+ /// msg.truncate(n); -+ /// break; -+ /// } -+ /// Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// println!("GOT = {:?}", msg); -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub async fn readable(&self) -> io::Result<()> { -+ self.ready(Interest::READABLE).await?; -+ Ok(()) -+ } -+ -+ /// Polls for read readiness. -+ /// -+ /// If the pipe is not currently ready for reading, this method will -+ /// store a clone of the `Waker` from the provided `Context`. When the pipe -+ /// becomes ready for reading, `Waker::wake` will be called on the waker. -+ /// -+ /// Note that on multiple calls to `poll_read_ready` or `poll_read`, only -+ /// the `Waker` from the `Context` passed to the most recent call is -+ /// scheduled to receive a wakeup. -+ /// -+ /// This function is intended for cases where creating and pinning a future -+ /// via [`readable`] is not feasible. Where possible, using [`readable`] is -+ /// preferred, as this supports polling from multiple tasks at once. -+ /// -+ /// [`readable`]: Self::readable -+ /// -+ /// # Return value -+ /// -+ /// The function returns: -+ /// -+ /// * `Poll::Pending` if the pipe is not ready for reading. -+ /// * `Poll::Ready(Ok(()))` if the pipe is ready for reading. -+ /// * `Poll::Ready(Err(e))` if an error is encountered. -+ /// -+ /// # Errors -+ /// -+ /// This function may encounter any standard I/O error except `WouldBlock`. -+ pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll> { -+ self.io.registration().poll_read_ready(cx).map_ok(|_| ()) -+ } -+ -+ /// Tries to read data from the pipe into the provided buffer, returning how -+ /// many bytes were read. -+ /// -+ /// Reads any pending data from the pipe but does not wait for new data -+ /// to arrive. On success, returns the number of bytes read. Because -+ /// `try_read()` is non-blocking, the buffer does not have to be stored by -+ /// the async task and can exist entirely on the stack. -+ /// -+ /// Usually [`readable()`] is used with this function. -+ /// -+ /// [`readable()`]: Self::readable() -+ /// -+ /// # Return -+ /// -+ /// If data is successfully read, `Ok(n)` is returned, where `n` is the -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The pipe's writing end is closed and will no longer write data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the pipe is not ready to read data, -+ /// `Err(io::ErrorKind::WouldBlock)` is returned. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Open a reading end of a fifo -+ /// let rx = pipe::OpenOptions::new().open_receiver("path/to/a/fifo")?; -+ /// -+ /// let mut msg = vec![0; 1024]; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be readable -+ /// rx.readable().await?; -+ /// -+ /// // Try to read data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match rx.try_read(&mut msg) { -+ /// Ok(n) => { -+ /// msg.truncate(n); -+ /// break; -+ /// } -+ /// Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// println!("GOT = {:?}", msg); -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub fn try_read(&self, buf: &mut [u8]) -> io::Result { -+ self.io -+ .registration() -+ .try_io(Interest::READABLE, || (&*self.io).read(buf)) -+ } -+ -+ /// Tries to read data from the pipe into the provided buffers, returning -+ /// how many bytes were read. -+ /// -+ /// Data is copied to fill each buffer in order, with the final buffer -+ /// written to possibly being only partially filled. This method behaves -+ /// equivalently to a single call to [`try_read()`] with concatenated -+ /// buffers. -+ /// -+ /// Reads any pending data from the pipe but does not wait for new data -+ /// to arrive. On success, returns the number of bytes read. Because -+ /// `try_read_vectored()` is non-blocking, the buffer does not have to be -+ /// stored by the async task and can exist entirely on the stack. -+ /// -+ /// Usually, [`readable()`] is used with this function. -+ /// -+ /// [`try_read()`]: Self::try_read() -+ /// [`readable()`]: Self::readable() -+ /// -+ /// # Return -+ /// -+ /// If data is successfully read, `Ok(n)` is returned, where `n` is the -+ /// number of bytes read. `Ok(0)` indicates the pipe's writing end is -+ /// closed and will no longer write data. If the pipe is not ready to read -+ /// data `Err(io::ErrorKind::WouldBlock)` is returned. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Open a reading end of a fifo -+ /// let rx = pipe::OpenOptions::new().open_receiver("path/to/a/fifo")?; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be readable -+ /// rx.readable().await?; -+ /// -+ /// // Creating the buffer **after** the `await` prevents it from -+ /// // being stored in the async task. -+ /// let mut buf_a = [0; 512]; -+ /// let mut buf_b = [0; 1024]; -+ /// let mut bufs = [ -+ /// io::IoSliceMut::new(&mut buf_a), -+ /// io::IoSliceMut::new(&mut buf_b), -+ /// ]; -+ /// -+ /// // Try to read data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match rx.try_read_vectored(&mut bufs) { -+ /// Ok(0) => break, -+ /// Ok(n) => { -+ /// println!("read {} bytes", n); -+ /// } -+ /// Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub fn try_read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { -+ self.io -+ .registration() -+ .try_io(Interest::READABLE, || (&*self.io).read_vectored(bufs)) -+ } -+ -+ cfg_io_util! { -+ /// Tries to read data from the pipe into the provided buffer, advancing the -+ /// buffer's internal cursor, returning how many bytes were read. -+ /// -+ /// Reads any pending data from the pipe but does not wait for new data -+ /// to arrive. On success, returns the number of bytes read. Because -+ /// `try_read_buf()` is non-blocking, the buffer does not have to be stored by -+ /// the async task and can exist entirely on the stack. -+ /// -+ /// Usually, [`readable()`] or [`ready()`] is used with this function. -+ /// -+ /// [`readable()`]: Self::readable -+ /// [`ready()`]: Self::ready -+ /// -+ /// # Return -+ /// -+ /// If data is successfully read, `Ok(n)` is returned, where `n` is the -+ /// number of bytes read. `Ok(0)` indicates the pipe's writing end is -+ /// closed and will no longer write data. If the pipe is not ready to read -+ /// data `Err(io::ErrorKind::WouldBlock)` is returned. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::unix::pipe; -+ /// use std::io; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> io::Result<()> { -+ /// // Open a reading end of a fifo -+ /// let rx = pipe::OpenOptions::new().open_receiver("path/to/a/fifo")?; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be readable -+ /// rx.readable().await?; -+ /// -+ /// let mut buf = Vec::with_capacity(4096); -+ /// -+ /// // Try to read data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match rx.try_read_buf(&mut buf) { -+ /// Ok(0) => break, -+ /// Ok(n) => { -+ /// println!("read {} bytes", n); -+ /// } -+ /// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub fn try_read_buf(&self, buf: &mut B) -> io::Result { -+ self.io.registration().try_io(Interest::READABLE, || { -+ use std::io::Read; -+ -+ let dst = buf.chunk_mut(); -+ let dst = -+ unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; -+ -+ // Safety: `mio_pipe::Receiver` uses a `std::fs::File` underneath, -+ // which correctly handles reads into uninitialized memory. -+ let n = (&*self.io).read(dst)?; -+ -+ unsafe { -+ buf.advance_mut(n); -+ } -+ -+ Ok(n) -+ }) -+ } -+ } -+} -+ -+impl AsyncRead for Receiver { -+ fn poll_read( -+ self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ buf: &mut ReadBuf<'_>, -+ ) -> Poll> { -+ // Safety: `mio_pipe::Receiver` uses a `std::fs::File` underneath, -+ // which correctly handles reads into uninitialized memory. -+ unsafe { self.io.poll_read(cx, buf) } -+ } -+} -+ -+impl AsRawFd for Receiver { -+ fn as_raw_fd(&self) -> RawFd { -+ self.io.as_raw_fd() -+ } -+} -+ -+#[cfg(not(tokio_no_as_fd))] -+impl AsFd for Receiver { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -+ -+/// Checks if file is a FIFO -+fn is_fifo(file: &File) -> io::Result { -+ Ok(file.metadata()?.file_type().is_fifo()) -+} -+ -+/// Gets file descriptor's flags by fcntl. -+fn get_file_flags(file: &File) -> io::Result { -+ let fd = file.as_raw_fd(); -+ let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) }; -+ if flags < 0 { -+ Err(io::Error::last_os_error()) -+ } else { -+ Ok(flags) -+ } -+} -+ -+/// Checks for O_RDONLY or O_RDWR access mode. -+fn has_read_access(flags: libc::c_int) -> bool { -+ let mode = flags & libc::O_ACCMODE; -+ mode == libc::O_RDONLY || mode == libc::O_RDWR -+} -+ -+/// Checks for O_WRONLY or O_RDWR access mode. -+fn has_write_access(flags: libc::c_int) -> bool { -+ let mode = flags & libc::O_ACCMODE; -+ mode == libc::O_WRONLY || mode == libc::O_RDWR -+} -+ -+/// Sets file's flags with O_NONBLOCK by fcntl. -+fn set_nonblocking(file: &mut File, current_flags: libc::c_int) -> io::Result<()> { -+ let fd = file.as_raw_fd(); -+ -+ let flags = current_flags | libc::O_NONBLOCK; -+ -+ if flags != current_flags { -+ let ret = unsafe { libc::fcntl(fd, libc::F_SETFL, flags) }; -+ if ret < 0 { -+ return Err(io::Error::last_os_error()); -+ } -+ } -+ -+ Ok(()) -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/net/unix/split.rs b/KubeOS-Rust/vendor/tokio/src/net/unix/split.rs -index d4686c22..6fc7067a 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/unix/split.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/unix/split.rs -@@ -55,9 +55,20 @@ pub(crate) fn split(stream: &mut UnixStream) -> (ReadHalf<'_>, WriteHalf<'_>) { - impl ReadHalf<'_> { - /// Wait for any of the requested ready states. - /// -- /// This function is usually paired with `try_read()` or `try_write()`. It -- /// can be used to concurrently read / write to the same socket on a single -- /// task without splitting the socket. -+ /// This function is usually paired with [`try_read()`]. It can be used instead -+ /// of [`readable()`] to check the returned ready set for [`Ready::READABLE`] -+ /// and [`Ready::READ_CLOSED`] events. -+ /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// -+ /// This function is equivalent to [`UnixStream::ready`]. -+ /// -+ /// [`try_read()`]: Self::try_read -+ /// [`readable()`]: Self::readable - /// - /// # Cancel safety - /// -@@ -100,8 +111,12 @@ impl ReadHalf<'_> { - /// # Return - /// - /// If data is successfully read, `Ok(n)` is returned, where `n` is the -- /// number of bytes read. `Ok(0)` indicates the stream's read half is closed -- /// and will no longer yield data. If the stream is not ready to read data -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The stream's read half is closed and will no longer yield data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the stream is not ready to read data, - /// `Err(io::ErrorKind::WouldBlock)` is returned. - pub fn try_read(&self, buf: &mut [u8]) -> io::Result { - self.0.try_read(buf) -@@ -174,9 +189,20 @@ impl ReadHalf<'_> { - impl WriteHalf<'_> { - /// Waits for any of the requested ready states. - /// -- /// This function is usually paired with `try_read()` or `try_write()`. It -- /// can be used to concurrently read / write to the same socket on a single -- /// task without splitting the socket. -+ /// This function is usually paired with [`try_write()`]. It can be used instead -+ /// of [`writable()`] to check the returned ready set for [`Ready::WRITABLE`] -+ /// and [`Ready::WRITE_CLOSED`] events. -+ /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// -+ /// This function is equivalent to [`UnixStream::ready`]. -+ /// -+ /// [`try_write()`]: Self::try_write -+ /// [`writable()`]: Self::writable - /// - /// # Cancel safety - /// -diff --git a/KubeOS-Rust/vendor/tokio/src/net/unix/split_owned.rs b/KubeOS-Rust/vendor/tokio/src/net/unix/split_owned.rs -index 9c3a2a41..d1c6f93d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/unix/split_owned.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/unix/split_owned.rs -@@ -110,9 +110,20 @@ impl OwnedReadHalf { - - /// Waits for any of the requested ready states. - /// -- /// This function is usually paired with `try_read()` or `try_write()`. It -- /// can be used to concurrently read / write to the same socket on a single -- /// task without splitting the socket. -+ /// This function is usually paired with [`try_read()`]. It can be used instead -+ /// of [`readable()`] to check the returned ready set for [`Ready::READABLE`] -+ /// and [`Ready::READ_CLOSED`] events. -+ /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// -+ /// This function is equivalent to [`UnixStream::ready`]. -+ /// -+ /// [`try_read()`]: Self::try_read -+ /// [`readable()`]: Self::readable - /// - /// # Cancel safety - /// -@@ -155,8 +166,12 @@ impl OwnedReadHalf { - /// # Return - /// - /// If data is successfully read, `Ok(n)` is returned, where `n` is the -- /// number of bytes read. `Ok(0)` indicates the stream's read half is closed -- /// and will no longer yield data. If the stream is not ready to read data -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The stream's read half is closed and will no longer yield data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the stream is not ready to read data, - /// `Err(io::ErrorKind::WouldBlock)` is returned. - pub fn try_read(&self, buf: &mut [u8]) -> io::Result { - self.inner.try_read(buf) -@@ -257,9 +272,20 @@ impl OwnedWriteHalf { - - /// Waits for any of the requested ready states. - /// -- /// This function is usually paired with `try_read()` or `try_write()`. It -- /// can be used to concurrently read / write to the same socket on a single -- /// task without splitting the socket. -+ /// This function is usually paired with [`try_write()`]. It can be used instead -+ /// of [`writable()`] to check the returned ready set for [`Ready::WRITABLE`] -+ /// and [`Ready::WRITE_CLOSED`] events. -+ /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// -+ /// This function is equivalent to [`UnixStream::ready`]. -+ /// -+ /// [`try_write()`]: Self::try_write -+ /// [`writable()`]: Self::writable - /// - /// # Cancel safety - /// -@@ -382,12 +408,12 @@ impl AsyncWrite for OwnedWriteHalf { - - impl AsRef for OwnedReadHalf { - fn as_ref(&self) -> &UnixStream { -- &*self.inner -+ &self.inner - } - } - - impl AsRef for OwnedWriteHalf { - fn as_ref(&self) -> &UnixStream { -- &*self.inner -+ &self.inner - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/net/unix/stream.rs b/KubeOS-Rust/vendor/tokio/src/net/unix/stream.rs -index 4e7ef87b..f8afa5a8 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/unix/stream.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/unix/stream.rs -@@ -5,10 +5,11 @@ use crate::net::unix::split_owned::{split_owned, OwnedReadHalf, OwnedWriteHalf}; - use crate::net::unix::ucred::{self, UCred}; - use crate::net::unix::SocketAddr; - --use std::convert::TryFrom; - use std::fmt; - use std::io::{self, Read, Write}; - use std::net::Shutdown; -+#[cfg(not(tokio_no_as_fd))] -+use std::os::unix::io::{AsFd, BorrowedFd}; - use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; - use std::os::unix::net; - use std::path::Path; -@@ -22,8 +23,8 @@ cfg_io_util! { - cfg_net_unix! { - /// A structure representing a connected Unix socket. - /// -- /// This socket can be connected directly with `UnixStream::connect` or accepted -- /// from a listener with `UnixListener::incoming`. Additionally, a pair of -+ /// This socket can be connected directly with [`UnixStream::connect`] or accepted -+ /// from a listener with [`UnixListener::accept`]. Additionally, a pair of - /// anonymous Unix sockets can be created with `UnixStream::pair`. - /// - /// To shut down the stream in the write direction, you can call the -@@ -32,6 +33,7 @@ cfg_net_unix! { - /// the stream in one direction. - /// - /// [`shutdown()`]: fn@crate::io::AsyncWriteExt::shutdown -+ /// [`UnixListener::accept`]: crate::net::UnixListener::accept - pub struct UnixStream { - io: PollEvented, - } -@@ -65,6 +67,12 @@ impl UnixStream { - /// can be used to concurrently read / write to the same socket on a single - /// task without splitting the socket. - /// -+ /// The function may complete without the socket being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// - /// # Cancel safety - /// - /// This method is cancel safe. Once a readiness event occurs, the method -@@ -239,8 +247,12 @@ impl UnixStream { - /// # Return - /// - /// If data is successfully read, `Ok(n)` is returned, where `n` is the -- /// number of bytes read. `Ok(0)` indicates the stream's read half is closed -- /// and will no longer yield data. If the stream is not ready to read data -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The stream's read half is closed and will no longer yield data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the stream is not ready to read data, - /// `Err(io::ErrorKind::WouldBlock)` is returned. - /// - /// # Examples -@@ -656,7 +668,7 @@ impl UnixStream { - /// Tries to read or write from the socket using a user-provided IO operation. - /// - /// If the socket is ready, the provided closure is called. The closure -- /// should attempt to perform IO operation from the socket by manually -+ /// should attempt to perform IO operation on the socket by manually - /// calling the appropriate syscall. If the operation fails because the - /// socket is not actually ready, then the closure should return a - /// `WouldBlock` error and the readiness flag is cleared. The return value -@@ -675,6 +687,11 @@ impl UnixStream { - /// defined on the Tokio `UnixStream` type, as this will mess with the - /// readiness flag and can cause the socket to behave incorrectly. - /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ /// - /// Usually, [`readable()`], [`writable()`] or [`ready()`] is used with this function. - /// - /// [`readable()`]: UnixStream::readable() -@@ -685,23 +702,85 @@ impl UnixStream { - interest: Interest, - f: impl FnOnce() -> io::Result, - ) -> io::Result { -- self.io.registration().try_io(interest, f) -+ self.io -+ .registration() -+ .try_io(interest, || self.io.try_io(f)) -+ } -+ -+ /// Reads or writes from the socket using a user-provided IO operation. -+ /// -+ /// The readiness of the socket is awaited and when the socket is ready, -+ /// the provided closure is called. The closure should attempt to perform -+ /// IO operation on the socket by manually calling the appropriate syscall. -+ /// If the operation fails because the socket is not actually ready, -+ /// then the closure should return a `WouldBlock` error. In such case the -+ /// readiness flag is cleared and the socket readiness is awaited again. -+ /// This loop is repeated until the closure returns an `Ok` or an error -+ /// other than `WouldBlock`. -+ /// -+ /// The closure should only return a `WouldBlock` error if it has performed -+ /// an IO operation on the socket that failed due to the socket not being -+ /// ready. Returning a `WouldBlock` error in any other situation will -+ /// incorrectly clear the readiness flag, which can cause the socket to -+ /// behave incorrectly. -+ /// -+ /// The closure should not perform the IO operation using any of the methods -+ /// defined on the Tokio `UnixStream` type, as this will mess with the -+ /// readiness flag and can cause the socket to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ pub async fn async_io( -+ &self, -+ interest: Interest, -+ mut f: impl FnMut() -> io::Result, -+ ) -> io::Result { -+ self.io -+ .registration() -+ .async_io(interest, || self.io.try_io(&mut f)) -+ .await - } - - /// Creates new `UnixStream` from a `std::os::unix::net::UnixStream`. - /// - /// This function is intended to be used to wrap a UnixStream from the -- /// standard library in the Tokio equivalent. The conversion assumes -- /// nothing about the underlying stream; it is left up to the user to set -- /// it in non-blocking mode. -+ /// standard library in the Tokio equivalent. -+ /// -+ /// # Notes -+ /// -+ /// The caller is responsible for ensuring that the stream is in -+ /// non-blocking mode. Otherwise all I/O operations on the stream -+ /// will block the thread, which will cause unexpected behavior. -+ /// Non-blocking mode can be set using [`set_nonblocking`]. -+ /// -+ /// [`set_nonblocking`]: std::os::unix::net::UnixStream::set_nonblocking -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::UnixStream; -+ /// use std::os::unix::net::UnixStream as StdUnixStream; -+ /// # use std::error::Error; -+ /// -+ /// # async fn dox() -> Result<(), Box> { -+ /// let std_stream = StdUnixStream::connect("/path/to/the/socket")?; -+ /// std_stream.set_nonblocking(true)?; -+ /// let stream = UnixStream::from_std(std_stream)?; -+ /// # Ok(()) -+ /// # } -+ /// ``` - /// - /// # Panics - /// -- /// This function panics if thread-local runtime is not set. -+ /// This function panics if it is not called from within a runtime with -+ /// IO enabled. - /// - /// The runtime is usually set implicitly when this function is called - /// from a future driven by a tokio runtime, otherwise runtime can be set - /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function. -+ #[track_caller] - pub fn from_std(stream: net::UnixStream) -> io::Result { - let stream = mio::net::UnixStream::from_std(stream); - let io = PollEvented::new(stream)?; -@@ -958,3 +1037,10 @@ impl AsRawFd for UnixStream { - self.io.as_raw_fd() - } - } -+ -+#[cfg(not(tokio_no_as_fd))] -+impl AsFd for UnixStream { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/net/unix/ucred.rs b/KubeOS-Rust/vendor/tokio/src/net/unix/ucred.rs -index 865303b4..0a78fc5d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/unix/ucred.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/unix/ucred.rs -@@ -1,24 +1,24 @@ --use libc::{gid_t, pid_t, uid_t}; -+use crate::net::unix; - - /// Credentials of a process. - #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)] - pub struct UCred { - /// PID (process ID) of the process. -- pid: Option, -+ pid: Option, - /// UID (user ID) of the process. -- uid: uid_t, -+ uid: unix::uid_t, - /// GID (group ID) of the process. -- gid: gid_t, -+ gid: unix::gid_t, - } - - impl UCred { - /// Gets UID (user ID) of the process. -- pub fn uid(&self) -> uid_t { -+ pub fn uid(&self) -> unix::uid_t { - self.uid - } - - /// Gets GID (group ID) of the process. -- pub fn gid(&self) -> gid_t { -+ pub fn gid(&self) -> unix::gid_t { - self.gid - } - -@@ -26,7 +26,7 @@ impl UCred { - /// - /// This is only implemented under Linux, Android, iOS, macOS, Solaris and - /// Illumos. On other platforms this will always return `None`. -- pub fn pid(&self) -> Option { -+ pub fn pid(&self) -> Option { - self.pid - } - } -@@ -46,9 +46,12 @@ pub(crate) use self::impl_macos::get_peer_cred; - #[cfg(any(target_os = "solaris", target_os = "illumos"))] - pub(crate) use self::impl_solaris::get_peer_cred; - -+#[cfg(target_os = "aix")] -+pub(crate) use self::impl_aix::get_peer_cred; -+ - #[cfg(any(target_os = "linux", target_os = "android", target_os = "openbsd"))] - pub(crate) mod impl_linux { -- use crate::net::unix::UnixStream; -+ use crate::net::unix::{self, UnixStream}; - - use libc::{c_void, getsockopt, socklen_t, SOL_SOCKET, SO_PEERCRED}; - use std::{io, mem}; -@@ -87,9 +90,9 @@ pub(crate) mod impl_linux { - ); - if ret == 0 && ucred_size as usize == mem::size_of::() { - Ok(super::UCred { -- uid: ucred.uid, -- gid: ucred.gid, -- pid: Some(ucred.pid), -+ uid: ucred.uid as unix::uid_t, -+ gid: ucred.gid as unix::gid_t, -+ pid: Some(ucred.pid as unix::pid_t), - }) - } else { - Err(io::Error::last_os_error()) -@@ -100,7 +103,7 @@ pub(crate) mod impl_linux { - - #[cfg(any(target_os = "netbsd"))] - pub(crate) mod impl_netbsd { -- use crate::net::unix::UnixStream; -+ use crate::net::unix::{self, UnixStream}; - - use libc::{c_void, getsockopt, socklen_t, unpcbid, LOCAL_PEEREID, SOL_SOCKET}; - use std::io; -@@ -129,9 +132,9 @@ pub(crate) mod impl_netbsd { - ); - if ret == 0 && unpcbid_size as usize == size_of::() { - Ok(super::UCred { -- uid: unpcbid.unp_euid, -- gid: unpcbid.unp_egid, -- pid: Some(unpcbid.unp_pid), -+ uid: unpcbid.unp_euid as unix::uid_t, -+ gid: unpcbid.unp_egid as unix::gid_t, -+ pid: Some(unpcbid.unp_pid as unix::pid_t), - }) - } else { - Err(io::Error::last_os_error()) -@@ -142,7 +145,7 @@ pub(crate) mod impl_netbsd { - - #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))] - pub(crate) mod impl_bsd { -- use crate::net::unix::UnixStream; -+ use crate::net::unix::{self, UnixStream}; - - use libc::getpeereid; - use std::io; -@@ -160,8 +163,8 @@ pub(crate) mod impl_bsd { - - if ret == 0 { - Ok(super::UCred { -- uid: uid.assume_init(), -- gid: gid.assume_init(), -+ uid: uid.assume_init() as unix::uid_t, -+ gid: gid.assume_init() as unix::gid_t, - pid: None, - }) - } else { -@@ -173,7 +176,7 @@ pub(crate) mod impl_bsd { - - #[cfg(any(target_os = "macos", target_os = "ios"))] - pub(crate) mod impl_macos { -- use crate::net::unix::UnixStream; -+ use crate::net::unix::{self, UnixStream}; - - use libc::{c_void, getpeereid, getsockopt, pid_t, LOCAL_PEEREPID, SOL_LOCAL}; - use std::io; -@@ -207,9 +210,9 @@ pub(crate) mod impl_macos { - - if ret == 0 { - Ok(super::UCred { -- uid: uid.assume_init(), -- gid: gid.assume_init(), -- pid: Some(pid.assume_init()), -+ uid: uid.assume_init() as unix::uid_t, -+ gid: gid.assume_init() as unix::gid_t, -+ pid: Some(pid.assume_init() as unix::pid_t), - }) - } else { - Err(io::Error::last_os_error()) -@@ -220,7 +223,7 @@ pub(crate) mod impl_macos { - - #[cfg(any(target_os = "solaris", target_os = "illumos"))] - pub(crate) mod impl_solaris { -- use crate::net::unix::UnixStream; -+ use crate::net::unix::{self, UnixStream}; - use std::io; - use std::os::unix::io::AsRawFd; - use std::ptr; -@@ -240,9 +243,37 @@ pub(crate) mod impl_solaris { - libc::ucred_free(cred); - - Ok(super::UCred { -- uid, -- gid, -- pid: Some(pid), -+ uid: uid as unix::uid_t, -+ gid: gid as unix::gid_t, -+ pid: Some(pid as unix::pid_t), -+ }) -+ } else { -+ Err(io::Error::last_os_error()) -+ } -+ } -+ } -+} -+ -+#[cfg(target_os = "aix")] -+pub(crate) mod impl_aix { -+ use crate::net::unix::UnixStream; -+ use std::io; -+ use std::os::unix::io::AsRawFd; -+ -+ pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result { -+ unsafe { -+ let raw_fd = sock.as_raw_fd(); -+ -+ let mut uid = std::mem::MaybeUninit::uninit(); -+ let mut gid = std::mem::MaybeUninit::uninit(); -+ -+ let ret = libc::getpeereid(raw_fd, uid.as_mut_ptr(), gid.as_mut_ptr()); -+ -+ if ret == 0 { -+ Ok(super::UCred { -+ uid: uid.assume_init(), -+ gid: gid.assume_init(), -+ pid: None, - }) - } else { - Err(io::Error::last_os_error()) -diff --git a/KubeOS-Rust/vendor/tokio/src/net/windows/named_pipe.rs b/KubeOS-Rust/vendor/tokio/src/net/windows/named_pipe.rs -index 550fd4df..91f01626 100644 ---- a/KubeOS-Rust/vendor/tokio/src/net/windows/named_pipe.rs -+++ b/KubeOS-Rust/vendor/tokio/src/net/windows/named_pipe.rs -@@ -10,27 +10,30 @@ use std::ptr; - use std::task::{Context, Poll}; - - use crate::io::{AsyncRead, AsyncWrite, Interest, PollEvented, ReadBuf, Ready}; -+#[cfg(not(tokio_no_as_fd))] -+use crate::os::windows::io::{AsHandle, BorrowedHandle}; - use crate::os::windows::io::{AsRawHandle, FromRawHandle, RawHandle}; - -+cfg_io_util! { -+ use bytes::BufMut; -+} -+ - // Hide imports which are not used when generating documentation. - #[cfg(not(docsrs))] - mod doc { - pub(super) use crate::os::windows::ffi::OsStrExt; -- pub(super) use crate::winapi::shared::minwindef::{DWORD, FALSE}; -- pub(super) use crate::winapi::um::fileapi; -- pub(super) use crate::winapi::um::handleapi; -- pub(super) use crate::winapi::um::namedpipeapi; -- pub(super) use crate::winapi::um::winbase; -- pub(super) use crate::winapi::um::winnt; -- -+ pub(super) mod windows_sys { -+ pub(crate) use windows_sys::{ -+ Win32::Foundation::*, Win32::Storage::FileSystem::*, Win32::System::Pipes::*, -+ Win32::System::SystemServices::*, -+ }; -+ } - pub(super) use mio::windows as mio_windows; - } - - // NB: none of these shows up in public API, so don't document them. - #[cfg(docsrs)] - mod doc { -- pub type DWORD = crate::doc::NotDefinedHere; -- - pub(super) mod mio_windows { - pub type NamedPipe = crate::doc::NotDefinedHere; - } -@@ -97,7 +100,6 @@ use self::doc::*; - /// # Ok(()) } - /// ``` - /// --/// [`ERROR_PIPE_BUSY`]: crate::winapi::shared::winerror::ERROR_PIPE_BUSY - /// [Windows named pipe]: https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes - #[derive(Debug)] - pub struct NamedPipeServer { -@@ -188,17 +190,15 @@ impl NamedPipeServer { - /// # Ok(()) } - /// ``` - pub async fn connect(&self) -> io::Result<()> { -- loop { -- match self.io.connect() { -- Ok(()) => break, -- Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -- self.io.registration().readiness(Interest::WRITABLE).await?; -- } -- Err(e) => return Err(e), -+ match self.io.connect() { -+ Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ self.io -+ .registration() -+ .async_io(Interest::WRITABLE, || self.io.connect()) -+ .await - } -+ x => x, - } -- -- Ok(()) - } - - /// Disconnects the server end of a named pipe instance from a client -@@ -207,7 +207,7 @@ impl NamedPipeServer { - /// ``` - /// use tokio::io::AsyncWriteExt; - /// use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions}; -- /// use winapi::shared::winerror; -+ /// use windows_sys::Win32::Foundation::ERROR_PIPE_NOT_CONNECTED; - /// - /// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-disconnect"; - /// -@@ -227,7 +227,7 @@ impl NamedPipeServer { - /// // Write fails with an OS-specific error after client has been - /// // disconnected. - /// let e = client.write(b"ping").await.unwrap_err(); -- /// assert_eq!(e.raw_os_error(), Some(winerror::ERROR_PIPE_NOT_CONNECTED as i32)); -+ /// assert_eq!(e.raw_os_error(), Some(ERROR_PIPE_NOT_CONNECTED as i32)); - /// # Ok(()) } - /// ``` - pub fn disconnect(&self) -> io::Result<()> { -@@ -240,6 +240,12 @@ impl NamedPipeServer { - /// can be used to concurrently read / write to the same pipe on a single - /// task without splitting the pipe. - /// -+ /// The function may complete without the pipe being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// - /// # Examples - /// - /// Concurrently read and write to the pipe on the same task without -@@ -399,8 +405,12 @@ impl NamedPipeServer { - /// # Return - /// - /// If data is successfully read, `Ok(n)` is returned, where `n` is the -- /// number of bytes read. `Ok(0)` indicates the pipe's read half is closed -- /// and will no longer yield data. If the pipe is not ready to read data -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The pipe's read half is closed and will no longer yield data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the pipe is not ready to read data, - /// `Err(io::ErrorKind::WouldBlock)` is returned. - /// - /// # Examples -@@ -528,6 +538,86 @@ impl NamedPipeServer { - .try_io(Interest::READABLE, || (&*self.io).read_vectored(bufs)) - } - -+ cfg_io_util! { -+ /// Tries to read data from the stream into the provided buffer, advancing the -+ /// buffer's internal cursor, returning how many bytes were read. -+ /// -+ /// Receives any pending data from the pipe but does not wait for new data -+ /// to arrive. On success, returns the number of bytes read. Because -+ /// `try_read_buf()` is non-blocking, the buffer does not have to be stored by -+ /// the async task and can exist entirely on the stack. -+ /// -+ /// Usually, [`readable()`] or [`ready()`] is used with this function. -+ /// -+ /// [`readable()`]: NamedPipeServer::readable() -+ /// [`ready()`]: NamedPipeServer::ready() -+ /// -+ /// # Return -+ /// -+ /// If data is successfully read, `Ok(n)` is returned, where `n` is the -+ /// number of bytes read. `Ok(0)` indicates the stream's read half is closed -+ /// and will no longer yield data. If the stream is not ready to read data -+ /// `Err(io::ErrorKind::WouldBlock)` is returned. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::windows::named_pipe; -+ /// use std::error::Error; -+ /// use std::io; -+ /// -+ /// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-readable"; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> Result<(), Box> { -+ /// let server = named_pipe::ServerOptions::new().create(PIPE_NAME)?; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be readable -+ /// server.readable().await?; -+ /// -+ /// let mut buf = Vec::with_capacity(4096); -+ /// -+ /// // Try to read data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match server.try_read_buf(&mut buf) { -+ /// Ok(0) => break, -+ /// Ok(n) => { -+ /// println!("read {} bytes", n); -+ /// } -+ /// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub fn try_read_buf(&self, buf: &mut B) -> io::Result { -+ self.io.registration().try_io(Interest::READABLE, || { -+ use std::io::Read; -+ -+ let dst = buf.chunk_mut(); -+ let dst = -+ unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; -+ -+ // Safety: We trust `NamedPipeServer::read` to have filled up `n` bytes in the -+ // buffer. -+ let n = (&*self.io).read(dst)?; -+ -+ unsafe { -+ buf.advance_mut(n); -+ } -+ -+ Ok(n) -+ }) -+ } -+ } -+ - /// Waits for the pipe to become writable. - /// - /// This function is equivalent to `ready(Interest::WRITABLE)` and is usually -@@ -724,27 +814,32 @@ impl NamedPipeServer { - .try_io(Interest::WRITABLE, || (&*self.io).write_vectored(buf)) - } - -- /// Tries to read or write from the socket using a user-provided IO operation. -+ /// Tries to read or write from the pipe using a user-provided IO operation. - /// -- /// If the socket is ready, the provided closure is called. The closure -- /// should attempt to perform IO operation from the socket by manually -+ /// If the pipe is ready, the provided closure is called. The closure -+ /// should attempt to perform IO operation from the pipe by manually - /// calling the appropriate syscall. If the operation fails because the -- /// socket is not actually ready, then the closure should return a -+ /// pipe is not actually ready, then the closure should return a - /// `WouldBlock` error and the readiness flag is cleared. The return value - /// of the closure is then returned by `try_io`. - /// -- /// If the socket is not ready, then the closure is not called -+ /// If the pipe is not ready, then the closure is not called - /// and a `WouldBlock` error is returned. - /// - /// The closure should only return a `WouldBlock` error if it has performed -- /// an IO operation on the socket that failed due to the socket not being -+ /// an IO operation on the pipe that failed due to the pipe not being - /// ready. Returning a `WouldBlock` error in any other situation will -- /// incorrectly clear the readiness flag, which can cause the socket to -+ /// incorrectly clear the readiness flag, which can cause the pipe to - /// behave incorrectly. - /// - /// The closure should not perform the IO operation using any of the - /// methods defined on the Tokio `NamedPipeServer` type, as this will mess with -- /// the readiness flag and can cause the socket to behave incorrectly. -+ /// the readiness flag and can cause the pipe to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. - /// - /// Usually, [`readable()`], [`writable()`] or [`ready()`] is used with this function. - /// -@@ -758,6 +853,39 @@ impl NamedPipeServer { - ) -> io::Result { - self.io.registration().try_io(interest, f) - } -+ -+ /// Reads or writes from the pipe using a user-provided IO operation. -+ /// -+ /// The readiness of the pipe is awaited and when the pipe is ready, -+ /// the provided closure is called. The closure should attempt to perform -+ /// IO operation on the pipe by manually calling the appropriate syscall. -+ /// If the operation fails because the pipe is not actually ready, -+ /// then the closure should return a `WouldBlock` error. In such case the -+ /// readiness flag is cleared and the pipe readiness is awaited again. -+ /// This loop is repeated until the closure returns an `Ok` or an error -+ /// other than `WouldBlock`. -+ /// -+ /// The closure should only return a `WouldBlock` error if it has performed -+ /// an IO operation on the pipe that failed due to the pipe not being -+ /// ready. Returning a `WouldBlock` error in any other situation will -+ /// incorrectly clear the readiness flag, which can cause the pipe to -+ /// behave incorrectly. -+ /// -+ /// The closure should not perform the IO operation using any of the methods -+ /// defined on the Tokio `NamedPipeServer` type, as this will mess with the -+ /// readiness flag and can cause the pipe to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ pub async fn async_io( -+ &self, -+ interest: Interest, -+ f: impl FnMut() -> io::Result, -+ ) -> io::Result { -+ self.io.registration().async_io(interest, f).await -+ } - } - - impl AsyncRead for NamedPipeServer { -@@ -802,6 +930,13 @@ impl AsRawHandle for NamedPipeServer { - } - } - -+#[cfg(not(tokio_no_as_fd))] -+impl AsHandle for NamedPipeServer { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) } -+ } -+} -+ - /// A [Windows named pipe] client. - /// - /// Constructed using [`ClientOptions::open`]. -@@ -819,7 +954,7 @@ impl AsRawHandle for NamedPipeServer { - /// use std::time::Duration; - /// use tokio::net::windows::named_pipe::ClientOptions; - /// use tokio::time; --/// use winapi::shared::winerror; -+/// use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY; - /// - /// const PIPE_NAME: &str = r"\\.\pipe\named-pipe-idiomatic-client"; - /// -@@ -827,7 +962,7 @@ impl AsRawHandle for NamedPipeServer { - /// let client = loop { - /// match ClientOptions::new().open(PIPE_NAME) { - /// Ok(client) => break client, --/// Err(e) if e.raw_os_error() == Some(winerror::ERROR_PIPE_BUSY as i32) => (), -+/// Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (), - /// Err(e) => return Err(e), - /// } - /// -@@ -838,7 +973,7 @@ impl AsRawHandle for NamedPipeServer { - /// # Ok(()) } - /// ``` - /// --/// [`ERROR_PIPE_BUSY`]: crate::winapi::shared::winerror::ERROR_PIPE_BUSY -+/// [`ERROR_PIPE_BUSY`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Foundation/constant.ERROR_PIPE_BUSY.html - /// [Windows named pipe]: https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes - #[derive(Debug)] - pub struct NamedPipeClient { -@@ -902,6 +1037,12 @@ impl NamedPipeClient { - /// can be used to concurrently read / write to the same pipe on a single - /// task without splitting the pipe. - /// -+ /// The function may complete without the pipe being ready. This is a -+ /// false-positive and attempting an operation will return with -+ /// `io::ErrorKind::WouldBlock`. The function can also return with an empty -+ /// [`Ready`] set, so you should always check the returned value and possibly -+ /// wait again if the requested states are not set. -+ /// - /// # Examples - /// - /// Concurrently read and write to the pipe on the same task without -@@ -1059,8 +1200,12 @@ impl NamedPipeClient { - /// # Return - /// - /// If data is successfully read, `Ok(n)` is returned, where `n` is the -- /// number of bytes read. `Ok(0)` indicates the pipe's read half is closed -- /// and will no longer yield data. If the pipe is not ready to read data -+ /// number of bytes read. If `n` is `0`, then it can indicate one of two scenarios: -+ /// -+ /// 1. The pipe's read half is closed and will no longer yield data. -+ /// 2. The specified buffer was 0 bytes in length. -+ /// -+ /// If the pipe is not ready to read data, - /// `Err(io::ErrorKind::WouldBlock)` is returned. - /// - /// # Examples -@@ -1186,6 +1331,86 @@ impl NamedPipeClient { - .try_io(Interest::READABLE, || (&*self.io).read_vectored(bufs)) - } - -+ cfg_io_util! { -+ /// Tries to read data from the stream into the provided buffer, advancing the -+ /// buffer's internal cursor, returning how many bytes were read. -+ /// -+ /// Receives any pending data from the pipe but does not wait for new data -+ /// to arrive. On success, returns the number of bytes read. Because -+ /// `try_read_buf()` is non-blocking, the buffer does not have to be stored by -+ /// the async task and can exist entirely on the stack. -+ /// -+ /// Usually, [`readable()`] or [`ready()`] is used with this function. -+ /// -+ /// [`readable()`]: NamedPipeClient::readable() -+ /// [`ready()`]: NamedPipeClient::ready() -+ /// -+ /// # Return -+ /// -+ /// If data is successfully read, `Ok(n)` is returned, where `n` is the -+ /// number of bytes read. `Ok(0)` indicates the stream's read half is closed -+ /// and will no longer yield data. If the stream is not ready to read data -+ /// `Err(io::ErrorKind::WouldBlock)` is returned. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::net::windows::named_pipe; -+ /// use std::error::Error; -+ /// use std::io; -+ /// -+ /// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-readable"; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> Result<(), Box> { -+ /// let client = named_pipe::ClientOptions::new().open(PIPE_NAME)?; -+ /// -+ /// loop { -+ /// // Wait for the pipe to be readable -+ /// client.readable().await?; -+ /// -+ /// let mut buf = Vec::with_capacity(4096); -+ /// -+ /// // Try to read data, this may still fail with `WouldBlock` -+ /// // if the readiness event is a false positive. -+ /// match client.try_read_buf(&mut buf) { -+ /// Ok(0) => break, -+ /// Ok(n) => { -+ /// println!("read {} bytes", n); -+ /// } -+ /// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { -+ /// continue; -+ /// } -+ /// Err(e) => { -+ /// return Err(e.into()); -+ /// } -+ /// } -+ /// } -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub fn try_read_buf(&self, buf: &mut B) -> io::Result { -+ self.io.registration().try_io(Interest::READABLE, || { -+ use std::io::Read; -+ -+ let dst = buf.chunk_mut(); -+ let dst = -+ unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit] as *mut [u8]) }; -+ -+ // Safety: We trust `NamedPipeClient::read` to have filled up `n` bytes in the -+ // buffer. -+ let n = (&*self.io).read(dst)?; -+ -+ unsafe { -+ buf.advance_mut(n); -+ } -+ -+ Ok(n) -+ }) -+ } -+ } -+ - /// Waits for the pipe to become writable. - /// - /// This function is equivalent to `ready(Interest::WRITABLE)` and is usually -@@ -1379,27 +1604,32 @@ impl NamedPipeClient { - .try_io(Interest::WRITABLE, || (&*self.io).write_vectored(buf)) - } - -- /// Tries to read or write from the socket using a user-provided IO operation. -+ /// Tries to read or write from the pipe using a user-provided IO operation. - /// -- /// If the socket is ready, the provided closure is called. The closure -- /// should attempt to perform IO operation from the socket by manually -+ /// If the pipe is ready, the provided closure is called. The closure -+ /// should attempt to perform IO operation from the pipe by manually - /// calling the appropriate syscall. If the operation fails because the -- /// socket is not actually ready, then the closure should return a -+ /// pipe is not actually ready, then the closure should return a - /// `WouldBlock` error and the readiness flag is cleared. The return value - /// of the closure is then returned by `try_io`. - /// -- /// If the socket is not ready, then the closure is not called -+ /// If the pipe is not ready, then the closure is not called - /// and a `WouldBlock` error is returned. - /// - /// The closure should only return a `WouldBlock` error if it has performed -- /// an IO operation on the socket that failed due to the socket not being -+ /// an IO operation on the pipe that failed due to the pipe not being - /// ready. Returning a `WouldBlock` error in any other situation will -- /// incorrectly clear the readiness flag, which can cause the socket to -+ /// incorrectly clear the readiness flag, which can cause the pipe to - /// behave incorrectly. - /// - /// The closure should not perform the IO operation using any of the methods - /// defined on the Tokio `NamedPipeClient` type, as this will mess with the -- /// readiness flag and can cause the socket to behave incorrectly. -+ /// readiness flag and can cause the pipe to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. - /// - /// Usually, [`readable()`], [`writable()`] or [`ready()`] is used with this function. - /// -@@ -1413,6 +1643,39 @@ impl NamedPipeClient { - ) -> io::Result { - self.io.registration().try_io(interest, f) - } -+ -+ /// Reads or writes from the pipe using a user-provided IO operation. -+ /// -+ /// The readiness of the pipe is awaited and when the pipe is ready, -+ /// the provided closure is called. The closure should attempt to perform -+ /// IO operation on the pipe by manually calling the appropriate syscall. -+ /// If the operation fails because the pipe is not actually ready, -+ /// then the closure should return a `WouldBlock` error. In such case the -+ /// readiness flag is cleared and the pipe readiness is awaited again. -+ /// This loop is repeated until the closure returns an `Ok` or an error -+ /// other than `WouldBlock`. -+ /// -+ /// The closure should only return a `WouldBlock` error if it has performed -+ /// an IO operation on the pipe that failed due to the pipe not being -+ /// ready. Returning a `WouldBlock` error in any other situation will -+ /// incorrectly clear the readiness flag, which can cause the pipe to -+ /// behave incorrectly. -+ /// -+ /// The closure should not perform the IO operation using any of the methods -+ /// defined on the Tokio `NamedPipeClient` type, as this will mess with the -+ /// readiness flag and can cause the pipe to behave incorrectly. -+ /// -+ /// This method is not intended to be used with combined interests. -+ /// The closure should perform only one type of IO operation, so it should not -+ /// require more than one ready state. This method may panic or sleep forever -+ /// if it is called with a combined interest. -+ pub async fn async_io( -+ &self, -+ interest: Interest, -+ f: impl FnMut() -> io::Result, -+ ) -> io::Result { -+ self.io.registration().async_io(interest, f).await -+ } - } - - impl AsyncRead for NamedPipeClient { -@@ -1457,17 +1720,11 @@ impl AsRawHandle for NamedPipeClient { - } - } - --// Helper to set a boolean flag as a bitfield. --macro_rules! bool_flag { -- ($f:expr, $t:expr, $flag:expr) => {{ -- let current = $f; -- -- if $t { -- $f = current | $flag; -- } else { -- $f = current & !$flag; -- }; -- }}; -+#[cfg(not(tokio_no_as_fd))] -+impl AsHandle for NamedPipeClient { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) } -+ } - } - - /// A builder structure for construct a named pipe with named pipe-specific -@@ -1477,12 +1734,21 @@ macro_rules! bool_flag { - /// See [`ServerOptions::create`]. - #[derive(Debug, Clone)] - pub struct ServerOptions { -- open_mode: DWORD, -- pipe_mode: DWORD, -- max_instances: DWORD, -- out_buffer_size: DWORD, -- in_buffer_size: DWORD, -- default_timeout: DWORD, -+ // dwOpenMode -+ access_inbound: bool, -+ access_outbound: bool, -+ first_pipe_instance: bool, -+ write_dac: bool, -+ write_owner: bool, -+ access_system_security: bool, -+ // dwPipeMode -+ pipe_mode: PipeMode, -+ reject_remote_clients: bool, -+ // other options -+ max_instances: u32, -+ out_buffer_size: u32, -+ in_buffer_size: u32, -+ default_timeout: u32, - } - - impl ServerOptions { -@@ -1499,9 +1765,15 @@ impl ServerOptions { - /// ``` - pub fn new() -> ServerOptions { - ServerOptions { -- open_mode: winbase::PIPE_ACCESS_DUPLEX | winbase::FILE_FLAG_OVERLAPPED, -- pipe_mode: winbase::PIPE_TYPE_BYTE | winbase::PIPE_REJECT_REMOTE_CLIENTS, -- max_instances: winbase::PIPE_UNLIMITED_INSTANCES, -+ access_inbound: true, -+ access_outbound: true, -+ first_pipe_instance: false, -+ write_dac: false, -+ write_owner: false, -+ access_system_security: false, -+ pipe_mode: PipeMode::Byte, -+ reject_remote_clients: true, -+ max_instances: windows_sys::PIPE_UNLIMITED_INSTANCES, - out_buffer_size: 65536, - in_buffer_size: 65536, - default_timeout: 0, -@@ -1513,15 +1785,11 @@ impl ServerOptions { - /// The default pipe mode is [`PipeMode::Byte`]. See [`PipeMode`] for - /// documentation of what each mode means. - /// -- /// This corresponding to specifying [`dwPipeMode`]. -+ /// This corresponds to specifying `PIPE_TYPE_` and `PIPE_READMODE_` in [`dwPipeMode`]. - /// - /// [`dwPipeMode`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea - pub fn pipe_mode(&mut self, pipe_mode: PipeMode) -> &mut Self { -- self.pipe_mode = match pipe_mode { -- PipeMode::Byte => winbase::PIPE_TYPE_BYTE, -- PipeMode::Message => winbase::PIPE_TYPE_MESSAGE, -- }; -- -+ self.pipe_mode = pipe_mode; - self - } - -@@ -1617,7 +1885,7 @@ impl ServerOptions { - /// # Ok(()) } - /// ``` - pub fn access_inbound(&mut self, allowed: bool) -> &mut Self { -- bool_flag!(self.open_mode, allowed, winbase::PIPE_ACCESS_INBOUND); -+ self.access_inbound = allowed; - self - } - -@@ -1715,7 +1983,7 @@ impl ServerOptions { - /// # Ok(()) } - /// ``` - pub fn access_outbound(&mut self, allowed: bool) -> &mut Self { -- bool_flag!(self.open_mode, allowed, winbase::PIPE_ACCESS_OUTBOUND); -+ self.access_outbound = allowed; - self - } - -@@ -1783,11 +2051,109 @@ impl ServerOptions { - /// [`create`]: ServerOptions::create - /// [`FILE_FLAG_FIRST_PIPE_INSTANCE`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea#pipe_first_pipe_instance - pub fn first_pipe_instance(&mut self, first: bool) -> &mut Self { -- bool_flag!( -- self.open_mode, -- first, -- winbase::FILE_FLAG_FIRST_PIPE_INSTANCE -- ); -+ self.first_pipe_instance = first; -+ self -+ } -+ -+ /// Requests permission to modify the pipe's discretionary access control list. -+ /// -+ /// This corresponds to setting [`WRITE_DAC`] in dwOpenMode. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use std::{io, os::windows::prelude::AsRawHandle, ptr}; -+ // -+ /// use tokio::net::windows::named_pipe::ServerOptions; -+ /// use windows_sys::{ -+ /// Win32::Foundation::ERROR_SUCCESS, -+ /// Win32::Security::DACL_SECURITY_INFORMATION, -+ /// Win32::Security::Authorization::{SetSecurityInfo, SE_KERNEL_OBJECT}, -+ /// }; -+ /// -+ /// const PIPE_NAME: &str = r"\\.\pipe\write_dac_pipe"; -+ /// -+ /// # #[tokio::main] async fn main() -> io::Result<()> { -+ /// let mut pipe_template = ServerOptions::new(); -+ /// pipe_template.write_dac(true); -+ /// let pipe = pipe_template.create(PIPE_NAME)?; -+ /// -+ /// unsafe { -+ /// assert_eq!( -+ /// ERROR_SUCCESS, -+ /// SetSecurityInfo( -+ /// pipe.as_raw_handle() as _, -+ /// SE_KERNEL_OBJECT, -+ /// DACL_SECURITY_INFORMATION, -+ /// ptr::null_mut(), -+ /// ptr::null_mut(), -+ /// ptr::null_mut(), -+ /// ptr::null_mut(), -+ /// ) -+ /// ); -+ /// } -+ /// -+ /// # Ok(()) } -+ /// ``` -+ /// -+ /// ``` -+ /// use std::{io, os::windows::prelude::AsRawHandle, ptr}; -+ // -+ /// use tokio::net::windows::named_pipe::ServerOptions; -+ /// use windows_sys::{ -+ /// Win32::Foundation::ERROR_ACCESS_DENIED, -+ /// Win32::Security::DACL_SECURITY_INFORMATION, -+ /// Win32::Security::Authorization::{SetSecurityInfo, SE_KERNEL_OBJECT}, -+ /// }; -+ /// -+ /// const PIPE_NAME: &str = r"\\.\pipe\write_dac_pipe_fail"; -+ /// -+ /// # #[tokio::main] async fn main() -> io::Result<()> { -+ /// let mut pipe_template = ServerOptions::new(); -+ /// pipe_template.write_dac(false); -+ /// let pipe = pipe_template.create(PIPE_NAME)?; -+ /// -+ /// unsafe { -+ /// assert_eq!( -+ /// ERROR_ACCESS_DENIED, -+ /// SetSecurityInfo( -+ /// pipe.as_raw_handle() as _, -+ /// SE_KERNEL_OBJECT, -+ /// DACL_SECURITY_INFORMATION, -+ /// ptr::null_mut(), -+ /// ptr::null_mut(), -+ /// ptr::null_mut(), -+ /// ptr::null_mut(), -+ /// ) -+ /// ); -+ /// } -+ /// -+ /// # Ok(()) } -+ /// ``` -+ /// -+ /// [`WRITE_DAC`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea -+ pub fn write_dac(&mut self, requested: bool) -> &mut Self { -+ self.write_dac = requested; -+ self -+ } -+ -+ /// Requests permission to modify the pipe's owner. -+ /// -+ /// This corresponds to setting [`WRITE_OWNER`] in dwOpenMode. -+ /// -+ /// [`WRITE_OWNER`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea -+ pub fn write_owner(&mut self, requested: bool) -> &mut Self { -+ self.write_owner = requested; -+ self -+ } -+ -+ /// Requests permission to modify the pipe's system access control list. -+ /// -+ /// This corresponds to setting [`ACCESS_SYSTEM_SECURITY`] in dwOpenMode. -+ /// -+ /// [`ACCESS_SYSTEM_SECURITY`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea -+ pub fn access_system_security(&mut self, requested: bool) -> &mut Self { -+ self.access_system_security = requested; - self - } - -@@ -1798,7 +2164,7 @@ impl ServerOptions { - /// - /// [`PIPE_REJECT_REMOTE_CLIENTS`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea#pipe_reject_remote_clients - pub fn reject_remote_clients(&mut self, reject: bool) -> &mut Self { -- bool_flag!(self.pipe_mode, reject, winbase::PIPE_REJECT_REMOTE_CLIENTS); -+ self.reject_remote_clients = reject; - self - } - -@@ -1820,7 +2186,7 @@ impl ServerOptions { - /// ``` - /// use std::io; - /// use tokio::net::windows::named_pipe::{ServerOptions, ClientOptions}; -- /// use winapi::shared::winerror; -+ /// use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY; - /// - /// const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-max-instances"; - /// -@@ -1836,11 +2202,11 @@ impl ServerOptions { - /// - /// // Too many servers! - /// let e = server.create(PIPE_NAME).unwrap_err(); -- /// assert_eq!(e.raw_os_error(), Some(winerror::ERROR_PIPE_BUSY as i32)); -+ /// assert_eq!(e.raw_os_error(), Some(ERROR_PIPE_BUSY as i32)); - /// - /// // Still too many servers even if we specify a higher value! - /// let e = server.max_instances(100).create(PIPE_NAME).unwrap_err(); -- /// assert_eq!(e.raw_os_error(), Some(winerror::ERROR_PIPE_BUSY as i32)); -+ /// assert_eq!(e.raw_os_error(), Some(ERROR_PIPE_BUSY as i32)); - /// # Ok(()) } - /// ``` - /// -@@ -1856,9 +2222,10 @@ impl ServerOptions { - /// let builder = ServerOptions::new().max_instances(255); - /// # Ok(()) } - /// ``` -+ #[track_caller] - pub fn max_instances(&mut self, instances: usize) -> &mut Self { - assert!(instances < 255, "cannot specify more than 254 instances"); -- self.max_instances = instances as DWORD; -+ self.max_instances = instances as u32; - self - } - -@@ -1868,7 +2235,7 @@ impl ServerOptions { - /// - /// [`nOutBufferSize`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea - pub fn out_buffer_size(&mut self, buffer: u32) -> &mut Self { -- self.out_buffer_size = buffer as DWORD; -+ self.out_buffer_size = buffer; - self - } - -@@ -1878,7 +2245,7 @@ impl ServerOptions { - /// - /// [`nInBufferSize`]: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea - pub fn in_buffer_size(&mut self, buffer: u32) -> &mut Self { -- self.in_buffer_size = buffer as DWORD; -+ self.in_buffer_size = buffer; - self - } - -@@ -1935,7 +2302,7 @@ impl ServerOptions { - /// - /// [`create`]: ServerOptions::create - /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew -- /// [`SECURITY_ATTRIBUTES`]: crate::winapi::um::minwinbase::SECURITY_ATTRIBUTES -+ /// [`SECURITY_ATTRIBUTES`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Security/struct.SECURITY_ATTRIBUTES.html - pub unsafe fn create_with_security_attributes_raw( - &self, - addr: impl AsRef, -@@ -1943,10 +2310,46 @@ impl ServerOptions { - ) -> io::Result { - let addr = encode_addr(addr); - -- let h = namedpipeapi::CreateNamedPipeW( -+ let pipe_mode = { -+ let mut mode = if matches!(self.pipe_mode, PipeMode::Message) { -+ windows_sys::PIPE_TYPE_MESSAGE | windows_sys::PIPE_READMODE_MESSAGE -+ } else { -+ windows_sys::PIPE_TYPE_BYTE | windows_sys::PIPE_READMODE_BYTE -+ }; -+ if self.reject_remote_clients { -+ mode |= windows_sys::PIPE_REJECT_REMOTE_CLIENTS; -+ } else { -+ mode |= windows_sys::PIPE_ACCEPT_REMOTE_CLIENTS; -+ } -+ mode -+ }; -+ let open_mode = { -+ let mut mode = windows_sys::FILE_FLAG_OVERLAPPED; -+ if self.access_inbound { -+ mode |= windows_sys::PIPE_ACCESS_INBOUND; -+ } -+ if self.access_outbound { -+ mode |= windows_sys::PIPE_ACCESS_OUTBOUND; -+ } -+ if self.first_pipe_instance { -+ mode |= windows_sys::FILE_FLAG_FIRST_PIPE_INSTANCE; -+ } -+ if self.write_dac { -+ mode |= windows_sys::WRITE_DAC; -+ } -+ if self.write_owner { -+ mode |= windows_sys::WRITE_OWNER; -+ } -+ if self.access_system_security { -+ mode |= windows_sys::ACCESS_SYSTEM_SECURITY; -+ } -+ mode -+ }; -+ -+ let h = windows_sys::CreateNamedPipeW( - addr.as_ptr(), -- self.open_mode, -- self.pipe_mode, -+ open_mode, -+ pipe_mode, - self.max_instances, - self.out_buffer_size, - self.in_buffer_size, -@@ -1954,11 +2357,11 @@ impl ServerOptions { - attrs as *mut _, - ); - -- if h == handleapi::INVALID_HANDLE_VALUE { -+ if h == windows_sys::INVALID_HANDLE_VALUE { - return Err(io::Error::last_os_error()); - } - -- NamedPipeServer::from_raw_handle(h) -+ NamedPipeServer::from_raw_handle(h as _) - } - } - -@@ -1968,8 +2371,10 @@ impl ServerOptions { - /// See [`ClientOptions::open`]. - #[derive(Debug, Clone)] - pub struct ClientOptions { -- desired_access: DWORD, -- security_qos_flags: DWORD, -+ generic_read: bool, -+ generic_write: bool, -+ security_qos_flags: u32, -+ pipe_mode: PipeMode, - } - - impl ClientOptions { -@@ -1988,8 +2393,11 @@ impl ClientOptions { - /// ``` - pub fn new() -> Self { - Self { -- desired_access: winnt::GENERIC_READ | winnt::GENERIC_WRITE, -- security_qos_flags: winbase::SECURITY_IDENTIFICATION | winbase::SECURITY_SQOS_PRESENT, -+ generic_read: true, -+ generic_write: true, -+ security_qos_flags: windows_sys::SECURITY_IDENTIFICATION -+ | windows_sys::SECURITY_SQOS_PRESENT, -+ pipe_mode: PipeMode::Byte, - } - } - -@@ -2000,7 +2408,7 @@ impl ClientOptions { - /// [`GENERIC_READ`]: https://docs.microsoft.com/en-us/windows/win32/secauthz/generic-access-rights - /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew - pub fn read(&mut self, allowed: bool) -> &mut Self { -- bool_flag!(self.desired_access, allowed, winnt::GENERIC_READ); -+ self.generic_read = allowed; - self - } - -@@ -2011,7 +2419,7 @@ impl ClientOptions { - /// [`GENERIC_WRITE`]: https://docs.microsoft.com/en-us/windows/win32/secauthz/generic-access-rights - /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew - pub fn write(&mut self, allowed: bool) -> &mut Self { -- bool_flag!(self.desired_access, allowed, winnt::GENERIC_WRITE); -+ self.generic_write = allowed; - self - } - -@@ -2034,11 +2442,20 @@ impl ClientOptions { - /// automatically when using this method. - /// - /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea -- /// [`SECURITY_IDENTIFICATION`]: crate::winapi::um::winbase::SECURITY_IDENTIFICATION -+ /// [`SECURITY_IDENTIFICATION`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Storage/FileSystem/constant.SECURITY_IDENTIFICATION.html - /// [Impersonation Levels]: https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level - pub fn security_qos_flags(&mut self, flags: u32) -> &mut Self { - // See: https://github.com/rust-lang/rust/pull/58216 -- self.security_qos_flags = flags | winbase::SECURITY_SQOS_PRESENT; -+ self.security_qos_flags = flags | windows_sys::SECURITY_SQOS_PRESENT; -+ self -+ } -+ -+ /// The pipe mode. -+ /// -+ /// The default pipe mode is [`PipeMode::Byte`]. See [`PipeMode`] for -+ /// documentation of what each mode means. -+ pub fn pipe_mode(&mut self, pipe_mode: PipeMode) -> &mut Self { -+ self.pipe_mode = pipe_mode; - self - } - -@@ -2063,8 +2480,7 @@ impl ClientOptions { - /// but the server is not currently waiting for a connection. Please see the - /// examples for how to check for this error. - /// -- /// [`ERROR_PIPE_BUSY`]: crate::winapi::shared::winerror::ERROR_PIPE_BUSY -- /// [`winapi`]: crate::winapi -+ /// [`ERROR_PIPE_BUSY`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Foundation/constant.ERROR_PIPE_BUSY.html - /// [enabled I/O]: crate::runtime::Builder::enable_io - /// [Tokio Runtime]: crate::runtime::Runtime - /// -@@ -2075,7 +2491,7 @@ impl ClientOptions { - /// use std::time::Duration; - /// use tokio::net::windows::named_pipe::ClientOptions; - /// use tokio::time; -- /// use winapi::shared::winerror; -+ /// use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY; - /// - /// const PIPE_NAME: &str = r"\\.\pipe\mynamedpipe"; - /// -@@ -2083,7 +2499,7 @@ impl ClientOptions { - /// let client = loop { - /// match ClientOptions::new().open(PIPE_NAME) { - /// Ok(client) => break client, -- /// Err(e) if e.raw_os_error() == Some(winerror::ERROR_PIPE_BUSY as i32) => (), -+ /// Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (), - /// Err(e) => return Err(e), - /// } - /// -@@ -2113,7 +2529,7 @@ impl ClientOptions { - /// - /// [`open`]: ClientOptions::open - /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew -- /// [`SECURITY_ATTRIBUTES`]: crate::winapi::um::minwinbase::SECURITY_ATTRIBUTES -+ /// [`SECURITY_ATTRIBUTES`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Security/struct.SECURITY_ATTRIBUTES.html - pub unsafe fn open_with_security_attributes_raw( - &self, - addr: impl AsRef, -@@ -2121,29 +2537,50 @@ impl ClientOptions { - ) -> io::Result { - let addr = encode_addr(addr); - -+ let desired_access = { -+ let mut access = 0; -+ if self.generic_read { -+ access |= windows_sys::GENERIC_READ; -+ } -+ if self.generic_write { -+ access |= windows_sys::GENERIC_WRITE; -+ } -+ access -+ }; -+ - // NB: We could use a platform specialized `OpenOptions` here, but since -- // we have access to winapi it ultimately doesn't hurt to use -+ // we have access to windows_sys it ultimately doesn't hurt to use - // `CreateFile` explicitly since it allows the use of our already - // well-structured wide `addr` to pass into CreateFileW. -- let h = fileapi::CreateFileW( -+ let h = windows_sys::CreateFileW( - addr.as_ptr(), -- self.desired_access, -+ desired_access, - 0, - attrs as *mut _, -- fileapi::OPEN_EXISTING, -+ windows_sys::OPEN_EXISTING, - self.get_flags(), -- ptr::null_mut(), -+ 0, - ); - -- if h == handleapi::INVALID_HANDLE_VALUE { -+ if h == windows_sys::INVALID_HANDLE_VALUE { - return Err(io::Error::last_os_error()); - } - -- NamedPipeClient::from_raw_handle(h) -+ if matches!(self.pipe_mode, PipeMode::Message) { -+ let mode = windows_sys::PIPE_READMODE_MESSAGE; -+ let result = -+ windows_sys::SetNamedPipeHandleState(h, &mode, ptr::null_mut(), ptr::null_mut()); -+ -+ if result == 0 { -+ return Err(io::Error::last_os_error()); -+ } -+ } -+ -+ NamedPipeClient::from_raw_handle(h as _) - } - - fn get_flags(&self) -> u32 { -- self.security_qos_flags | winbase::FILE_FLAG_OVERLAPPED -+ self.security_qos_flags | windows_sys::FILE_FLAG_OVERLAPPED - } - } - -@@ -2156,16 +2593,19 @@ pub enum PipeMode { - /// Data is written to the pipe as a stream of bytes. The pipe does not - /// distinguish bytes written during different write operations. - /// -- /// Corresponds to [`PIPE_TYPE_BYTE`][crate::winapi::um::winbase::PIPE_TYPE_BYTE]. -+ /// Corresponds to [`PIPE_TYPE_BYTE`]. -+ /// -+ /// [`PIPE_TYPE_BYTE`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/System/Pipes/constant.PIPE_TYPE_BYTE.html - Byte, - /// Data is written to the pipe as a stream of messages. The pipe treats the - /// bytes written during each write operation as a message unit. Any reading - /// on a named pipe returns [`ERROR_MORE_DATA`] when a message is not read - /// completely. - /// -- /// Corresponds to [`PIPE_TYPE_MESSAGE`][crate::winapi::um::winbase::PIPE_TYPE_MESSAGE]. -+ /// Corresponds to [`PIPE_TYPE_MESSAGE`]. - /// -- /// [`ERROR_MORE_DATA`]: crate::winapi::shared::winerror::ERROR_MORE_DATA -+ /// [`ERROR_MORE_DATA`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/Foundation/constant.ERROR_MORE_DATA.html -+ /// [`PIPE_TYPE_MESSAGE`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/System/Pipes/constant.PIPE_TYPE_MESSAGE.html - Message, - } - -@@ -2175,11 +2615,15 @@ pub enum PipeMode { - pub enum PipeEnd { - /// The named pipe refers to the client end of a named pipe instance. - /// -- /// Corresponds to [`PIPE_CLIENT_END`][crate::winapi::um::winbase::PIPE_CLIENT_END]. -+ /// Corresponds to [`PIPE_CLIENT_END`]. -+ /// -+ /// [`PIPE_CLIENT_END`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/System/Pipes/constant.PIPE_CLIENT_END.html - Client, - /// The named pipe refers to the server end of a named pipe instance. - /// -- /// Corresponds to [`PIPE_SERVER_END`][crate::winapi::um::winbase::PIPE_SERVER_END]. -+ /// Corresponds to [`PIPE_SERVER_END`]. -+ /// -+ /// [`PIPE_SERVER_END`]: https://docs.rs/windows-sys/latest/windows_sys/Win32/System/Pipes/constant.PIPE_SERVER_END.html - Server, - } - -@@ -2217,26 +2661,26 @@ unsafe fn named_pipe_info(handle: RawHandle) -> io::Result { - let mut in_buffer_size = 0; - let mut max_instances = 0; - -- let result = namedpipeapi::GetNamedPipeInfo( -- handle, -+ let result = windows_sys::GetNamedPipeInfo( -+ handle as _, - &mut flags, - &mut out_buffer_size, - &mut in_buffer_size, - &mut max_instances, - ); - -- if result == FALSE { -+ if result == 0 { - return Err(io::Error::last_os_error()); - } - - let mut end = PipeEnd::Client; - let mut mode = PipeMode::Byte; - -- if flags & winbase::PIPE_SERVER_END != 0 { -+ if flags & windows_sys::PIPE_SERVER_END != 0 { - end = PipeEnd::Server; - } - -- if flags & winbase::PIPE_TYPE_MESSAGE != 0 { -+ if flags & windows_sys::PIPE_TYPE_MESSAGE != 0 { - mode = PipeMode::Message; - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/park/either.rs b/KubeOS-Rust/vendor/tokio/src/park/either.rs -deleted file mode 100644 -index ee02ec15..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/park/either.rs -+++ /dev/null -@@ -1,74 +0,0 @@ --#![cfg_attr(not(feature = "full"), allow(dead_code))] -- --use crate::park::{Park, Unpark}; -- --use std::fmt; --use std::time::Duration; -- --pub(crate) enum Either { -- A(A), -- B(B), --} -- --impl Park for Either --where -- A: Park, -- B: Park, --{ -- type Unpark = Either; -- type Error = Either; -- -- fn unpark(&self) -> Self::Unpark { -- match self { -- Either::A(a) => Either::A(a.unpark()), -- Either::B(b) => Either::B(b.unpark()), -- } -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -- match self { -- Either::A(a) => a.park().map_err(Either::A), -- Either::B(b) => b.park().map_err(Either::B), -- } -- } -- -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- match self { -- Either::A(a) => a.park_timeout(duration).map_err(Either::A), -- Either::B(b) => b.park_timeout(duration).map_err(Either::B), -- } -- } -- -- fn shutdown(&mut self) { -- match self { -- Either::A(a) => a.shutdown(), -- Either::B(b) => b.shutdown(), -- } -- } --} -- --impl Unpark for Either --where -- A: Unpark, -- B: Unpark, --{ -- fn unpark(&self) { -- match self { -- Either::A(a) => a.unpark(), -- Either::B(b) => b.unpark(), -- } -- } --} -- --impl fmt::Debug for Either --where -- A: fmt::Debug, -- B: fmt::Debug, --{ -- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- match self { -- Either::A(a) => a.fmt(fmt), -- Either::B(b) => b.fmt(fmt), -- } -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/park/mod.rs b/KubeOS-Rust/vendor/tokio/src/park/mod.rs -deleted file mode 100644 -index 87d04ff7..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/park/mod.rs -+++ /dev/null -@@ -1,117 +0,0 @@ --//! Abstraction over blocking and unblocking the current thread. --//! --//! Provides an abstraction over blocking the current thread. This is similar to --//! the park / unpark constructs provided by `std` but made generic. This allows --//! embedding custom functionality to perform when the thread is blocked. --//! --//! A blocked `Park` instance is unblocked by calling `unpark` on its --//! `Unpark` handle. --//! --//! The `ParkThread` struct implements `Park` using `thread::park` to put the --//! thread to sleep. The Tokio reactor also implements park, but uses --//! `mio::Poll` to block the thread instead. --//! --//! The `Park` trait is composable. A timer implementation might decorate a --//! `Park` implementation by checking if any timeouts have elapsed after the --//! inner `Park` implementation unblocks. --//! --//! # Model --//! --//! Conceptually, each `Park` instance has an associated token, which is --//! initially not present: --//! --//! * The `park` method blocks the current thread unless or until the token is --//! available, at which point it atomically consumes the token. --//! * The `unpark` method atomically makes the token available if it wasn't --//! already. --//! --//! Some things to note: --//! --//! * If `unpark` is called before `park`, the next call to `park` will --//! **not** block the thread. --//! * **Spurious** wakeups are permitted, i.e., the `park` method may unblock --//! even if `unpark` was not called. --//! * `park_timeout` does the same as `park` but allows specifying a maximum --//! time to block the thread for. -- --cfg_rt! { -- pub(crate) mod either; --} -- --#[cfg(any(feature = "rt", feature = "sync"))] --pub(crate) mod thread; -- --use std::fmt::Debug; --use std::sync::Arc; --use std::time::Duration; -- --/// Blocks the current thread. --pub(crate) trait Park { -- /// Unpark handle type for the `Park` implementation. -- type Unpark: Unpark; -- -- /// Error returned by `park`. -- type Error: Debug; -- -- /// Gets a new `Unpark` handle associated with this `Park` instance. -- fn unpark(&self) -> Self::Unpark; -- -- /// Blocks the current thread unless or until the token is available. -- /// -- /// A call to `park` does not guarantee that the thread will remain blocked -- /// forever, and callers should be prepared for this possibility. This -- /// function may wakeup spuriously for any reason. -- /// -- /// # Panics -- /// -- /// This function **should** not panic, but ultimately, panics are left as -- /// an implementation detail. Refer to the documentation for the specific -- /// `Park` implementation. -- fn park(&mut self) -> Result<(), Self::Error>; -- -- /// Parks the current thread for at most `duration`. -- /// -- /// This function is the same as `park` but allows specifying a maximum time -- /// to block the thread for. -- /// -- /// Same as `park`, there is no guarantee that the thread will remain -- /// blocked for any amount of time. Spurious wakeups are permitted for any -- /// reason. -- /// -- /// # Panics -- /// -- /// This function **should** not panic, but ultimately, panics are left as -- /// an implementation detail. Refer to the documentation for the specific -- /// `Park` implementation. -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error>; -- -- /// Releases all resources holded by the parker for proper leak-free shutdown. -- fn shutdown(&mut self); --} -- --/// Unblock a thread blocked by the associated `Park` instance. --pub(crate) trait Unpark: Sync + Send + 'static { -- /// Unblocks a thread that is blocked by the associated `Park` handle. -- /// -- /// Calling `unpark` atomically makes available the unpark token, if it is -- /// not already available. -- /// -- /// # Panics -- /// -- /// This function **should** not panic, but ultimately, panics are left as -- /// an implementation detail. Refer to the documentation for the specific -- /// `Unpark` implementation. -- fn unpark(&self); --} -- --impl Unpark for Box { -- fn unpark(&self) { -- (**self).unpark() -- } --} -- --impl Unpark for Arc { -- fn unpark(&self) { -- (**self).unpark() -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/park/thread.rs b/KubeOS-Rust/vendor/tokio/src/park/thread.rs -deleted file mode 100644 -index 27ce2024..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/park/thread.rs -+++ /dev/null -@@ -1,346 +0,0 @@ --#![cfg_attr(not(feature = "full"), allow(dead_code))] -- --use crate::loom::sync::atomic::AtomicUsize; --use crate::loom::sync::{Arc, Condvar, Mutex}; --use crate::park::{Park, Unpark}; -- --use std::sync::atomic::Ordering::SeqCst; --use std::time::Duration; -- --#[derive(Debug)] --pub(crate) struct ParkThread { -- inner: Arc, --} -- --pub(crate) type ParkError = (); -- --/// Unblocks a thread that was blocked by `ParkThread`. --#[derive(Clone, Debug)] --pub(crate) struct UnparkThread { -- inner: Arc, --} -- --#[derive(Debug)] --struct Inner { -- state: AtomicUsize, -- mutex: Mutex<()>, -- condvar: Condvar, --} -- --const EMPTY: usize = 0; --const PARKED: usize = 1; --const NOTIFIED: usize = 2; -- --thread_local! { -- static CURRENT_PARKER: ParkThread = ParkThread::new(); --} -- --// ==== impl ParkThread ==== -- --impl ParkThread { -- pub(crate) fn new() -> Self { -- Self { -- inner: Arc::new(Inner { -- state: AtomicUsize::new(EMPTY), -- mutex: Mutex::new(()), -- condvar: Condvar::new(), -- }), -- } -- } --} -- --impl Park for ParkThread { -- type Unpark = UnparkThread; -- type Error = ParkError; -- -- fn unpark(&self) -> Self::Unpark { -- let inner = self.inner.clone(); -- UnparkThread { inner } -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -- self.inner.park(); -- Ok(()) -- } -- -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- self.inner.park_timeout(duration); -- Ok(()) -- } -- -- fn shutdown(&mut self) { -- self.inner.shutdown(); -- } --} -- --// ==== impl Inner ==== -- --impl Inner { -- /// Parks the current thread for at most `dur`. -- fn park(&self) { -- // If we were previously notified then we consume this notification and -- // return quickly. -- if self -- .state -- .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) -- .is_ok() -- { -- return; -- } -- -- // Otherwise we need to coordinate going to sleep -- let mut m = self.mutex.lock(); -- -- match self.state.compare_exchange(EMPTY, PARKED, SeqCst, SeqCst) { -- Ok(_) => {} -- Err(NOTIFIED) => { -- // We must read here, even though we know it will be `NOTIFIED`. -- // This is because `unpark` may have been called again since we read -- // `NOTIFIED` in the `compare_exchange` above. We must perform an -- // acquire operation that synchronizes with that `unpark` to observe -- // any writes it made before the call to unpark. To do that we must -- // read from the write it made to `state`. -- let old = self.state.swap(EMPTY, SeqCst); -- debug_assert_eq!(old, NOTIFIED, "park state changed unexpectedly"); -- -- return; -- } -- Err(actual) => panic!("inconsistent park state; actual = {}", actual), -- } -- -- loop { -- m = self.condvar.wait(m).unwrap(); -- -- if self -- .state -- .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) -- .is_ok() -- { -- // got a notification -- return; -- } -- -- // spurious wakeup, go back to sleep -- } -- } -- -- fn park_timeout(&self, dur: Duration) { -- // Like `park` above we have a fast path for an already-notified thread, -- // and afterwards we start coordinating for a sleep. Return quickly. -- if self -- .state -- .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) -- .is_ok() -- { -- return; -- } -- -- if dur == Duration::from_millis(0) { -- return; -- } -- -- let m = self.mutex.lock(); -- -- match self.state.compare_exchange(EMPTY, PARKED, SeqCst, SeqCst) { -- Ok(_) => {} -- Err(NOTIFIED) => { -- // We must read again here, see `park`. -- let old = self.state.swap(EMPTY, SeqCst); -- debug_assert_eq!(old, NOTIFIED, "park state changed unexpectedly"); -- -- return; -- } -- Err(actual) => panic!("inconsistent park_timeout state; actual = {}", actual), -- } -- -- // Wait with a timeout, and if we spuriously wake up or otherwise wake up -- // from a notification, we just want to unconditionally set the state back to -- // empty, either consuming a notification or un-flagging ourselves as -- // parked. -- let (_m, _result) = self.condvar.wait_timeout(m, dur).unwrap(); -- -- match self.state.swap(EMPTY, SeqCst) { -- NOTIFIED => {} // got a notification, hurray! -- PARKED => {} // no notification, alas -- n => panic!("inconsistent park_timeout state: {}", n), -- } -- } -- -- fn unpark(&self) { -- // To ensure the unparked thread will observe any writes we made before -- // this call, we must perform a release operation that `park` can -- // synchronize with. To do that we must write `NOTIFIED` even if `state` -- // is already `NOTIFIED`. That is why this must be a swap rather than a -- // compare-and-swap that returns if it reads `NOTIFIED` on failure. -- match self.state.swap(NOTIFIED, SeqCst) { -- EMPTY => return, // no one was waiting -- NOTIFIED => return, // already unparked -- PARKED => {} // gotta go wake someone up -- _ => panic!("inconsistent state in unpark"), -- } -- -- // There is a period between when the parked thread sets `state` to -- // `PARKED` (or last checked `state` in the case of a spurious wake -- // up) and when it actually waits on `cvar`. If we were to notify -- // during this period it would be ignored and then when the parked -- // thread went to sleep it would never wake up. Fortunately, it has -- // `lock` locked at this stage so we can acquire `lock` to wait until -- // it is ready to receive the notification. -- // -- // Releasing `lock` before the call to `notify_one` means that when the -- // parked thread wakes it doesn't get woken only to have to wait for us -- // to release `lock`. -- drop(self.mutex.lock()); -- -- self.condvar.notify_one() -- } -- -- fn shutdown(&self) { -- self.condvar.notify_all(); -- } --} -- --impl Default for ParkThread { -- fn default() -> Self { -- Self::new() -- } --} -- --// ===== impl UnparkThread ===== -- --impl Unpark for UnparkThread { -- fn unpark(&self) { -- self.inner.unpark(); -- } --} -- --use std::future::Future; --use std::marker::PhantomData; --use std::mem; --use std::rc::Rc; --use std::task::{RawWaker, RawWakerVTable, Waker}; -- --/// Blocks the current thread using a condition variable. --#[derive(Debug)] --pub(crate) struct CachedParkThread { -- _anchor: PhantomData>, --} -- --impl CachedParkThread { -- /// Creates a new `ParkThread` handle for the current thread. -- /// -- /// This type cannot be moved to other threads, so it should be created on -- /// the thread that the caller intends to park. -- pub(crate) fn new() -> CachedParkThread { -- CachedParkThread { -- _anchor: PhantomData, -- } -- } -- -- pub(crate) fn get_unpark(&self) -> Result { -- self.with_current(|park_thread| park_thread.unpark()) -- } -- -- /// Gets a reference to the `ParkThread` handle for this thread. -- fn with_current(&self, f: F) -> Result -- where -- F: FnOnce(&ParkThread) -> R, -- { -- CURRENT_PARKER.try_with(|inner| f(inner)).map_err(|_| ()) -- } -- -- pub(crate) fn block_on(&mut self, f: F) -> Result { -- use std::task::Context; -- use std::task::Poll::Ready; -- -- // `get_unpark()` should not return a Result -- let waker = self.get_unpark()?.into_waker(); -- let mut cx = Context::from_waker(&waker); -- -- pin!(f); -- -- loop { -- if let Ready(v) = crate::coop::budget(|| f.as_mut().poll(&mut cx)) { -- return Ok(v); -- } -- -- self.park()?; -- } -- } --} -- --impl Park for CachedParkThread { -- type Unpark = UnparkThread; -- type Error = ParkError; -- -- fn unpark(&self) -> Self::Unpark { -- self.get_unpark().unwrap() -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -- self.with_current(|park_thread| park_thread.inner.park())?; -- Ok(()) -- } -- -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- self.with_current(|park_thread| park_thread.inner.park_timeout(duration))?; -- Ok(()) -- } -- -- fn shutdown(&mut self) { -- let _ = self.with_current(|park_thread| park_thread.inner.shutdown()); -- } --} -- --impl UnparkThread { -- pub(crate) fn into_waker(self) -> Waker { -- unsafe { -- let raw = unparker_to_raw_waker(self.inner); -- Waker::from_raw(raw) -- } -- } --} -- --impl Inner { -- #[allow(clippy::wrong_self_convention)] -- fn into_raw(this: Arc) -> *const () { -- Arc::into_raw(this) as *const () -- } -- -- unsafe fn from_raw(ptr: *const ()) -> Arc { -- Arc::from_raw(ptr as *const Inner) -- } --} -- --unsafe fn unparker_to_raw_waker(unparker: Arc) -> RawWaker { -- RawWaker::new( -- Inner::into_raw(unparker), -- &RawWakerVTable::new(clone, wake, wake_by_ref, drop_waker), -- ) --} -- --unsafe fn clone(raw: *const ()) -> RawWaker { -- let unparker = Inner::from_raw(raw); -- -- // Increment the ref count -- mem::forget(unparker.clone()); -- -- unparker_to_raw_waker(unparker) --} -- --unsafe fn drop_waker(raw: *const ()) { -- let _ = Inner::from_raw(raw); --} -- --unsafe fn wake(raw: *const ()) { -- let unparker = Inner::from_raw(raw); -- unparker.unpark(); --} -- --unsafe fn wake_by_ref(raw: *const ()) { -- let unparker = Inner::from_raw(raw); -- unparker.unpark(); -- -- // We don't actually own a reference to the unparker -- mem::forget(unparker); --} -diff --git a/KubeOS-Rust/vendor/tokio/src/process/mod.rs b/KubeOS-Rust/vendor/tokio/src/process/mod.rs -index 6eeefdbe..58c50aa8 100644 ---- a/KubeOS-Rust/vendor/tokio/src/process/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/process/mod.rs -@@ -97,13 +97,65 @@ - //! } - //! ``` - //! -+//! Here is another example using `sort` writing into the child process -+//! standard input, capturing the output of the sorted text. -+//! -+//! ```no_run -+//! use tokio::io::AsyncWriteExt; -+//! use tokio::process::Command; -+//! -+//! use std::process::Stdio; -+//! -+//! #[tokio::main] -+//! async fn main() -> Result<(), Box> { -+//! let mut cmd = Command::new("sort"); -+//! -+//! // Specifying that we want pipe both the output and the input. -+//! // Similarly to capturing the output, by configuring the pipe -+//! // to stdin it can now be used as an asynchronous writer. -+//! cmd.stdout(Stdio::piped()); -+//! cmd.stdin(Stdio::piped()); -+//! -+//! let mut child = cmd.spawn().expect("failed to spawn command"); -+//! -+//! // These are the animals we want to sort -+//! let animals: &[&str] = &["dog", "bird", "frog", "cat", "fish"]; -+//! -+//! let mut stdin = child -+//! .stdin -+//! .take() -+//! .expect("child did not have a handle to stdin"); -+//! -+//! // Write our animals to the child process -+//! // Note that the behavior of `sort` is to buffer _all input_ before writing any output. -+//! // In the general sense, it is recommended to write to the child in a separate task as -+//! // awaiting its exit (or output) to avoid deadlocks (for example, the child tries to write -+//! // some output but gets stuck waiting on the parent to read from it, meanwhile the parent -+//! // is stuck waiting to write its input completely before reading the output). -+//! stdin -+//! .write(animals.join("\n").as_bytes()) -+//! .await -+//! .expect("could not write to stdin"); -+//! -+//! // We drop the handle here which signals EOF to the child process. -+//! // This tells the child process that it there is no more data on the pipe. -+//! drop(stdin); -+//! -+//! let op = child.wait_with_output().await?; -+//! -+//! // Results should come back in sorted order -+//! assert_eq!(op.stdout, "bird\ncat\ndog\nfish\nfrog\n".as_bytes()); -+//! -+//! Ok(()) -+//! } -+//! ``` -+//! - //! With some coordination, we can also pipe the output of one command into - //! another. - //! - //! ```no_run - //! use tokio::join; - //! use tokio::process::Command; --//! use std::convert::TryInto; - //! use std::process::Stdio; - //! - //! #[tokio::main] -@@ -164,7 +216,7 @@ - //! from being spawned. - //! - //! The tokio runtime will, on a best-effort basis, attempt to reap and clean up --//! any process which it has spawned. No additional guarantees are made with regards -+//! any process which it has spawned. No additional guarantees are made with regard to - //! how quickly or how often this procedure will take place. - //! - //! It is recommended to avoid dropping a [`Child`] process handle before it has been -@@ -192,22 +244,26 @@ mod kill; - use crate::io::{AsyncRead, AsyncWrite, ReadBuf}; - use crate::process::kill::Kill; - --use std::convert::TryInto; - use std::ffi::OsStr; - use std::future::Future; - use std::io; --#[cfg(unix)] --use std::os::unix::process::CommandExt; --#[cfg(windows)] --use std::os::windows::io::{AsRawHandle, RawHandle}; --#[cfg(windows)] --use std::os::windows::process::CommandExt; - use std::path::Path; - use std::pin::Pin; - use std::process::{Command as StdCommand, ExitStatus, Output, Stdio}; - use std::task::Context; - use std::task::Poll; - -+#[cfg(unix)] -+use std::os::unix::process::CommandExt; -+#[cfg(windows)] -+use std::os::windows::process::CommandExt; -+ -+cfg_windows! { -+ use crate::os::windows::io::{AsRawHandle, RawHandle}; -+ #[cfg(not(tokio_no_as_fd))] -+ use crate::os::windows::io::{AsHandle, BorrowedHandle}; -+} -+ - /// This structure mimics the API of [`std::process::Command`] found in the standard library, but - /// replaces functions that create a process with an asynchronous variant. The main provided - /// asynchronous functions are [spawn](Command::spawn), [status](Command::status), and -@@ -256,7 +312,8 @@ impl Command { - /// - /// ```no_run - /// use tokio::process::Command; -- /// let command = Command::new("sh"); -+ /// let mut command = Command::new("sh"); -+ /// # let _ = command.output(); // assert borrow checker - /// ``` - /// - /// [rust-lang/rust#37519]: https://github.com/rust-lang/rust/issues/37519 -@@ -264,21 +321,31 @@ impl Command { - Self::from(StdCommand::new(program)) - } - -+ /// Cheaply convert to a `&std::process::Command` for places where the type from the standard -+ /// library is expected. -+ pub fn as_std(&self) -> &StdCommand { -+ &self.std -+ } -+ - /// Adds an argument to pass to the program. - /// - /// Only one argument can be passed per use. So instead of: - /// - /// ```no_run -- /// tokio::process::Command::new("sh") -- /// .arg("-C /path/to/repo"); -+ /// let mut command = tokio::process::Command::new("sh"); -+ /// command.arg("-C /path/to/repo"); -+ /// -+ /// # let _ = command.output(); // assert borrow checker - /// ``` - /// - /// usage would be: - /// - /// ```no_run -- /// tokio::process::Command::new("sh") -- /// .arg("-C") -- /// .arg("/path/to/repo"); -+ /// let mut command = tokio::process::Command::new("sh"); -+ /// command.arg("-C"); -+ /// command.arg("/path/to/repo"); -+ /// -+ /// # let _ = command.output(); // assert borrow checker - /// ``` - /// - /// To pass multiple arguments see [`args`]. -@@ -290,11 +357,15 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// -- /// let command = Command::new("ls") -+ /// let output = Command::new("ls") - /// .arg("-l") -- /// .arg("-a"); -+ /// .arg("-a") -+ /// .output().await.unwrap(); -+ /// # } -+ /// - /// ``` - pub fn arg>(&mut self, arg: S) -> &mut Command { - self.std.arg(arg); -@@ -312,10 +383,13 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// -- /// let command = Command::new("ls") -- /// .args(&["-l", "-a"]); -+ /// let output = Command::new("ls") -+ /// .args(&["-l", "-a"]) -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn args(&mut self, args: I) -> &mut Command - where -@@ -336,10 +410,13 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// -- /// let command = Command::new("ls") -- /// .env("PATH", "/bin"); -+ /// let output = Command::new("ls") -+ /// .env("PATH", "/bin") -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn env(&mut self, key: K, val: V) -> &mut Command - where -@@ -357,6 +434,7 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// use std::process::{Stdio}; - /// use std::env; -@@ -367,11 +445,13 @@ impl Command { - /// k == "TERM" || k == "TZ" || k == "LANG" || k == "PATH" - /// ).collect(); - /// -- /// let command = Command::new("printenv") -+ /// let output = Command::new("printenv") - /// .stdin(Stdio::null()) - /// .stdout(Stdio::inherit()) - /// .env_clear() -- /// .envs(&filtered_env); -+ /// .envs(&filtered_env) -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn envs(&mut self, vars: I) -> &mut Command - where -@@ -390,10 +470,13 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// -- /// let command = Command::new("ls") -- /// .env_remove("PATH"); -+ /// let output = Command::new("ls") -+ /// .env_remove("PATH") -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn env_remove>(&mut self, key: K) -> &mut Command { - self.std.env_remove(key); -@@ -407,10 +490,13 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// -- /// let command = Command::new("ls") -- /// .env_clear(); -+ /// let output = Command::new("ls") -+ /// .env_clear() -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn env_clear(&mut self) -> &mut Command { - self.std.env_clear(); -@@ -434,10 +520,13 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// -- /// let command = Command::new("ls") -- /// .current_dir("/bin"); -+ /// let output = Command::new("ls") -+ /// .current_dir("/bin") -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn current_dir>(&mut self, dir: P) -> &mut Command { - self.std.current_dir(dir); -@@ -457,11 +546,14 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use std::process::{Stdio}; - /// use tokio::process::Command; - /// -- /// let command = Command::new("ls") -- /// .stdin(Stdio::null()); -+ /// let output = Command::new("ls") -+ /// .stdin(Stdio::null()) -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn stdin>(&mut self, cfg: T) -> &mut Command { - self.std.stdin(cfg); -@@ -481,11 +573,14 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// use std::process::Stdio; - /// -- /// let command = Command::new("ls") -- /// .stdout(Stdio::null()); -+ /// let output = Command::new("ls") -+ /// .stdout(Stdio::null()) -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn stdout>(&mut self, cfg: T) -> &mut Command { - self.std.stdout(cfg); -@@ -505,11 +600,14 @@ impl Command { - /// Basic usage: - /// - /// ```no_run -+ /// # async fn test() { // allow using await - /// use tokio::process::Command; - /// use std::process::{Stdio}; - /// -- /// let command = Command::new("ls") -- /// .stderr(Stdio::null()); -+ /// let output = Command::new("ls") -+ /// .stderr(Stdio::null()) -+ /// .output().await.unwrap(); -+ /// # } - /// ``` - pub fn stderr>(&mut self, cfg: T) -> &mut Command { - self.std.stderr(cfg); -@@ -536,7 +634,7 @@ impl Command { - /// operation, the resulting zombie process cannot be `.await`ed inside of the - /// destructor to avoid blocking other tasks. The tokio runtime will, on a - /// best-effort basis, attempt to reap and clean up such processes in the -- /// background, but makes no additional guarantees are made with regards -+ /// background, but no additional guarantees are made with regard to - /// how quickly or how often this procedure will take place. - /// - /// If stronger guarantees are required, it is recommended to avoid dropping -@@ -547,16 +645,16 @@ impl Command { - self - } - -- /// Sets the [process creation flags][1] to be passed to `CreateProcess`. -- /// -- /// These will always be ORed with `CREATE_UNICODE_ENVIRONMENT`. -- /// -- /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684863(v=vs.85).aspx -- #[cfg(windows)] -- #[cfg_attr(docsrs, doc(cfg(windows)))] -- pub fn creation_flags(&mut self, flags: u32) -> &mut Command { -- self.std.creation_flags(flags); -- self -+ cfg_windows! { -+ /// Sets the [process creation flags][1] to be passed to `CreateProcess`. -+ /// -+ /// These will always be ORed with `CREATE_UNICODE_ENVIRONMENT`. -+ /// -+ /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684863(v=vs.85).aspx -+ pub fn creation_flags(&mut self, flags: u32) -> &mut Command { -+ self.std.creation_flags(flags); -+ self -+ } - } - - /// Sets the child process's user ID. This translates to a -@@ -631,6 +729,39 @@ impl Command { - self - } - -+ /// Sets the process group ID (PGID) of the child process. Equivalent to a -+ /// setpgid call in the child process, but may be more efficient. -+ /// -+ /// Process groups determine which processes receive signals. -+ /// -+ /// **Note**: This is an [unstable API][unstable] but will be stabilised once -+ /// tokio's MSRV is sufficiently new. See [the documentation on -+ /// unstable features][unstable] for details about using unstable features. -+ /// -+ /// If you want similar behaviour without using this unstable feature you can -+ /// create a [`std::process::Command`] and convert that into a -+ /// [`tokio::process::Command`] using the `From` trait. -+ /// -+ /// [unstable]: crate#unstable-features -+ /// [`tokio::process::Command`]: crate::process::Command -+ /// -+ /// ```no_run -+ /// # async fn test() { // allow using await -+ /// use tokio::process::Command; -+ /// -+ /// let output = Command::new("ls") -+ /// .process_group(0) -+ /// .output().await.unwrap(); -+ /// # } -+ /// ``` -+ #[cfg(unix)] -+ #[cfg(tokio_unstable)] -+ #[cfg_attr(docsrs, doc(cfg(all(unix, tokio_unstable))))] -+ pub fn process_group(&mut self, pgroup: i32) -> &mut Command { -+ self.std.process_group(pgroup); -+ self -+ } -+ - /// Executes the command as a child process, returning a handle to it. - /// - /// By default, stdin, stdout and stderr are inherited from the parent. -@@ -683,7 +814,7 @@ impl Command { - /// from being spawned. - /// - /// The tokio runtime will, on a best-effort basis, attempt to reap and clean up -- /// any process which it has spawned. No additional guarantees are made with regards -+ /// any process which it has spawned. No additional guarantees are made with regard to - /// how quickly or how often this procedure will take place. - /// - /// It is recommended to avoid dropping a [`Child`] process handle before it has been -@@ -865,7 +996,7 @@ where - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - // Keep track of task budget -- let coop = ready!(crate::coop::poll_proceed(cx)); -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); - - let ret = Pin::new(&mut self.inner).poll(cx); - -@@ -954,13 +1085,14 @@ impl Child { - } - } - -- /// Extracts the raw handle of the process associated with this child while -- /// it is still running. Returns `None` if the child has exited. -- #[cfg(windows)] -- pub fn raw_handle(&self) -> Option { -- match &self.child { -- FusedChild::Child(c) => Some(c.inner.as_raw_handle()), -- FusedChild::Done(_) => None, -+ cfg_windows! { -+ /// Extracts the raw handle of the process associated with this child while -+ /// it is still running. Returns `None` if the child has exited. -+ pub fn raw_handle(&self) -> Option { -+ match &self.child { -+ FusedChild::Child(c) => Some(c.inner.as_raw_handle()), -+ FusedChild::Done(_) => None, -+ } - } - } - -@@ -1124,19 +1256,26 @@ impl Child { - pub async fn wait_with_output(mut self) -> io::Result { - use crate::future::try_join3; - -- async fn read_to_end(io: Option) -> io::Result> { -+ async fn read_to_end(io: &mut Option) -> io::Result> { - let mut vec = Vec::new(); -- if let Some(mut io) = io { -- crate::io::util::read_to_end(&mut io, &mut vec).await?; -+ if let Some(io) = io.as_mut() { -+ crate::io::util::read_to_end(io, &mut vec).await?; - } - Ok(vec) - } - -- let stdout_fut = read_to_end(self.stdout.take()); -- let stderr_fut = read_to_end(self.stderr.take()); -+ let mut stdout_pipe = self.stdout.take(); -+ let mut stderr_pipe = self.stderr.take(); -+ -+ let stdout_fut = read_to_end(&mut stdout_pipe); -+ let stderr_fut = read_to_end(&mut stderr_pipe); - - let (status, stdout, stderr) = try_join3(self.wait(), stdout_fut, stderr_fut).await?; - -+ // Drop happens after `try_join` due to -+ drop(stdout_pipe); -+ drop(stderr_pipe); -+ - Ok(Output { - status, - stdout, -@@ -1188,7 +1327,7 @@ impl ChildStdin { - } - - impl ChildStdout { -- /// Creates an asynchronous `ChildStderr` from a synchronous one. -+ /// Creates an asynchronous `ChildStdout` from a synchronous one. - /// - /// # Errors - /// -@@ -1219,41 +1358,51 @@ impl ChildStderr { - - impl AsyncWrite for ChildStdin { - fn poll_write( -- self: Pin<&mut Self>, -+ mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &[u8], - ) -> Poll> { -- self.inner.poll_write(cx, buf) -+ Pin::new(&mut self.inner).poll_write(cx, buf) - } - -- fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { -- Poll::Ready(Ok(())) -+ fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { -+ Pin::new(&mut self.inner).poll_flush(cx) -+ } -+ -+ fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { -+ Pin::new(&mut self.inner).poll_shutdown(cx) -+ } -+ -+ fn poll_write_vectored( -+ mut self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ bufs: &[io::IoSlice<'_>], -+ ) -> Poll> { -+ Pin::new(&mut self.inner).poll_write_vectored(cx, bufs) - } - -- fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { -- Poll::Ready(Ok(())) -+ fn is_write_vectored(&self) -> bool { -+ self.inner.is_write_vectored() - } - } - - impl AsyncRead for ChildStdout { - fn poll_read( -- self: Pin<&mut Self>, -+ mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { -- // Safety: pipes support reading into uninitialized memory -- unsafe { self.inner.poll_read(cx, buf) } -+ Pin::new(&mut self.inner).poll_read(cx, buf) - } - } - - impl AsyncRead for ChildStderr { - fn poll_read( -- self: Pin<&mut Self>, -+ mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { -- // Safety: pipes support reading into uninitialized memory -- unsafe { self.inner.poll_read(cx, buf) } -+ Pin::new(&mut self.inner).poll_read(cx, buf) - } - } - -@@ -1283,6 +1432,8 @@ impl TryInto for ChildStderr { - - #[cfg(unix)] - mod sys { -+ #[cfg(not(tokio_no_as_fd))] -+ use std::os::unix::io::{AsFd, BorrowedFd}; - use std::os::unix::io::{AsRawFd, RawFd}; - - use super::{ChildStderr, ChildStdin, ChildStdout}; -@@ -1293,42 +1444,79 @@ mod sys { - } - } - -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for ChildStdin { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+ } -+ - impl AsRawFd for ChildStdout { - fn as_raw_fd(&self) -> RawFd { - self.inner.as_raw_fd() - } - } - -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for ChildStdout { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+ } -+ - impl AsRawFd for ChildStderr { - fn as_raw_fd(&self) -> RawFd { - self.inner.as_raw_fd() - } - } --} -- --#[cfg(windows)] --mod sys { -- use std::os::windows::io::{AsRawHandle, RawHandle}; - -- use super::{ChildStderr, ChildStdin, ChildStdout}; -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsFd for ChildStderr { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+ } -+} - -+cfg_windows! { - impl AsRawHandle for ChildStdin { - fn as_raw_handle(&self) -> RawHandle { - self.inner.as_raw_handle() - } - } - -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsHandle for ChildStdin { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) } -+ } -+ } -+ - impl AsRawHandle for ChildStdout { - fn as_raw_handle(&self) -> RawHandle { - self.inner.as_raw_handle() - } - } - -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsHandle for ChildStdout { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) } -+ } -+ } -+ - impl AsRawHandle for ChildStderr { - fn as_raw_handle(&self) -> RawHandle { - self.inner.as_raw_handle() - } - } -+ -+ #[cfg(not(tokio_no_as_fd))] -+ impl AsHandle for ChildStderr { -+ fn as_handle(&self) -> BorrowedHandle<'_> { -+ unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) } -+ } -+ } - } - - #[cfg(all(test, not(loom)))] -diff --git a/KubeOS-Rust/vendor/tokio/src/process/unix/mod.rs b/KubeOS-Rust/vendor/tokio/src/process/unix/mod.rs -index 576fe6cb..41857f49 100644 ---- a/KubeOS-Rust/vendor/tokio/src/process/unix/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/process/unix/mod.rs -@@ -21,27 +21,26 @@ - //! processes in general aren't scalable (e.g. millions) so it shouldn't be that - //! bad in theory... - --pub(crate) mod driver; -- - pub(crate) mod orphan; - use orphan::{OrphanQueue, OrphanQueueImpl, Wait}; - - mod reap; - use reap::Reaper; - --use crate::io::PollEvented; -+use crate::io::{AsyncRead, AsyncWrite, PollEvented, ReadBuf}; - use crate::process::kill::Kill; - use crate::process::SpawnedChild; --use crate::signal::unix::driver::Handle as SignalHandle; -+use crate::runtime::signal::Handle as SignalHandle; - use crate::signal::unix::{signal, Signal, SignalKind}; - - use mio::event::Source; - use mio::unix::SourceFd; --use once_cell::sync::Lazy; - use std::fmt; - use std::fs::File; - use std::future::Future; - use std::io; -+#[cfg(not(tokio_no_as_fd))] -+use std::os::unix::io::{AsFd, BorrowedFd}; - use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; - use std::pin::Pin; - use std::process::{Child as StdChild, ExitStatus, Stdio}; -@@ -64,25 +63,41 @@ impl Kill for StdChild { - } - } - --static ORPHAN_QUEUE: Lazy> = Lazy::new(OrphanQueueImpl::new); -+cfg_not_has_const_mutex_new! { -+ fn get_orphan_queue() -> &'static OrphanQueueImpl { -+ use crate::util::once_cell::OnceCell; -+ -+ static ORPHAN_QUEUE: OnceCell> = OnceCell::new(); -+ -+ ORPHAN_QUEUE.get(OrphanQueueImpl::new) -+ } -+} -+ -+cfg_has_const_mutex_new! { -+ fn get_orphan_queue() -> &'static OrphanQueueImpl { -+ static ORPHAN_QUEUE: OrphanQueueImpl = OrphanQueueImpl::new(); -+ -+ &ORPHAN_QUEUE -+ } -+} - - pub(crate) struct GlobalOrphanQueue; - - impl fmt::Debug for GlobalOrphanQueue { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- ORPHAN_QUEUE.fmt(fmt) -+ get_orphan_queue().fmt(fmt) - } - } - - impl GlobalOrphanQueue { -- fn reap_orphans(handle: &SignalHandle) { -- ORPHAN_QUEUE.reap_orphans(handle) -+ pub(crate) fn reap_orphans(handle: &SignalHandle) { -+ get_orphan_queue().reap_orphans(handle) - } - } - - impl OrphanQueue for GlobalOrphanQueue { - fn push_orphan(&self, orphan: StdChild) { -- ORPHAN_QUEUE.push_orphan(orphan) -+ get_orphan_queue().push_orphan(orphan) - } - } - -@@ -143,7 +158,7 @@ impl Future for Child { - - #[derive(Debug)] - pub(crate) struct Pipe { -- // Actually a pipe and not a File. However, we are reusing `File` to get -+ // Actually a pipe is not a File. However, we are reusing `File` to get - // close on drop. This is a similar trick as `mio`. - fd: File, - } -@@ -169,6 +184,10 @@ impl<'a> io::Write for &'a Pipe { - fn flush(&mut self) -> io::Result<()> { - (&self.fd).flush() - } -+ -+ fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { -+ (&self.fd).write_vectored(bufs) -+ } - } - - impl AsRawFd for Pipe { -@@ -177,8 +196,15 @@ impl AsRawFd for Pipe { - } - } - --pub(crate) fn convert_to_stdio(io: PollEvented) -> io::Result { -- let mut fd = io.into_inner()?.fd; -+#[cfg(not(tokio_no_as_fd))] -+impl AsFd for Pipe { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -+ -+pub(crate) fn convert_to_stdio(io: ChildStdio) -> io::Result { -+ let mut fd = io.inner.into_inner()?.fd; - - // Ensure that the fd to be inherited is set to *blocking* mode, as this - // is the default that virtually all programs expect to have. Those -@@ -213,7 +239,69 @@ impl Source for Pipe { - } - } - --pub(crate) type ChildStdio = PollEvented; -+pub(crate) struct ChildStdio { -+ inner: PollEvented, -+} -+ -+impl fmt::Debug for ChildStdio { -+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -+ self.inner.fmt(fmt) -+ } -+} -+ -+impl AsRawFd for ChildStdio { -+ fn as_raw_fd(&self) -> RawFd { -+ self.inner.as_raw_fd() -+ } -+} -+ -+#[cfg(not(tokio_no_as_fd))] -+impl AsFd for ChildStdio { -+ fn as_fd(&self) -> BorrowedFd<'_> { -+ unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) } -+ } -+} -+ -+impl AsyncWrite for ChildStdio { -+ fn poll_write( -+ self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ buf: &[u8], -+ ) -> Poll> { -+ self.inner.poll_write(cx, buf) -+ } -+ -+ fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { -+ Poll::Ready(Ok(())) -+ } -+ -+ fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { -+ Poll::Ready(Ok(())) -+ } -+ -+ fn poll_write_vectored( -+ self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ bufs: &[io::IoSlice<'_>], -+ ) -> Poll> { -+ self.inner.poll_write_vectored(cx, bufs) -+ } -+ -+ fn is_write_vectored(&self) -> bool { -+ true -+ } -+} -+ -+impl AsyncRead for ChildStdio { -+ fn poll_read( -+ self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ buf: &mut ReadBuf<'_>, -+ ) -> Poll> { -+ // Safety: pipes support reading into uninitialized memory -+ unsafe { self.inner.poll_read(cx, buf) } -+ } -+} - - fn set_nonblocking(fd: &mut T, nonblocking: bool) -> io::Result<()> { - unsafe { -@@ -238,7 +326,7 @@ fn set_nonblocking(fd: &mut T, nonblocking: bool) -> io::Result<()> - Ok(()) - } - --pub(super) fn stdio(io: T) -> io::Result> -+pub(super) fn stdio(io: T) -> io::Result - where - T: IntoRawFd, - { -@@ -246,5 +334,5 @@ where - let mut pipe = Pipe::from(io); - set_nonblocking(&mut pipe, true)?; - -- PollEvented::new(pipe) -+ PollEvented::new(pipe).map(|inner| ChildStdio { inner }) - } -diff --git a/KubeOS-Rust/vendor/tokio/src/process/unix/orphan.rs b/KubeOS-Rust/vendor/tokio/src/process/unix/orphan.rs -index 1b0022c6..34071960 100644 ---- a/KubeOS-Rust/vendor/tokio/src/process/unix/orphan.rs -+++ b/KubeOS-Rust/vendor/tokio/src/process/unix/orphan.rs -@@ -1,5 +1,5 @@ - use crate::loom::sync::{Mutex, MutexGuard}; --use crate::signal::unix::driver::Handle as SignalHandle; -+use crate::runtime::signal::Handle as SignalHandle; - use crate::signal::unix::{signal_with_handle, SignalKind}; - use crate::sync::watch; - use std::io; -@@ -43,10 +43,21 @@ pub(crate) struct OrphanQueueImpl { - } - - impl OrphanQueueImpl { -- pub(crate) fn new() -> Self { -- Self { -- sigchild: Mutex::new(None), -- queue: Mutex::new(Vec::new()), -+ cfg_not_has_const_mutex_new! { -+ pub(crate) fn new() -> Self { -+ Self { -+ sigchild: Mutex::new(None), -+ queue: Mutex::new(Vec::new()), -+ } -+ } -+ } -+ -+ cfg_has_const_mutex_new! { -+ pub(crate) const fn new() -> Self { -+ Self { -+ sigchild: Mutex::const_new(None), -+ queue: Mutex::const_new(Vec::new()), -+ } - } - } - -@@ -120,8 +131,8 @@ where - #[cfg(all(test, not(loom)))] - pub(crate) mod test { - use super::*; -- use crate::io::driver::Driver as IoDriver; -- use crate::signal::unix::driver::{Driver as SignalDriver, Handle as SignalHandle}; -+ use crate::runtime::io::Driver as IoDriver; -+ use crate::runtime::signal::{Driver as SignalDriver, Handle as SignalHandle}; - use crate::sync::watch; - use std::cell::{Cell, RefCell}; - use std::io; -@@ -280,9 +291,11 @@ pub(crate) mod test { - drop(signal_guard); - } - -+ #[cfg_attr(miri, ignore)] // Miri does not support epoll. - #[test] - fn does_not_register_signal_if_queue_empty() { -- let signal_driver = IoDriver::new().and_then(SignalDriver::new).unwrap(); -+ let (io_driver, io_handle) = IoDriver::new(1024).unwrap(); -+ let signal_driver = SignalDriver::new(io_driver, &io_handle).unwrap(); - let handle = signal_driver.handle(); - - let orphanage = OrphanQueueImpl::new(); -diff --git a/KubeOS-Rust/vendor/tokio/src/process/windows.rs b/KubeOS-Rust/vendor/tokio/src/process/windows.rs -index 136d5b0c..eb412cdc 100644 ---- a/KubeOS-Rust/vendor/tokio/src/process/windows.rs -+++ b/KubeOS-Rust/vendor/tokio/src/process/windows.rs -@@ -15,29 +15,30 @@ - //! `RegisterWaitForSingleObject` and then wait on the other end of the oneshot - //! from then on out. - --use crate::io::PollEvented; -+use crate::io::{blocking::Blocking, AsyncRead, AsyncWrite, ReadBuf}; - use crate::process::kill::Kill; - use crate::process::SpawnedChild; - use crate::sync::oneshot; - --use mio::windows::NamedPipe; - use std::fmt; -+use std::fs::File as StdFile; - use std::future::Future; - use std::io; --use std::os::windows::prelude::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle}; -+use std::os::windows::prelude::{AsRawHandle, IntoRawHandle, RawHandle}; - use std::pin::Pin; - use std::process::Stdio; - use std::process::{Child as StdChild, Command as StdCommand, ExitStatus}; --use std::ptr; --use std::task::Context; --use std::task::Poll; --use winapi::shared::minwindef::{DWORD, FALSE}; --use winapi::um::handleapi::{DuplicateHandle, INVALID_HANDLE_VALUE}; --use winapi::um::processthreadsapi::GetCurrentProcess; --use winapi::um::threadpoollegacyapiset::UnregisterWaitEx; --use winapi::um::winbase::{RegisterWaitForSingleObject, INFINITE}; --use winapi::um::winnt::{ -- BOOLEAN, DUPLICATE_SAME_ACCESS, HANDLE, PVOID, WT_EXECUTEINWAITTHREAD, WT_EXECUTEONLYONCE, -+use std::sync::Arc; -+use std::task::{Context, Poll}; -+ -+use windows_sys::{ -+ Win32::Foundation::{ -+ DuplicateHandle, BOOLEAN, DUPLICATE_SAME_ACCESS, HANDLE, INVALID_HANDLE_VALUE, -+ }, -+ Win32::System::Threading::{ -+ GetCurrentProcess, RegisterWaitForSingleObject, UnregisterWaitEx, INFINITE, -+ WT_EXECUTEINWAITTHREAD, WT_EXECUTEONLYONCE, -+ }, - }; - - #[must_use = "futures do nothing unless polled"] -@@ -119,11 +120,11 @@ impl Future for Child { - } - let (tx, rx) = oneshot::channel(); - let ptr = Box::into_raw(Box::new(Some(tx))); -- let mut wait_object = ptr::null_mut(); -+ let mut wait_object = 0; - let rc = unsafe { - RegisterWaitForSingleObject( - &mut wait_object, -- inner.child.as_raw_handle(), -+ inner.child.as_raw_handle() as _, - Some(callback), - ptr as *mut _, - INFINITE, -@@ -162,37 +163,106 @@ impl Drop for Waiting { - } - } - --unsafe extern "system" fn callback(ptr: PVOID, _timer_fired: BOOLEAN) { -+unsafe extern "system" fn callback(ptr: *mut std::ffi::c_void, _timer_fired: BOOLEAN) { - let complete = &mut *(ptr as *mut Option>); - let _ = complete.take().unwrap().send(()); - } - --pub(crate) type ChildStdio = PollEvented; -+#[derive(Debug)] -+struct ArcFile(Arc); -+ -+impl io::Read for ArcFile { -+ fn read(&mut self, bytes: &mut [u8]) -> io::Result { -+ (&*self.0).read(bytes) -+ } -+} -+ -+impl io::Write for ArcFile { -+ fn write(&mut self, bytes: &[u8]) -> io::Result { -+ (&*self.0).write(bytes) -+ } -+ -+ fn flush(&mut self) -> io::Result<()> { -+ (&*self.0).flush() -+ } -+} -+ -+#[derive(Debug)] -+pub(crate) struct ChildStdio { -+ // Used for accessing the raw handle, even if the io version is busy -+ raw: Arc, -+ // For doing I/O operations asynchronously -+ io: Blocking, -+} -+ -+impl AsRawHandle for ChildStdio { -+ fn as_raw_handle(&self) -> RawHandle { -+ self.raw.as_raw_handle() -+ } -+} - --pub(super) fn stdio(io: T) -> io::Result> -+impl AsyncRead for ChildStdio { -+ fn poll_read( -+ mut self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ buf: &mut ReadBuf<'_>, -+ ) -> Poll> { -+ Pin::new(&mut self.io).poll_read(cx, buf) -+ } -+} -+ -+impl AsyncWrite for ChildStdio { -+ fn poll_write( -+ mut self: Pin<&mut Self>, -+ cx: &mut Context<'_>, -+ buf: &[u8], -+ ) -> Poll> { -+ Pin::new(&mut self.io).poll_write(cx, buf) -+ } -+ -+ fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { -+ Pin::new(&mut self.io).poll_flush(cx) -+ } -+ -+ fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { -+ Pin::new(&mut self.io).poll_shutdown(cx) -+ } -+} -+ -+pub(super) fn stdio(io: T) -> io::Result - where - T: IntoRawHandle, - { -- let pipe = unsafe { NamedPipe::from_raw_handle(io.into_raw_handle()) }; -- PollEvented::new(pipe) -+ use std::os::windows::prelude::FromRawHandle; -+ -+ let raw = Arc::new(unsafe { StdFile::from_raw_handle(io.into_raw_handle()) }); -+ let io = Blocking::new(ArcFile(raw.clone())); -+ Ok(ChildStdio { raw, io }) -+} -+ -+pub(crate) fn convert_to_stdio(child_stdio: ChildStdio) -> io::Result { -+ let ChildStdio { raw, io } = child_stdio; -+ drop(io); // Try to drop the Arc count here -+ -+ Arc::try_unwrap(raw) -+ .or_else(|raw| duplicate_handle(&*raw)) -+ .map(Stdio::from) - } - --pub(crate) fn convert_to_stdio(io: PollEvented) -> io::Result { -- let named_pipe = io.into_inner()?; -+fn duplicate_handle(io: &T) -> io::Result { -+ use std::os::windows::prelude::FromRawHandle; - -- // Mio does not implement `IntoRawHandle` for `NamedPipe`, so we'll manually -- // duplicate the handle here... - unsafe { - let mut dup_handle = INVALID_HANDLE_VALUE; - let cur_proc = GetCurrentProcess(); - - let status = DuplicateHandle( - cur_proc, -- named_pipe.as_raw_handle(), -+ io.as_raw_handle() as _, - cur_proc, - &mut dup_handle, -- 0 as DWORD, -- FALSE, -+ 0, -+ 0, - DUPLICATE_SAME_ACCESS, - ); - -@@ -200,6 +270,6 @@ pub(crate) fn convert_to_stdio(io: PollEvented) -> io::Result - return Err(io::Error::last_os_error()); - } - -- Ok(Stdio::from_raw_handle(dup_handle)) -+ Ok(StdFile::from_raw_handle(dup_handle as _)) - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/basic_scheduler.rs b/KubeOS-Rust/vendor/tokio/src/runtime/basic_scheduler.rs -deleted file mode 100644 -index 872d0d5b..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/basic_scheduler.rs -+++ /dev/null -@@ -1,519 +0,0 @@ --use crate::future::poll_fn; --use crate::loom::sync::atomic::AtomicBool; --use crate::loom::sync::Mutex; --use crate::park::{Park, Unpark}; --use crate::runtime::context::EnterGuard; --use crate::runtime::stats::{RuntimeStats, WorkerStatsBatcher}; --use crate::runtime::task::{self, JoinHandle, OwnedTasks, Schedule, Task}; --use crate::runtime::Callback; --use crate::sync::notify::Notify; --use crate::util::{waker_ref, Wake, WakerRef}; -- --use std::cell::RefCell; --use std::collections::VecDeque; --use std::fmt; --use std::future::Future; --use std::sync::atomic::Ordering::{AcqRel, Release}; --use std::sync::Arc; --use std::task::Poll::{Pending, Ready}; --use std::time::Duration; -- --/// Executes tasks on the current thread --pub(crate) struct BasicScheduler { -- /// Inner state guarded by a mutex that is shared -- /// between all `block_on` calls. -- inner: Mutex>>, -- -- /// Notifier for waking up other threads to steal the -- /// parker. -- notify: Notify, -- -- /// Sendable task spawner -- spawner: Spawner, -- -- /// This is usually None, but right before dropping the BasicScheduler, it -- /// is changed to `Some` with the context being the runtime's own context. -- /// This ensures that any tasks dropped in the `BasicScheduler`s destructor -- /// run in that runtime's context. -- context_guard: Option, --} -- --/// The inner scheduler that owns the task queue and the main parker P. --struct Inner { -- /// Scheduler run queue -- /// -- /// When the scheduler is executed, the queue is removed from `self` and -- /// moved into `Context`. -- /// -- /// This indirection is to allow `BasicScheduler` to be `Send`. -- tasks: Option, -- -- /// Sendable task spawner -- spawner: Spawner, -- -- /// Current tick -- tick: u8, -- -- /// Thread park handle -- park: P, -- -- /// Callback for a worker parking itself -- before_park: Option, -- /// Callback for a worker unparking itself -- after_unpark: Option, -- -- /// Stats batcher -- stats: WorkerStatsBatcher, --} -- --#[derive(Clone)] --pub(crate) struct Spawner { -- shared: Arc, --} -- --struct Tasks { -- /// Local run queue. -- /// -- /// Tasks notified from the current thread are pushed into this queue. -- queue: VecDeque>>, --} -- --/// A remote scheduler entry. --/// --/// These are filled in by remote threads sending instructions to the scheduler. --enum RemoteMsg { -- /// A remote thread wants to spawn a task. -- Schedule(task::Notified>), --} -- --// Safety: Used correctly, the task header is "thread safe". Ultimately the task --// is owned by the current thread executor, for which this instruction is being --// sent. --unsafe impl Send for RemoteMsg {} -- --/// Scheduler state shared between threads. --struct Shared { -- /// Remote run queue. None if the `Runtime` has been dropped. -- queue: Mutex>>, -- -- /// Collection of all active tasks spawned onto this executor. -- owned: OwnedTasks>, -- -- /// Unpark the blocked thread. -- unpark: Box, -- -- /// Indicates whether the blocked on thread was woken. -- woken: AtomicBool, -- -- /// Keeps track of various runtime stats. -- stats: RuntimeStats, --} -- --/// Thread-local context. --struct Context { -- /// Shared scheduler state -- shared: Arc, -- -- /// Local queue -- tasks: RefCell, --} -- --/// Initial queue capacity. --const INITIAL_CAPACITY: usize = 64; -- --/// Max number of tasks to poll per tick. --#[cfg(loom)] --const MAX_TASKS_PER_TICK: usize = 4; --#[cfg(not(loom))] --const MAX_TASKS_PER_TICK: usize = 61; -- --/// How often to check the remote queue first. --const REMOTE_FIRST_INTERVAL: u8 = 31; -- --// Tracks the current BasicScheduler. --scoped_thread_local!(static CURRENT: Context); -- --impl BasicScheduler

{ -- pub(crate) fn new( -- park: P, -- before_park: Option, -- after_unpark: Option, -- ) -> BasicScheduler

{ -- let unpark = Box::new(park.unpark()); -- -- let spawner = Spawner { -- shared: Arc::new(Shared { -- queue: Mutex::new(Some(VecDeque::with_capacity(INITIAL_CAPACITY))), -- owned: OwnedTasks::new(), -- unpark: unpark as Box, -- woken: AtomicBool::new(false), -- stats: RuntimeStats::new(1), -- }), -- }; -- -- let inner = Mutex::new(Some(Inner { -- tasks: Some(Tasks { -- queue: VecDeque::with_capacity(INITIAL_CAPACITY), -- }), -- spawner: spawner.clone(), -- tick: 0, -- park, -- before_park, -- after_unpark, -- stats: WorkerStatsBatcher::new(0), -- })); -- -- BasicScheduler { -- inner, -- notify: Notify::new(), -- spawner, -- context_guard: None, -- } -- } -- -- pub(crate) fn spawner(&self) -> &Spawner { -- &self.spawner -- } -- -- pub(crate) fn block_on(&self, future: F) -> F::Output { -- pin!(future); -- -- // Attempt to steal the dedicated parker and block_on the future if we can there, -- // otherwise, lets select on a notification that the parker is available -- // or the future is complete. -- loop { -- if let Some(inner) = &mut self.take_inner() { -- return inner.block_on(future); -- } else { -- let mut enter = crate::runtime::enter(false); -- -- let notified = self.notify.notified(); -- pin!(notified); -- -- if let Some(out) = enter -- .block_on(poll_fn(|cx| { -- if notified.as_mut().poll(cx).is_ready() { -- return Ready(None); -- } -- -- if let Ready(out) = future.as_mut().poll(cx) { -- return Ready(Some(out)); -- } -- -- Pending -- })) -- .expect("Failed to `Enter::block_on`") -- { -- return out; -- } -- } -- } -- } -- -- fn take_inner(&self) -> Option> { -- let inner = self.inner.lock().take()?; -- -- Some(InnerGuard { -- inner: Some(inner), -- basic_scheduler: self, -- }) -- } -- -- pub(super) fn set_context_guard(&mut self, guard: EnterGuard) { -- self.context_guard = Some(guard); -- } --} -- --impl Inner

{ -- /// Blocks on the provided future and drives the runtime's driver. -- fn block_on(&mut self, future: F) -> F::Output { -- enter(self, |scheduler, context| { -- let _enter = crate::runtime::enter(false); -- let waker = scheduler.spawner.waker_ref(); -- let mut cx = std::task::Context::from_waker(&waker); -- -- pin!(future); -- -- 'outer: loop { -- if scheduler.spawner.reset_woken() { -- scheduler.stats.incr_poll_count(); -- if let Ready(v) = crate::coop::budget(|| future.as_mut().poll(&mut cx)) { -- return v; -- } -- } -- -- for _ in 0..MAX_TASKS_PER_TICK { -- // Get and increment the current tick -- let tick = scheduler.tick; -- scheduler.tick = scheduler.tick.wrapping_add(1); -- -- let entry = if tick % REMOTE_FIRST_INTERVAL == 0 { -- scheduler.spawner.pop().or_else(|| { -- context -- .tasks -- .borrow_mut() -- .queue -- .pop_front() -- .map(RemoteMsg::Schedule) -- }) -- } else { -- context -- .tasks -- .borrow_mut() -- .queue -- .pop_front() -- .map(RemoteMsg::Schedule) -- .or_else(|| scheduler.spawner.pop()) -- }; -- -- let entry = match entry { -- Some(entry) => entry, -- None => { -- if let Some(f) = &scheduler.before_park { -- f(); -- } -- // This check will fail if `before_park` spawns a task for us to run -- // instead of parking the thread -- if context.tasks.borrow_mut().queue.is_empty() { -- // Park until the thread is signaled -- scheduler.stats.about_to_park(); -- scheduler.stats.submit(&scheduler.spawner.shared.stats); -- scheduler.park.park().expect("failed to park"); -- scheduler.stats.returned_from_park(); -- } -- if let Some(f) = &scheduler.after_unpark { -- f(); -- } -- -- // Try polling the `block_on` future next -- continue 'outer; -- } -- }; -- -- match entry { -- RemoteMsg::Schedule(task) => { -- scheduler.stats.incr_poll_count(); -- let task = context.shared.owned.assert_owner(task); -- crate::coop::budget(|| task.run()) -- } -- } -- } -- -- // Yield to the park, this drives the timer and pulls any pending -- // I/O events. -- scheduler.stats.submit(&scheduler.spawner.shared.stats); -- scheduler -- .park -- .park_timeout(Duration::from_millis(0)) -- .expect("failed to park"); -- } -- }) -- } --} -- --/// Enters the scheduler context. This sets the queue and other necessary --/// scheduler state in the thread-local. --fn enter(scheduler: &mut Inner

, f: F) -> R --where -- F: FnOnce(&mut Inner

, &Context) -> R, -- P: Park, --{ -- // Ensures the run queue is placed back in the `BasicScheduler` instance -- // once `block_on` returns.` -- struct Guard<'a, P: Park> { -- context: Option, -- scheduler: &'a mut Inner

, -- } -- -- impl Drop for Guard<'_, P> { -- fn drop(&mut self) { -- let Context { tasks, .. } = self.context.take().expect("context missing"); -- self.scheduler.tasks = Some(tasks.into_inner()); -- } -- } -- -- // Remove `tasks` from `self` and place it in a `Context`. -- let tasks = scheduler.tasks.take().expect("invalid state"); -- -- let guard = Guard { -- context: Some(Context { -- shared: scheduler.spawner.shared.clone(), -- tasks: RefCell::new(tasks), -- }), -- scheduler, -- }; -- -- let context = guard.context.as_ref().unwrap(); -- let scheduler = &mut *guard.scheduler; -- -- CURRENT.set(context, || f(scheduler, context)) --} -- --impl Drop for BasicScheduler

{ -- fn drop(&mut self) { -- // Avoid a double panic if we are currently panicking and -- // the lock may be poisoned. -- -- let mut inner = match self.inner.lock().take() { -- Some(inner) => inner, -- None if std::thread::panicking() => return, -- None => panic!("Oh no! We never placed the Inner state back, this is a bug!"), -- }; -- -- enter(&mut inner, |scheduler, context| { -- // Drain the OwnedTasks collection. This call also closes the -- // collection, ensuring that no tasks are ever pushed after this -- // call returns. -- context.shared.owned.close_and_shutdown_all(); -- -- // Drain local queue -- // We already shut down every task, so we just need to drop the task. -- for task in context.tasks.borrow_mut().queue.drain(..) { -- drop(task); -- } -- -- // Drain remote queue and set it to None -- let remote_queue = scheduler.spawner.shared.queue.lock().take(); -- -- // Using `Option::take` to replace the shared queue with `None`. -- // We already shut down every task, so we just need to drop the task. -- if let Some(remote_queue) = remote_queue { -- for entry in remote_queue { -- match entry { -- RemoteMsg::Schedule(task) => { -- drop(task); -- } -- } -- } -- } -- -- assert!(context.shared.owned.is_empty()); -- }); -- } --} -- --impl fmt::Debug for BasicScheduler

{ -- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- fmt.debug_struct("BasicScheduler").finish() -- } --} -- --// ===== impl Spawner ===== -- --impl Spawner { -- /// Spawns a future onto the basic scheduler -- pub(crate) fn spawn(&self, future: F) -> JoinHandle -- where -- F: crate::future::Future + Send + 'static, -- F::Output: Send + 'static, -- { -- let (handle, notified) = self.shared.owned.bind(future, self.shared.clone()); -- -- if let Some(notified) = notified { -- self.shared.schedule(notified); -- } -- -- handle -- } -- -- pub(crate) fn stats(&self) -> &RuntimeStats { -- &self.shared.stats -- } -- -- fn pop(&self) -> Option { -- match self.shared.queue.lock().as_mut() { -- Some(queue) => queue.pop_front(), -- None => None, -- } -- } -- -- fn waker_ref(&self) -> WakerRef<'_> { -- // Set woken to true when enter block_on, ensure outer future -- // be polled for the first time when enter loop -- self.shared.woken.store(true, Release); -- waker_ref(&self.shared) -- } -- -- // reset woken to false and return original value -- pub(crate) fn reset_woken(&self) -> bool { -- self.shared.woken.swap(false, AcqRel) -- } --} -- --impl fmt::Debug for Spawner { -- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- fmt.debug_struct("Spawner").finish() -- } --} -- --// ===== impl Shared ===== -- --impl Schedule for Arc { -- fn release(&self, task: &Task) -> Option> { -- self.owned.remove(task) -- } -- -- fn schedule(&self, task: task::Notified) { -- CURRENT.with(|maybe_cx| match maybe_cx { -- Some(cx) if Arc::ptr_eq(self, &cx.shared) => { -- cx.tasks.borrow_mut().queue.push_back(task); -- } -- _ => { -- // If the queue is None, then the runtime has shut down. We -- // don't need to do anything with the notification in that case. -- let mut guard = self.queue.lock(); -- if let Some(queue) = guard.as_mut() { -- queue.push_back(RemoteMsg::Schedule(task)); -- drop(guard); -- self.unpark.unpark(); -- } -- } -- }); -- } --} -- --impl Wake for Shared { -- fn wake(self: Arc) { -- Wake::wake_by_ref(&self) -- } -- -- /// Wake by reference -- fn wake_by_ref(arc_self: &Arc) { -- arc_self.woken.store(true, Release); -- arc_self.unpark.unpark(); -- } --} -- --// ===== InnerGuard ===== -- --/// Used to ensure we always place the Inner value --/// back into its slot in `BasicScheduler`, even if the --/// future panics. --struct InnerGuard<'a, P: Park> { -- inner: Option>, -- basic_scheduler: &'a BasicScheduler

, --} -- --impl InnerGuard<'_, P> { -- fn block_on(&mut self, future: F) -> F::Output { -- // The only time inner gets set to `None` is if we have dropped -- // already so this unwrap is safe. -- self.inner.as_mut().unwrap().block_on(future) -- } --} -- --impl Drop for InnerGuard<'_, P> { -- fn drop(&mut self) { -- if let Some(scheduler) = self.inner.take() { -- let mut lock = self.basic_scheduler.inner.lock(); -- -- // Replace old scheduler back into the state to allow -- // other threads to pick it up and drive it. -- lock.replace(scheduler); -- -- // Wake up other possible threads that could steal -- // the dedicated parker P. -- self.basic_scheduler.notify.notify_one() -- } -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/mod.rs -index 670ec3a4..c42924be 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/mod.rs -@@ -6,10 +6,17 @@ - mod pool; - pub(crate) use pool::{spawn_blocking, BlockingPool, Spawner}; - -+cfg_fs! { -+ pub(crate) use pool::spawn_mandatory_blocking; -+} -+ -+cfg_trace! { -+ pub(crate) use pool::Mandatory; -+} -+ - mod schedule; - mod shutdown; - mod task; --pub(crate) use schedule::NoopSchedule; - pub(crate) use task::BlockingTask; - - use crate::runtime::Builder; -@@ -17,28 +24,3 @@ use crate::runtime::Builder; - pub(crate) fn create_blocking_pool(builder: &Builder, thread_cap: usize) -> BlockingPool { - BlockingPool::new(builder, thread_cap) - } -- --/* --cfg_not_blocking_impl! { -- use crate::runtime::Builder; -- use std::time::Duration; -- -- #[derive(Debug, Clone)] -- pub(crate) struct BlockingPool {} -- -- pub(crate) use BlockingPool as Spawner; -- -- pub(crate) fn create_blocking_pool(_builder: &Builder, _thread_cap: usize) -> BlockingPool { -- BlockingPool {} -- } -- -- impl BlockingPool { -- pub(crate) fn spawner(&self) -> &BlockingPool { -- self -- } -- -- pub(crate) fn shutdown(&mut self, _duration: Option) { -- } -- } --} --*/ -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/pool.rs b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/pool.rs -index 77ab4958..a23b0a0d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/pool.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/pool.rs -@@ -2,15 +2,16 @@ - - use crate::loom::sync::{Arc, Condvar, Mutex}; - use crate::loom::thread; --use crate::runtime::blocking::schedule::NoopSchedule; --use crate::runtime::blocking::shutdown; -+use crate::runtime::blocking::schedule::BlockingSchedule; -+use crate::runtime::blocking::{shutdown, BlockingTask}; - use crate::runtime::builder::ThreadNameFn; --use crate::runtime::context; - use crate::runtime::task::{self, JoinHandle}; - use crate::runtime::{Builder, Callback, Handle}; - - use std::collections::{HashMap, VecDeque}; - use std::fmt; -+use std::io; -+use std::sync::atomic::{AtomicUsize, Ordering}; - use std::time::Duration; - - pub(crate) struct BlockingPool { -@@ -23,6 +24,53 @@ pub(crate) struct Spawner { - inner: Arc, - } - -+#[derive(Default)] -+pub(crate) struct SpawnerMetrics { -+ num_threads: AtomicUsize, -+ num_idle_threads: AtomicUsize, -+ queue_depth: AtomicUsize, -+} -+ -+impl SpawnerMetrics { -+ fn num_threads(&self) -> usize { -+ self.num_threads.load(Ordering::Relaxed) -+ } -+ -+ fn num_idle_threads(&self) -> usize { -+ self.num_idle_threads.load(Ordering::Relaxed) -+ } -+ -+ cfg_metrics! { -+ fn queue_depth(&self) -> usize { -+ self.queue_depth.load(Ordering::Relaxed) -+ } -+ } -+ -+ fn inc_num_threads(&self) { -+ self.num_threads.fetch_add(1, Ordering::Relaxed); -+ } -+ -+ fn dec_num_threads(&self) { -+ self.num_threads.fetch_sub(1, Ordering::Relaxed); -+ } -+ -+ fn inc_num_idle_threads(&self) { -+ self.num_idle_threads.fetch_add(1, Ordering::Relaxed); -+ } -+ -+ fn dec_num_idle_threads(&self) -> usize { -+ self.num_idle_threads.fetch_sub(1, Ordering::Relaxed) -+ } -+ -+ fn inc_queue_depth(&self) { -+ self.queue_depth.fetch_add(1, Ordering::Relaxed); -+ } -+ -+ fn dec_queue_depth(&self) { -+ self.queue_depth.fetch_sub(1, Ordering::Relaxed); -+ } -+} -+ - struct Inner { - /// State shared between worker threads. - shared: Mutex, -@@ -47,12 +95,13 @@ struct Inner { - - // Customizable wait timeout. - keep_alive: Duration, -+ -+ // Metrics about the pool. -+ metrics: SpawnerMetrics, - } - - struct Shared { - queue: VecDeque, -- num_th: usize, -- num_idle: u32, - num_notify: u32, - shutdown: bool, - shutdown_tx: Option, -@@ -70,20 +119,89 @@ struct Shared { - worker_thread_index: usize, - } - --type Task = task::UnownedTask; -+pub(crate) struct Task { -+ task: task::UnownedTask, -+ mandatory: Mandatory, -+} -+ -+#[derive(PartialEq, Eq)] -+pub(crate) enum Mandatory { -+ #[cfg_attr(not(fs), allow(dead_code))] -+ Mandatory, -+ NonMandatory, -+} -+ -+pub(crate) enum SpawnError { -+ /// Pool is shutting down and the task was not scheduled -+ ShuttingDown, -+ /// There are no worker threads available to take the task -+ /// and the OS failed to spawn a new one -+ NoThreads(io::Error), -+} -+ -+impl From for io::Error { -+ fn from(e: SpawnError) -> Self { -+ match e { -+ SpawnError::ShuttingDown => { -+ io::Error::new(io::ErrorKind::Other, "blocking pool shutting down") -+ } -+ SpawnError::NoThreads(e) => e, -+ } -+ } -+} -+ -+impl Task { -+ pub(crate) fn new(task: task::UnownedTask, mandatory: Mandatory) -> Task { -+ Task { task, mandatory } -+ } -+ -+ fn run(self) { -+ self.task.run(); -+ } -+ -+ fn shutdown_or_run_if_mandatory(self) { -+ match self.mandatory { -+ Mandatory::NonMandatory => self.task.shutdown(), -+ Mandatory::Mandatory => self.task.run(), -+ } -+ } -+} - - const KEEP_ALIVE: Duration = Duration::from_secs(10); - - /// Runs the provided function on an executor dedicated to blocking operations. -+/// Tasks will be scheduled as non-mandatory, meaning they may not get executed -+/// in case of runtime shutdown. -+#[track_caller] -+#[cfg_attr(tokio_wasi, allow(dead_code))] - pub(crate) fn spawn_blocking(func: F) -> JoinHandle - where - F: FnOnce() -> R + Send + 'static, - R: Send + 'static, - { -- let rt = context::current(); -+ let rt = Handle::current(); - rt.spawn_blocking(func) - } - -+cfg_fs! { -+ #[cfg_attr(any( -+ all(loom, not(test)), // the function is covered by loom tests -+ test -+ ), allow(dead_code))] -+ /// Runs the provided function on an executor dedicated to blocking -+ /// operations. Tasks will be scheduled as mandatory, meaning they are -+ /// guaranteed to run unless a shutdown is already taking place. In case a -+ /// shutdown is already taking place, `None` will be returned. -+ pub(crate) fn spawn_mandatory_blocking(func: F) -> Option> -+ where -+ F: FnOnce() -> R + Send + 'static, -+ R: Send + 'static, -+ { -+ let rt = Handle::current(); -+ rt.inner.blocking_spawner().spawn_mandatory_blocking(&rt, func) -+ } -+} -+ - // ===== impl BlockingPool ===== - - impl BlockingPool { -@@ -96,8 +214,6 @@ impl BlockingPool { - inner: Arc::new(Inner { - shared: Mutex::new(Shared { - queue: VecDeque::new(), -- num_th: 0, -- num_idle: 0, - num_notify: 0, - shutdown: false, - shutdown_tx: Some(shutdown_tx), -@@ -112,6 +228,7 @@ impl BlockingPool { - before_stop: builder.before_stop.clone(), - thread_cap, - keep_alive, -+ metrics: Default::default(), - }), - }, - shutdown_rx, -@@ -171,53 +288,164 @@ impl fmt::Debug for BlockingPool { - // ===== impl Spawner ===== - - impl Spawner { -- pub(crate) fn spawn(&self, task: Task, rt: &Handle) -> Result<(), ()> { -- let shutdown_tx = { -- let mut shared = self.inner.shared.lock(); -- -- if shared.shutdown { -- // Shutdown the task -- task.shutdown(); -- -- // no need to even push this task; it would never get picked up -- return Err(()); -+ #[track_caller] -+ pub(crate) fn spawn_blocking(&self, rt: &Handle, func: F) -> JoinHandle -+ where -+ F: FnOnce() -> R + Send + 'static, -+ R: Send + 'static, -+ { -+ let (join_handle, spawn_result) = -+ if cfg!(debug_assertions) && std::mem::size_of::() > 2048 { -+ self.spawn_blocking_inner(Box::new(func), Mandatory::NonMandatory, None, rt) -+ } else { -+ self.spawn_blocking_inner(func, Mandatory::NonMandatory, None, rt) -+ }; -+ -+ match spawn_result { -+ Ok(()) => join_handle, -+ // Compat: do not panic here, return the join_handle even though it will never resolve -+ Err(SpawnError::ShuttingDown) => join_handle, -+ Err(SpawnError::NoThreads(e)) => { -+ panic!("OS can't spawn worker thread: {}", e) - } -+ } -+ } - -- shared.queue.push_back(task); -- -- if shared.num_idle == 0 { -- // No threads are able to process the task. -- -- if shared.num_th == self.inner.thread_cap { -- // At max number of threads -- None -- } else { -- shared.num_th += 1; -- assert!(shared.shutdown_tx.is_some()); -- shared.shutdown_tx.clone() -- } -+ cfg_fs! { -+ #[track_caller] -+ #[cfg_attr(any( -+ all(loom, not(test)), // the function is covered by loom tests -+ test -+ ), allow(dead_code))] -+ pub(crate) fn spawn_mandatory_blocking(&self, rt: &Handle, func: F) -> Option> -+ where -+ F: FnOnce() -> R + Send + 'static, -+ R: Send + 'static, -+ { -+ let (join_handle, spawn_result) = if cfg!(debug_assertions) && std::mem::size_of::() > 2048 { -+ self.spawn_blocking_inner( -+ Box::new(func), -+ Mandatory::Mandatory, -+ None, -+ rt, -+ ) -+ } else { -+ self.spawn_blocking_inner( -+ func, -+ Mandatory::Mandatory, -+ None, -+ rt, -+ ) -+ }; -+ -+ if spawn_result.is_ok() { -+ Some(join_handle) - } else { -- // Notify an idle worker thread. The notification counter -- // is used to count the needed amount of notifications -- // exactly. Thread libraries may generate spurious -- // wakeups, this counter is used to keep us in a -- // consistent state. -- shared.num_idle -= 1; -- shared.num_notify += 1; -- self.inner.condvar.notify_one(); - None - } -+ } -+ } -+ -+ #[track_caller] -+ pub(crate) fn spawn_blocking_inner( -+ &self, -+ func: F, -+ is_mandatory: Mandatory, -+ name: Option<&str>, -+ rt: &Handle, -+ ) -> (JoinHandle, Result<(), SpawnError>) -+ where -+ F: FnOnce() -> R + Send + 'static, -+ R: Send + 'static, -+ { -+ let fut = BlockingTask::new(func); -+ let id = task::Id::next(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let fut = { -+ use tracing::Instrument; -+ let location = std::panic::Location::caller(); -+ let span = tracing::trace_span!( -+ target: "tokio::task::blocking", -+ "runtime.spawn", -+ kind = %"blocking", -+ task.name = %name.unwrap_or_default(), -+ task.id = id.as_u64(), -+ "fn" = %std::any::type_name::(), -+ loc.file = location.file(), -+ loc.line = location.line(), -+ loc.col = location.column(), -+ ); -+ fut.instrument(span) - }; - -- if let Some(shutdown_tx) = shutdown_tx { -- let mut shared = self.inner.shared.lock(); -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ let _ = name; - -- let id = shared.worker_thread_index; -- shared.worker_thread_index += 1; -+ let (task, handle) = task::unowned(fut, BlockingSchedule::new(rt), id); - -- let handle = self.spawn_thread(shutdown_tx, rt, id); -+ let spawned = self.spawn_task(Task::new(task, is_mandatory), rt); -+ (handle, spawned) -+ } - -- shared.worker_threads.insert(id, handle); -+ fn spawn_task(&self, task: Task, rt: &Handle) -> Result<(), SpawnError> { -+ let mut shared = self.inner.shared.lock(); -+ -+ if shared.shutdown { -+ // Shutdown the task: it's fine to shutdown this task (even if -+ // mandatory) because it was scheduled after the shutdown of the -+ // runtime began. -+ task.task.shutdown(); -+ -+ // no need to even push this task; it would never get picked up -+ return Err(SpawnError::ShuttingDown); -+ } -+ -+ shared.queue.push_back(task); -+ self.inner.metrics.inc_queue_depth(); -+ -+ if self.inner.metrics.num_idle_threads() == 0 { -+ // No threads are able to process the task. -+ -+ if self.inner.metrics.num_threads() == self.inner.thread_cap { -+ // At max number of threads -+ } else { -+ assert!(shared.shutdown_tx.is_some()); -+ let shutdown_tx = shared.shutdown_tx.clone(); -+ -+ if let Some(shutdown_tx) = shutdown_tx { -+ let id = shared.worker_thread_index; -+ -+ match self.spawn_thread(shutdown_tx, rt, id) { -+ Ok(handle) => { -+ self.inner.metrics.inc_num_threads(); -+ shared.worker_thread_index += 1; -+ shared.worker_threads.insert(id, handle); -+ } -+ Err(ref e) -+ if is_temporary_os_thread_error(e) -+ && self.inner.metrics.num_threads() > 0 => -+ { -+ // OS temporarily failed to spawn a new thread. -+ // The task will be picked up eventually by a currently -+ // busy thread. -+ } -+ Err(e) => { -+ // The OS refused to spawn the thread and there is no thread -+ // to pick up the task that has just been pushed to the queue. -+ return Err(SpawnError::NoThreads(e)); -+ } -+ } -+ } -+ } -+ } else { -+ // Notify an idle worker thread. The notification counter -+ // is used to count the needed amount of notifications -+ // exactly. Thread libraries may generate spurious -+ // wakeups, this counter is used to keep us in a -+ // consistent state. -+ self.inner.metrics.dec_num_idle_threads(); -+ shared.num_notify += 1; -+ self.inner.condvar.notify_one(); - } - - Ok(()) -@@ -228,7 +456,7 @@ impl Spawner { - shutdown_tx: shutdown::Sender, - rt: &Handle, - id: usize, -- ) -> thread::JoinHandle<()> { -+ ) -> std::io::Result> { - let mut builder = thread::Builder::new().name((self.inner.thread_name)()); - - if let Some(stack_size) = self.inner.stack_size { -@@ -237,17 +465,37 @@ impl Spawner { - - let rt = rt.clone(); - -- builder -- .spawn(move || { -- // Only the reference should be moved into the closure -- let _enter = crate::runtime::context::enter(rt.clone()); -- rt.blocking_spawner.inner.run(id); -- drop(shutdown_tx); -- }) -- .unwrap() -+ builder.spawn(move || { -+ // Only the reference should be moved into the closure -+ let _enter = rt.enter(); -+ rt.inner.blocking_spawner().inner.run(id); -+ drop(shutdown_tx); -+ }) -+ } -+} -+ -+cfg_metrics! { -+ impl Spawner { -+ pub(crate) fn num_threads(&self) -> usize { -+ self.inner.metrics.num_threads() -+ } -+ -+ pub(crate) fn num_idle_threads(&self) -> usize { -+ self.inner.metrics.num_idle_threads() -+ } -+ -+ pub(crate) fn queue_depth(&self) -> usize { -+ self.inner.metrics.queue_depth() -+ } - } - } - -+// Tells whether the error when spawning a thread is temporary. -+#[inline] -+fn is_temporary_os_thread_error(error: &std::io::Error) -> bool { -+ matches!(error.kind(), std::io::ErrorKind::WouldBlock) -+} -+ - impl Inner { - fn run(&self, worker_thread_id: usize) { - if let Some(f) = &self.after_start { -@@ -260,6 +508,7 @@ impl Inner { - 'main: loop { - // BUSY - while let Some(task) = shared.queue.pop_front() { -+ self.metrics.dec_queue_depth(); - drop(shared); - task.run(); - -@@ -267,7 +516,7 @@ impl Inner { - } - - // IDLE -- shared.num_idle += 1; -+ self.metrics.inc_num_idle_threads(); - - while !shared.shutdown { - let lock_result = self.condvar.wait_timeout(shared, self.keep_alive).unwrap(); -@@ -301,8 +550,10 @@ impl Inner { - if shared.shutdown { - // Drain the queue - while let Some(task) = shared.queue.pop_front() { -+ self.metrics.dec_queue_depth(); - drop(shared); -- task.shutdown(); -+ -+ task.shutdown_or_run_if_mandatory(); - - shared = self.shared.lock(); - } -@@ -310,7 +561,7 @@ impl Inner { - // Work was produced, and we "took" it (by decrementing num_notify). - // This means that num_idle was decremented once for our wakeup. - // But, since we are exiting, we need to "undo" that, as we'll stay idle. -- shared.num_idle += 1; -+ self.metrics.inc_num_idle_threads(); - // NOTE: Technically we should also do num_notify++ and notify again, - // but since we're shutting down anyway, that won't be necessary. - break; -@@ -318,17 +569,17 @@ impl Inner { - } - - // Thread exit -- shared.num_th -= 1; -+ self.metrics.dec_num_threads(); - - // num_idle should now be tracked exactly, panic - // with a descriptive message if it is not the - // case. -- shared.num_idle = shared -- .num_idle -- .checked_sub(1) -- .expect("num_idle underflowed on thread exit"); -+ let prev_idle = self.metrics.dec_num_idle_threads(); -+ if prev_idle < self.metrics.num_idle_threads() { -+ panic!("num_idle_threads underflowed on thread exit") -+ } - -- if shared.shutdown && shared.num_th == 0 { -+ if shared.shutdown && self.metrics.num_threads() == 0 { - self.condvar.notify_one(); - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/schedule.rs b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/schedule.rs -index 54252241..edf775be 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/schedule.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/schedule.rs -@@ -1,15 +1,52 @@ -+#[cfg(feature = "test-util")] -+use crate::runtime::scheduler; - use crate::runtime::task::{self, Task}; -+use crate::runtime::Handle; - --/// `task::Schedule` implementation that does nothing. This is unique to the --/// blocking scheduler as tasks scheduled are not really futures but blocking --/// operations. -+/// `task::Schedule` implementation that does nothing (except some bookkeeping -+/// in test-util builds). This is unique to the blocking scheduler as tasks -+/// scheduled are not really futures but blocking operations. - /// - /// We avoid storing the task by forgetting it in `bind` and re-materializing it --/// in `release. --pub(crate) struct NoopSchedule; -+/// in `release`. -+pub(crate) struct BlockingSchedule { -+ #[cfg(feature = "test-util")] -+ handle: Handle, -+} -+ -+impl BlockingSchedule { -+ #[cfg_attr(not(feature = "test-util"), allow(unused_variables))] -+ pub(crate) fn new(handle: &Handle) -> Self { -+ #[cfg(feature = "test-util")] -+ { -+ match &handle.inner { -+ scheduler::Handle::CurrentThread(handle) => { -+ handle.driver.clock.inhibit_auto_advance(); -+ } -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ scheduler::Handle::MultiThread(_) => {} -+ } -+ } -+ BlockingSchedule { -+ #[cfg(feature = "test-util")] -+ handle: handle.clone(), -+ } -+ } -+} - --impl task::Schedule for NoopSchedule { -+impl task::Schedule for BlockingSchedule { - fn release(&self, _task: &Task) -> Option> { -+ #[cfg(feature = "test-util")] -+ { -+ match &self.handle.inner { -+ scheduler::Handle::CurrentThread(handle) => { -+ handle.driver.clock.allow_auto_advance(); -+ handle.driver.unpark(); -+ } -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ scheduler::Handle::MultiThread(_) => {} -+ } -+ } - None - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/shutdown.rs b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/shutdown.rs -index e6f46741..fe5abae0 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/shutdown.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/shutdown.rs -@@ -35,13 +35,13 @@ impl Receiver { - /// - /// If the timeout has elapsed, it returns `false`, otherwise it returns `true`. - pub(crate) fn wait(&mut self, timeout: Option) -> bool { -- use crate::runtime::enter::try_enter; -+ use crate::runtime::context::try_enter_blocking_region; - - if timeout == Some(Duration::from_nanos(0)) { - return false; - } - -- let mut e = match try_enter(false) { -+ let mut e = match try_enter_blocking_region() { - Some(enter) => enter, - _ => { - if std::thread::panicking() { -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/task.rs b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/task.rs -index 0b7803a6..c4461754 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/blocking/task.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/blocking/task.rs -@@ -37,7 +37,7 @@ where - // currently goes through Task::poll(), and so is subject to budgeting. That isn't really - // what we want; a blocking task may itself want to run tasks (it might be a Worker!), so - // we want it to start without any budgeting. -- crate::coop::stop(); -+ crate::runtime::coop::stop(); - - Poll::Ready(func()) - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/builder.rs b/KubeOS-Rust/vendor/tokio/src/runtime/builder.rs -index 91c365fd..ea0df2e3 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/builder.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/builder.rs -@@ -1,5 +1,6 @@ - use crate::runtime::handle::Handle; --use crate::runtime::{blocking, driver, Callback, Runtime, Spawner}; -+use crate::runtime::{blocking, driver, Callback, Runtime}; -+use crate::util::rand::{RngSeed, RngSeedGenerator}; - - use std::fmt; - use std::io; -@@ -43,6 +44,7 @@ pub struct Builder { - - /// Whether or not to enable the I/O driver - enable_io: bool, -+ nevents: usize, - - /// Whether or not to enable the time driver - enable_time: bool, -@@ -78,13 +80,112 @@ pub struct Builder { - - /// Customizable keep alive timeout for BlockingPool - pub(super) keep_alive: Option, -+ -+ /// How many ticks before pulling a task from the global/remote queue? -+ pub(super) global_queue_interval: u32, -+ -+ /// How many ticks before yielding to the driver for timer and I/O events? -+ pub(super) event_interval: u32, -+ -+ /// When true, the multi-threade scheduler LIFO slot should not be used. -+ /// -+ /// This option should only be exposed as unstable. -+ pub(super) disable_lifo_slot: bool, -+ -+ /// Specify a random number generator seed to provide deterministic results -+ pub(super) seed_generator: RngSeedGenerator, -+ -+ #[cfg(tokio_unstable)] -+ pub(super) unhandled_panic: UnhandledPanic, -+} -+ -+cfg_unstable! { -+ /// How the runtime should respond to unhandled panics. -+ /// -+ /// Instances of `UnhandledPanic` are passed to `Builder::unhandled_panic` -+ /// to configure the runtime behavior when a spawned task panics. -+ /// -+ /// See [`Builder::unhandled_panic`] for more details. -+ #[derive(Debug, Clone)] -+ #[non_exhaustive] -+ pub enum UnhandledPanic { -+ /// The runtime should ignore panics on spawned tasks. -+ /// -+ /// The panic is forwarded to the task's [`JoinHandle`] and all spawned -+ /// tasks continue running normally. -+ /// -+ /// This is the default behavior. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::{self, UnhandledPanic}; -+ /// -+ /// # pub fn main() { -+ /// let rt = runtime::Builder::new_current_thread() -+ /// .unhandled_panic(UnhandledPanic::Ignore) -+ /// .build() -+ /// .unwrap(); -+ /// -+ /// let task1 = rt.spawn(async { panic!("boom"); }); -+ /// let task2 = rt.spawn(async { -+ /// // This task completes normally -+ /// "done" -+ /// }); -+ /// -+ /// rt.block_on(async { -+ /// // The panic on the first task is forwarded to the `JoinHandle` -+ /// assert!(task1.await.is_err()); -+ /// -+ /// // The second task completes normally -+ /// assert!(task2.await.is_ok()); -+ /// }) -+ /// # } -+ /// ``` -+ /// -+ /// [`JoinHandle`]: struct@crate::task::JoinHandle -+ Ignore, -+ -+ /// The runtime should immediately shutdown if a spawned task panics. -+ /// -+ /// The runtime will immediately shutdown even if the panicked task's -+ /// [`JoinHandle`] is still available. All further spawned tasks will be -+ /// immediately dropped and call to [`Runtime::block_on`] will panic. -+ /// -+ /// # Examples -+ /// -+ /// ```should_panic -+ /// use tokio::runtime::{self, UnhandledPanic}; -+ /// -+ /// # pub fn main() { -+ /// let rt = runtime::Builder::new_current_thread() -+ /// .unhandled_panic(UnhandledPanic::ShutdownRuntime) -+ /// .build() -+ /// .unwrap(); -+ /// -+ /// rt.spawn(async { panic!("boom"); }); -+ /// rt.spawn(async { -+ /// // This task never completes. -+ /// }); -+ /// -+ /// rt.block_on(async { -+ /// // Do some work -+ /// # loop { tokio::task::yield_now().await; } -+ /// }) -+ /// # } -+ /// ``` -+ /// -+ /// [`JoinHandle`]: struct@crate::task::JoinHandle -+ ShutdownRuntime, -+ } - } - - pub(crate) type ThreadNameFn = std::sync::Arc String + Send + Sync + 'static>; - -+#[derive(Clone, Copy)] - pub(crate) enum Kind { - CurrentThread, -- #[cfg(feature = "rt-multi-thread")] -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] - MultiThread, - } - -@@ -98,28 +199,38 @@ impl Builder { - /// - /// [`LocalSet`]: crate::task::LocalSet - pub fn new_current_thread() -> Builder { -- Builder::new(Kind::CurrentThread) -+ #[cfg(loom)] -+ const EVENT_INTERVAL: u32 = 4; -+ // The number `61` is fairly arbitrary. I believe this value was copied from golang. -+ #[cfg(not(loom))] -+ const EVENT_INTERVAL: u32 = 61; -+ -+ Builder::new(Kind::CurrentThread, 31, EVENT_INTERVAL) - } - -- /// Returns a new builder with the multi thread scheduler selected. -- /// -- /// Configuration methods can be chained on the return value. -- #[cfg(feature = "rt-multi-thread")] -- #[cfg_attr(docsrs, doc(cfg(feature = "rt-multi-thread")))] -- pub fn new_multi_thread() -> Builder { -- Builder::new(Kind::MultiThread) -+ cfg_not_wasi! { -+ /// Returns a new builder with the multi thread scheduler selected. -+ /// -+ /// Configuration methods can be chained on the return value. -+ #[cfg(feature = "rt-multi-thread")] -+ #[cfg_attr(docsrs, doc(cfg(feature = "rt-multi-thread")))] -+ pub fn new_multi_thread() -> Builder { -+ // The number `61` is fairly arbitrary. I believe this value was copied from golang. -+ Builder::new(Kind::MultiThread, 61, 61) -+ } - } - - /// Returns a new runtime builder initialized with default configuration - /// values. - /// - /// Configuration methods can be chained on the return value. -- pub(crate) fn new(kind: Kind) -> Builder { -+ pub(crate) fn new(kind: Kind, global_queue_interval: u32, event_interval: u32) -> Builder { - Builder { - kind, - - // I/O defaults to "off" - enable_io: false, -+ nevents: 1024, - - // Time defaults to "off" - enable_time: false, -@@ -127,6 +238,7 @@ impl Builder { - // The clock starts not-paused - start_paused: false, - -+ // Read from environment variable first in multi-threaded mode. - // Default to lazy auto-detection (one thread per CPU core) - worker_threads: None, - -@@ -145,6 +257,18 @@ impl Builder { - after_unpark: None, - - keep_alive: None, -+ -+ // Defaults for these values depend on the scheduler kind, so we get them -+ // as parameters. -+ global_queue_interval, -+ event_interval, -+ -+ seed_generator: RngSeedGenerator::new(RngSeed::new()), -+ -+ #[cfg(tokio_unstable)] -+ unhandled_panic: UnhandledPanic::Ignore, -+ -+ disable_lifo_slot: false, - } - } - -@@ -165,7 +289,11 @@ impl Builder { - /// .unwrap(); - /// ``` - pub fn enable_all(&mut self) -> &mut Self { -- #[cfg(any(feature = "net", feature = "process", all(unix, feature = "signal")))] -+ #[cfg(any( -+ feature = "net", -+ all(unix, feature = "process"), -+ all(unix, feature = "signal") -+ ))] - self.enable_io(); - #[cfg(feature = "time")] - self.enable_time(); -@@ -178,15 +306,13 @@ impl Builder { - /// This can be any number above 0 though it is advised to keep this value - /// on the smaller side. - /// -+ /// This will override the value read from environment variable `TOKIO_WORKER_THREADS`. -+ /// - /// # Default - /// - /// The default value is the number of cores available to the system. - /// -- /// # Panic -- /// -- /// When using the `current_thread` runtime this method will panic, since -- /// those variants do not allow setting worker thread counts. -- /// -+ /// When using the `current_thread` runtime this method has no effect. - /// - /// # Examples - /// -@@ -219,9 +345,10 @@ impl Builder { - /// rt.block_on(async move {}); - /// ``` - /// -- /// # Panic -+ /// # Panics - /// - /// This will panic if `val` is not larger than `0`. -+ #[track_caller] - pub fn worker_threads(&mut self, val: usize) -> &mut Self { - assert!(val > 0, "Worker threads cannot be set to 0"); - self.worker_threads = Some(val); -@@ -237,7 +364,7 @@ impl Builder { - /// - /// The default value is 512. - /// -- /// # Panic -+ /// # Panics - /// - /// This will panic if `val` is not larger than `0`. - /// -@@ -249,6 +376,7 @@ impl Builder { - /// [`spawn_blocking`]: fn@crate::task::spawn_blocking - /// [`worker_threads`]: Self::worker_threads - /// [`thread_keep_alive`]: Self::thread_keep_alive -+ #[track_caller] - #[cfg_attr(docsrs, doc(alias = "max_threads"))] - pub fn max_blocking_threads(&mut self, val: usize) -> &mut Self { - assert!(val > 0, "Max blocking threads cannot be set to 0"); -@@ -286,7 +414,6 @@ impl Builder { - /// ``` - /// # use tokio::runtime; - /// # use std::sync::atomic::{AtomicUsize, Ordering}; -- /// - /// # pub fn main() { - /// let rt = runtime::Builder::new_multi_thread() - /// .thread_name_fn(|| { -@@ -338,7 +465,6 @@ impl Builder { - /// - /// ``` - /// # use tokio::runtime; -- /// - /// # pub fn main() { - /// let runtime = runtime::Builder::new_multi_thread() - /// .on_thread_start(|| { -@@ -364,7 +490,6 @@ impl Builder { - /// - /// ``` - /// # use tokio::runtime; -- /// - /// # pub fn main() { - /// let runtime = runtime::Builder::new_multi_thread() - /// .on_thread_stop(|| { -@@ -473,7 +598,6 @@ impl Builder { - /// - /// ``` - /// # use tokio::runtime; -- /// - /// # pub fn main() { - /// let runtime = runtime::Builder::new_multi_thread() - /// .on_thread_unpark(|| { -@@ -513,8 +637,8 @@ impl Builder { - /// ``` - pub fn build(&mut self) -> io::Result { - match &self.kind { -- Kind::CurrentThread => self.build_basic_runtime(), -- #[cfg(feature = "rt-multi-thread")] -+ Kind::CurrentThread => self.build_current_thread_runtime(), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] - Kind::MultiThread => self.build_threaded_runtime(), - } - } -@@ -523,12 +647,13 @@ impl Builder { - driver::Cfg { - enable_pause_time: match self.kind { - Kind::CurrentThread => true, -- #[cfg(feature = "rt-multi-thread")] -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] - Kind::MultiThread => false, - }, - enable_io: self.enable_io, - enable_time: self.enable_time, - start_paused: self.start_paused, -+ nevents: self.nevents, - } - } - -@@ -542,7 +667,6 @@ impl Builder { - /// ``` - /// # use tokio::runtime; - /// # use std::time::Duration; -- /// - /// # pub fn main() { - /// let rt = runtime::Builder::new_multi_thread() - /// .thread_keep_alive(Duration::from_millis(100)) -@@ -554,35 +678,249 @@ impl Builder { - self - } - -- fn build_basic_runtime(&mut self) -> io::Result { -- use crate::runtime::{BasicScheduler, Kind}; -+ /// Sets the number of scheduler ticks after which the scheduler will poll the global -+ /// task queue. -+ /// -+ /// A scheduler "tick" roughly corresponds to one `poll` invocation on a task. -+ /// -+ /// By default the global queue interval is: -+ /// -+ /// * `31` for the current-thread scheduler. -+ /// * `61` for the multithreaded scheduler. -+ /// -+ /// Schedulers have a local queue of already-claimed tasks, and a global queue of incoming -+ /// tasks. Setting the interval to a smaller value increases the fairness of the scheduler, -+ /// at the cost of more synchronization overhead. That can be beneficial for prioritizing -+ /// getting started on new work, especially if tasks frequently yield rather than complete -+ /// or await on further I/O. Conversely, a higher value prioritizes existing work, and -+ /// is a good choice when most tasks quickly complete polling. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// # use tokio::runtime; -+ /// # pub fn main() { -+ /// let rt = runtime::Builder::new_multi_thread() -+ /// .global_queue_interval(31) -+ /// .build(); -+ /// # } -+ /// ``` -+ pub fn global_queue_interval(&mut self, val: u32) -> &mut Self { -+ self.global_queue_interval = val; -+ self -+ } - -- let (driver, resources) = driver::Driver::new(self.get_cfg())?; -+ /// Sets the number of scheduler ticks after which the scheduler will poll for -+ /// external events (timers, I/O, and so on). -+ /// -+ /// A scheduler "tick" roughly corresponds to one `poll` invocation on a task. -+ /// -+ /// By default, the event interval is `61` for all scheduler types. -+ /// -+ /// Setting the event interval determines the effective "priority" of delivering -+ /// these external events (which may wake up additional tasks), compared to -+ /// executing tasks that are currently ready to run. A smaller value is useful -+ /// when tasks frequently spend a long time in polling, or frequently yield, -+ /// which can result in overly long delays picking up I/O events. Conversely, -+ /// picking up new events requires extra synchronization and syscall overhead, -+ /// so if tasks generally complete their polling quickly, a higher event interval -+ /// will minimize that overhead while still keeping the scheduler responsive to -+ /// events. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// # use tokio::runtime; -+ /// # pub fn main() { -+ /// let rt = runtime::Builder::new_multi_thread() -+ /// .event_interval(31) -+ /// .build(); -+ /// # } -+ /// ``` -+ pub fn event_interval(&mut self, val: u32) -> &mut Self { -+ self.event_interval = val; -+ self -+ } - -- // And now put a single-threaded scheduler on top of the timer. When -- // there are no futures ready to do something, it'll let the timer or -- // the reactor to generate some new stimuli for the futures to continue -- // in their life. -- let scheduler = -- BasicScheduler::new(driver, self.before_park.clone(), self.after_unpark.clone()); -- let spawner = Spawner::Basic(scheduler.spawner().clone()); -+ cfg_unstable! { -+ /// Configure how the runtime responds to an unhandled panic on a -+ /// spawned task. -+ /// -+ /// By default, an unhandled panic (i.e. a panic not caught by -+ /// [`std::panic::catch_unwind`]) has no impact on the runtime's -+ /// execution. The panic is error value is forwarded to the task's -+ /// [`JoinHandle`] and all other spawned tasks continue running. -+ /// -+ /// The `unhandled_panic` option enables configuring this behavior. -+ /// -+ /// * `UnhandledPanic::Ignore` is the default behavior. Panics on -+ /// spawned tasks have no impact on the runtime's execution. -+ /// * `UnhandledPanic::ShutdownRuntime` will force the runtime to -+ /// shutdown immediately when a spawned task panics even if that -+ /// task's `JoinHandle` has not been dropped. All other spawned tasks -+ /// will immediately terminate and further calls to -+ /// [`Runtime::block_on`] will panic. -+ /// -+ /// # Unstable -+ /// -+ /// This option is currently unstable and its implementation is -+ /// incomplete. The API may change or be removed in the future. See -+ /// tokio-rs/tokio#4516 for more details. -+ /// -+ /// # Examples -+ /// -+ /// The following demonstrates a runtime configured to shutdown on -+ /// panic. The first spawned task panics and results in the runtime -+ /// shutting down. The second spawned task never has a chance to -+ /// execute. The call to `block_on` will panic due to the runtime being -+ /// forcibly shutdown. -+ /// -+ /// ```should_panic -+ /// use tokio::runtime::{self, UnhandledPanic}; -+ /// -+ /// # pub fn main() { -+ /// let rt = runtime::Builder::new_current_thread() -+ /// .unhandled_panic(UnhandledPanic::ShutdownRuntime) -+ /// .build() -+ /// .unwrap(); -+ /// -+ /// rt.spawn(async { panic!("boom"); }); -+ /// rt.spawn(async { -+ /// // This task never completes. -+ /// }); -+ /// -+ /// rt.block_on(async { -+ /// // Do some work -+ /// # loop { tokio::task::yield_now().await; } -+ /// }) -+ /// # } -+ /// ``` -+ /// -+ /// [`JoinHandle`]: struct@crate::task::JoinHandle -+ pub fn unhandled_panic(&mut self, behavior: UnhandledPanic) -> &mut Self { -+ self.unhandled_panic = behavior; -+ self -+ } -+ -+ /// Disables the LIFO task scheduler heuristic. -+ /// -+ /// The multi-threaded scheduler includes a heuristic for optimizing -+ /// message-passing patterns. This heuristic results in the **last** -+ /// scheduled task being polled first. -+ /// -+ /// To implement this heuristic, each worker thread has a slot which -+ /// holds the task that should be polled next. However, this slot cannot -+ /// be stolen by other worker threads, which can result in lower total -+ /// throughput when tasks tend to have longer poll times. -+ /// -+ /// This configuration option will disable this heuristic resulting in -+ /// all scheduled tasks being pushed into the worker-local queue, which -+ /// is stealable. -+ /// -+ /// Consider trying this option when the task "scheduled" time is high -+ /// but the runtime is underutilized. Use tokio-rs/tokio-metrics to -+ /// collect this data. -+ /// -+ /// # Unstable -+ /// -+ /// This configuration option is considered a workaround for the LIFO -+ /// slot not being stealable. When the slot becomes stealable, we will -+ /// revisit whether or not this option is necessary. See -+ /// tokio-rs/tokio#4941. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime; -+ /// -+ /// let rt = runtime::Builder::new_multi_thread() -+ /// .disable_lifo_slot() -+ /// .build() -+ /// .unwrap(); -+ /// ``` -+ pub fn disable_lifo_slot(&mut self) -> &mut Self { -+ self.disable_lifo_slot = true; -+ self -+ } -+ -+ /// Specifies the random number generation seed to use within all -+ /// threads associated with the runtime being built. -+ /// -+ /// This option is intended to make certain parts of the runtime -+ /// deterministic (e.g. the [`tokio::select!`] macro). In the case of -+ /// [`tokio::select!`] it will ensure that the order that branches are -+ /// polled is deterministic. -+ /// -+ /// In addition to the code specifying `rng_seed` and interacting with -+ /// the runtime, the internals of Tokio and the Rust compiler may affect -+ /// the sequences of random numbers. In order to ensure repeatable -+ /// results, the version of Tokio, the versions of all other -+ /// dependencies that interact with Tokio, and the Rust compiler version -+ /// should also all remain constant. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// # use tokio::runtime::{self, RngSeed}; -+ /// # pub fn main() { -+ /// let seed = RngSeed::from_bytes(b"place your seed here"); -+ /// let rt = runtime::Builder::new_current_thread() -+ /// .rng_seed(seed) -+ /// .build(); -+ /// # } -+ /// ``` -+ /// -+ /// [`tokio::select!`]: crate::select -+ pub fn rng_seed(&mut self, seed: RngSeed) -> &mut Self { -+ self.seed_generator = RngSeedGenerator::new(seed); -+ self -+ } -+ } -+ -+ fn build_current_thread_runtime(&mut self) -> io::Result { -+ use crate::runtime::scheduler::{self, CurrentThread}; -+ use crate::runtime::{runtime::Scheduler, Config}; -+ -+ let (driver, driver_handle) = driver::Driver::new(self.get_cfg())?; - - // Blocking pool - let blocking_pool = blocking::create_blocking_pool(self, self.max_blocking_threads); - let blocking_spawner = blocking_pool.spawner().clone(); - -- Ok(Runtime { -- kind: Kind::CurrentThread(scheduler), -- handle: Handle { -- spawner, -- io_handle: resources.io_handle, -- time_handle: resources.time_handle, -- signal_handle: resources.signal_handle, -- clock: resources.clock, -- blocking_spawner, -+ // Generate a rng seed for this runtime. -+ let seed_generator_1 = self.seed_generator.next_generator(); -+ let seed_generator_2 = self.seed_generator.next_generator(); -+ -+ // And now put a single-threaded scheduler on top of the timer. When -+ // there are no futures ready to do something, it'll let the timer or -+ // the reactor to generate some new stimuli for the futures to continue -+ // in their life. -+ let (scheduler, handle) = CurrentThread::new( -+ driver, -+ driver_handle, -+ blocking_spawner, -+ seed_generator_2, -+ Config { -+ before_park: self.before_park.clone(), -+ after_unpark: self.after_unpark.clone(), -+ global_queue_interval: self.global_queue_interval, -+ event_interval: self.event_interval, -+ #[cfg(tokio_unstable)] -+ unhandled_panic: self.unhandled_panic.clone(), -+ disable_lifo_slot: self.disable_lifo_slot, -+ seed_generator: seed_generator_1, - }, -+ ); -+ -+ let handle = Handle { -+ inner: scheduler::Handle::CurrentThread(handle), -+ }; -+ -+ Ok(Runtime::from_parts( -+ Scheduler::CurrentThread(scheduler), -+ handle, - blocking_pool, -- }) -+ )) - } - } - -@@ -607,6 +945,25 @@ cfg_io_driver! { - self.enable_io = true; - self - } -+ -+ /// Enables the I/O driver and configures the max number of events to be -+ /// processed per tick. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime; -+ /// -+ /// let rt = runtime::Builder::new_current_thread() -+ /// .enable_io() -+ /// .max_io_events_per_tick(1024) -+ /// .build() -+ /// .unwrap(); -+ /// ``` -+ pub fn max_io_events_per_tick(&mut self, capacity: usize) -> &mut Self { -+ self.nevents = capacity; -+ self -+ } - } - } - -@@ -662,39 +1019,47 @@ cfg_rt_multi_thread! { - impl Builder { - fn build_threaded_runtime(&mut self) -> io::Result { - use crate::loom::sys::num_cpus; -- use crate::runtime::{Kind, ThreadPool}; -- use crate::runtime::park::Parker; -+ use crate::runtime::{Config, runtime::Scheduler}; -+ use crate::runtime::scheduler::{self, MultiThread}; - - let core_threads = self.worker_threads.unwrap_or_else(num_cpus); - -- let (driver, resources) = driver::Driver::new(self.get_cfg())?; -- -- let (scheduler, launch) = ThreadPool::new(core_threads, Parker::new(driver), self.before_park.clone(), self.after_unpark.clone()); -- let spawner = Spawner::ThreadPool(scheduler.spawner().clone()); -+ let (driver, driver_handle) = driver::Driver::new(self.get_cfg())?; - - // Create the blocking pool -- let blocking_pool = blocking::create_blocking_pool(self, self.max_blocking_threads + core_threads); -+ let blocking_pool = -+ blocking::create_blocking_pool(self, self.max_blocking_threads + core_threads); - let blocking_spawner = blocking_pool.spawner().clone(); - -- // Create the runtime handle -- let handle = Handle { -- spawner, -- io_handle: resources.io_handle, -- time_handle: resources.time_handle, -- signal_handle: resources.signal_handle, -- clock: resources.clock, -+ // Generate a rng seed for this runtime. -+ let seed_generator_1 = self.seed_generator.next_generator(); -+ let seed_generator_2 = self.seed_generator.next_generator(); -+ -+ let (scheduler, handle, launch) = MultiThread::new( -+ core_threads, -+ driver, -+ driver_handle, - blocking_spawner, -- }; -+ seed_generator_2, -+ Config { -+ before_park: self.before_park.clone(), -+ after_unpark: self.after_unpark.clone(), -+ global_queue_interval: self.global_queue_interval, -+ event_interval: self.event_interval, -+ #[cfg(tokio_unstable)] -+ unhandled_panic: self.unhandled_panic.clone(), -+ disable_lifo_slot: self.disable_lifo_slot, -+ seed_generator: seed_generator_1, -+ }, -+ ); -+ -+ let handle = Handle { inner: scheduler::Handle::MultiThread(handle) }; - - // Spawn the thread pool workers -- let _enter = crate::runtime::context::enter(handle.clone()); -+ let _enter = handle.enter(); - launch.launch(); - -- Ok(Runtime { -- kind: Kind::ThreadPool(scheduler), -- handle, -- blocking_pool, -- }) -+ Ok(Runtime::from_parts(Scheduler::MultiThread(scheduler), handle, blocking_pool)) - } - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/config.rs b/KubeOS-Rust/vendor/tokio/src/runtime/config.rs -new file mode 100644 -index 00000000..39eb1cf1 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/config.rs -@@ -0,0 +1,34 @@ -+#![cfg_attr(any(not(feature = "full"), tokio_wasm), allow(dead_code))] -+use crate::runtime::Callback; -+use crate::util::RngSeedGenerator; -+ -+pub(crate) struct Config { -+ /// How many ticks before pulling a task from the global/remote queue? -+ pub(crate) global_queue_interval: u32, -+ -+ /// How many ticks before yielding to the driver for timer and I/O events? -+ pub(crate) event_interval: u32, -+ -+ /// Callback for a worker parking itself -+ pub(crate) before_park: Option, -+ -+ /// Callback for a worker unparking itself -+ pub(crate) after_unpark: Option, -+ -+ /// The multi-threaded scheduler includes a per-worker LIFO slot used to -+ /// store the last scheduled task. This can improve certain usage patterns, -+ /// especially message passing between tasks. However, this LIFO slot is not -+ /// currently stealable. -+ /// -+ /// Eventually, the LIFO slot **will** become stealable, however as a -+ /// stop-gap, this unstable option lets users disable the LIFO task. -+ pub(crate) disable_lifo_slot: bool, -+ -+ /// Random number generator seed to configure runtimes to act in a -+ /// deterministic way. -+ pub(crate) seed_generator: RngSeedGenerator, -+ -+ #[cfg(tokio_unstable)] -+ /// How to respond to unhandled task panics. -+ pub(crate) unhandled_panic: crate::runtime::UnhandledPanic, -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/context.rs b/KubeOS-Rust/vendor/tokio/src/runtime/context.rs -index 1f44a534..a2401306 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/context.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/context.rs -@@ -1,111 +1,420 @@ --//! Thread local runtime context --use crate::runtime::{Handle, TryCurrentError}; -+use crate::loom::thread::AccessError; -+use crate::runtime::coop; - --use std::cell::RefCell; -+use std::cell::Cell; - --thread_local! { -- static CONTEXT: RefCell> = RefCell::new(None) -+#[cfg(any(feature = "rt", feature = "macros"))] -+use crate::util::rand::{FastRand, RngSeed}; -+ -+cfg_rt! { -+ use crate::runtime::{scheduler, task::Id, Defer}; -+ -+ use std::cell::RefCell; -+ use std::marker::PhantomData; -+ use std::time::Duration; - } - --pub(crate) fn try_current() -> Result { -- match CONTEXT.try_with(|ctx| ctx.borrow().clone()) { -- Ok(Some(handle)) => Ok(handle), -- Ok(None) => Err(TryCurrentError::new_no_context()), -- Err(_access_error) => Err(TryCurrentError::new_thread_local_destroyed()), -- } -+struct Context { -+ /// Uniquely identifies the current thread -+ #[cfg(feature = "rt")] -+ thread_id: Cell>, -+ -+ /// Handle to the runtime scheduler running on the current thread. -+ #[cfg(feature = "rt")] -+ handle: RefCell>, -+ -+ #[cfg(feature = "rt")] -+ current_task_id: Cell>, -+ -+ /// Tracks if the current thread is currently driving a runtime. -+ /// Note, that if this is set to "entered", the current scheduler -+ /// handle may not reference the runtime currently executing. This -+ /// is because other runtime handles may be set to current from -+ /// within a runtime. -+ #[cfg(feature = "rt")] -+ runtime: Cell, -+ -+ /// Yielded task wakers are stored here and notified after resource drivers -+ /// are polled. -+ #[cfg(feature = "rt")] -+ defer: RefCell>, -+ -+ #[cfg(any(feature = "rt", feature = "macros"))] -+ rng: FastRand, -+ -+ /// Tracks the amount of "work" a task may still do before yielding back to -+ /// the sheduler -+ budget: Cell, - } - --pub(crate) fn current() -> Handle { -- match try_current() { -- Ok(handle) => handle, -- Err(e) => panic!("{}", e), -+tokio_thread_local! { -+ static CONTEXT: Context = { -+ Context { -+ #[cfg(feature = "rt")] -+ thread_id: Cell::new(None), -+ -+ /// Tracks the current runtime handle to use when spawning, -+ /// accessing drivers, etc... -+ #[cfg(feature = "rt")] -+ handle: RefCell::new(None), -+ #[cfg(feature = "rt")] -+ current_task_id: Cell::new(None), -+ -+ /// Tracks if the current thread is currently driving a runtime. -+ /// Note, that if this is set to "entered", the current scheduler -+ /// handle may not reference the runtime currently executing. This -+ /// is because other runtime handles may be set to current from -+ /// within a runtime. -+ #[cfg(feature = "rt")] -+ runtime: Cell::new(EnterRuntime::NotEntered), -+ -+ #[cfg(feature = "rt")] -+ defer: RefCell::new(None), -+ -+ #[cfg(any(feature = "rt", feature = "macros"))] -+ rng: FastRand::new(RngSeed::new()), -+ -+ budget: Cell::new(coop::Budget::unconstrained()), -+ } - } - } - --cfg_io_driver! { -- pub(crate) fn io_handle() -> crate::runtime::driver::IoHandle { -- match CONTEXT.try_with(|ctx| { -- let ctx = ctx.borrow(); -- ctx.as_ref().expect(crate::util::error::CONTEXT_MISSING_ERROR).io_handle.clone() -- }) { -- Ok(io_handle) => io_handle, -- Err(_) => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR), -+#[cfg(any(feature = "macros", all(feature = "sync", feature = "rt")))] -+pub(crate) fn thread_rng_n(n: u32) -> u32 { -+ CONTEXT.with(|ctx| ctx.rng.fastrand_n(n)) -+} -+ -+pub(super) fn budget(f: impl FnOnce(&Cell) -> R) -> Result { -+ CONTEXT.try_with(|ctx| f(&ctx.budget)) -+} -+ -+cfg_rt! { -+ use crate::runtime::{ThreadId, TryCurrentError}; -+ -+ use std::fmt; -+ -+ pub(crate) fn thread_id() -> Result { -+ CONTEXT.try_with(|ctx| { -+ match ctx.thread_id.get() { -+ Some(id) => id, -+ None => { -+ let id = ThreadId::next(); -+ ctx.thread_id.set(Some(id)); -+ id -+ } -+ } -+ }) -+ } -+ -+ #[derive(Debug, Clone, Copy)] -+ #[must_use] -+ pub(crate) enum EnterRuntime { -+ /// Currently in a runtime context. -+ #[cfg_attr(not(feature = "rt"), allow(dead_code))] -+ Entered { allow_block_in_place: bool }, -+ -+ /// Not in a runtime context **or** a blocking region. -+ NotEntered, -+ } -+ -+ #[derive(Debug)] -+ #[must_use] -+ pub(crate) struct SetCurrentGuard { -+ old_handle: Option, -+ old_seed: RngSeed, -+ } -+ -+ /// Guard tracking that a caller has entered a runtime context. -+ #[must_use] -+ pub(crate) struct EnterRuntimeGuard { -+ /// Tracks that the current thread has entered a blocking function call. -+ pub(crate) blocking: BlockingRegionGuard, -+ -+ #[allow(dead_code)] // Only tracking the guard. -+ pub(crate) handle: SetCurrentGuard, -+ -+ /// If true, then this is the root runtime guard. It is possible to nest -+ /// runtime guards by using `block_in_place` between the calls. We need -+ /// to track the root guard as this is the guard responsible for freeing -+ /// the deferred task queue. -+ is_root: bool, -+ } -+ -+ /// Guard tracking that a caller has entered a blocking region. -+ #[must_use] -+ pub(crate) struct BlockingRegionGuard { -+ _p: PhantomData>, -+ } -+ -+ pub(crate) struct DisallowBlockInPlaceGuard(bool); -+ -+ pub(crate) fn set_current_task_id(id: Option) -> Option { -+ CONTEXT.try_with(|ctx| ctx.current_task_id.replace(id)).unwrap_or(None) -+ } -+ -+ pub(crate) fn current_task_id() -> Option { -+ CONTEXT.try_with(|ctx| ctx.current_task_id.get()).unwrap_or(None) -+ } -+ -+ pub(crate) fn try_current() -> Result { -+ match CONTEXT.try_with(|ctx| ctx.handle.borrow().clone()) { -+ Ok(Some(handle)) => Ok(handle), -+ Ok(None) => Err(TryCurrentError::new_no_context()), -+ Err(_access_error) => Err(TryCurrentError::new_thread_local_destroyed()), - } - } --} - --cfg_signal_internal! { -- #[cfg(unix)] -- pub(crate) fn signal_handle() -> crate::runtime::driver::SignalHandle { -- match CONTEXT.try_with(|ctx| { -- let ctx = ctx.borrow(); -- ctx.as_ref().expect(crate::util::error::CONTEXT_MISSING_ERROR).signal_handle.clone() -- }) { -- Ok(signal_handle) => signal_handle, -- Err(_) => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR), -+ /// Sets this [`Handle`] as the current active [`Handle`]. -+ /// -+ /// [`Handle`]: crate::runtime::scheduler::Handle -+ pub(crate) fn try_set_current(handle: &scheduler::Handle) -> Option { -+ CONTEXT.try_with(|ctx| ctx.set_current(handle)).ok() -+ } -+ -+ -+ /// Marks the current thread as being within the dynamic extent of an -+ /// executor. -+ #[track_caller] -+ pub(crate) fn enter_runtime(handle: &scheduler::Handle, allow_block_in_place: bool) -> EnterRuntimeGuard { -+ if let Some(enter) = try_enter_runtime(handle, allow_block_in_place) { -+ return enter; - } -+ -+ panic!( -+ "Cannot start a runtime from within a runtime. This happens \ -+ because a function (like `block_on`) attempted to block the \ -+ current thread while the thread is being used to drive \ -+ asynchronous tasks." -+ ); - } --} - --cfg_time! { -- pub(crate) fn time_handle() -> crate::runtime::driver::TimeHandle { -- match CONTEXT.try_with(|ctx| { -- let ctx = ctx.borrow(); -- ctx.as_ref().expect(crate::util::error::CONTEXT_MISSING_ERROR).time_handle.clone() -- }) { -- Ok(time_handle) => time_handle, -- Err(_) => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR), -+ /// Tries to enter a runtime context, returns `None` if already in a runtime -+ /// context. -+ fn try_enter_runtime(handle: &scheduler::Handle, allow_block_in_place: bool) -> Option { -+ CONTEXT.with(|c| { -+ if c.runtime.get().is_entered() { -+ None -+ } else { -+ // Set the entered flag -+ c.runtime.set(EnterRuntime::Entered { allow_block_in_place }); -+ -+ // Initialize queue to track yielded tasks -+ let mut defer = c.defer.borrow_mut(); -+ -+ let is_root = if defer.is_none() { -+ *defer = Some(Defer::new()); -+ true -+ } else { -+ false -+ }; -+ -+ Some(EnterRuntimeGuard { -+ blocking: BlockingRegionGuard::new(), -+ handle: c.set_current(handle), -+ is_root, -+ }) -+ } -+ }) -+ } -+ -+ pub(crate) fn try_enter_blocking_region() -> Option { -+ CONTEXT.try_with(|c| { -+ if c.runtime.get().is_entered() { -+ None -+ } else { -+ Some(BlockingRegionGuard::new()) -+ } -+ // If accessing the thread-local fails, the thread is terminating -+ // and thread-locals are being destroyed. Because we don't know if -+ // we are currently in a runtime or not, we default to being -+ // permissive. -+ }).unwrap_or_else(|_| Some(BlockingRegionGuard::new())) -+ } -+ -+ /// Disallows blocking in the current runtime context until the guard is dropped. -+ pub(crate) fn disallow_block_in_place() -> DisallowBlockInPlaceGuard { -+ let reset = CONTEXT.with(|c| { -+ if let EnterRuntime::Entered { -+ allow_block_in_place: true, -+ } = c.runtime.get() -+ { -+ c.runtime.set(EnterRuntime::Entered { -+ allow_block_in_place: false, -+ }); -+ true -+ } else { -+ false -+ } -+ }); -+ -+ DisallowBlockInPlaceGuard(reset) -+ } -+ -+ pub(crate) fn with_defer(f: impl FnOnce(&mut Defer) -> R) -> Option { -+ CONTEXT.with(|c| { -+ let mut defer = c.defer.borrow_mut(); -+ defer.as_mut().map(f) -+ }) -+ } -+ -+ impl Context { -+ fn set_current(&self, handle: &scheduler::Handle) -> SetCurrentGuard { -+ let rng_seed = handle.seed_generator().next_seed(); -+ -+ let old_handle = self.handle.borrow_mut().replace(handle.clone()); -+ let old_seed = self.rng.replace_seed(rng_seed); -+ -+ SetCurrentGuard { -+ old_handle, -+ old_seed, -+ } - } - } - -- cfg_test_util! { -- pub(crate) fn clock() -> Option { -- match CONTEXT.try_with(|ctx| (*ctx.borrow()).as_ref().map(|ctx| ctx.clock.clone())) { -- Ok(clock) => clock, -- Err(_) => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR), -+ impl Drop for SetCurrentGuard { -+ fn drop(&mut self) { -+ CONTEXT.with(|ctx| { -+ *ctx.handle.borrow_mut() = self.old_handle.take(); -+ ctx.rng.replace_seed(self.old_seed.clone()); -+ }); -+ } -+ } -+ -+ impl fmt::Debug for EnterRuntimeGuard { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ f.debug_struct("Enter").finish() -+ } -+ } -+ -+ impl Drop for EnterRuntimeGuard { -+ fn drop(&mut self) { -+ CONTEXT.with(|c| { -+ assert!(c.runtime.get().is_entered()); -+ c.runtime.set(EnterRuntime::NotEntered); -+ -+ if self.is_root { -+ *c.defer.borrow_mut() = None; -+ } -+ }); -+ } -+ } -+ -+ impl BlockingRegionGuard { -+ fn new() -> BlockingRegionGuard { -+ BlockingRegionGuard { _p: PhantomData } -+ } -+ /// Blocks the thread on the specified future, returning the value with -+ /// which that future completes. -+ pub(crate) fn block_on(&mut self, f: F) -> Result -+ where -+ F: std::future::Future, -+ { -+ use crate::runtime::park::CachedParkThread; -+ -+ let mut park = CachedParkThread::new(); -+ park.block_on(f) -+ } -+ -+ /// Blocks the thread on the specified future for **at most** `timeout` -+ /// -+ /// If the future completes before `timeout`, the result is returned. If -+ /// `timeout` elapses, then `Err` is returned. -+ pub(crate) fn block_on_timeout(&mut self, f: F, timeout: Duration) -> Result -+ where -+ F: std::future::Future, -+ { -+ use crate::runtime::park::CachedParkThread; -+ use std::task::Context; -+ use std::task::Poll::Ready; -+ use std::time::Instant; -+ -+ let mut park = CachedParkThread::new(); -+ let waker = park.waker().map_err(|_| ())?; -+ let mut cx = Context::from_waker(&waker); -+ -+ pin!(f); -+ let when = Instant::now() + timeout; -+ -+ loop { -+ if let Ready(v) = crate::runtime::coop::budget(|| f.as_mut().poll(&mut cx)) { -+ return Ok(v); -+ } -+ -+ let now = Instant::now(); -+ -+ if now >= when { -+ return Err(()); -+ } -+ -+ // Wake any yielded tasks before parking in order to avoid -+ // blocking. -+ with_defer(|defer| defer.wake()); -+ -+ park.park_timeout(when - now); - } - } - } --} - --cfg_rt! { -- pub(crate) fn spawn_handle() -> Option { -- match CONTEXT.try_with(|ctx| (*ctx.borrow()).as_ref().map(|ctx| ctx.spawner.clone())) { -- Ok(spawner) => spawner, -- Err(_) => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR), -+ impl Drop for DisallowBlockInPlaceGuard { -+ fn drop(&mut self) { -+ if self.0 { -+ // XXX: Do we want some kind of assertion here, or is "best effort" okay? -+ CONTEXT.with(|c| { -+ if let EnterRuntime::Entered { -+ allow_block_in_place: false, -+ } = c.runtime.get() -+ { -+ c.runtime.set(EnterRuntime::Entered { -+ allow_block_in_place: true, -+ }); -+ } -+ }) -+ } - } - } --} - --/// Sets this [`Handle`] as the current active [`Handle`]. --/// --/// [`Handle`]: Handle --pub(crate) fn enter(new: Handle) -> EnterGuard { -- match try_enter(new) { -- Some(guard) => guard, -- None => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR), -+ impl EnterRuntime { -+ pub(crate) fn is_entered(self) -> bool { -+ matches!(self, EnterRuntime::Entered { .. }) -+ } - } - } - --/// Sets this [`Handle`] as the current active [`Handle`]. --/// --/// [`Handle`]: Handle --pub(crate) fn try_enter(new: Handle) -> Option { -- CONTEXT -- .try_with(|ctx| { -- let old = ctx.borrow_mut().replace(new); -- EnterGuard(old) -- }) -- .ok() --} -+// Forces the current "entered" state to be cleared while the closure -+// is executed. -+// -+// # Warning -+// -+// This is hidden for a reason. Do not use without fully understanding -+// executors. Misusing can easily cause your program to deadlock. -+cfg_rt_multi_thread! { -+ /// Returns true if in a runtime context. -+ pub(crate) fn current_enter_context() -> EnterRuntime { -+ CONTEXT.with(|c| c.runtime.get()) -+ } -+ -+ pub(crate) fn exit_runtime R, R>(f: F) -> R { -+ // Reset in case the closure panics -+ struct Reset(EnterRuntime); - --#[derive(Debug)] --pub(crate) struct EnterGuard(Option); -+ impl Drop for Reset { -+ fn drop(&mut self) { -+ CONTEXT.with(|c| { -+ assert!(!c.runtime.get().is_entered(), "closure claimed permanent executor"); -+ c.runtime.set(self.0); -+ }); -+ } -+ } - --impl Drop for EnterGuard { -- fn drop(&mut self) { -- CONTEXT.with(|ctx| { -- *ctx.borrow_mut() = self.0.take(); -+ let was = CONTEXT.with(|c| { -+ let e = c.runtime.get(); -+ assert!(e.is_entered(), "asked to exit when not entered"); -+ c.runtime.set(EnterRuntime::NotEntered); -+ e - }); -+ -+ let _reset = Reset(was); -+ // dropping _reset after f() will reset ENTERED -+ f() - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/coop.rs b/KubeOS-Rust/vendor/tokio/src/runtime/coop.rs -similarity index 76% -rename from KubeOS-Rust/vendor/tokio/src/coop.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/coop.rs -index 256e9620..f3ed17cf 100644 ---- a/KubeOS-Rust/vendor/tokio/src/coop.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/coop.rs -@@ -29,17 +29,18 @@ - // other futures. By doing this, you avoid double-counting each iteration of - // the outer future against the cooperating budget. - --use std::cell::Cell; -- --thread_local! { -- static CURRENT: Cell = Cell::new(Budget::unconstrained()); --} -+use crate::runtime::context; - - /// Opaque type tracking the amount of "work" a task may still do before - /// yielding back to the scheduler. - #[derive(Debug, Copy, Clone)] - pub(crate) struct Budget(Option); - -+pub(crate) struct BudgetDecrement { -+ success: bool, -+ hit_zero: bool, -+} -+ - impl Budget { - /// Budget assigned to a task on each poll. - /// -@@ -56,16 +57,12 @@ impl Budget { - } - - /// Returns an unconstrained budget. Operations will not be limited. -- const fn unconstrained() -> Budget { -+ pub(super) const fn unconstrained() -> Budget { - Budget(None) - } --} - --cfg_rt_multi_thread! { -- impl Budget { -- fn has_remaining(self) -> bool { -- self.0.map(|budget| budget > 0).unwrap_or(true) -- } -+ fn has_remaining(self) -> bool { -+ self.0.map(|budget| budget > 0).unwrap_or(true) - } - } - -@@ -85,37 +82,42 @@ pub(crate) fn with_unconstrained(f: impl FnOnce() -> R) -> R { - - #[inline(always)] - fn with_budget(budget: Budget, f: impl FnOnce() -> R) -> R { -- struct ResetGuard<'a> { -- cell: &'a Cell, -+ struct ResetGuard { - prev: Budget, - } - -- impl<'a> Drop for ResetGuard<'a> { -+ impl Drop for ResetGuard { - fn drop(&mut self) { -- self.cell.set(self.prev); -+ let _ = context::budget(|cell| { -+ cell.set(self.prev); -+ }); - } - } - -- CURRENT.with(move |cell| { -+ #[allow(unused_variables)] -+ let maybe_guard = context::budget(|cell| { - let prev = cell.get(); -- - cell.set(budget); - -- let _guard = ResetGuard { cell, prev }; -+ ResetGuard { prev } -+ }); -+ -+ // The function is called regardless even if the budget is not successfully -+ // set due to the thread-local being destroyed. -+ f() -+} - -- f() -- }) -+#[inline(always)] -+pub(crate) fn has_budget_remaining() -> bool { -+ // If the current budget cannot be accessed due to the thread-local being -+ // shutdown, then we assume there is budget remaining. -+ context::budget(|cell| cell.get().has_remaining()).unwrap_or(true) - } - - cfg_rt_multi_thread! { - /// Sets the current task's budget. - pub(crate) fn set(budget: Budget) { -- CURRENT.with(|cell| cell.set(budget)) -- } -- -- #[inline(always)] -- pub(crate) fn has_budget_remaining() -> bool { -- CURRENT.with(|cell| cell.get().has_remaining()) -+ let _ = context::budget(|cell| cell.set(budget)); - } - } - -@@ -124,15 +126,16 @@ cfg_rt! { - /// - /// Returns the remaining budget - pub(crate) fn stop() -> Budget { -- CURRENT.with(|cell| { -+ context::budget(|cell| { - let prev = cell.get(); - cell.set(Budget::unconstrained()); - prev -- }) -+ }).unwrap_or(Budget::unconstrained()) - } - } - - cfg_coop! { -+ use std::cell::Cell; - use std::task::{Context, Poll}; - - #[must_use] -@@ -150,7 +153,7 @@ cfg_coop! { - // They are both represented as the remembered budget being unconstrained. - let budget = self.0.get(); - if !budget.is_unconstrained() { -- CURRENT.with(|cell| { -+ let _ = context::budget(|cell| { - cell.set(budget); - }); - } -@@ -171,33 +174,65 @@ cfg_coop! { - /// that progress was made. - #[inline] - pub(crate) fn poll_proceed(cx: &mut Context<'_>) -> Poll { -- CURRENT.with(|cell| { -+ context::budget(|cell| { - let mut budget = cell.get(); - -- if budget.decrement() { -+ let decrement = budget.decrement(); -+ -+ if decrement.success { - let restore = RestoreOnPending(Cell::new(cell.get())); - cell.set(budget); -+ -+ // avoid double counting -+ if decrement.hit_zero { -+ inc_budget_forced_yield_count(); -+ } -+ - Poll::Ready(restore) - } else { - cx.waker().wake_by_ref(); - Poll::Pending - } -- }) -+ }).unwrap_or(Poll::Ready(RestoreOnPending(Cell::new(Budget::unconstrained())))) -+ } -+ -+ cfg_rt! { -+ cfg_metrics! { -+ #[inline(always)] -+ fn inc_budget_forced_yield_count() { -+ if let Ok(handle) = context::try_current() { -+ handle.scheduler_metrics().inc_budget_forced_yield_count(); -+ } -+ } -+ } -+ -+ cfg_not_metrics! { -+ #[inline(always)] -+ fn inc_budget_forced_yield_count() {} -+ } -+ } -+ -+ cfg_not_rt! { -+ #[inline(always)] -+ fn inc_budget_forced_yield_count() {} - } - - impl Budget { - /// Decrements the budget. Returns `true` if successful. Decrementing fails - /// when there is not enough remaining budget. -- fn decrement(&mut self) -> bool { -+ fn decrement(&mut self) -> BudgetDecrement { - if let Some(num) = &mut self.0 { - if *num > 0 { - *num -= 1; -- true -+ -+ let hit_zero = *num == 0; -+ -+ BudgetDecrement { success: true, hit_zero } - } else { -- false -+ BudgetDecrement { success: false, hit_zero: false } - } - } else { -- true -+ BudgetDecrement { success: true, hit_zero: false } - } - } - -@@ -211,12 +246,15 @@ cfg_coop! { - mod test { - use super::*; - -+ #[cfg(tokio_wasm_not_wasi)] -+ use wasm_bindgen_test::wasm_bindgen_test as test; -+ - fn get() -> Budget { -- CURRENT.with(|cell| cell.get()) -+ context::budget(|cell| cell.get()).unwrap_or(Budget::unconstrained()) - } - - #[test] -- fn bugeting() { -+ fn budgeting() { - use futures::future::poll_fn; - use tokio_test::*; - -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/defer.rs b/KubeOS-Rust/vendor/tokio/src/runtime/defer.rs -new file mode 100644 -index 00000000..4078512d ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/defer.rs -@@ -0,0 +1,27 @@ -+use std::task::Waker; -+ -+pub(crate) struct Defer { -+ deferred: Vec, -+} -+ -+impl Defer { -+ pub(crate) fn new() -> Defer { -+ Defer { -+ deferred: Default::default(), -+ } -+ } -+ -+ pub(crate) fn defer(&mut self, waker: Waker) { -+ self.deferred.push(waker); -+ } -+ -+ pub(crate) fn is_empty(&self) -> bool { -+ self.deferred.is_empty() -+ } -+ -+ pub(crate) fn wake(&mut self) { -+ for waker in self.deferred.drain(..) { -+ waker.wake(); -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/driver.rs b/KubeOS-Rust/vendor/tokio/src/runtime/driver.rs -index 7e459779..572fdefb 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/driver.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/driver.rs -@@ -1,63 +1,233 @@ - //! Abstracts out the entire chain of runtime sub-drivers into common types. --use crate::park::thread::ParkThread; --use crate::park::Park; -+ -+// Eventually, this file will see significant refactoring / cleanup. For now, we -+// don't need to worry much about dead code with certain feature permutations. -+#![cfg_attr(not(feature = "full"), allow(dead_code))] -+ -+use crate::runtime::park::{ParkThread, UnparkThread}; - - use std::io; - use std::time::Duration; - -+#[derive(Debug)] -+pub(crate) struct Driver { -+ inner: TimeDriver, -+} -+ -+#[derive(Debug)] -+pub(crate) struct Handle { -+ /// IO driver handle -+ pub(crate) io: IoHandle, -+ -+ /// Signal driver handle -+ #[cfg_attr(any(not(unix), loom), allow(dead_code))] -+ pub(crate) signal: SignalHandle, -+ -+ /// Time driver handle -+ pub(crate) time: TimeHandle, -+ -+ /// Source of `Instant::now()` -+ #[cfg_attr(not(all(feature = "time", feature = "test-util")), allow(dead_code))] -+ pub(crate) clock: Clock, -+} -+ -+pub(crate) struct Cfg { -+ pub(crate) enable_io: bool, -+ pub(crate) enable_time: bool, -+ pub(crate) enable_pause_time: bool, -+ pub(crate) start_paused: bool, -+ pub(crate) nevents: usize, -+} -+ -+impl Driver { -+ pub(crate) fn new(cfg: Cfg) -> io::Result<(Self, Handle)> { -+ let (io_stack, io_handle, signal_handle) = create_io_stack(cfg.enable_io, cfg.nevents)?; -+ -+ let clock = create_clock(cfg.enable_pause_time, cfg.start_paused); -+ -+ let (time_driver, time_handle) = create_time_driver(cfg.enable_time, io_stack, &clock); -+ -+ Ok(( -+ Self { inner: time_driver }, -+ Handle { -+ io: io_handle, -+ signal: signal_handle, -+ time: time_handle, -+ clock, -+ }, -+ )) -+ } -+ -+ pub(crate) fn park(&mut self, handle: &Handle) { -+ self.inner.park(handle) -+ } -+ -+ pub(crate) fn park_timeout(&mut self, handle: &Handle, duration: Duration) { -+ self.inner.park_timeout(handle, duration) -+ } -+ -+ pub(crate) fn shutdown(&mut self, handle: &Handle) { -+ self.inner.shutdown(handle) -+ } -+} -+ -+impl Handle { -+ pub(crate) fn unpark(&self) { -+ #[cfg(feature = "time")] -+ if let Some(handle) = &self.time { -+ handle.unpark(); -+ } -+ -+ self.io.unpark(); -+ } -+ -+ cfg_io_driver! { -+ #[track_caller] -+ pub(crate) fn io(&self) -> &crate::runtime::io::Handle { -+ self.io -+ .as_ref() -+ .expect("A Tokio 1.x context was found, but IO is disabled. Call `enable_io` on the runtime builder to enable IO.") -+ } -+ } -+ -+ cfg_signal_internal_and_unix! { -+ #[track_caller] -+ pub(crate) fn signal(&self) -> &crate::runtime::signal::Handle { -+ self.signal -+ .as_ref() -+ .expect("there is no signal driver running, must be called from the context of Tokio runtime") -+ } -+ } -+ -+ cfg_time! { -+ /// Returns a reference to the time driver handle. -+ /// -+ /// Panics if no time driver is present. -+ #[track_caller] -+ pub(crate) fn time(&self) -> &crate::runtime::time::Handle { -+ self.time -+ .as_ref() -+ .expect("A Tokio 1.x context was found, but timers are disabled. Call `enable_time` on the runtime builder to enable timers.") -+ } -+ -+ pub(crate) fn clock(&self) -> &Clock { -+ &self.clock -+ } -+ } -+} -+ - // ===== io driver ===== - - cfg_io_driver! { -- type IoDriver = crate::io::driver::Driver; -- type IoStack = crate::park::either::Either; -- pub(crate) type IoHandle = Option; -+ pub(crate) type IoDriver = crate::runtime::io::Driver; - -- fn create_io_stack(enabled: bool) -> io::Result<(IoStack, IoHandle, SignalHandle)> { -- use crate::park::either::Either; -+ #[derive(Debug)] -+ pub(crate) enum IoStack { -+ Enabled(ProcessDriver), -+ Disabled(ParkThread), -+ } -+ -+ #[derive(Debug)] -+ pub(crate) enum IoHandle { -+ Enabled(crate::runtime::io::Handle), -+ Disabled(UnparkThread), -+ } - -+ fn create_io_stack(enabled: bool, nevents: usize) -> io::Result<(IoStack, IoHandle, SignalHandle)> { - #[cfg(loom)] - assert!(!enabled); - - let ret = if enabled { -- let io_driver = crate::io::driver::Driver::new()?; -- let io_handle = io_driver.handle(); -+ let (io_driver, io_handle) = crate::runtime::io::Driver::new(nevents)?; - -- let (signal_driver, signal_handle) = create_signal_driver(io_driver)?; -+ let (signal_driver, signal_handle) = create_signal_driver(io_driver, &io_handle)?; - let process_driver = create_process_driver(signal_driver); - -- (Either::A(process_driver), Some(io_handle), signal_handle) -+ (IoStack::Enabled(process_driver), IoHandle::Enabled(io_handle), signal_handle) - } else { -- (Either::B(ParkThread::new()), Default::default(), Default::default()) -+ let park_thread = ParkThread::new(); -+ let unpark_thread = park_thread.unpark(); -+ (IoStack::Disabled(park_thread), IoHandle::Disabled(unpark_thread), Default::default()) - }; - - Ok(ret) - } -+ -+ impl IoStack { -+ pub(crate) fn park(&mut self, handle: &Handle) { -+ match self { -+ IoStack::Enabled(v) => v.park(handle), -+ IoStack::Disabled(v) => v.park(), -+ } -+ } -+ -+ pub(crate) fn park_timeout(&mut self, handle: &Handle, duration: Duration) { -+ match self { -+ IoStack::Enabled(v) => v.park_timeout(handle, duration), -+ IoStack::Disabled(v) => v.park_timeout(duration), -+ } -+ } -+ -+ pub(crate) fn shutdown(&mut self, handle: &Handle) { -+ match self { -+ IoStack::Enabled(v) => v.shutdown(handle), -+ IoStack::Disabled(v) => v.shutdown(), -+ } -+ } -+ } -+ -+ impl IoHandle { -+ pub(crate) fn unpark(&self) { -+ match self { -+ IoHandle::Enabled(handle) => handle.unpark(), -+ IoHandle::Disabled(handle) => handle.unpark(), -+ } -+ } -+ -+ pub(crate) fn as_ref(&self) -> Option<&crate::runtime::io::Handle> { -+ match self { -+ IoHandle::Enabled(v) => Some(v), -+ IoHandle::Disabled(..) => None, -+ } -+ } -+ } - } - - cfg_not_io_driver! { -- pub(crate) type IoHandle = (); -- type IoStack = ParkThread; -+ pub(crate) type IoHandle = UnparkThread; -+ -+ #[derive(Debug)] -+ pub(crate) struct IoStack(ParkThread); - -- fn create_io_stack(_enabled: bool) -> io::Result<(IoStack, IoHandle, SignalHandle)> { -- Ok((ParkThread::new(), Default::default(), Default::default())) -+ fn create_io_stack(_enabled: bool, _nevents: usize) -> io::Result<(IoStack, IoHandle, SignalHandle)> { -+ let park_thread = ParkThread::new(); -+ let unpark_thread = park_thread.unpark(); -+ Ok((IoStack(park_thread), unpark_thread, Default::default())) - } --} - --// ===== signal driver ===== -+ impl IoStack { -+ pub(crate) fn park(&mut self, _handle: &Handle) { -+ self.0.park(); -+ } -+ -+ pub(crate) fn park_timeout(&mut self, _handle: &Handle, duration: Duration) { -+ self.0.park_timeout(duration); -+ } - --macro_rules! cfg_signal_internal_and_unix { -- ($($item:item)*) => { -- #[cfg(unix)] -- cfg_signal_internal! { $($item)* } -+ pub(crate) fn shutdown(&mut self, _handle: &Handle) { -+ self.0.shutdown(); -+ } - } - } - -+// ===== signal driver ===== -+ - cfg_signal_internal_and_unix! { -- type SignalDriver = crate::signal::unix::driver::Driver; -- pub(crate) type SignalHandle = Option; -+ type SignalDriver = crate::runtime::signal::Driver; -+ pub(crate) type SignalHandle = Option; - -- fn create_signal_driver(io_driver: IoDriver) -> io::Result<(SignalDriver, SignalHandle)> { -- let driver = crate::signal::unix::driver::Driver::new(io_driver)?; -+ fn create_signal_driver(io_driver: IoDriver, io_handle: &crate::runtime::io::Handle) -> io::Result<(SignalDriver, SignalHandle)> { -+ let driver = crate::runtime::signal::Driver::new(io_driver, io_handle)?; - let handle = driver.handle(); - Ok((driver, Some(handle))) - } -@@ -69,7 +239,7 @@ cfg_not_signal_internal! { - cfg_io_driver! { - type SignalDriver = IoDriver; - -- fn create_signal_driver(io_driver: IoDriver) -> io::Result<(SignalDriver, SignalHandle)> { -+ fn create_signal_driver(io_driver: IoDriver, _io_handle: &crate::runtime::io::Handle) -> io::Result<(SignalDriver, SignalHandle)> { - Ok((io_driver, ())) - } - } -@@ -78,10 +248,10 @@ cfg_not_signal_internal! { - // ===== process driver ===== - - cfg_process_driver! { -- type ProcessDriver = crate::process::unix::driver::Driver; -+ type ProcessDriver = crate::runtime::process::Driver; - - fn create_process_driver(signal_driver: SignalDriver) -> ProcessDriver { -- crate::process::unix::driver::Driver::new(signal_driver) -+ ProcessDriver::new(signal_driver) - } - } - -@@ -98,10 +268,16 @@ cfg_not_process_driver! { - // ===== time driver ===== - - cfg_time! { -- type TimeDriver = crate::park::either::Either, IoStack>; -+ #[derive(Debug)] -+ pub(crate) enum TimeDriver { -+ Enabled { -+ driver: crate::runtime::time::Driver, -+ }, -+ Disabled(IoStack), -+ } - - pub(crate) type Clock = crate::time::Clock; -- pub(crate) type TimeHandle = Option; -+ pub(crate) type TimeHandle = Option; - - fn create_clock(enable_pausing: bool, start_paused: bool) -> Clock { - crate::time::Clock::new(enable_pausing, start_paused) -@@ -110,17 +286,37 @@ cfg_time! { - fn create_time_driver( - enable: bool, - io_stack: IoStack, -- clock: Clock, -+ clock: &Clock, - ) -> (TimeDriver, TimeHandle) { -- use crate::park::either::Either; -- - if enable { -- let driver = crate::time::driver::Driver::new(io_stack, clock); -- let handle = driver.handle(); -+ let (driver, handle) = crate::runtime::time::Driver::new(io_stack, clock); - -- (Either::A(driver), Some(handle)) -+ (TimeDriver::Enabled { driver }, Some(handle)) - } else { -- (Either::B(io_stack), None) -+ (TimeDriver::Disabled(io_stack), None) -+ } -+ } -+ -+ impl TimeDriver { -+ pub(crate) fn park(&mut self, handle: &Handle) { -+ match self { -+ TimeDriver::Enabled { driver, .. } => driver.park(handle), -+ TimeDriver::Disabled(v) => v.park(handle), -+ } -+ } -+ -+ pub(crate) fn park_timeout(&mut self, handle: &Handle, duration: Duration) { -+ match self { -+ TimeDriver::Enabled { driver } => driver.park_timeout(handle, duration), -+ TimeDriver::Disabled(v) => v.park_timeout(handle, duration), -+ } -+ } -+ -+ pub(crate) fn shutdown(&mut self, handle: &Handle) { -+ match self { -+ TimeDriver::Enabled { driver } => driver.shutdown(handle), -+ TimeDriver::Disabled(v) => v.shutdown(handle), -+ } - } - } - } -@@ -138,71 +334,8 @@ cfg_not_time! { - fn create_time_driver( - _enable: bool, - io_stack: IoStack, -- _clock: Clock, -+ _clock: &Clock, - ) -> (TimeDriver, TimeHandle) { - (io_stack, ()) - } - } -- --// ===== runtime driver ===== -- --#[derive(Debug)] --pub(crate) struct Driver { -- inner: TimeDriver, --} -- --pub(crate) struct Resources { -- pub(crate) io_handle: IoHandle, -- pub(crate) signal_handle: SignalHandle, -- pub(crate) time_handle: TimeHandle, -- pub(crate) clock: Clock, --} -- --pub(crate) struct Cfg { -- pub(crate) enable_io: bool, -- pub(crate) enable_time: bool, -- pub(crate) enable_pause_time: bool, -- pub(crate) start_paused: bool, --} -- --impl Driver { -- pub(crate) fn new(cfg: Cfg) -> io::Result<(Self, Resources)> { -- let (io_stack, io_handle, signal_handle) = create_io_stack(cfg.enable_io)?; -- -- let clock = create_clock(cfg.enable_pause_time, cfg.start_paused); -- -- let (time_driver, time_handle) = -- create_time_driver(cfg.enable_time, io_stack, clock.clone()); -- -- Ok(( -- Self { inner: time_driver }, -- Resources { -- io_handle, -- signal_handle, -- time_handle, -- clock, -- }, -- )) -- } --} -- --impl Park for Driver { -- type Unpark = ::Unpark; -- type Error = ::Error; -- -- fn unpark(&self) -> Self::Unpark { -- self.inner.unpark() -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -- self.inner.park() -- } -- -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- self.inner.park_timeout(duration) -- } -- -- fn shutdown(&mut self) { -- self.inner.shutdown() -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/enter.rs b/KubeOS-Rust/vendor/tokio/src/runtime/enter.rs -deleted file mode 100644 -index 3f14cb58..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/enter.rs -+++ /dev/null -@@ -1,205 +0,0 @@ --use std::cell::{Cell, RefCell}; --use std::fmt; --use std::marker::PhantomData; -- --#[derive(Debug, Clone, Copy)] --pub(crate) enum EnterContext { -- #[cfg_attr(not(feature = "rt"), allow(dead_code))] -- Entered { -- allow_blocking: bool, -- }, -- NotEntered, --} -- --impl EnterContext { -- pub(crate) fn is_entered(self) -> bool { -- matches!(self, EnterContext::Entered { .. }) -- } --} -- --thread_local!(static ENTERED: Cell = Cell::new(EnterContext::NotEntered)); -- --/// Represents an executor context. --pub(crate) struct Enter { -- _p: PhantomData>, --} -- --cfg_rt! { -- use crate::park::thread::ParkError; -- -- use std::time::Duration; -- -- /// Marks the current thread as being within the dynamic extent of an -- /// executor. -- pub(crate) fn enter(allow_blocking: bool) -> Enter { -- if let Some(enter) = try_enter(allow_blocking) { -- return enter; -- } -- -- panic!( -- "Cannot start a runtime from within a runtime. This happens \ -- because a function (like `block_on`) attempted to block the \ -- current thread while the thread is being used to drive \ -- asynchronous tasks." -- ); -- } -- -- /// Tries to enter a runtime context, returns `None` if already in a runtime -- /// context. -- pub(crate) fn try_enter(allow_blocking: bool) -> Option { -- ENTERED.with(|c| { -- if c.get().is_entered() { -- None -- } else { -- c.set(EnterContext::Entered { allow_blocking }); -- Some(Enter { _p: PhantomData }) -- } -- }) -- } --} -- --// Forces the current "entered" state to be cleared while the closure --// is executed. --// --// # Warning --// --// This is hidden for a reason. Do not use without fully understanding --// executors. Misusing can easily cause your program to deadlock. --cfg_rt_multi_thread! { -- pub(crate) fn exit R, R>(f: F) -> R { -- // Reset in case the closure panics -- struct Reset(EnterContext); -- impl Drop for Reset { -- fn drop(&mut self) { -- ENTERED.with(|c| { -- assert!(!c.get().is_entered(), "closure claimed permanent executor"); -- c.set(self.0); -- }); -- } -- } -- -- let was = ENTERED.with(|c| { -- let e = c.get(); -- assert!(e.is_entered(), "asked to exit when not entered"); -- c.set(EnterContext::NotEntered); -- e -- }); -- -- let _reset = Reset(was); -- // dropping _reset after f() will reset ENTERED -- f() -- } --} -- --cfg_rt! { -- /// Disallows blocking in the current runtime context until the guard is dropped. -- pub(crate) fn disallow_blocking() -> DisallowBlockingGuard { -- let reset = ENTERED.with(|c| { -- if let EnterContext::Entered { -- allow_blocking: true, -- } = c.get() -- { -- c.set(EnterContext::Entered { -- allow_blocking: false, -- }); -- true -- } else { -- false -- } -- }); -- DisallowBlockingGuard(reset) -- } -- -- pub(crate) struct DisallowBlockingGuard(bool); -- impl Drop for DisallowBlockingGuard { -- fn drop(&mut self) { -- if self.0 { -- // XXX: Do we want some kind of assertion here, or is "best effort" okay? -- ENTERED.with(|c| { -- if let EnterContext::Entered { -- allow_blocking: false, -- } = c.get() -- { -- c.set(EnterContext::Entered { -- allow_blocking: true, -- }); -- } -- }) -- } -- } -- } --} -- --cfg_rt_multi_thread! { -- /// Returns true if in a runtime context. -- pub(crate) fn context() -> EnterContext { -- ENTERED.with(|c| c.get()) -- } --} -- --cfg_rt! { -- impl Enter { -- /// Blocks the thread on the specified future, returning the value with -- /// which that future completes. -- pub(crate) fn block_on(&mut self, f: F) -> Result -- where -- F: std::future::Future, -- { -- use crate::park::thread::CachedParkThread; -- -- let mut park = CachedParkThread::new(); -- park.block_on(f) -- } -- -- /// Blocks the thread on the specified future for **at most** `timeout` -- /// -- /// If the future completes before `timeout`, the result is returned. If -- /// `timeout` elapses, then `Err` is returned. -- pub(crate) fn block_on_timeout(&mut self, f: F, timeout: Duration) -> Result -- where -- F: std::future::Future, -- { -- use crate::park::Park; -- use crate::park::thread::CachedParkThread; -- use std::task::Context; -- use std::task::Poll::Ready; -- use std::time::Instant; -- -- let mut park = CachedParkThread::new(); -- let waker = park.get_unpark()?.into_waker(); -- let mut cx = Context::from_waker(&waker); -- -- pin!(f); -- let when = Instant::now() + timeout; -- -- loop { -- if let Ready(v) = crate::coop::budget(|| f.as_mut().poll(&mut cx)) { -- return Ok(v); -- } -- -- let now = Instant::now(); -- -- if now >= when { -- return Err(()); -- } -- -- park.park_timeout(when - now)?; -- } -- } -- } --} -- --impl fmt::Debug for Enter { -- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -- f.debug_struct("Enter").finish() -- } --} -- --impl Drop for Enter { -- fn drop(&mut self) { -- ENTERED.with(|c| { -- assert!(c.get().is_entered()); -- c.set(EnterContext::NotEntered); -- }); -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/handle.rs b/KubeOS-Rust/vendor/tokio/src/runtime/handle.rs -index cd1cb760..fca1cbb4 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/handle.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/handle.rs -@@ -1,11 +1,4 @@ --use crate::runtime::blocking::{BlockingTask, NoopSchedule}; --use crate::runtime::task::{self, JoinHandle}; --use crate::runtime::{blocking, context, driver, Spawner}; --use crate::util::error::{CONTEXT_MISSING_ERROR, THREAD_LOCAL_DESTROYED_ERROR}; -- --use std::future::Future; --use std::marker::PhantomData; --use std::{error, fmt}; -+use crate::runtime::{context, scheduler, RuntimeFlavor}; - - /// Handle to the runtime. - /// -@@ -14,34 +7,18 @@ use std::{error, fmt}; - /// - /// [`Runtime::handle`]: crate::runtime::Runtime::handle() - #[derive(Debug, Clone)] -+// When the `rt` feature is *not* enabled, this type is still defined, but not -+// included in the public API. - pub struct Handle { -- pub(super) spawner: Spawner, -- -- /// Handles to the I/O drivers -- #[cfg_attr( -- not(any(feature = "net", feature = "process", all(unix, feature = "signal"))), -- allow(dead_code) -- )] -- pub(super) io_handle: driver::IoHandle, -- -- /// Handles to the signal drivers -- #[cfg_attr( -- not(any(feature = "signal", all(unix, feature = "process"))), -- allow(dead_code) -- )] -- pub(super) signal_handle: driver::SignalHandle, -- -- /// Handles to the time drivers -- #[cfg_attr(not(feature = "time"), allow(dead_code))] -- pub(super) time_handle: driver::TimeHandle, -+ pub(crate) inner: scheduler::Handle, -+} - -- /// Source of `Instant::now()` -- #[cfg_attr(not(all(feature = "time", feature = "test-util")), allow(dead_code))] -- pub(super) clock: driver::Clock, -+use crate::runtime::task::JoinHandle; -+use crate::util::error::{CONTEXT_MISSING_ERROR, THREAD_LOCAL_DESTROYED_ERROR}; - -- /// Blocking pool spawner -- pub(super) blocking_spawner: blocking::Spawner, --} -+use std::future::Future; -+use std::marker::PhantomData; -+use std::{error, fmt}; - - /// Runtime context guard. - /// -@@ -52,32 +29,37 @@ pub struct Handle { - #[derive(Debug)] - #[must_use = "Creating and dropping a guard does nothing"] - pub struct EnterGuard<'a> { -- _guard: context::EnterGuard, -+ _guard: context::SetCurrentGuard, - _handle_lifetime: PhantomData<&'a Handle>, - } - - impl Handle { - /// Enters the runtime context. This allows you to construct types that must - /// have an executor available on creation such as [`Sleep`] or [`TcpStream`]. -- /// It will also allow you to call methods such as [`tokio::spawn`]. -+ /// It will also allow you to call methods such as [`tokio::spawn`] and [`Handle::current`] -+ /// without panicking. - /// - /// [`Sleep`]: struct@crate::time::Sleep - /// [`TcpStream`]: struct@crate::net::TcpStream - /// [`tokio::spawn`]: fn@crate::spawn - pub fn enter(&self) -> EnterGuard<'_> { - EnterGuard { -- _guard: context::enter(self.clone()), -+ _guard: match context::try_set_current(&self.inner) { -+ Some(guard) => guard, -+ None => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR), -+ }, - _handle_lifetime: PhantomData, - } - } - - /// Returns a `Handle` view over the currently running `Runtime`. - /// -- /// # Panic -+ /// # Panics - /// - /// This will panic if called outside the context of a Tokio runtime. That means that you must -- /// call this on one of the threads **being run by the runtime**. Calling this from within a -- /// thread created by `std::thread::spawn` (for example) will cause a panic. -+ /// call this on one of the threads **being run by the runtime**, or from a thread with an active -+ /// `EnterGuard`. Calling this from within a thread created by `std::thread::spawn` (for example) -+ /// will cause a panic unless that thread has an active `EnterGuard`. - /// - /// # Examples - /// -@@ -101,16 +83,24 @@ impl Handle { - /// # let handle = - /// thread::spawn(move || { - /// // Notice that the handle is created outside of this thread and then moved in -- /// handle.spawn(async { /* ... */ }) -- /// // This next line would cause a panic -- /// // let handle2 = Handle::current(); -+ /// handle.spawn(async { /* ... */ }); -+ /// // This next line would cause a panic because we haven't entered the runtime -+ /// // and created an EnterGuard -+ /// // let handle2 = Handle::current(); // panic -+ /// // So we create a guard here with Handle::enter(); -+ /// let _guard = handle.enter(); -+ /// // Now we can call Handle::current(); -+ /// let handle2 = Handle::current(); - /// }); - /// # handle.join().unwrap(); - /// # }); - /// # } - /// ``` -+ #[track_caller] - pub fn current() -> Self { -- context::current() -+ Handle { -+ inner: scheduler::Handle::current(), -+ } - } - - /// Returns a Handle view over the currently running Runtime -@@ -119,15 +109,7 @@ impl Handle { - /// - /// Contrary to `current`, this never panics - pub fn try_current() -> Result { -- context::try_current() -- } -- -- cfg_stats! { -- /// Returns a view that lets you get information about how the runtime -- /// is performing. -- pub fn stats(&self) -> &crate::runtime::stats::RuntimeStats { -- self.spawner.stats() -- } -+ context::try_current().map(|inner| Handle { inner }) - } - - /// Spawns a future onto the Tokio runtime. -@@ -136,6 +118,10 @@ impl Handle { - /// thread pool. The thread pool is then responsible for polling the future - /// until it completes. - /// -+ /// The provided future will start running in the background immediately -+ /// when `spawn` is called, even if you don't await the returned -+ /// `JoinHandle`. -+ /// - /// See [module level][mod] documentation for more details. - /// - /// [mod]: index.html -@@ -157,18 +143,16 @@ impl Handle { - /// }); - /// # } - /// ``` -- #[cfg_attr(tokio_track_caller, track_caller)] -+ #[track_caller] - pub fn spawn(&self, future: F) -> JoinHandle - where - F: Future + Send + 'static, - F::Output: Send + 'static, - { -- #[cfg(all(tokio_unstable, feature = "tracing"))] -- let future = crate::util::trace::task(future, "task", None); -- self.spawner.spawn(future) -+ self.spawn_named(future, None) - } - -- /// Runs the provided function on an executor dedicated to blocking. -+ /// Runs the provided function on an executor dedicated to blocking - /// operations. - /// - /// # Examples -@@ -187,58 +171,13 @@ impl Handle { - /// println!("now running on a worker thread"); - /// }); - /// # } -- #[cfg_attr(tokio_track_caller, track_caller)] -+ #[track_caller] - pub fn spawn_blocking(&self, func: F) -> JoinHandle - where - F: FnOnce() -> R + Send + 'static, - R: Send + 'static, - { -- if cfg!(debug_assertions) && std::mem::size_of::() > 2048 { -- self.spawn_blocking_inner(Box::new(func), None) -- } else { -- self.spawn_blocking_inner(func, None) -- } -- } -- -- #[cfg_attr(tokio_track_caller, track_caller)] -- pub(crate) fn spawn_blocking_inner(&self, func: F, name: Option<&str>) -> JoinHandle -- where -- F: FnOnce() -> R + Send + 'static, -- R: Send + 'static, -- { -- let fut = BlockingTask::new(func); -- -- #[cfg(all(tokio_unstable, feature = "tracing"))] -- let fut = { -- use tracing::Instrument; -- #[cfg(tokio_track_caller)] -- let location = std::panic::Location::caller(); -- #[cfg(tokio_track_caller)] -- let span = tracing::trace_span!( -- target: "tokio::task::blocking", -- "runtime.spawn", -- kind = %"blocking", -- task.name = %name.unwrap_or_default(), -- "fn" = %std::any::type_name::(), -- spawn.location = %format_args!("{}:{}:{}", location.file(), location.line(), location.column()), -- ); -- #[cfg(not(tokio_track_caller))] -- let span = tracing::trace_span!( -- target: "tokio::task::blocking", -- "runtime.spawn", -- kind = %"blocking", -- task.name = %name.unwrap_or_default(), -- "fn" = %std::any::type_name::(), -- ); -- fut.instrument(span) -- }; -- -- #[cfg(not(all(tokio_unstable, feature = "tracing")))] -- let _ = name; -- -- let (task, handle) = task::unowned(fut, NoopSchedule); -- let _ = self.blocking_spawner.spawn(task, self); -- handle -+ self.inner.blocking_spawner().spawn_blocking(self, func) - } - - /// Runs a future to completion on this `Handle`'s associated `Runtime`. -@@ -311,25 +250,74 @@ impl Handle { - /// [`tokio::fs`]: crate::fs - /// [`tokio::net`]: crate::net - /// [`tokio::time`]: crate::time -- #[cfg_attr(tokio_track_caller, track_caller)] -+ #[track_caller] - pub fn block_on(&self, future: F) -> F::Output { - #[cfg(all(tokio_unstable, feature = "tracing"))] -- let future = crate::util::trace::task(future, "block_on", None); -- -- // Enter the **runtime** context. This configures spawning, the current I/O driver, ... -- let _rt_enter = self.enter(); -+ let future = -+ crate::util::trace::task(future, "block_on", None, super::task::Id::next().as_u64()); - -- // Enter a **blocking** context. This prevents blocking from a runtime. -- let mut blocking_enter = crate::runtime::enter(true); -+ // Enter the runtime context. This sets the current driver handles and -+ // prevents blocking an existing runtime. -+ let mut enter = context::enter_runtime(&self.inner, true); - - // Block on the future -- blocking_enter -+ enter -+ .blocking - .block_on(future) - .expect("failed to park thread") - } - -- pub(crate) fn shutdown(mut self) { -- self.spawner.shutdown(); -+ #[track_caller] -+ pub(crate) fn spawn_named(&self, future: F, _name: Option<&str>) -> JoinHandle -+ where -+ F: Future + Send + 'static, -+ F::Output: Send + 'static, -+ { -+ let id = crate::runtime::task::Id::next(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let future = crate::util::trace::task(future, "task", _name, id.as_u64()); -+ self.inner.spawn(future, id) -+ } -+ -+ /// Returns the flavor of the current `Runtime`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::{Handle, RuntimeFlavor}; -+ /// -+ /// #[tokio::main(flavor = "current_thread")] -+ /// async fn main() { -+ /// assert_eq!(RuntimeFlavor::CurrentThread, Handle::current().runtime_flavor()); -+ /// } -+ /// ``` -+ /// -+ /// ``` -+ /// use tokio::runtime::{Handle, RuntimeFlavor}; -+ /// -+ /// #[tokio::main(flavor = "multi_thread", worker_threads = 4)] -+ /// async fn main() { -+ /// assert_eq!(RuntimeFlavor::MultiThread, Handle::current().runtime_flavor()); -+ /// } -+ /// ``` -+ pub fn runtime_flavor(&self) -> RuntimeFlavor { -+ match self.inner { -+ scheduler::Handle::CurrentThread(_) => RuntimeFlavor::CurrentThread, -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ scheduler::Handle::MultiThread(_) => RuntimeFlavor::MultiThread, -+ } -+ } -+} -+ -+cfg_metrics! { -+ use crate::runtime::RuntimeMetrics; -+ -+ impl Handle { -+ /// Returns a view that lets you get information about how the runtime -+ /// is performing. -+ pub fn metrics(&self) -> RuntimeMetrics { -+ RuntimeMetrics::new(self.clone()) -+ } - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/io/metrics.rs b/KubeOS-Rust/vendor/tokio/src/runtime/io/metrics.rs -new file mode 100644 -index 00000000..ec341efe ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/io/metrics.rs -@@ -0,0 +1,24 @@ -+//! This file contains mocks of the metrics types used in the I/O driver. -+//! -+//! The reason these mocks don't live in `src/runtime/mock.rs` is because -+//! these need to be available in the case when `net` is enabled but -+//! `rt` is not. -+ -+cfg_not_rt_and_metrics_and_net! { -+ #[derive(Default)] -+ pub(crate) struct IoDriverMetrics {} -+ -+ impl IoDriverMetrics { -+ pub(crate) fn incr_fd_count(&self) {} -+ pub(crate) fn dec_fd_count(&self) {} -+ pub(crate) fn incr_ready_count_by(&self, _amt: u64) {} -+ } -+} -+ -+cfg_net! { -+ cfg_rt! { -+ cfg_metrics! { -+ pub(crate) use crate::runtime::IoDriverMetrics; -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/io/driver/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/io/mod.rs -similarity index 53% -rename from KubeOS-Rust/vendor/tokio/src/io/driver/mod.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/io/mod.rs -index 19f67a24..2e578b6e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/driver/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/io/mod.rs -@@ -1,12 +1,4 @@ --#![cfg_attr(not(feature = "rt"), allow(dead_code))] -- --mod interest; --#[allow(unreachable_pub)] --pub use interest::Interest; -- --mod ready; --#[allow(unreachable_pub)] --pub use ready::Ready; -+#![cfg_attr(not(all(feature = "rt", feature = "net")), allow(dead_code))] - - mod registration; - pub(crate) use registration::Registration; -@@ -14,13 +6,18 @@ pub(crate) use registration::Registration; - mod scheduled_io; - use scheduled_io::ScheduledIo; - --use crate::park::{Park, Unpark}; -+mod metrics; -+ -+use crate::io::interest::Interest; -+use crate::io::ready::Ready; -+use crate::runtime::driver; - use crate::util::slab::{self, Slab}; --use crate::{loom::sync::Mutex, util::bit}; -+use crate::{loom::sync::RwLock, util::bit}; -+ -+use metrics::IoDriverMetrics; - - use std::fmt; - use std::io; --use std::sync::{Arc, Weak}; - use std::time::Duration; - - /// I/O driver, backed by Mio. -@@ -29,51 +26,46 @@ pub(crate) struct Driver { - /// as it is mostly used to determine when to call `compact()`. - tick: u8, - -+ /// True when an event with the signal token is received -+ signal_ready: bool, -+ - /// Reuse the `mio::Events` value across calls to poll. -- events: Option, -+ events: mio::Events, - - /// Primary slab handle containing the state for each resource registered -- /// with this driver. During Drop this is moved into the Inner structure, so -- /// this is an Option to allow it to be vacated (until Drop this is always -- /// Some). -- resources: Option>, -+ /// with this driver. -+ resources: Slab, - - /// The system event queue. - poll: mio::Poll, -- -- /// State shared between the reactor and the handles. -- inner: Arc, - } - - /// A reference to an I/O driver. --#[derive(Clone)] - pub(crate) struct Handle { -- inner: Weak, -+ /// Registers I/O resources. -+ registry: mio::Registry, -+ -+ /// Allocates `ScheduledIo` handles when creating new resources. -+ io_dispatch: RwLock, -+ -+ /// Used to wake up the reactor from a call to `turn`. -+ /// Not supported on Wasi due to lack of threading support. -+ #[cfg(not(tokio_wasi))] -+ waker: mio::Waker, -+ -+ pub(crate) metrics: IoDriverMetrics, - } - - #[derive(Debug)] - pub(crate) struct ReadyEvent { - tick: u8, - pub(crate) ready: Ready, -+ is_shutdown: bool, - } - --pub(super) struct Inner { -- /// Primary slab handle containing the state for each resource registered -- /// with this driver. -- /// -- /// The ownership of this slab is moved into this structure during -- /// `Driver::drop`, so that `Inner::drop` can notify all outstanding handles -- /// without risking new ones being registered in the meantime. -- resources: Mutex>>, -- -- /// Registers I/O resources. -- registry: mio::Registry, -- -- /// Allocates `ScheduledIo` handles when creating new resources. -- pub(super) io_dispatch: slab::Allocator, -- -- /// Used to wake up the reactor from a call to `turn`. -- waker: mio::Waker, -+struct IoDispatcher { -+ allocator: slab::Allocator, -+ is_shutdown: bool, - } - - #[derive(Debug, Eq, PartialEq, Clone, Copy)] -@@ -90,6 +82,7 @@ enum Tick { - // TODO: Don't use a fake token. Instead, reserve a slot entry for the wakeup - // token. - const TOKEN_WAKEUP: mio::Token = mio::Token(1 << 31); -+const TOKEN_SIGNAL: mio::Token = mio::Token(1 + (1 << 31)); - - const ADDRESS: bit::Pack = bit::Pack::least_significant(24); - -@@ -112,85 +105,113 @@ fn _assert_kinds() { - impl Driver { - /// Creates a new event loop, returning any error that happened during the - /// creation. -- pub(crate) fn new() -> io::Result { -+ pub(crate) fn new(nevents: usize) -> io::Result<(Driver, Handle)> { - let poll = mio::Poll::new()?; -+ #[cfg(not(tokio_wasi))] - let waker = mio::Waker::new(poll.registry(), TOKEN_WAKEUP)?; - let registry = poll.registry().try_clone()?; - - let slab = Slab::new(); - let allocator = slab.allocator(); - -- Ok(Driver { -+ let driver = Driver { - tick: 0, -- events: Some(mio::Events::with_capacity(1024)), -+ signal_ready: false, -+ events: mio::Events::with_capacity(nevents), - poll, -- resources: Some(slab), -- inner: Arc::new(Inner { -- resources: Mutex::new(None), -- registry, -- io_dispatch: allocator, -- waker, -- }), -- }) -+ resources: slab, -+ }; -+ -+ let handle = Handle { -+ registry, -+ io_dispatch: RwLock::new(IoDispatcher::new(allocator)), -+ #[cfg(not(tokio_wasi))] -+ waker, -+ metrics: IoDriverMetrics::default(), -+ }; -+ -+ Ok((driver, handle)) - } - -- /// Returns a handle to this event loop which can be sent across threads -- /// and can be used as a proxy to the event loop itself. -- /// -- /// Handles are cloneable and clones always refer to the same event loop. -- /// This handle is typically passed into functions that create I/O objects -- /// to bind them to this event loop. -- pub(crate) fn handle(&self) -> Handle { -- Handle { -- inner: Arc::downgrade(&self.inner), -+ pub(crate) fn park(&mut self, rt_handle: &driver::Handle) { -+ let handle = rt_handle.io(); -+ self.turn(handle, None); -+ } -+ -+ pub(crate) fn park_timeout(&mut self, rt_handle: &driver::Handle, duration: Duration) { -+ let handle = rt_handle.io(); -+ self.turn(handle, Some(duration)); -+ } -+ -+ pub(crate) fn shutdown(&mut self, rt_handle: &driver::Handle) { -+ let handle = rt_handle.io(); -+ -+ if handle.shutdown() { -+ self.resources.for_each(|io| { -+ // If a task is waiting on the I/O resource, notify it that the -+ // runtime is being shutdown. And shutdown will clear all wakers. -+ io.shutdown(); -+ }); - } - } - -- fn turn(&mut self, max_wait: Option) -> io::Result<()> { -+ fn turn(&mut self, handle: &Handle, max_wait: Option) { - // How often to call `compact()` on the resource slab - const COMPACT_INTERVAL: u8 = 255; - - self.tick = self.tick.wrapping_add(1); - - if self.tick == COMPACT_INTERVAL { -- self.resources.as_mut().unwrap().compact() -+ self.resources.compact() - } - -- let mut events = self.events.take().expect("i/o driver event store missing"); -+ let events = &mut self.events; - - // Block waiting for an event to happen, peeling out how many events - // happened. -- match self.poll.poll(&mut events, max_wait) { -+ match self.poll.poll(events, max_wait) { - Ok(_) => {} - Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} -- Err(e) => return Err(e), -+ #[cfg(tokio_wasi)] -+ Err(e) if e.kind() == io::ErrorKind::InvalidInput => { -+ // In case of wasm32_wasi this error happens, when trying to poll without subscriptions -+ // just return from the park, as there would be nothing, which wakes us up. -+ } -+ Err(e) => panic!("unexpected error when polling the I/O driver: {:?}", e), - } - - // Process all the events that came in, dispatching appropriately -+ let mut ready_count = 0; - for event in events.iter() { - let token = event.token(); - -- if token != TOKEN_WAKEUP { -- self.dispatch(token, Ready::from_mio(event)); -+ if token == TOKEN_WAKEUP { -+ // Nothing to do, the event is used to unblock the I/O driver -+ } else if token == TOKEN_SIGNAL { -+ self.signal_ready = true; -+ } else { -+ Self::dispatch( -+ &mut self.resources, -+ self.tick, -+ token, -+ Ready::from_mio(event), -+ ); -+ ready_count += 1; - } - } - -- self.events = Some(events); -- -- Ok(()) -+ handle.metrics.incr_ready_count_by(ready_count); - } - -- fn dispatch(&mut self, token: mio::Token, ready: Ready) { -+ fn dispatch(resources: &mut Slab, tick: u8, token: mio::Token, ready: Ready) { - let addr = slab::Address::from_usize(ADDRESS.unpack(token.0)); - -- let resources = self.resources.as_mut().unwrap(); -- - let io = match resources.get(addr) { - Some(io) => io, - None => return, - }; - -- let res = io.set_readiness(Some(token.0), Tick::Set(self.tick), |curr| curr | ready); -+ let res = io.set_readiness(Some(token.0), Tick::Set(tick), |curr| curr | ready); - - if res.is_err() { - // token no longer valid! -@@ -201,84 +222,12 @@ impl Driver { - } - } - --impl Drop for Driver { -- fn drop(&mut self) { -- (*self.inner.resources.lock()) = self.resources.take(); -- } --} -- --impl Drop for Inner { -- fn drop(&mut self) { -- let resources = self.resources.lock().take(); -- -- if let Some(mut slab) = resources { -- slab.for_each(|io| { -- // If a task is waiting on the I/O resource, notify it. The task -- // will then attempt to use the I/O resource and fail due to the -- // driver being shutdown. -- io.shutdown(); -- }); -- } -- } --} -- --impl Park for Driver { -- type Unpark = Handle; -- type Error = io::Error; -- -- fn unpark(&self) -> Self::Unpark { -- self.handle() -- } -- -- fn park(&mut self) -> io::Result<()> { -- self.turn(None)?; -- Ok(()) -- } -- -- fn park_timeout(&mut self, duration: Duration) -> io::Result<()> { -- self.turn(Some(duration))?; -- Ok(()) -- } -- -- fn shutdown(&mut self) {} --} -- - impl fmt::Debug for Driver { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "Driver") - } - } - --// ===== impl Handle ===== -- --cfg_rt! { -- impl Handle { -- /// Returns a handle to the current reactor. -- /// -- /// # Panics -- /// -- /// This function panics if there is no current reactor set and `rt` feature -- /// flag is not enabled. -- pub(super) fn current() -> Self { -- crate::runtime::context::io_handle().expect("A Tokio 1.x context was found, but IO is disabled. Call `enable_io` on the runtime builder to enable IO.") -- } -- } --} -- --cfg_not_rt! { -- impl Handle { -- /// Returns a handle to the current reactor. -- /// -- /// # Panics -- /// -- /// This function panics if there is no current reactor set, or if the `rt` -- /// feature flag is not enabled. -- pub(super) fn current() -> Self { -- panic!("{}", crate::util::error::CONTEXT_MISSING_ERROR) -- } -- } --} -- - impl Handle { - /// Forces a reactor blocked in a call to `turn` to wakeup, or otherwise - /// makes the next call to `turn` return immediately. -@@ -289,32 +238,11 @@ impl Handle { - /// after this method has been called. If the reactor is not currently - /// blocked in `turn`, then the next call to `turn` will not block and - /// return immediately. -- fn wakeup(&self) { -- if let Some(inner) = self.inner() { -- inner.waker.wake().expect("failed to wake I/O driver"); -- } -- } -- -- pub(super) fn inner(&self) -> Option> { -- self.inner.upgrade() -- } --} -- --impl Unpark for Handle { -- fn unpark(&self) { -- self.wakeup(); -- } --} -- --impl fmt::Debug for Handle { -- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -- write!(f, "Handle") -+ pub(crate) fn unpark(&self) { -+ #[cfg(not(tokio_wasi))] -+ self.waker.wake().expect("failed to wake I/O driver"); - } --} - --// ===== impl Inner ===== -- --impl Inner { - /// Registers an I/O resource with the reactor for a given `mio::Ready` state. - /// - /// The registration token is returned. -@@ -323,24 +251,68 @@ impl Inner { - source: &mut impl mio::event::Source, - interest: Interest, - ) -> io::Result> { -- let (address, shared) = self.io_dispatch.allocate().ok_or_else(|| { -- io::Error::new( -- io::ErrorKind::Other, -- "reactor at max registered I/O resources", -- ) -- })?; -+ let (address, shared) = self.allocate()?; - - let token = GENERATION.pack(shared.generation(), ADDRESS.pack(address.as_usize(), 0)); - - self.registry - .register(source, mio::Token(token), interest.to_mio())?; - -+ self.metrics.incr_fd_count(); -+ - Ok(shared) - } - - /// Deregisters an I/O resource from the reactor. - pub(super) fn deregister_source(&self, source: &mut impl mio::event::Source) -> io::Result<()> { -- self.registry.deregister(source) -+ self.registry.deregister(source)?; -+ -+ self.metrics.dec_fd_count(); -+ -+ Ok(()) -+ } -+ -+ /// shutdown the dispatcher. -+ fn shutdown(&self) -> bool { -+ let mut io = self.io_dispatch.write().unwrap(); -+ if io.is_shutdown { -+ return false; -+ } -+ io.is_shutdown = true; -+ true -+ } -+ -+ fn allocate(&self) -> io::Result<(slab::Address, slab::Ref)> { -+ let io = self.io_dispatch.read().unwrap(); -+ if io.is_shutdown { -+ return Err(io::Error::new( -+ io::ErrorKind::Other, -+ crate::util::error::RUNTIME_SHUTTING_DOWN_ERROR, -+ )); -+ } -+ io.allocator.allocate().ok_or_else(|| { -+ io::Error::new( -+ io::ErrorKind::Other, -+ "reactor at max registered I/O resources", -+ ) -+ }) -+ } -+} -+ -+impl fmt::Debug for Handle { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ write!(f, "Handle") -+ } -+} -+ -+// ===== impl IoDispatcher ===== -+ -+impl IoDispatcher { -+ fn new(allocator: slab::Allocator) -> Self { -+ Self { -+ allocator, -+ is_shutdown: false, -+ } - } - } - -@@ -352,3 +324,21 @@ impl Direction { - } - } - } -+ -+// Signal handling -+cfg_signal_internal_and_unix! { -+ impl Handle { -+ pub(crate) fn register_signal_receiver(&self, receiver: &mut mio::net::UnixStream) -> io::Result<()> { -+ self.registry.register(receiver, TOKEN_SIGNAL, mio::Interest::READABLE)?; -+ Ok(()) -+ } -+ } -+ -+ impl Driver { -+ pub(crate) fn consume_signal_ready(&mut self) -> bool { -+ let ret = self.signal_ready; -+ self.signal_ready = false; -+ ret -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/io/driver/platform.rs b/KubeOS-Rust/vendor/tokio/src/runtime/io/platform.rs -similarity index 100% -rename from KubeOS-Rust/vendor/tokio/src/io/driver/platform.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/io/platform.rs -diff --git a/KubeOS-Rust/vendor/tokio/src/io/driver/registration.rs b/KubeOS-Rust/vendor/tokio/src/runtime/io/registration.rs -similarity index 82% -rename from KubeOS-Rust/vendor/tokio/src/io/driver/registration.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/io/registration.rs -index 7350be63..140b9240 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/driver/registration.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/io/registration.rs -@@ -1,6 +1,8 @@ - #![cfg_attr(not(feature = "net"), allow(dead_code))] - --use crate::io::driver::{Direction, Handle, Interest, ReadyEvent, ScheduledIo}; -+use crate::io::interest::Interest; -+use crate::runtime::io::{Direction, Handle, ReadyEvent, ScheduledIo}; -+use crate::runtime::scheduler; - use crate::util::slab; - - use mio::event::Source; -@@ -42,8 +44,8 @@ cfg_io_driver! { - /// [`poll_write_ready`]: method@Self::poll_write_ready` - #[derive(Debug)] - pub(crate) struct Registration { -- /// Handle to the associated driver. -- handle: Handle, -+ /// Handle to the associated runtime. -+ handle: scheduler::Handle, - - /// Reference to state stored by the driver. - shared: slab::Ref, -@@ -56,10 +58,8 @@ unsafe impl Sync for Registration {} - // ===== impl Registration ===== - - impl Registration { -- /// Registers the I/O resource with the default reactor, for a specific -- /// `Interest`. `new_with_interest` should be used over `new` when you need -- /// control over the readiness state, such as when a file descriptor only -- /// allows reads. This does not add `hup` or `error` so if you are -+ /// Registers the I/O resource with the reactor for the provided handle, for -+ /// a specific `Interest`. This does not add `hup` or `error` so if you are - /// interested in those states, you will need to add them to the readiness - /// state passed to this function. - /// -@@ -67,19 +67,13 @@ impl Registration { - /// - /// - `Ok` if the registration happened successfully - /// - `Err` if an error was encountered during registration -+ #[track_caller] - pub(crate) fn new_with_interest_and_handle( - io: &mut impl Source, - interest: Interest, -- handle: Handle, -+ handle: scheduler::Handle, - ) -> io::Result { -- let shared = if let Some(inner) = handle.inner() { -- inner.add_source(io, interest)? -- } else { -- return Err(io::Error::new( -- io::ErrorKind::Other, -- "failed to find event loop", -- )); -- }; -+ let shared = handle.driver().io().add_source(io, interest)?; - - Ok(Registration { handle, shared }) - } -@@ -101,11 +95,7 @@ impl Registration { - /// - /// `Err` is returned if an error is encountered. - pub(crate) fn deregister(&mut self, io: &mut impl Source) -> io::Result<()> { -- let inner = match self.handle.inner() { -- Some(inner) => inner, -- None => return Err(io::Error::new(io::ErrorKind::Other, "reactor gone")), -- }; -- inner.deregister_source(io) -+ self.handle().deregister_source(io) - } - - pub(crate) fn clear_readiness(&self, event: ReadyEvent) { -@@ -126,6 +116,7 @@ impl Registration { - - // Uses the poll path, requiring the caller to ensure mutual exclusion for - // correctness. Only the last task to call this function is notified. -+ #[cfg(not(tokio_wasi))] - pub(crate) fn poll_read_io( - &self, - cx: &mut Context<'_>, -@@ -154,10 +145,10 @@ impl Registration { - direction: Direction, - ) -> Poll> { - // Keep track of task budget -- let coop = ready!(crate::coop::poll_proceed(cx)); -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); - let ev = ready!(self.shared.poll_readiness(cx, direction)); - -- if self.handle.inner().is_none() { -+ if ev.is_shutdown { - return Poll::Ready(Err(gone())); - } - -@@ -206,6 +197,10 @@ impl Registration { - res => res, - } - } -+ -+ fn handle(&self) -> &Handle { -+ self.handle.driver().io() -+ } - } - - impl Drop for Registration { -@@ -222,28 +217,22 @@ impl Drop for Registration { - } - - fn gone() -> io::Error { -- io::Error::new(io::ErrorKind::Other, "IO driver has terminated") -+ io::Error::new( -+ io::ErrorKind::Other, -+ crate::util::error::RUNTIME_SHUTTING_DOWN_ERROR, -+ ) - } - - cfg_io_readiness! { - impl Registration { - pub(crate) async fn readiness(&self, interest: Interest) -> io::Result { -- use std::future::Future; -- use std::pin::Pin; -- -- let fut = self.shared.readiness(interest); -- pin!(fut); -+ let ev = self.shared.readiness(interest).await; - -- crate::future::poll_fn(|cx| { -- if self.handle.inner().is_none() { -- return Poll::Ready(Err(io::Error::new( -- io::ErrorKind::Other, -- crate::util::error::RUNTIME_SHUTTING_DOWN_ERROR -- ))); -- } -+ if ev.is_shutdown { -+ return Err(gone()) -+ } - -- Pin::new(&mut fut).poll(cx).map(Ok) -- }).await -+ Ok(ev) - } - - pub(crate) async fn async_io(&self, interest: Interest, mut f: impl FnMut() -> io::Result) -> io::Result { -diff --git a/KubeOS-Rust/vendor/tokio/src/io/driver/scheduled_io.rs b/KubeOS-Rust/vendor/tokio/src/runtime/io/scheduled_io.rs -similarity index 88% -rename from KubeOS-Rust/vendor/tokio/src/io/driver/scheduled_io.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/io/scheduled_io.rs -index 76f93431..197a4e0e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/io/driver/scheduled_io.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/io/scheduled_io.rs -@@ -1,4 +1,6 @@ --use super::{Interest, Ready, ReadyEvent, Tick}; -+use super::{ReadyEvent, Tick}; -+use crate::io::interest::Interest; -+use crate::io::ready::Ready; - use crate::loom::sync::atomic::AtomicUsize; - use crate::loom::sync::Mutex; - use crate::util::bit; -@@ -44,9 +46,6 @@ struct Waiters { - - /// Waker used for AsyncWrite. - writer: Option, -- -- /// True if this ScheduledIo has been killed due to IO driver shutdown. -- is_shutdown: bool, - } - - cfg_io_readiness! { -@@ -66,6 +65,14 @@ cfg_io_readiness! { - _p: PhantomPinned, - } - -+ generate_addr_of_methods! { -+ impl<> Waiter { -+ unsafe fn addr_of_pointers(self: NonNull) -> NonNull> { -+ &self.pointers -+ } -+ } -+ } -+ - /// Future returned by `readiness()`. - struct Readiness<'a> { - scheduled_io: &'a ScheduledIo, -@@ -85,7 +92,7 @@ cfg_io_readiness! { - - // The `ScheduledIo::readiness` (`AtomicUsize`) is packed full of goodness. - // --// | reserved | generation | driver tick | readiness | -+// | shutdown | generation | driver tick | readiness | - // |----------+------------+--------------+-----------| - // | 1 bit | 7 bits + 8 bits + 16 bits | - -@@ -95,6 +102,8 @@ const TICK: bit::Pack = READINESS.then(8); - - const GENERATION: bit::Pack = TICK.then(7); - -+const SHUTDOWN: bit::Pack = GENERATION.then(1); -+ - #[test] - fn test_generations_assert_same() { - assert_eq!(super::GENERATION, GENERATION); -@@ -128,9 +137,11 @@ impl ScheduledIo { - } - - /// Invoked when the IO driver is shut down; forces this ScheduledIo into a -- /// permanently ready state. -+ /// permanently shutdown state. - pub(super) fn shutdown(&self) { -- self.wake0(Ready::ALL, true) -+ let mask = SHUTDOWN.pack(1, 0); -+ self.readiness.fetch_or(mask, AcqRel); -+ self.wake(Ready::ALL); - } - - /// Sets the readiness on this `ScheduledIo` by invoking the given closure on -@@ -209,16 +220,10 @@ impl ScheduledIo { - /// than 32 wakers to notify, if the stack array fills up, the lock is - /// released, the array is cleared, and the iteration continues. - pub(super) fn wake(&self, ready: Ready) { -- self.wake0(ready, false); -- } -- -- fn wake0(&self, ready: Ready, shutdown: bool) { - let mut wakers = WakeList::new(); - - let mut waiters = self.waiters.lock(); - -- waiters.is_shutdown |= shutdown; -- - // check for AsyncRead slot - if ready.is_readable() { - if let Some(waker) = waiters.reader.take() { -@@ -273,6 +278,7 @@ impl ScheduledIo { - ReadyEvent { - tick: TICK.unpack(curr) as u8, - ready: interest.mask() & Ready::from_usize(READINESS.unpack(curr)), -+ is_shutdown: SHUTDOWN.unpack(curr) != 0, - } - } - -@@ -289,8 +295,9 @@ impl ScheduledIo { - let curr = self.readiness.load(Acquire); - - let ready = direction.mask() & Ready::from_usize(READINESS.unpack(curr)); -+ let is_shutdown = SHUTDOWN.unpack(curr) != 0; - -- if ready.is_empty() { -+ if ready.is_empty() && !is_shutdown { - // Update the task info - let mut waiters = self.waiters.lock(); - let slot = match direction { -@@ -315,10 +322,12 @@ impl ScheduledIo { - // taking the waiters lock - let curr = self.readiness.load(Acquire); - let ready = direction.mask() & Ready::from_usize(READINESS.unpack(curr)); -- if waiters.is_shutdown { -+ let is_shutdown = SHUTDOWN.unpack(curr) != 0; -+ if is_shutdown { - Poll::Ready(ReadyEvent { - tick: TICK.unpack(curr) as u8, - ready: direction.mask(), -+ is_shutdown, - }) - } else if ready.is_empty() { - Poll::Pending -@@ -326,12 +335,14 @@ impl ScheduledIo { - Poll::Ready(ReadyEvent { - tick: TICK.unpack(curr) as u8, - ready, -+ is_shutdown, - }) - } - } else { - Poll::Ready(ReadyEvent { - tick: TICK.unpack(curr) as u8, - ready, -+ is_shutdown, - }) - } - } -@@ -399,8 +410,8 @@ cfg_io_readiness! { - ptr - } - -- unsafe fn pointers(mut target: NonNull) -> NonNull> { -- NonNull::from(&mut target.as_mut().pointers) -+ unsafe fn pointers(target: NonNull) -> NonNull> { -+ Waiter::addr_of_pointers(target) - } - } - -@@ -423,16 +434,17 @@ cfg_io_readiness! { - // Optimistically check existing readiness - let curr = scheduled_io.readiness.load(SeqCst); - let ready = Ready::from_usize(READINESS.unpack(curr)); -+ let is_shutdown = SHUTDOWN.unpack(curr) != 0; - - // Safety: `waiter.interest` never changes - let interest = unsafe { (*waiter.get()).interest }; - let ready = ready.intersection(interest); - -- if !ready.is_empty() { -+ if !ready.is_empty() || is_shutdown { - // Currently ready! - let tick = TICK.unpack(curr) as u8; - *state = State::Done; -- return Poll::Ready(ReadyEvent { tick, ready }); -+ return Poll::Ready(ReadyEvent { tick, ready, is_shutdown }); - } - - // Wasn't ready, take the lock (and check again while locked). -@@ -440,18 +452,19 @@ cfg_io_readiness! { - - let curr = scheduled_io.readiness.load(SeqCst); - let mut ready = Ready::from_usize(READINESS.unpack(curr)); -+ let is_shutdown = SHUTDOWN.unpack(curr) != 0; - -- if waiters.is_shutdown { -+ if is_shutdown { - ready = Ready::ALL; - } - - let ready = ready.intersection(interest); - -- if !ready.is_empty() { -+ if !ready.is_empty() || is_shutdown { - // Currently ready! - let tick = TICK.unpack(curr) as u8; - *state = State::Done; -- return Poll::Ready(ReadyEvent { tick, ready }); -+ return Poll::Ready(ReadyEvent { tick, ready, is_shutdown }); - } - - // Not ready even after locked, insert into list... -@@ -500,14 +513,26 @@ cfg_io_readiness! { - drop(waiters); - } - State::Done => { -- let tick = TICK.unpack(scheduled_io.readiness.load(Acquire)) as u8; -- - // Safety: State::Done means it is no longer shared - let w = unsafe { &mut *waiter.get() }; - -+ let curr = scheduled_io.readiness.load(Acquire); -+ let is_shutdown = SHUTDOWN.unpack(curr) != 0; -+ -+ // The returned tick might be newer than the event -+ // which notified our waker. This is ok because the future -+ // still didn't return `Poll::Ready`. -+ let tick = TICK.unpack(curr) as u8; -+ -+ // The readiness state could have been cleared in the meantime, -+ // but we allow the returned ready set to be empty. -+ let curr_ready = Ready::from_usize(READINESS.unpack(curr)); -+ let ready = curr_ready.intersection(w.interest); -+ - return Poll::Ready(ReadyEvent { - tick, -- ready: Ready::from_interest(w.interest), -+ ready, -+ is_shutdown, - }); - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/metrics/batch.rs b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/batch.rs -new file mode 100644 -index 00000000..ec299741 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/batch.rs -@@ -0,0 +1,115 @@ -+use crate::runtime::WorkerMetrics; -+ -+use std::sync::atomic::Ordering::Relaxed; -+use std::time::Instant; -+ -+pub(crate) struct MetricsBatch { -+ /// Number of times the worker parked. -+ park_count: u64, -+ -+ /// Number of times the worker woke w/o doing work. -+ noop_count: u64, -+ -+ /// Number of tasks stolen. -+ steal_count: u64, -+ -+ /// Number of times tasks where stolen. -+ steal_operations: u64, -+ -+ /// Number of tasks that were polled by the worker. -+ poll_count: u64, -+ -+ /// Number of tasks polled when the worker entered park. This is used to -+ /// track the noop count. -+ poll_count_on_last_park: u64, -+ -+ /// Number of tasks that were scheduled locally on this worker. -+ local_schedule_count: u64, -+ -+ /// Number of tasks moved to the global queue to make space in the local -+ /// queue -+ overflow_count: u64, -+ -+ /// The total busy duration in nanoseconds. -+ busy_duration_total: u64, -+ last_resume_time: Instant, -+} -+ -+impl MetricsBatch { -+ pub(crate) fn new() -> MetricsBatch { -+ MetricsBatch { -+ park_count: 0, -+ noop_count: 0, -+ steal_count: 0, -+ steal_operations: 0, -+ poll_count: 0, -+ poll_count_on_last_park: 0, -+ local_schedule_count: 0, -+ overflow_count: 0, -+ busy_duration_total: 0, -+ last_resume_time: Instant::now(), -+ } -+ } -+ -+ pub(crate) fn submit(&mut self, worker: &WorkerMetrics) { -+ worker.park_count.store(self.park_count, Relaxed); -+ worker.noop_count.store(self.noop_count, Relaxed); -+ worker.steal_count.store(self.steal_count, Relaxed); -+ worker -+ .steal_operations -+ .store(self.steal_operations, Relaxed); -+ worker.poll_count.store(self.poll_count, Relaxed); -+ -+ worker -+ .busy_duration_total -+ .store(self.busy_duration_total, Relaxed); -+ -+ worker -+ .local_schedule_count -+ .store(self.local_schedule_count, Relaxed); -+ worker.overflow_count.store(self.overflow_count, Relaxed); -+ } -+ -+ /// The worker is about to park. -+ pub(crate) fn about_to_park(&mut self) { -+ self.park_count += 1; -+ -+ if self.poll_count_on_last_park == self.poll_count { -+ self.noop_count += 1; -+ } else { -+ self.poll_count_on_last_park = self.poll_count; -+ } -+ -+ let busy_duration = self.last_resume_time.elapsed(); -+ let busy_duration = u64::try_from(busy_duration.as_nanos()).unwrap_or(u64::MAX); -+ self.busy_duration_total += busy_duration; -+ } -+ -+ pub(crate) fn returned_from_park(&mut self) { -+ self.last_resume_time = Instant::now(); -+ } -+ -+ pub(crate) fn inc_local_schedule_count(&mut self) { -+ self.local_schedule_count += 1; -+ } -+ -+ pub(crate) fn incr_poll_count(&mut self) { -+ self.poll_count += 1; -+ } -+} -+ -+cfg_rt_multi_thread! { -+ impl MetricsBatch { -+ pub(crate) fn incr_steal_count(&mut self, by: u16) { -+ self.steal_count += by as u64; -+ } -+ -+ pub(crate) fn incr_steal_operations(&mut self) { -+ self.steal_operations += 1; -+ } -+ -+ pub(crate) fn incr_overflow_count(&mut self) { -+ self.overflow_count += 1; -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/metrics/io.rs b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/io.rs -new file mode 100644 -index 00000000..06efdd42 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/io.rs -@@ -0,0 +1,24 @@ -+#![cfg_attr(not(feature = "net"), allow(dead_code))] -+ -+use crate::loom::sync::atomic::{AtomicU64, Ordering::Relaxed}; -+ -+#[derive(Default)] -+pub(crate) struct IoDriverMetrics { -+ pub(super) fd_registered_count: AtomicU64, -+ pub(super) fd_deregistered_count: AtomicU64, -+ pub(super) ready_count: AtomicU64, -+} -+ -+impl IoDriverMetrics { -+ pub(crate) fn incr_fd_count(&self) { -+ self.fd_registered_count.fetch_add(1, Relaxed); -+ } -+ -+ pub(crate) fn dec_fd_count(&self) { -+ self.fd_deregistered_count.fetch_add(1, Relaxed); -+ } -+ -+ pub(crate) fn incr_ready_count_by(&self, amt: u64) { -+ self.ready_count.fetch_add(amt, Relaxed); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/metrics/mock.rs b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/mock.rs -new file mode 100644 -index 00000000..c388dc06 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/mock.rs -@@ -0,0 +1,44 @@ -+//! This file contains mocks of the types in src/runtime/metrics -+ -+pub(crate) struct SchedulerMetrics {} -+ -+pub(crate) struct WorkerMetrics {} -+ -+pub(crate) struct MetricsBatch {} -+ -+impl SchedulerMetrics { -+ pub(crate) fn new() -> Self { -+ Self {} -+ } -+ -+ /// Increment the number of tasks scheduled externally -+ pub(crate) fn inc_remote_schedule_count(&self) {} -+} -+ -+impl WorkerMetrics { -+ pub(crate) fn new() -> Self { -+ Self {} -+ } -+ -+ pub(crate) fn set_queue_depth(&self, _len: usize) {} -+} -+ -+impl MetricsBatch { -+ pub(crate) fn new() -> Self { -+ Self {} -+ } -+ -+ pub(crate) fn submit(&mut self, _to: &WorkerMetrics) {} -+ pub(crate) fn about_to_park(&mut self) {} -+ pub(crate) fn returned_from_park(&mut self) {} -+ pub(crate) fn incr_poll_count(&mut self) {} -+ pub(crate) fn inc_local_schedule_count(&mut self) {} -+} -+ -+cfg_rt_multi_thread! { -+ impl MetricsBatch { -+ pub(crate) fn incr_steal_count(&mut self, _by: u16) {} -+ pub(crate) fn incr_steal_operations(&mut self) {} -+ pub(crate) fn incr_overflow_count(&mut self) {} -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/metrics/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/mod.rs -new file mode 100644 -index 00000000..4b96f1b7 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/mod.rs -@@ -0,0 +1,35 @@ -+//! This module contains information need to view information about how the -+//! runtime is performing. -+//! -+//! **Note**: This is an [unstable API][unstable]. The public API of types in -+//! this module may break in 1.x releases. See [the documentation on unstable -+//! features][unstable] for details. -+//! -+//! [unstable]: crate#unstable-features -+#![allow(clippy::module_inception)] -+ -+cfg_metrics! { -+ mod batch; -+ pub(crate) use batch::MetricsBatch; -+ -+ mod runtime; -+ #[allow(unreachable_pub)] // rust-lang/rust#57411 -+ pub use runtime::RuntimeMetrics; -+ -+ mod scheduler; -+ pub(crate) use scheduler::SchedulerMetrics; -+ -+ mod worker; -+ pub(crate) use worker::WorkerMetrics; -+ -+ cfg_net! { -+ mod io; -+ pub(crate) use io::IoDriverMetrics; -+ } -+} -+ -+cfg_not_metrics! { -+ mod mock; -+ -+ pub(crate) use mock::{SchedulerMetrics, WorkerMetrics, MetricsBatch}; -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/metrics/runtime.rs b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/runtime.rs -new file mode 100644 -index 00000000..8e52fead ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/runtime.rs -@@ -0,0 +1,673 @@ -+use crate::runtime::Handle; -+ -+use std::sync::atomic::Ordering::Relaxed; -+use std::time::Duration; -+ -+/// Handle to the runtime's metrics. -+/// -+/// This handle is internally reference-counted and can be freely cloned. A -+/// `RuntimeMetrics` handle is obtained using the [`Runtime::metrics`] method. -+/// -+/// [`Runtime::metrics`]: crate::runtime::Runtime::metrics() -+#[derive(Clone, Debug)] -+pub struct RuntimeMetrics { -+ handle: Handle, -+} -+ -+impl RuntimeMetrics { -+ pub(crate) fn new(handle: Handle) -> RuntimeMetrics { -+ RuntimeMetrics { handle } -+ } -+ -+ /// Returns the number of worker threads used by the runtime. -+ /// -+ /// The number of workers is set by configuring `worker_threads` on -+ /// `runtime::Builder`. When using the `current_thread` runtime, the return -+ /// value is always `1`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.num_workers(); -+ /// println!("Runtime is using {} workers", n); -+ /// } -+ /// ``` -+ pub fn num_workers(&self) -> usize { -+ self.handle.inner.num_workers() -+ } -+ -+ /// Returns the number of additional threads spawned by the runtime. -+ /// -+ /// The number of workers is set by configuring `max_blocking_threads` on -+ /// `runtime::Builder`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let _ = tokio::task::spawn_blocking(move || { -+ /// // Stand-in for compute-heavy work or using synchronous APIs -+ /// 1 + 1 -+ /// }).await; -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.num_blocking_threads(); -+ /// println!("Runtime has created {} threads", n); -+ /// } -+ /// ``` -+ pub fn num_blocking_threads(&self) -> usize { -+ self.handle.inner.num_blocking_threads() -+ } -+ -+ /// Returns the number of idle threads, which have spawned by the runtime -+ /// for `spawn_blocking` calls. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let _ = tokio::task::spawn_blocking(move || { -+ /// // Stand-in for compute-heavy work or using synchronous APIs -+ /// 1 + 1 -+ /// }).await; -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.num_idle_blocking_threads(); -+ /// println!("Runtime has {} idle blocking thread pool threads", n); -+ /// } -+ /// ``` -+ pub fn num_idle_blocking_threads(&self) -> usize { -+ self.handle.inner.num_idle_blocking_threads() -+ } -+ -+ /// Returns the number of tasks scheduled from **outside** of the runtime. -+ /// -+ /// The remote schedule count starts at zero when the runtime is created and -+ /// increases by one each time a task is woken from **outside** of the -+ /// runtime. This usually means that a task is spawned or notified from a -+ /// non-runtime thread and must be queued using the Runtime's injection -+ /// queue, which tends to be slower. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.remote_schedule_count(); -+ /// println!("{} tasks were scheduled from outside the runtime", n); -+ /// } -+ /// ``` -+ pub fn remote_schedule_count(&self) -> u64 { -+ self.handle -+ .inner -+ .scheduler_metrics() -+ .remote_schedule_count -+ .load(Relaxed) -+ } -+ -+ /// Returns the number of times that tasks have been forced to yield back to the scheduler -+ /// after exhausting their task budgets. -+ /// -+ /// This count starts at zero when the runtime is created and increases by one each time a task yields due to exhausting its budget. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ pub fn budget_forced_yield_count(&self) -> u64 { -+ self.handle -+ .inner -+ .scheduler_metrics() -+ .budget_forced_yield_count -+ .load(Relaxed) -+ } -+ -+ /// Returns the total number of times the given worker thread has parked. -+ /// -+ /// The worker park count starts at zero when the runtime is created and -+ /// increases by one each time the worker parks the thread waiting for new -+ /// inbound events to process. This usually means the worker has processed -+ /// all pending work and is currently idle. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_park_count(0); -+ /// println!("worker 0 parked {} times", n); -+ /// } -+ /// ``` -+ pub fn worker_park_count(&self, worker: usize) -> u64 { -+ self.handle -+ .inner -+ .worker_metrics(worker) -+ .park_count -+ .load(Relaxed) -+ } -+ -+ /// Returns the number of times the given worker thread unparked but -+ /// performed no work before parking again. -+ /// -+ /// The worker no-op count starts at zero when the runtime is created and -+ /// increases by one each time the worker unparks the thread but finds no -+ /// new work and goes back to sleep. This indicates a false-positive wake up. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_noop_count(0); -+ /// println!("worker 0 had {} no-op unparks", n); -+ /// } -+ /// ``` -+ pub fn worker_noop_count(&self, worker: usize) -> u64 { -+ self.handle -+ .inner -+ .worker_metrics(worker) -+ .noop_count -+ .load(Relaxed) -+ } -+ -+ /// Returns the number of tasks the given worker thread stole from -+ /// another worker thread. -+ /// -+ /// This metric only applies to the **multi-threaded** runtime and will -+ /// always return `0` when using the current thread runtime. -+ /// -+ /// The worker steal count starts at zero when the runtime is created and -+ /// increases by `N` each time the worker has processed its scheduled queue -+ /// and successfully steals `N` more pending tasks from another worker. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_steal_count(0); -+ /// println!("worker 0 has stolen {} tasks", n); -+ /// } -+ /// ``` -+ pub fn worker_steal_count(&self, worker: usize) -> u64 { -+ self.handle -+ .inner -+ .worker_metrics(worker) -+ .steal_count -+ .load(Relaxed) -+ } -+ -+ /// Returns the number of times the given worker thread stole tasks from -+ /// another worker thread. -+ /// -+ /// This metric only applies to the **multi-threaded** runtime and will -+ /// always return `0` when using the current thread runtime. -+ /// -+ /// The worker steal count starts at zero when the runtime is created and -+ /// increases by one each time the worker has processed its scheduled queue -+ /// and successfully steals more pending tasks from another worker. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_steal_operations(0); -+ /// println!("worker 0 has stolen tasks {} times", n); -+ /// } -+ /// ``` -+ pub fn worker_steal_operations(&self, worker: usize) -> u64 { -+ self.handle -+ .inner -+ .worker_metrics(worker) -+ .steal_operations -+ .load(Relaxed) -+ } -+ -+ /// Returns the number of tasks the given worker thread has polled. -+ /// -+ /// The worker poll count starts at zero when the runtime is created and -+ /// increases by one each time the worker polls a scheduled task. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_poll_count(0); -+ /// println!("worker 0 has polled {} tasks", n); -+ /// } -+ /// ``` -+ pub fn worker_poll_count(&self, worker: usize) -> u64 { -+ self.handle -+ .inner -+ .worker_metrics(worker) -+ .poll_count -+ .load(Relaxed) -+ } -+ -+ /// Returns the amount of time the given worker thread has been busy. -+ /// -+ /// The worker busy duration starts at zero when the runtime is created and -+ /// increases whenever the worker is spending time processing work. Using -+ /// this value can indicate the load of the given worker. If a lot of time -+ /// is spent busy, then the worker is under load and will check for inbound -+ /// events less often. -+ /// -+ /// The timer is monotonically increasing. It is never decremented or reset -+ /// to zero. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_total_busy_duration(0); -+ /// println!("worker 0 was busy for a total of {:?}", n); -+ /// } -+ /// ``` -+ pub fn worker_total_busy_duration(&self, worker: usize) -> Duration { -+ let nanos = self -+ .handle -+ .inner -+ .worker_metrics(worker) -+ .busy_duration_total -+ .load(Relaxed); -+ Duration::from_nanos(nanos) -+ } -+ -+ /// Returns the number of tasks scheduled from **within** the runtime on the -+ /// given worker's local queue. -+ /// -+ /// The local schedule count starts at zero when the runtime is created and -+ /// increases by one each time a task is woken from **inside** of the -+ /// runtime on the given worker. This usually means that a task is spawned -+ /// or notified from within a runtime thread and will be queued on the -+ /// worker-local queue. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_local_schedule_count(0); -+ /// println!("{} tasks were scheduled on the worker's local queue", n); -+ /// } -+ /// ``` -+ pub fn worker_local_schedule_count(&self, worker: usize) -> u64 { -+ self.handle -+ .inner -+ .worker_metrics(worker) -+ .local_schedule_count -+ .load(Relaxed) -+ } -+ -+ /// Returns the number of times the given worker thread saturated its local -+ /// queue. -+ /// -+ /// This metric only applies to the **multi-threaded** scheduler. -+ /// -+ /// The worker steal count starts at zero when the runtime is created and -+ /// increases by one each time the worker attempts to schedule a task -+ /// locally, but its local queue is full. When this happens, half of the -+ /// local queue is moved to the injection queue. -+ /// -+ /// The counter is monotonically increasing. It is never decremented or -+ /// reset to zero. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_overflow_count(0); -+ /// println!("worker 0 has overflowed its queue {} times", n); -+ /// } -+ /// ``` -+ pub fn worker_overflow_count(&self, worker: usize) -> u64 { -+ self.handle -+ .inner -+ .worker_metrics(worker) -+ .overflow_count -+ .load(Relaxed) -+ } -+ -+ /// Returns the number of tasks currently scheduled in the runtime's -+ /// injection queue. -+ /// -+ /// Tasks that are spawned or notified from a non-runtime thread are -+ /// scheduled using the runtime's injection queue. This metric returns the -+ /// **current** number of tasks pending in the injection queue. As such, the -+ /// returned value may increase or decrease as new tasks are scheduled and -+ /// processed. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.injection_queue_depth(); -+ /// println!("{} tasks currently pending in the runtime's injection queue", n); -+ /// } -+ /// ``` -+ pub fn injection_queue_depth(&self) -> usize { -+ self.handle.inner.injection_queue_depth() -+ } -+ -+ /// Returns the number of tasks currently scheduled in the given worker's -+ /// local queue. -+ /// -+ /// Tasks that are spawned or notified from within a runtime thread are -+ /// scheduled using that worker's local queue. This metric returns the -+ /// **current** number of tasks pending in the worker's local queue. As -+ /// such, the returned value may increase or decrease as new tasks are -+ /// scheduled and processed. -+ /// -+ /// # Arguments -+ /// -+ /// `worker` is the index of the worker being queried. The given value must -+ /// be between 0 and `num_workers()`. The index uniquely identifies a single -+ /// worker and will continue to identify the worker throughout the lifetime -+ /// of the runtime instance. -+ /// -+ /// # Panics -+ /// -+ /// The method panics when `worker` represents an invalid worker, i.e. is -+ /// greater than or equal to `num_workers()`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.worker_local_queue_depth(0); -+ /// println!("{} tasks currently pending in worker 0's local queue", n); -+ /// } -+ /// ``` -+ pub fn worker_local_queue_depth(&self, worker: usize) -> usize { -+ self.handle.inner.worker_local_queue_depth(worker) -+ } -+ -+ /// Returns the number of tasks currently scheduled in the blocking -+ /// thread pool, spawned using `spawn_blocking`. -+ /// -+ /// This metric returns the **current** number of tasks pending in -+ /// blocking thread pool. As such, the returned value may increase -+ /// or decrease as new tasks are scheduled and processed. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.blocking_queue_depth(); -+ /// println!("{} tasks currently pending in the blocking thread pool", n); -+ /// } -+ /// ``` -+ pub fn blocking_queue_depth(&self) -> usize { -+ self.handle.inner.blocking_queue_depth() -+ } -+} -+ -+cfg_net! { -+ impl RuntimeMetrics { -+ /// Returns the number of file descriptors that have been registered with the -+ /// runtime's I/O driver. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let registered_fds = metrics.io_driver_fd_registered_count(); -+ /// println!("{} fds have been registered with the runtime's I/O driver.", registered_fds); -+ /// -+ /// let deregistered_fds = metrics.io_driver_fd_deregistered_count(); -+ /// -+ /// let current_fd_count = registered_fds - deregistered_fds; -+ /// println!("{} fds are currently registered by the runtime's I/O driver.", current_fd_count); -+ /// } -+ /// ``` -+ pub fn io_driver_fd_registered_count(&self) -> u64 { -+ self.with_io_driver_metrics(|m| { -+ m.fd_registered_count.load(Relaxed) -+ }) -+ } -+ -+ /// Returns the number of file descriptors that have been deregistered by the -+ /// runtime's I/O driver. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.io_driver_fd_deregistered_count(); -+ /// println!("{} fds have been deregistered by the runtime's I/O driver.", n); -+ /// } -+ /// ``` -+ pub fn io_driver_fd_deregistered_count(&self) -> u64 { -+ self.with_io_driver_metrics(|m| { -+ m.fd_deregistered_count.load(Relaxed) -+ }) -+ } -+ -+ /// Returns the number of ready events processed by the runtime's -+ /// I/O driver. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Handle; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let metrics = Handle::current().metrics(); -+ /// -+ /// let n = metrics.io_driver_ready_count(); -+ /// println!("{} ready events processed by the runtime's I/O driver.", n); -+ /// } -+ /// ``` -+ pub fn io_driver_ready_count(&self) -> u64 { -+ self.with_io_driver_metrics(|m| m.ready_count.load(Relaxed)) -+ } -+ -+ fn with_io_driver_metrics(&self, f: F) -> u64 -+ where -+ F: Fn(&super::IoDriverMetrics) -> u64, -+ { -+ // TODO: Investigate if this should return 0, most of our metrics always increase -+ // thus this breaks that guarantee. -+ self.handle -+ .inner -+ .driver() -+ .io -+ .as_ref() -+ .map(|h| f(&h.metrics)) -+ .unwrap_or(0) -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/metrics/scheduler.rs b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/scheduler.rs -new file mode 100644 -index 00000000..d9f8edfa ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/scheduler.rs -@@ -0,0 +1,34 @@ -+use crate::loom::sync::atomic::{AtomicU64, Ordering::Relaxed}; -+ -+/// Retrieves metrics from the Tokio runtime. -+/// -+/// **Note**: This is an [unstable API][unstable]. The public API of this type -+/// may break in 1.x releases. See [the documentation on unstable -+/// features][unstable] for details. -+/// -+/// [unstable]: crate#unstable-features -+#[derive(Debug)] -+pub(crate) struct SchedulerMetrics { -+ /// Number of tasks that are scheduled from outside the runtime. -+ pub(super) remote_schedule_count: AtomicU64, -+ pub(super) budget_forced_yield_count: AtomicU64, -+} -+ -+impl SchedulerMetrics { -+ pub(crate) fn new() -> SchedulerMetrics { -+ SchedulerMetrics { -+ remote_schedule_count: AtomicU64::new(0), -+ budget_forced_yield_count: AtomicU64::new(0), -+ } -+ } -+ -+ /// Increment the number of tasks scheduled externally -+ pub(crate) fn inc_remote_schedule_count(&self) { -+ self.remote_schedule_count.fetch_add(1, Relaxed); -+ } -+ -+ /// Increment the number of tasks forced to yield due to budget exhaustion -+ pub(crate) fn inc_budget_forced_yield_count(&self) { -+ self.budget_forced_yield_count.fetch_add(1, Relaxed); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/metrics/worker.rs b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/worker.rs -new file mode 100644 -index 00000000..a40c76ef ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/metrics/worker.rs -@@ -0,0 +1,65 @@ -+use crate::loom::sync::atomic::Ordering::Relaxed; -+use crate::loom::sync::atomic::{AtomicU64, AtomicUsize}; -+ -+/// Retrieve runtime worker metrics. -+/// -+/// **Note**: This is an [unstable API][unstable]. The public API of this type -+/// may break in 1.x releases. See [the documentation on unstable -+/// features][unstable] for details. -+/// -+/// [unstable]: crate#unstable-features -+#[derive(Debug)] -+#[repr(align(128))] -+pub(crate) struct WorkerMetrics { -+ /// Number of times the worker parked. -+ pub(crate) park_count: AtomicU64, -+ -+ /// Number of times the worker woke then parked again without doing work. -+ pub(crate) noop_count: AtomicU64, -+ -+ /// Number of tasks the worker stole. -+ pub(crate) steal_count: AtomicU64, -+ -+ /// Number of times the worker stole -+ pub(crate) steal_operations: AtomicU64, -+ -+ /// Number of tasks the worker polled. -+ pub(crate) poll_count: AtomicU64, -+ -+ /// Amount of time the worker spent doing work vs. parking. -+ pub(crate) busy_duration_total: AtomicU64, -+ -+ /// Number of tasks scheduled for execution on the worker's local queue. -+ pub(crate) local_schedule_count: AtomicU64, -+ -+ /// Number of tasks moved from the local queue to the global queue to free space. -+ pub(crate) overflow_count: AtomicU64, -+ -+ /// Number of tasks currently in the local queue. Used only by the -+ /// current-thread scheduler. -+ pub(crate) queue_depth: AtomicUsize, -+} -+ -+impl WorkerMetrics { -+ pub(crate) fn new() -> WorkerMetrics { -+ WorkerMetrics { -+ park_count: AtomicU64::new(0), -+ noop_count: AtomicU64::new(0), -+ steal_count: AtomicU64::new(0), -+ steal_operations: AtomicU64::new(0), -+ poll_count: AtomicU64::new(0), -+ overflow_count: AtomicU64::new(0), -+ busy_duration_total: AtomicU64::new(0), -+ local_schedule_count: AtomicU64::new(0), -+ queue_depth: AtomicUsize::new(0), -+ } -+ } -+ -+ pub(crate) fn queue_depth(&self) -> usize { -+ self.queue_depth.load(Relaxed) -+ } -+ -+ pub(crate) fn set_queue_depth(&self, len: usize) { -+ self.queue_depth.store(len, Relaxed); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/mod.rs -index 96bb47c1..8cd99917 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/mod.rs -@@ -137,7 +137,7 @@ - //! use tokio::runtime; - //! - //! # fn main() -> Result<(), Box> { --//! let basic_rt = runtime::Builder::new_current_thread() -+//! let rt = runtime::Builder::new_current_thread() - //! .build()?; - //! # Ok(()) } - //! ``` -@@ -156,9 +156,11 @@ - //! multi-thread scheduler spawns threads to schedule tasks and for `spawn_blocking` - //! calls. - //! --//! While the `Runtime` is active, threads may shutdown after periods of being --//! idle. Once `Runtime` is dropped, all runtime threads are forcibly shutdown. --//! Any tasks that have not yet completed will be dropped. -+//! While the `Runtime` is active, threads may shut down after periods of being -+//! idle. Once `Runtime` is dropped, all runtime threads have usually been -+//! terminated, but in the presence of unstoppable spawned work are not -+//! guaranteed to have been terminated. See the -+//! [struct level documentation](Runtime#shutdown) for more details. - //! - //! [tasks]: crate::task - //! [`Runtime`]: Runtime -@@ -166,7 +168,6 @@ - //! [`tokio::main`]: ../attr.main.html - //! [runtime builder]: crate::runtime::Builder - //! [`Runtime::new`]: crate::runtime::Runtime::new --//! [`Builder::basic_scheduler`]: crate::runtime::Builder::basic_scheduler - //! [`Builder::threaded_scheduler`]: crate::runtime::Builder::threaded_scheduler - //! [`Builder::enable_io`]: crate::runtime::Builder::enable_io - //! [`Builder::enable_time`]: crate::runtime::Builder::enable_time -@@ -174,427 +175,89 @@ - - // At the top due to macros - #[cfg(test)] -+#[cfg(not(tokio_wasm))] - #[macro_use] - mod tests; - --pub(crate) mod enter; -+pub(crate) mod context; - --pub(crate) mod task; -+pub(crate) mod coop; - --cfg_stats! { -- pub mod stats; --} --cfg_not_stats! { -- pub(crate) mod stats; --} -- --cfg_rt! { -- mod basic_scheduler; -- use basic_scheduler::BasicScheduler; -- -- mod blocking; -- use blocking::BlockingPool; -- pub(crate) use blocking::spawn_blocking; -- -- mod builder; -- pub use self::builder::Builder; -+pub(crate) mod park; - -- pub(crate) mod context; -- pub(crate) mod driver; -+mod driver; - -- use self::enter::enter; -+pub(crate) mod scheduler; - -- mod handle; -- pub use handle::{EnterGuard, Handle, TryCurrentError}; -- -- mod spawner; -- use self::spawner::Spawner; -+cfg_io_driver_impl! { -+ pub(crate) mod io; - } - --cfg_rt_multi_thread! { -- mod park; -- use park::Parker; -+cfg_process_driver! { -+ mod process; - } - --cfg_rt_multi_thread! { -- mod queue; -+cfg_time! { -+ pub(crate) mod time; -+} - -- pub(crate) mod thread_pool; -- use self::thread_pool::ThreadPool; -+cfg_signal_internal_and_unix! { -+ pub(crate) mod signal; - } - - cfg_rt! { -- use crate::task::JoinHandle; -- -- use std::future::Future; -- use std::time::Duration; -+ pub(crate) mod task; - -- /// The Tokio runtime. -- /// -- /// The runtime provides an I/O driver, task scheduler, [timer], and -- /// blocking pool, necessary for running asynchronous tasks. -- /// -- /// Instances of `Runtime` can be created using [`new`], or [`Builder`]. -- /// However, most users will use the `#[tokio::main]` annotation on their -- /// entry point instead. -- /// -- /// See [module level][mod] documentation for more details. -- /// -- /// # Shutdown -- /// -- /// Shutting down the runtime is done by dropping the value. The current -- /// thread will block until the shut down operation has completed. -- /// -- /// * Drain any scheduled work queues. -- /// * Drop any futures that have not yet completed. -- /// * Drop the reactor. -- /// -- /// Once the reactor has dropped, any outstanding I/O resources bound to -- /// that reactor will no longer function. Calling any method on them will -- /// result in an error. -- /// -- /// # Sharing -- /// -- /// The Tokio runtime implements `Sync` and `Send` to allow you to wrap it -- /// in a `Arc`. Most fn take `&self` to allow you to call them concurrently -- /// across multiple threads. -- /// -- /// Calls to `shutdown` and `shutdown_timeout` require exclusive ownership of -- /// the runtime type and this can be achieved via `Arc::try_unwrap` when only -- /// one strong count reference is left over. -- /// -- /// [timer]: crate::time -- /// [mod]: index.html -- /// [`new`]: method@Self::new -- /// [`Builder`]: struct@Builder -- #[derive(Debug)] -- pub struct Runtime { -- /// Task executor -- kind: Kind, -+ mod config; -+ use config::Config; - -- /// Handle to runtime, also contains driver handles -- handle: Handle, -+ mod blocking; -+ #[cfg_attr(tokio_wasi, allow(unused_imports))] -+ pub(crate) use blocking::spawn_blocking; - -- /// Blocking pool handle, used to signal shutdown -- blocking_pool: BlockingPool, -+ cfg_trace! { -+ pub(crate) use blocking::Mandatory; - } - -- /// The runtime executor is either a thread-pool or a current-thread executor. -- #[derive(Debug)] -- enum Kind { -- /// Execute all tasks on the current-thread. -- CurrentThread(BasicScheduler), -- -- /// Execute tasks across multiple threads. -- #[cfg(feature = "rt-multi-thread")] -- ThreadPool(ThreadPool), -+ cfg_fs! { -+ pub(crate) use blocking::spawn_mandatory_blocking; - } - -- /// After thread starts / before thread stops -- type Callback = std::sync::Arc; -- -- impl Runtime { -- /// Creates a new runtime instance with default configuration values. -- /// -- /// This results in the multi threaded scheduler, I/O driver, and time driver being -- /// initialized. -- /// -- /// Most applications will not need to call this function directly. Instead, -- /// they will use the [`#[tokio::main]` attribute][main]. When a more complex -- /// configuration is necessary, the [runtime builder] may be used. -- /// -- /// See [module level][mod] documentation for more details. -- /// -- /// # Examples -- /// -- /// Creating a new `Runtime` with default configuration values. -- /// -- /// ``` -- /// use tokio::runtime::Runtime; -- /// -- /// let rt = Runtime::new() -- /// .unwrap(); -- /// -- /// // Use the runtime... -- /// ``` -- /// -- /// [mod]: index.html -- /// [main]: ../attr.main.html -- /// [threaded scheduler]: index.html#threaded-scheduler -- /// [basic scheduler]: index.html#basic-scheduler -- /// [runtime builder]: crate::runtime::Builder -- #[cfg(feature = "rt-multi-thread")] -- #[cfg_attr(docsrs, doc(cfg(feature = "rt-multi-thread")))] -- pub fn new() -> std::io::Result { -- Builder::new_multi_thread().enable_all().build() -- } -- -- /// Returns a handle to the runtime's spawner. -- /// -- /// The returned handle can be used to spawn tasks that run on this runtime, and can -- /// be cloned to allow moving the `Handle` to other threads. -- /// -- /// # Examples -- /// -- /// ``` -- /// use tokio::runtime::Runtime; -- /// -- /// let rt = Runtime::new() -- /// .unwrap(); -- /// -- /// let handle = rt.handle(); -- /// -- /// // Use the handle... -- /// ``` -- pub fn handle(&self) -> &Handle { -- &self.handle -- } -- -- /// Spawns a future onto the Tokio runtime. -- /// -- /// This spawns the given future onto the runtime's executor, usually a -- /// thread pool. The thread pool is then responsible for polling the future -- /// until it completes. -- /// -- /// See [module level][mod] documentation for more details. -- /// -- /// [mod]: index.html -- /// -- /// # Examples -- /// -- /// ``` -- /// use tokio::runtime::Runtime; -- /// -- /// # fn dox() { -- /// // Create the runtime -- /// let rt = Runtime::new().unwrap(); -- /// -- /// // Spawn a future onto the runtime -- /// rt.spawn(async { -- /// println!("now running on a worker thread"); -- /// }); -- /// # } -- /// ``` -- #[cfg_attr(tokio_track_caller, track_caller)] -- pub fn spawn(&self, future: F) -> JoinHandle -- where -- F: Future + Send + 'static, -- F::Output: Send + 'static, -- { -- self.handle.spawn(future) -- } -+ mod builder; -+ pub use self::builder::Builder; -+ cfg_unstable! { -+ pub use self::builder::UnhandledPanic; -+ pub use crate::util::rand::RngSeed; -+ } - -- /// Runs the provided function on an executor dedicated to blocking operations. -- /// -- /// # Examples -- /// -- /// ``` -- /// use tokio::runtime::Runtime; -- /// -- /// # fn dox() { -- /// // Create the runtime -- /// let rt = Runtime::new().unwrap(); -- /// -- /// // Spawn a blocking function onto the runtime -- /// rt.spawn_blocking(|| { -- /// println!("now running on a worker thread"); -- /// }); -- /// # } -- #[cfg_attr(tokio_track_caller, track_caller)] -- pub fn spawn_blocking(&self, func: F) -> JoinHandle -- where -- F: FnOnce() -> R + Send + 'static, -- R: Send + 'static, -- { -- self.handle.spawn_blocking(func) -- } -+ mod defer; -+ pub(crate) use defer::Defer; - -- /// Runs a future to completion on the Tokio runtime. This is the -- /// runtime's entry point. -- /// -- /// This runs the given future on the current thread, blocking until it is -- /// complete, and yielding its resolved result. Any tasks or timers -- /// which the future spawns internally will be executed on the runtime. -- /// -- /// # Multi thread scheduler -- /// -- /// When the multi thread scheduler is used this will allow futures -- /// to run within the io driver and timer context of the overall runtime. -- /// -- /// # Current thread scheduler -- /// -- /// When the current thread scheduler is enabled `block_on` -- /// can be called concurrently from multiple threads. The first call -- /// will take ownership of the io and timer drivers. This means -- /// other threads which do not own the drivers will hook into that one. -- /// When the first `block_on` completes, other threads will be able to -- /// "steal" the driver to allow continued execution of their futures. -- /// -- /// # Panics -- /// -- /// This function panics if the provided future panics, or if called within an -- /// asynchronous execution context. -- /// -- /// # Examples -- /// -- /// ```no_run -- /// use tokio::runtime::Runtime; -- /// -- /// // Create the runtime -- /// let rt = Runtime::new().unwrap(); -- /// -- /// // Execute the future, blocking the current thread until completion -- /// rt.block_on(async { -- /// println!("hello"); -- /// }); -- /// ``` -- /// -- /// [handle]: fn@Handle::block_on -- #[cfg_attr(tokio_track_caller, track_caller)] -- pub fn block_on(&self, future: F) -> F::Output { -- #[cfg(all(tokio_unstable, feature = "tracing"))] -- let future = crate::util::trace::task(future, "block_on", None); -+ mod handle; -+ pub use handle::{EnterGuard, Handle, TryCurrentError}; - -- let _enter = self.enter(); -+ mod runtime; -+ pub use runtime::{Runtime, RuntimeFlavor}; - -- match &self.kind { -- Kind::CurrentThread(exec) => exec.block_on(future), -- #[cfg(feature = "rt-multi-thread")] -- Kind::ThreadPool(exec) => exec.block_on(future), -- } -- } -+ mod thread_id; -+ pub(crate) use thread_id::ThreadId; - -- /// Enters the runtime context. -- /// -- /// This allows you to construct types that must have an executor -- /// available on creation such as [`Sleep`] or [`TcpStream`]. It will -- /// also allow you to call methods such as [`tokio::spawn`]. -- /// -- /// [`Sleep`]: struct@crate::time::Sleep -- /// [`TcpStream`]: struct@crate::net::TcpStream -- /// [`tokio::spawn`]: fn@crate::spawn -- /// -- /// # Example -- /// -- /// ``` -- /// use tokio::runtime::Runtime; -- /// -- /// fn function_that_spawns(msg: String) { -- /// // Had we not used `rt.enter` below, this would panic. -- /// tokio::spawn(async move { -- /// println!("{}", msg); -- /// }); -- /// } -- /// -- /// fn main() { -- /// let rt = Runtime::new().unwrap(); -- /// -- /// let s = "Hello World!".to_string(); -- /// -- /// // By entering the context, we tie `tokio::spawn` to this executor. -- /// let _guard = rt.enter(); -- /// function_that_spawns(s); -- /// } -- /// ``` -- pub fn enter(&self) -> EnterGuard<'_> { -- self.handle.enter() -- } -+ cfg_metrics! { -+ mod metrics; -+ pub use metrics::RuntimeMetrics; - -- /// Shuts down the runtime, waiting for at most `duration` for all spawned -- /// task to shutdown. -- /// -- /// Usually, dropping a `Runtime` handle is sufficient as tasks are able to -- /// shutdown in a timely fashion. However, dropping a `Runtime` will wait -- /// indefinitely for all tasks to terminate, and there are cases where a long -- /// blocking task has been spawned, which can block dropping `Runtime`. -- /// -- /// In this case, calling `shutdown_timeout` with an explicit wait timeout -- /// can work. The `shutdown_timeout` will signal all tasks to shutdown and -- /// will wait for at most `duration` for all spawned tasks to terminate. If -- /// `timeout` elapses before all tasks are dropped, the function returns and -- /// outstanding tasks are potentially leaked. -- /// -- /// # Examples -- /// -- /// ``` -- /// use tokio::runtime::Runtime; -- /// use tokio::task; -- /// -- /// use std::thread; -- /// use std::time::Duration; -- /// -- /// fn main() { -- /// let runtime = Runtime::new().unwrap(); -- /// -- /// runtime.block_on(async move { -- /// task::spawn_blocking(move || { -- /// thread::sleep(Duration::from_secs(10_000)); -- /// }); -- /// }); -- /// -- /// runtime.shutdown_timeout(Duration::from_millis(100)); -- /// } -- /// ``` -- pub fn shutdown_timeout(mut self, duration: Duration) { -- // Wakeup and shutdown all the worker threads -- self.handle.clone().shutdown(); -- self.blocking_pool.shutdown(Some(duration)); -- } -+ pub(crate) use metrics::{MetricsBatch, SchedulerMetrics, WorkerMetrics}; - -- /// Shuts down the runtime, without waiting for any spawned tasks to shutdown. -- /// -- /// This can be useful if you want to drop a runtime from within another runtime. -- /// Normally, dropping a runtime will block indefinitely for spawned blocking tasks -- /// to complete, which would normally not be permitted within an asynchronous context. -- /// By calling `shutdown_background()`, you can drop the runtime from such a context. -- /// -- /// Note however, that because we do not wait for any blocking tasks to complete, this -- /// may result in a resource leak (in that any blocking tasks are still running until they -- /// return. -- /// -- /// This function is equivalent to calling `shutdown_timeout(Duration::of_nanos(0))`. -- /// -- /// ``` -- /// use tokio::runtime::Runtime; -- /// -- /// fn main() { -- /// let runtime = Runtime::new().unwrap(); -- /// -- /// runtime.block_on(async move { -- /// let inner_runtime = Runtime::new().unwrap(); -- /// // ... -- /// inner_runtime.shutdown_background(); -- /// }); -- /// } -- /// ``` -- pub fn shutdown_background(self) { -- self.shutdown_timeout(Duration::from_nanos(0)) -+ cfg_net! { -+ pub(crate) use metrics::IoDriverMetrics; - } - } - -- #[allow(clippy::single_match)] // there are comments in the error branch, so we don't want if-let -- impl Drop for Runtime { -- fn drop(&mut self) { -- match &mut self.kind { -- Kind::CurrentThread(basic) => { -- // This ensures that tasks spawned on the basic runtime are dropped inside the -- // runtime's context. -- match self::context::try_enter(self.handle.clone()) { -- Some(guard) => basic.set_context_guard(guard), -- None => { -- // The context thread-local has alread been destroyed. -- // -- // We don't set the guard in this case. Calls to tokio::spawn in task -- // destructors would fail regardless if this happens. -- }, -- } -- }, -- #[cfg(feature = "rt-multi-thread")] -- Kind::ThreadPool(_) => { -- // The threaded scheduler drops its tasks on its worker threads, which is -- // already in the runtime's context. -- }, -- } -- } -+ cfg_not_metrics! { -+ pub(crate) mod metrics; -+ pub(crate) use metrics::{SchedulerMetrics, WorkerMetrics, MetricsBatch}; - } -+ -+ /// After thread starts / before thread stops -+ type Callback = std::sync::Arc; - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/park.rs b/KubeOS-Rust/vendor/tokio/src/runtime/park.rs -index 033b9f20..dc86f42a 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/park.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/park.rs -@@ -1,153 +1,102 @@ --//! Parks the runtime. --//! --//! A combination of the various resource driver park handles. -+#![cfg_attr(not(feature = "full"), allow(dead_code))] - - use crate::loom::sync::atomic::AtomicUsize; - use crate::loom::sync::{Arc, Condvar, Mutex}; --use crate::loom::thread; --use crate::park::{Park, Unpark}; --use crate::runtime::driver::Driver; --use crate::util::TryLock; - - use std::sync::atomic::Ordering::SeqCst; - use std::time::Duration; - --pub(crate) struct Parker { -+#[derive(Debug)] -+pub(crate) struct ParkThread { - inner: Arc, - } - --pub(crate) struct Unparker { -+/// Unblocks a thread that was blocked by `ParkThread`. -+#[derive(Clone, Debug)] -+pub(crate) struct UnparkThread { - inner: Arc, - } - -+#[derive(Debug)] - struct Inner { -- /// Avoids entering the park if possible - state: AtomicUsize, -- -- /// Used to coordinate access to the driver / condvar - mutex: Mutex<()>, -- -- /// Condvar to block on if the driver is unavailable. - condvar: Condvar, -- -- /// Resource (I/O, time, ...) driver -- shared: Arc, - } - - const EMPTY: usize = 0; --const PARKED_CONDVAR: usize = 1; --const PARKED_DRIVER: usize = 2; --const NOTIFIED: usize = 3; -+const PARKED: usize = 1; -+const NOTIFIED: usize = 2; - --/// Shared across multiple Parker handles --struct Shared { -- /// Shared driver. Only one thread at a time can use this -- driver: TryLock, -+tokio_thread_local! { -+ static CURRENT_PARKER: ParkThread = ParkThread::new(); -+} - -- /// Unpark handle -- handle: ::Unpark, -+// Bit of a hack, but it is only for loom -+#[cfg(loom)] -+tokio_thread_local! { -+ static CURRENT_THREAD_PARK_COUNT: AtomicUsize = AtomicUsize::new(0); - } - --impl Parker { -- pub(crate) fn new(driver: Driver) -> Parker { -- let handle = driver.unpark(); -+// ==== impl ParkThread ==== - -- Parker { -+impl ParkThread { -+ pub(crate) fn new() -> Self { -+ Self { - inner: Arc::new(Inner { - state: AtomicUsize::new(EMPTY), - mutex: Mutex::new(()), - condvar: Condvar::new(), -- shared: Arc::new(Shared { -- driver: TryLock::new(driver), -- handle, -- }), - }), - } - } --} - --impl Clone for Parker { -- fn clone(&self) -> Parker { -- Parker { -- inner: Arc::new(Inner { -- state: AtomicUsize::new(EMPTY), -- mutex: Mutex::new(()), -- condvar: Condvar::new(), -- shared: self.inner.shared.clone(), -- }), -- } -+ pub(crate) fn unpark(&self) -> UnparkThread { -+ let inner = self.inner.clone(); -+ UnparkThread { inner } - } --} -- --impl Park for Parker { -- type Unpark = Unparker; -- type Error = (); - -- fn unpark(&self) -> Unparker { -- Unparker { -- inner: self.inner.clone(), -- } -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -+ pub(crate) fn park(&mut self) { -+ #[cfg(loom)] -+ CURRENT_THREAD_PARK_COUNT.with(|count| count.fetch_add(1, SeqCst)); - self.inner.park(); -- Ok(()) - } - -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- // Only parking with zero is supported... -- assert_eq!(duration, Duration::from_millis(0)); -+ pub(crate) fn park_timeout(&mut self, duration: Duration) { -+ #[cfg(loom)] -+ CURRENT_THREAD_PARK_COUNT.with(|count| count.fetch_add(1, SeqCst)); - -- if let Some(mut driver) = self.inner.shared.driver.try_lock() { -- driver.park_timeout(duration).map_err(|_| ()) -- } else { -- Ok(()) -- } -+ // Wasm doesn't have threads, so just sleep. -+ #[cfg(not(tokio_wasm))] -+ self.inner.park_timeout(duration); -+ #[cfg(tokio_wasm)] -+ std::thread::sleep(duration); - } - -- fn shutdown(&mut self) { -+ pub(crate) fn shutdown(&mut self) { - self.inner.shutdown(); - } - } - --impl Unpark for Unparker { -- fn unpark(&self) { -- self.inner.unpark(); -- } --} -+// ==== impl Inner ==== - - impl Inner { - /// Parks the current thread for at most `dur`. - fn park(&self) { -- for _ in 0..3 { -- // If we were previously notified then we consume this notification and -- // return quickly. -- if self -- .state -- .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) -- .is_ok() -- { -- return; -- } -- -- thread::yield_now(); -- } -- -- if let Some(mut driver) = self.shared.driver.try_lock() { -- self.park_driver(&mut driver); -- } else { -- self.park_condvar(); -+ // If we were previously notified then we consume this notification and -+ // return quickly. -+ if self -+ .state -+ .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) -+ .is_ok() -+ { -+ return; - } -- } - -- fn park_condvar(&self) { - // Otherwise we need to coordinate going to sleep - let mut m = self.mutex.lock(); - -- match self -- .state -- .compare_exchange(EMPTY, PARKED_CONDVAR, SeqCst, SeqCst) -- { -+ match self.state.compare_exchange(EMPTY, PARKED, SeqCst, SeqCst) { - Ok(_) => {} - Err(NOTIFIED) => { - // We must read here, even though we know it will be `NOTIFIED`. -@@ -180,33 +129,44 @@ impl Inner { - } - } - -- fn park_driver(&self, driver: &mut Driver) { -- match self -+ fn park_timeout(&self, dur: Duration) { -+ // Like `park` above we have a fast path for an already-notified thread, -+ // and afterwards we start coordinating for a sleep. Return quickly. -+ if self - .state -- .compare_exchange(EMPTY, PARKED_DRIVER, SeqCst, SeqCst) -+ .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) -+ .is_ok() - { -+ return; -+ } -+ -+ if dur == Duration::from_millis(0) { -+ return; -+ } -+ -+ let m = self.mutex.lock(); -+ -+ match self.state.compare_exchange(EMPTY, PARKED, SeqCst, SeqCst) { - Ok(_) => {} - Err(NOTIFIED) => { -- // We must read here, even though we know it will be `NOTIFIED`. -- // This is because `unpark` may have been called again since we read -- // `NOTIFIED` in the `compare_exchange` above. We must perform an -- // acquire operation that synchronizes with that `unpark` to observe -- // any writes it made before the call to unpark. To do that we must -- // read from the write it made to `state`. -+ // We must read again here, see `park`. - let old = self.state.swap(EMPTY, SeqCst); - debug_assert_eq!(old, NOTIFIED, "park state changed unexpectedly"); - - return; - } -- Err(actual) => panic!("inconsistent park state; actual = {}", actual), -+ Err(actual) => panic!("inconsistent park_timeout state; actual = {}", actual), - } - -- // TODO: don't unwrap -- driver.park().unwrap(); -+ // Wait with a timeout, and if we spuriously wake up or otherwise wake up -+ // from a notification, we just want to unconditionally set the state back to -+ // empty, either consuming a notification or un-flagging ourselves as -+ // parked. -+ let (_m, _result) = self.condvar.wait_timeout(m, dur).unwrap(); - - match self.state.swap(EMPTY, SeqCst) { -- NOTIFIED => {} // got a notification, hurray! -- PARKED_DRIVER => {} // no notification, alas -+ NOTIFIED => {} // got a notification, hurray! -+ PARKED => {} // no notification, alas - n => panic!("inconsistent park_timeout state: {}", n), - } - } -@@ -218,15 +178,12 @@ impl Inner { - // is already `NOTIFIED`. That is why this must be a swap rather than a - // compare-and-swap that returns if it reads `NOTIFIED` on failure. - match self.state.swap(NOTIFIED, SeqCst) { -- EMPTY => {} // no one was waiting -- NOTIFIED => {} // already unparked -- PARKED_CONDVAR => self.unpark_condvar(), -- PARKED_DRIVER => self.unpark_driver(), -- actual => panic!("inconsistent state in unpark; actual = {}", actual), -+ EMPTY => return, // no one was waiting -+ NOTIFIED => return, // already unparked -+ PARKED => {} // gotta go wake someone up -+ _ => panic!("inconsistent state in unpark"), - } -- } - -- fn unpark_condvar(&self) { - // There is a period between when the parked thread sets `state` to - // `PARKED` (or last checked `state` in the case of a spurious wake - // up) and when it actually waits on `cvar`. If we were to notify -@@ -243,15 +200,154 @@ impl Inner { - self.condvar.notify_one() - } - -- fn unpark_driver(&self) { -- self.shared.handle.unpark(); -+ fn shutdown(&self) { -+ self.condvar.notify_all(); - } -+} - -- fn shutdown(&self) { -- if let Some(mut driver) = self.shared.driver.try_lock() { -- driver.shutdown(); -+impl Default for ParkThread { -+ fn default() -> Self { -+ Self::new() -+ } -+} -+ -+// ===== impl UnparkThread ===== -+ -+impl UnparkThread { -+ pub(crate) fn unpark(&self) { -+ self.inner.unpark(); -+ } -+} -+ -+use crate::loom::thread::AccessError; -+use std::future::Future; -+use std::marker::PhantomData; -+use std::mem; -+use std::rc::Rc; -+use std::task::{RawWaker, RawWakerVTable, Waker}; -+ -+/// Blocks the current thread using a condition variable. -+#[derive(Debug)] -+pub(crate) struct CachedParkThread { -+ _anchor: PhantomData>, -+} -+ -+impl CachedParkThread { -+ /// Creates a new `ParkThread` handle for the current thread. -+ /// -+ /// This type cannot be moved to other threads, so it should be created on -+ /// the thread that the caller intends to park. -+ pub(crate) fn new() -> CachedParkThread { -+ CachedParkThread { -+ _anchor: PhantomData, - } -+ } - -- self.condvar.notify_all(); -+ pub(crate) fn waker(&self) -> Result { -+ self.unpark().map(|unpark| unpark.into_waker()) -+ } -+ -+ fn unpark(&self) -> Result { -+ self.with_current(|park_thread| park_thread.unpark()) -+ } -+ -+ pub(crate) fn park(&mut self) { -+ self.with_current(|park_thread| park_thread.inner.park()) -+ .unwrap(); -+ } -+ -+ pub(crate) fn park_timeout(&mut self, duration: Duration) { -+ self.with_current(|park_thread| park_thread.inner.park_timeout(duration)) -+ .unwrap(); -+ } -+ -+ /// Gets a reference to the `ParkThread` handle for this thread. -+ fn with_current(&self, f: F) -> Result -+ where -+ F: FnOnce(&ParkThread) -> R, -+ { -+ CURRENT_PARKER.try_with(|inner| f(inner)) -+ } -+ -+ pub(crate) fn block_on(&mut self, f: F) -> Result { -+ use std::task::Context; -+ use std::task::Poll::Ready; -+ -+ // `get_unpark()` should not return a Result -+ let waker = self.waker()?; -+ let mut cx = Context::from_waker(&waker); -+ -+ pin!(f); -+ -+ loop { -+ if let Ready(v) = crate::runtime::coop::budget(|| f.as_mut().poll(&mut cx)) { -+ return Ok(v); -+ } -+ -+ // Wake any yielded tasks before parking in order to avoid -+ // blocking. -+ #[cfg(feature = "rt")] -+ crate::runtime::context::with_defer(|defer| defer.wake()); -+ -+ self.park(); -+ } -+ } -+} -+ -+impl UnparkThread { -+ pub(crate) fn into_waker(self) -> Waker { -+ unsafe { -+ let raw = unparker_to_raw_waker(self.inner); -+ Waker::from_raw(raw) -+ } -+ } -+} -+ -+impl Inner { -+ #[allow(clippy::wrong_self_convention)] -+ fn into_raw(this: Arc) -> *const () { -+ Arc::into_raw(this) as *const () - } -+ -+ unsafe fn from_raw(ptr: *const ()) -> Arc { -+ Arc::from_raw(ptr as *const Inner) -+ } -+} -+ -+unsafe fn unparker_to_raw_waker(unparker: Arc) -> RawWaker { -+ RawWaker::new( -+ Inner::into_raw(unparker), -+ &RawWakerVTable::new(clone, wake, wake_by_ref, drop_waker), -+ ) -+} -+ -+unsafe fn clone(raw: *const ()) -> RawWaker { -+ let unparker = Inner::from_raw(raw); -+ -+ // Increment the ref count -+ mem::forget(unparker.clone()); -+ -+ unparker_to_raw_waker(unparker) -+} -+ -+unsafe fn drop_waker(raw: *const ()) { -+ let _ = Inner::from_raw(raw); -+} -+ -+unsafe fn wake(raw: *const ()) { -+ let unparker = Inner::from_raw(raw); -+ unparker.unpark(); -+} -+ -+unsafe fn wake_by_ref(raw: *const ()) { -+ let unparker = Inner::from_raw(raw); -+ unparker.unpark(); -+ -+ // We don't actually own a reference to the unparker -+ mem::forget(unparker); -+} -+ -+#[cfg(loom)] -+pub(crate) fn current_thread_park_count() -> usize { -+ CURRENT_THREAD_PARK_COUNT.with(|count| count.load(SeqCst)) - } -diff --git a/KubeOS-Rust/vendor/tokio/src/process/unix/driver.rs b/KubeOS-Rust/vendor/tokio/src/runtime/process.rs -similarity index 55% -rename from KubeOS-Rust/vendor/tokio/src/process/unix/driver.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/process.rs -index 84dc8fbd..df339b0e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/process/unix/driver.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/process.rs -@@ -2,11 +2,10 @@ - - //! Process driver. - --use crate::park::Park; - use crate::process::unix::GlobalOrphanQueue; --use crate::signal::unix::driver::{Driver as SignalDriver, Handle as SignalHandle}; -+use crate::runtime::driver; -+use crate::runtime::signal::{Driver as SignalDriver, Handle as SignalHandle}; - --use std::io; - use std::time::Duration; - - /// Responsible for cleaning up orphaned child processes on Unix platforms. -@@ -28,31 +27,18 @@ impl Driver { - signal_handle, - } - } --} -- --// ===== impl Park for Driver ===== -- --impl Park for Driver { -- type Unpark = ::Unpark; -- type Error = io::Error; -- -- fn unpark(&self) -> Self::Unpark { -- self.park.unpark() -- } - -- fn park(&mut self) -> Result<(), Self::Error> { -- self.park.park()?; -+ pub(crate) fn park(&mut self, handle: &driver::Handle) { -+ self.park.park(handle); - GlobalOrphanQueue::reap_orphans(&self.signal_handle); -- Ok(()) - } - -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- self.park.park_timeout(duration)?; -+ pub(crate) fn park_timeout(&mut self, handle: &driver::Handle, duration: Duration) { -+ self.park.park_timeout(handle, duration); - GlobalOrphanQueue::reap_orphans(&self.signal_handle); -- Ok(()) - } - -- fn shutdown(&mut self) { -- self.park.shutdown() -+ pub(crate) fn shutdown(&mut self, handle: &driver::Handle) { -+ self.park.shutdown(handle) - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/runtime.rs b/KubeOS-Rust/vendor/tokio/src/runtime/runtime.rs -new file mode 100644 -index 00000000..60c3fc77 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/runtime.rs -@@ -0,0 +1,436 @@ -+use crate::runtime::blocking::BlockingPool; -+use crate::runtime::scheduler::CurrentThread; -+use crate::runtime::{context, EnterGuard, Handle}; -+use crate::task::JoinHandle; -+ -+use std::future::Future; -+use std::time::Duration; -+ -+cfg_rt_multi_thread! { -+ use crate::runtime::Builder; -+ use crate::runtime::scheduler::MultiThread; -+} -+ -+/// The Tokio runtime. -+/// -+/// The runtime provides an I/O driver, task scheduler, [timer], and -+/// blocking pool, necessary for running asynchronous tasks. -+/// -+/// Instances of `Runtime` can be created using [`new`], or [`Builder`]. -+/// However, most users will use the `#[tokio::main]` annotation on their -+/// entry point instead. -+/// -+/// See [module level][mod] documentation for more details. -+/// -+/// # Shutdown -+/// -+/// Shutting down the runtime is done by dropping the value, or calling -+/// [`Runtime::shutdown_background`] or [`Runtime::shutdown_timeout`]. -+/// -+/// Tasks spawned through [`Runtime::spawn`] keep running until they yield. -+/// Then they are dropped. They are not *guaranteed* to run to completion, but -+/// *might* do so if they do not yield until completion. -+/// -+/// Blocking functions spawned through [`Runtime::spawn_blocking`] keep running -+/// until they return. -+/// -+/// The thread initiating the shutdown blocks until all spawned work has been -+/// stopped. This can take an indefinite amount of time. The `Drop` -+/// implementation waits forever for this. -+/// -+/// `shutdown_background` and `shutdown_timeout` can be used if waiting forever -+/// is undesired. When the timeout is reached, spawned work that did not stop -+/// in time and threads running it are leaked. The work continues to run until -+/// one of the stopping conditions is fulfilled, but the thread initiating the -+/// shutdown is unblocked. -+/// -+/// Once the runtime has been dropped, any outstanding I/O resources bound to -+/// it will no longer function. Calling any method on them will result in an -+/// error. -+/// -+/// # Sharing -+/// -+/// The Tokio runtime implements `Sync` and `Send` to allow you to wrap it -+/// in a `Arc`. Most fn take `&self` to allow you to call them concurrently -+/// across multiple threads. -+/// -+/// Calls to `shutdown` and `shutdown_timeout` require exclusive ownership of -+/// the runtime type and this can be achieved via `Arc::try_unwrap` when only -+/// one strong count reference is left over. -+/// -+/// [timer]: crate::time -+/// [mod]: index.html -+/// [`new`]: method@Self::new -+/// [`Builder`]: struct@Builder -+#[derive(Debug)] -+pub struct Runtime { -+ /// Task scheduler -+ scheduler: Scheduler, -+ -+ /// Handle to runtime, also contains driver handles -+ handle: Handle, -+ -+ /// Blocking pool handle, used to signal shutdown -+ blocking_pool: BlockingPool, -+} -+ -+/// The flavor of a `Runtime`. -+/// -+/// This is the return type for [`Handle::runtime_flavor`](crate::runtime::Handle::runtime_flavor()). -+#[derive(Debug, PartialEq, Eq)] -+#[non_exhaustive] -+pub enum RuntimeFlavor { -+ /// The flavor that executes all tasks on the current thread. -+ CurrentThread, -+ /// The flavor that executes tasks across multiple threads. -+ MultiThread, -+} -+ -+/// The runtime scheduler is either a multi-thread or a current-thread executor. -+#[derive(Debug)] -+pub(super) enum Scheduler { -+ /// Execute all tasks on the current-thread. -+ CurrentThread(CurrentThread), -+ -+ /// Execute tasks across multiple threads. -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ MultiThread(MultiThread), -+} -+ -+impl Runtime { -+ pub(super) fn from_parts( -+ scheduler: Scheduler, -+ handle: Handle, -+ blocking_pool: BlockingPool, -+ ) -> Runtime { -+ Runtime { -+ scheduler, -+ handle, -+ blocking_pool, -+ } -+ } -+ -+ cfg_not_wasi! { -+ /// Creates a new runtime instance with default configuration values. -+ /// -+ /// This results in the multi threaded scheduler, I/O driver, and time driver being -+ /// initialized. -+ /// -+ /// Most applications will not need to call this function directly. Instead, -+ /// they will use the [`#[tokio::main]` attribute][main]. When a more complex -+ /// configuration is necessary, the [runtime builder] may be used. -+ /// -+ /// See [module level][mod] documentation for more details. -+ /// -+ /// # Examples -+ /// -+ /// Creating a new `Runtime` with default configuration values. -+ /// -+ /// ``` -+ /// use tokio::runtime::Runtime; -+ /// -+ /// let rt = Runtime::new() -+ /// .unwrap(); -+ /// -+ /// // Use the runtime... -+ /// ``` -+ /// -+ /// [mod]: index.html -+ /// [main]: ../attr.main.html -+ /// [threaded scheduler]: index.html#threaded-scheduler -+ /// [runtime builder]: crate::runtime::Builder -+ #[cfg(feature = "rt-multi-thread")] -+ #[cfg_attr(docsrs, doc(cfg(feature = "rt-multi-thread")))] -+ pub fn new() -> std::io::Result { -+ Builder::new_multi_thread().enable_all().build() -+ } -+ } -+ -+ /// Returns a handle to the runtime's spawner. -+ /// -+ /// The returned handle can be used to spawn tasks that run on this runtime, and can -+ /// be cloned to allow moving the `Handle` to other threads. -+ /// -+ /// Calling [`Handle::block_on`] on a handle to a `current_thread` runtime is error-prone. -+ /// Refer to the documentation of [`Handle::block_on`] for more. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Runtime; -+ /// -+ /// let rt = Runtime::new() -+ /// .unwrap(); -+ /// -+ /// let handle = rt.handle(); -+ /// -+ /// // Use the handle... -+ /// ``` -+ pub fn handle(&self) -> &Handle { -+ &self.handle -+ } -+ -+ /// Spawns a future onto the Tokio runtime. -+ /// -+ /// This spawns the given future onto the runtime's executor, usually a -+ /// thread pool. The thread pool is then responsible for polling the future -+ /// until it completes. -+ /// -+ /// The provided future will start running in the background immediately -+ /// when `spawn` is called, even if you don't await the returned -+ /// `JoinHandle`. -+ /// -+ /// See [module level][mod] documentation for more details. -+ /// -+ /// [mod]: index.html -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Runtime; -+ /// -+ /// # fn dox() { -+ /// // Create the runtime -+ /// let rt = Runtime::new().unwrap(); -+ /// -+ /// // Spawn a future onto the runtime -+ /// rt.spawn(async { -+ /// println!("now running on a worker thread"); -+ /// }); -+ /// # } -+ /// ``` -+ #[track_caller] -+ pub fn spawn(&self, future: F) -> JoinHandle -+ where -+ F: Future + Send + 'static, -+ F::Output: Send + 'static, -+ { -+ self.handle.spawn(future) -+ } -+ -+ /// Runs the provided function on an executor dedicated to blocking operations. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Runtime; -+ /// -+ /// # fn dox() { -+ /// // Create the runtime -+ /// let rt = Runtime::new().unwrap(); -+ /// -+ /// // Spawn a blocking function onto the runtime -+ /// rt.spawn_blocking(|| { -+ /// println!("now running on a worker thread"); -+ /// }); -+ /// # } -+ #[track_caller] -+ pub fn spawn_blocking(&self, func: F) -> JoinHandle -+ where -+ F: FnOnce() -> R + Send + 'static, -+ R: Send + 'static, -+ { -+ self.handle.spawn_blocking(func) -+ } -+ -+ /// Runs a future to completion on the Tokio runtime. This is the -+ /// runtime's entry point. -+ /// -+ /// This runs the given future on the current thread, blocking until it is -+ /// complete, and yielding its resolved result. Any tasks or timers -+ /// which the future spawns internally will be executed on the runtime. -+ /// -+ /// # Non-worker future -+ /// -+ /// Note that the future required by this function does not run as a -+ /// worker. The expectation is that other tasks are spawned by the future here. -+ /// Awaiting on other futures from the future provided here will not -+ /// perform as fast as those spawned as workers. -+ /// -+ /// # Multi thread scheduler -+ /// -+ /// When the multi thread scheduler is used this will allow futures -+ /// to run within the io driver and timer context of the overall runtime. -+ /// -+ /// Any spawned tasks will continue running after `block_on` returns. -+ /// -+ /// # Current thread scheduler -+ /// -+ /// When the current thread scheduler is enabled `block_on` -+ /// can be called concurrently from multiple threads. The first call -+ /// will take ownership of the io and timer drivers. This means -+ /// other threads which do not own the drivers will hook into that one. -+ /// When the first `block_on` completes, other threads will be able to -+ /// "steal" the driver to allow continued execution of their futures. -+ /// -+ /// Any spawned tasks will be suspended after `block_on` returns. Calling -+ /// `block_on` again will resume previously spawned tasks. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if the provided future panics, or if called within an -+ /// asynchronous execution context. -+ /// -+ /// # Examples -+ /// -+ /// ```no_run -+ /// use tokio::runtime::Runtime; -+ /// -+ /// // Create the runtime -+ /// let rt = Runtime::new().unwrap(); -+ /// -+ /// // Execute the future, blocking the current thread until completion -+ /// rt.block_on(async { -+ /// println!("hello"); -+ /// }); -+ /// ``` -+ /// -+ /// [handle]: fn@Handle::block_on -+ #[track_caller] -+ pub fn block_on(&self, future: F) -> F::Output { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let future = crate::util::trace::task( -+ future, -+ "block_on", -+ None, -+ crate::runtime::task::Id::next().as_u64(), -+ ); -+ -+ let _enter = self.enter(); -+ -+ match &self.scheduler { -+ Scheduler::CurrentThread(exec) => exec.block_on(&self.handle.inner, future), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Scheduler::MultiThread(exec) => exec.block_on(&self.handle.inner, future), -+ } -+ } -+ -+ /// Enters the runtime context. -+ /// -+ /// This allows you to construct types that must have an executor -+ /// available on creation such as [`Sleep`] or [`TcpStream`]. It will -+ /// also allow you to call methods such as [`tokio::spawn`]. -+ /// -+ /// [`Sleep`]: struct@crate::time::Sleep -+ /// [`TcpStream`]: struct@crate::net::TcpStream -+ /// [`tokio::spawn`]: fn@crate::spawn -+ /// -+ /// # Example -+ /// -+ /// ``` -+ /// use tokio::runtime::Runtime; -+ /// -+ /// fn function_that_spawns(msg: String) { -+ /// // Had we not used `rt.enter` below, this would panic. -+ /// tokio::spawn(async move { -+ /// println!("{}", msg); -+ /// }); -+ /// } -+ /// -+ /// fn main() { -+ /// let rt = Runtime::new().unwrap(); -+ /// -+ /// let s = "Hello World!".to_string(); -+ /// -+ /// // By entering the context, we tie `tokio::spawn` to this executor. -+ /// let _guard = rt.enter(); -+ /// function_that_spawns(s); -+ /// } -+ /// ``` -+ pub fn enter(&self) -> EnterGuard<'_> { -+ self.handle.enter() -+ } -+ -+ /// Shuts down the runtime, waiting for at most `duration` for all spawned -+ /// work to stop. -+ /// -+ /// See the [struct level documentation](Runtime#shutdown) for more details. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::runtime::Runtime; -+ /// use tokio::task; -+ /// -+ /// use std::thread; -+ /// use std::time::Duration; -+ /// -+ /// fn main() { -+ /// let runtime = Runtime::new().unwrap(); -+ /// -+ /// runtime.block_on(async move { -+ /// task::spawn_blocking(move || { -+ /// thread::sleep(Duration::from_secs(10_000)); -+ /// }); -+ /// }); -+ /// -+ /// runtime.shutdown_timeout(Duration::from_millis(100)); -+ /// } -+ /// ``` -+ pub fn shutdown_timeout(mut self, duration: Duration) { -+ // Wakeup and shutdown all the worker threads -+ self.handle.inner.shutdown(); -+ self.blocking_pool.shutdown(Some(duration)); -+ } -+ -+ /// Shuts down the runtime, without waiting for any spawned work to stop. -+ /// -+ /// This can be useful if you want to drop a runtime from within another runtime. -+ /// Normally, dropping a runtime will block indefinitely for spawned blocking tasks -+ /// to complete, which would normally not be permitted within an asynchronous context. -+ /// By calling `shutdown_background()`, you can drop the runtime from such a context. -+ /// -+ /// Note however, that because we do not wait for any blocking tasks to complete, this -+ /// may result in a resource leak (in that any blocking tasks are still running until they -+ /// return. -+ /// -+ /// See the [struct level documentation](Runtime#shutdown) for more details. -+ /// -+ /// This function is equivalent to calling `shutdown_timeout(Duration::from_nanos(0))`. -+ /// -+ /// ``` -+ /// use tokio::runtime::Runtime; -+ /// -+ /// fn main() { -+ /// let runtime = Runtime::new().unwrap(); -+ /// -+ /// runtime.block_on(async move { -+ /// let inner_runtime = Runtime::new().unwrap(); -+ /// // ... -+ /// inner_runtime.shutdown_background(); -+ /// }); -+ /// } -+ /// ``` -+ pub fn shutdown_background(self) { -+ self.shutdown_timeout(Duration::from_nanos(0)) -+ } -+} -+ -+#[allow(clippy::single_match)] // there are comments in the error branch, so we don't want if-let -+impl Drop for Runtime { -+ fn drop(&mut self) { -+ match &mut self.scheduler { -+ Scheduler::CurrentThread(current_thread) => { -+ // This ensures that tasks spawned on the current-thread -+ // runtime are dropped inside the runtime's context. -+ let _guard = context::try_set_current(&self.handle.inner); -+ current_thread.shutdown(&self.handle.inner); -+ } -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Scheduler::MultiThread(multi_thread) => { -+ // The threaded scheduler drops its tasks on its worker threads, which is -+ // already in the runtime's context. -+ multi_thread.shutdown(&self.handle.inner); -+ } -+ } -+ } -+} -+ -+cfg_metrics! { -+ impl Runtime { -+ /// TODO -+ pub fn metrics(&self) -> crate::runtime::RuntimeMetrics { -+ self.handle.metrics() -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/current_thread.rs b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/current_thread.rs -new file mode 100644 -index 00000000..375e47c4 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/current_thread.rs -@@ -0,0 +1,634 @@ -+use crate::future::poll_fn; -+use crate::loom::sync::atomic::AtomicBool; -+use crate::loom::sync::{Arc, Mutex}; -+use crate::runtime::driver::{self, Driver}; -+use crate::runtime::task::{self, JoinHandle, OwnedTasks, Schedule, Task}; -+use crate::runtime::{blocking, context, scheduler, Config}; -+use crate::runtime::{MetricsBatch, SchedulerMetrics, WorkerMetrics}; -+use crate::sync::notify::Notify; -+use crate::util::atomic_cell::AtomicCell; -+use crate::util::{waker_ref, RngSeedGenerator, Wake, WakerRef}; -+ -+use std::cell::RefCell; -+use std::collections::VecDeque; -+use std::fmt; -+use std::future::Future; -+use std::sync::atomic::Ordering::{AcqRel, Release}; -+use std::task::Poll::{Pending, Ready}; -+use std::time::Duration; -+ -+/// Executes tasks on the current thread -+pub(crate) struct CurrentThread { -+ /// Core scheduler data is acquired by a thread entering `block_on`. -+ core: AtomicCell, -+ -+ /// Notifier for waking up other threads to steal the -+ /// driver. -+ notify: Notify, -+} -+ -+/// Handle to the current thread scheduler -+pub(crate) struct Handle { -+ /// Scheduler state shared across threads -+ shared: Shared, -+ -+ /// Resource driver handles -+ pub(crate) driver: driver::Handle, -+ -+ /// Blocking pool spawner -+ pub(crate) blocking_spawner: blocking::Spawner, -+ -+ /// Current random number generator seed -+ pub(crate) seed_generator: RngSeedGenerator, -+} -+ -+/// Data required for executing the scheduler. The struct is passed around to -+/// a function that will perform the scheduling work and acts as a capability token. -+struct Core { -+ /// Scheduler run queue -+ tasks: VecDeque>>, -+ -+ /// Current tick -+ tick: u32, -+ -+ /// Runtime driver -+ /// -+ /// The driver is removed before starting to park the thread -+ driver: Option, -+ -+ /// Metrics batch -+ metrics: MetricsBatch, -+ -+ /// True if a task panicked without being handled and the runtime is -+ /// configured to shutdown on unhandled panic. -+ unhandled_panic: bool, -+} -+ -+/// Scheduler state shared between threads. -+struct Shared { -+ /// Remote run queue. None if the `Runtime` has been dropped. -+ queue: Mutex>>>>, -+ -+ /// Collection of all active tasks spawned onto this executor. -+ owned: OwnedTasks>, -+ -+ /// Indicates whether the blocked on thread was woken. -+ woken: AtomicBool, -+ -+ /// Scheduler configuration options -+ config: Config, -+ -+ /// Keeps track of various runtime metrics. -+ scheduler_metrics: SchedulerMetrics, -+ -+ /// This scheduler only has one worker. -+ worker_metrics: WorkerMetrics, -+} -+ -+/// Thread-local context. -+struct Context { -+ /// Scheduler handle -+ handle: Arc, -+ -+ /// Scheduler core, enabling the holder of `Context` to execute the -+ /// scheduler. -+ core: RefCell>>, -+} -+ -+/// Initial queue capacity. -+const INITIAL_CAPACITY: usize = 64; -+ -+// Tracks the current CurrentThread. -+scoped_thread_local!(static CURRENT: Context); -+ -+impl CurrentThread { -+ pub(crate) fn new( -+ driver: Driver, -+ driver_handle: driver::Handle, -+ blocking_spawner: blocking::Spawner, -+ seed_generator: RngSeedGenerator, -+ config: Config, -+ ) -> (CurrentThread, Arc) { -+ let handle = Arc::new(Handle { -+ shared: Shared { -+ queue: Mutex::new(Some(VecDeque::with_capacity(INITIAL_CAPACITY))), -+ owned: OwnedTasks::new(), -+ woken: AtomicBool::new(false), -+ config, -+ scheduler_metrics: SchedulerMetrics::new(), -+ worker_metrics: WorkerMetrics::new(), -+ }, -+ driver: driver_handle, -+ blocking_spawner, -+ seed_generator, -+ }); -+ -+ let core = AtomicCell::new(Some(Box::new(Core { -+ tasks: VecDeque::with_capacity(INITIAL_CAPACITY), -+ tick: 0, -+ driver: Some(driver), -+ metrics: MetricsBatch::new(), -+ unhandled_panic: false, -+ }))); -+ -+ let scheduler = CurrentThread { -+ core, -+ notify: Notify::new(), -+ }; -+ -+ (scheduler, handle) -+ } -+ -+ #[track_caller] -+ pub(crate) fn block_on(&self, handle: &scheduler::Handle, future: F) -> F::Output { -+ pin!(future); -+ -+ let mut enter = crate::runtime::context::enter_runtime(handle, false); -+ let handle = handle.as_current_thread(); -+ -+ // Attempt to steal the scheduler core and block_on the future if we can -+ // there, otherwise, lets select on a notification that the core is -+ // available or the future is complete. -+ loop { -+ if let Some(core) = self.take_core(handle) { -+ return core.block_on(future); -+ } else { -+ let notified = self.notify.notified(); -+ pin!(notified); -+ -+ if let Some(out) = enter -+ .blocking -+ .block_on(poll_fn(|cx| { -+ if notified.as_mut().poll(cx).is_ready() { -+ return Ready(None); -+ } -+ -+ if let Ready(out) = future.as_mut().poll(cx) { -+ return Ready(Some(out)); -+ } -+ -+ Pending -+ })) -+ .expect("Failed to `Enter::block_on`") -+ { -+ return out; -+ } -+ } -+ } -+ } -+ -+ fn take_core(&self, handle: &Arc) -> Option> { -+ let core = self.core.take()?; -+ -+ Some(CoreGuard { -+ context: Context { -+ handle: handle.clone(), -+ core: RefCell::new(Some(core)), -+ }, -+ scheduler: self, -+ }) -+ } -+ -+ pub(crate) fn shutdown(&mut self, handle: &scheduler::Handle) { -+ let handle = handle.as_current_thread(); -+ -+ // Avoid a double panic if we are currently panicking and -+ // the lock may be poisoned. -+ -+ let core = match self.take_core(handle) { -+ Some(core) => core, -+ None if std::thread::panicking() => return, -+ None => panic!("Oh no! We never placed the Core back, this is a bug!"), -+ }; -+ -+ core.enter(|mut core, _context| { -+ // Drain the OwnedTasks collection. This call also closes the -+ // collection, ensuring that no tasks are ever pushed after this -+ // call returns. -+ handle.shared.owned.close_and_shutdown_all(); -+ -+ // Drain local queue -+ // We already shut down every task, so we just need to drop the task. -+ while let Some(task) = core.pop_task(handle) { -+ drop(task); -+ } -+ -+ // Drain remote queue and set it to None -+ let remote_queue = handle.shared.queue.lock().take(); -+ -+ // Using `Option::take` to replace the shared queue with `None`. -+ // We already shut down every task, so we just need to drop the task. -+ if let Some(remote_queue) = remote_queue { -+ for task in remote_queue { -+ drop(task); -+ } -+ } -+ -+ assert!(handle.shared.owned.is_empty()); -+ -+ // Submit metrics -+ core.metrics.submit(&handle.shared.worker_metrics); -+ -+ // Shutdown the resource drivers -+ if let Some(driver) = core.driver.as_mut() { -+ driver.shutdown(&handle.driver); -+ } -+ -+ (core, ()) -+ }); -+ } -+} -+ -+impl fmt::Debug for CurrentThread { -+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt.debug_struct("CurrentThread").finish() -+ } -+} -+ -+// ===== impl Core ===== -+ -+impl Core { -+ fn pop_task(&mut self, handle: &Handle) -> Option>> { -+ let ret = self.tasks.pop_front(); -+ handle -+ .shared -+ .worker_metrics -+ .set_queue_depth(self.tasks.len()); -+ ret -+ } -+ -+ fn push_task(&mut self, handle: &Handle, task: task::Notified>) { -+ self.tasks.push_back(task); -+ self.metrics.inc_local_schedule_count(); -+ handle -+ .shared -+ .worker_metrics -+ .set_queue_depth(self.tasks.len()); -+ } -+} -+ -+fn did_defer_tasks() -> bool { -+ context::with_defer(|deferred| !deferred.is_empty()).unwrap() -+} -+ -+fn wake_deferred_tasks() { -+ context::with_defer(|deferred| deferred.wake()); -+} -+ -+// ===== impl Context ===== -+ -+impl Context { -+ /// Execute the closure with the given scheduler core stored in the -+ /// thread-local context. -+ fn run_task(&self, mut core: Box, f: impl FnOnce() -> R) -> (Box, R) { -+ core.metrics.incr_poll_count(); -+ self.enter(core, || crate::runtime::coop::budget(f)) -+ } -+ -+ /// Blocks the current thread until an event is received by the driver, -+ /// including I/O events, timer events, ... -+ fn park(&self, mut core: Box, handle: &Handle) -> Box { -+ let mut driver = core.driver.take().expect("driver missing"); -+ -+ if let Some(f) = &handle.shared.config.before_park { -+ // Incorrect lint, the closures are actually different types so `f` -+ // cannot be passed as an argument to `enter`. -+ #[allow(clippy::redundant_closure)] -+ let (c, _) = self.enter(core, || f()); -+ core = c; -+ } -+ -+ // This check will fail if `before_park` spawns a task for us to run -+ // instead of parking the thread -+ if core.tasks.is_empty() { -+ // Park until the thread is signaled -+ core.metrics.about_to_park(); -+ core.metrics.submit(&handle.shared.worker_metrics); -+ -+ let (c, _) = self.enter(core, || { -+ driver.park(&handle.driver); -+ wake_deferred_tasks(); -+ }); -+ -+ core = c; -+ core.metrics.returned_from_park(); -+ } -+ -+ if let Some(f) = &handle.shared.config.after_unpark { -+ // Incorrect lint, the closures are actually different types so `f` -+ // cannot be passed as an argument to `enter`. -+ #[allow(clippy::redundant_closure)] -+ let (c, _) = self.enter(core, || f()); -+ core = c; -+ } -+ -+ core.driver = Some(driver); -+ core -+ } -+ -+ /// Checks the driver for new events without blocking the thread. -+ fn park_yield(&self, mut core: Box, handle: &Handle) -> Box { -+ let mut driver = core.driver.take().expect("driver missing"); -+ -+ core.metrics.submit(&handle.shared.worker_metrics); -+ let (mut core, _) = self.enter(core, || { -+ driver.park_timeout(&handle.driver, Duration::from_millis(0)); -+ wake_deferred_tasks(); -+ }); -+ -+ core.driver = Some(driver); -+ core -+ } -+ -+ fn enter(&self, core: Box, f: impl FnOnce() -> R) -> (Box, R) { -+ // Store the scheduler core in the thread-local context -+ // -+ // A drop-guard is employed at a higher level. -+ *self.core.borrow_mut() = Some(core); -+ -+ // Execute the closure while tracking the execution budget -+ let ret = f(); -+ -+ // Take the scheduler core back -+ let core = self.core.borrow_mut().take().expect("core missing"); -+ (core, ret) -+ } -+} -+ -+// ===== impl Handle ===== -+ -+impl Handle { -+ /// Spawns a future onto the `CurrentThread` scheduler -+ pub(crate) fn spawn( -+ me: &Arc, -+ future: F, -+ id: crate::runtime::task::Id, -+ ) -> JoinHandle -+ where -+ F: crate::future::Future + Send + 'static, -+ F::Output: Send + 'static, -+ { -+ let (handle, notified) = me.shared.owned.bind(future, me.clone(), id); -+ -+ if let Some(notified) = notified { -+ me.schedule(notified); -+ } -+ -+ handle -+ } -+ -+ fn pop(&self) -> Option>> { -+ match self.shared.queue.lock().as_mut() { -+ Some(queue) => queue.pop_front(), -+ None => None, -+ } -+ } -+ -+ fn waker_ref(me: &Arc) -> WakerRef<'_> { -+ // Set woken to true when enter block_on, ensure outer future -+ // be polled for the first time when enter loop -+ me.shared.woken.store(true, Release); -+ waker_ref(me) -+ } -+ -+ // reset woken to false and return original value -+ pub(crate) fn reset_woken(&self) -> bool { -+ self.shared.woken.swap(false, AcqRel) -+ } -+} -+ -+cfg_metrics! { -+ impl Handle { -+ pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics { -+ &self.shared.scheduler_metrics -+ } -+ -+ pub(crate) fn injection_queue_depth(&self) -> usize { -+ // TODO: avoid having to lock. The multi-threaded injection queue -+ // could probably be used here. -+ self.shared -+ .queue -+ .lock() -+ .as_ref() -+ .map(|queue| queue.len()) -+ .unwrap_or(0) -+ } -+ -+ pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics { -+ assert_eq!(0, worker); -+ &self.shared.worker_metrics -+ } -+ -+ pub(crate) fn num_blocking_threads(&self) -> usize { -+ self.blocking_spawner.num_threads() -+ } -+ -+ pub(crate) fn num_idle_blocking_threads(&self) -> usize { -+ self.blocking_spawner.num_idle_threads() -+ } -+ -+ pub(crate) fn blocking_queue_depth(&self) -> usize { -+ self.blocking_spawner.queue_depth() -+ } -+ } -+} -+ -+impl fmt::Debug for Handle { -+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt.debug_struct("current_thread::Handle { ... }").finish() -+ } -+} -+ -+// ===== impl Shared ===== -+ -+impl Schedule for Arc { -+ fn release(&self, task: &Task) -> Option> { -+ self.shared.owned.remove(task) -+ } -+ -+ fn schedule(&self, task: task::Notified) { -+ CURRENT.with(|maybe_cx| match maybe_cx { -+ Some(cx) if Arc::ptr_eq(self, &cx.handle) => { -+ let mut core = cx.core.borrow_mut(); -+ -+ // If `None`, the runtime is shutting down, so there is no need -+ // to schedule the task. -+ if let Some(core) = core.as_mut() { -+ core.push_task(self, task); -+ } -+ } -+ _ => { -+ // Track that a task was scheduled from **outside** of the runtime. -+ self.shared.scheduler_metrics.inc_remote_schedule_count(); -+ -+ // If the queue is None, then the runtime has shut down. We -+ // don't need to do anything with the notification in that case. -+ let mut guard = self.shared.queue.lock(); -+ if let Some(queue) = guard.as_mut() { -+ queue.push_back(task); -+ drop(guard); -+ self.driver.unpark(); -+ } -+ } -+ }); -+ } -+ -+ cfg_unstable! { -+ fn unhandled_panic(&self) { -+ use crate::runtime::UnhandledPanic; -+ -+ match self.shared.config.unhandled_panic { -+ UnhandledPanic::Ignore => { -+ // Do nothing -+ } -+ UnhandledPanic::ShutdownRuntime => { -+ // This hook is only called from within the runtime, so -+ // `CURRENT` should match with `&self`, i.e. there is no -+ // opportunity for a nested scheduler to be called. -+ CURRENT.with(|maybe_cx| match maybe_cx { -+ Some(cx) if Arc::ptr_eq(self, &cx.handle) => { -+ let mut core = cx.core.borrow_mut(); -+ -+ // If `None`, the runtime is shutting down, so there is no need to signal shutdown -+ if let Some(core) = core.as_mut() { -+ core.unhandled_panic = true; -+ self.shared.owned.close_and_shutdown_all(); -+ } -+ } -+ _ => unreachable!("runtime core not set in CURRENT thread-local"), -+ }) -+ } -+ } -+ } -+ } -+} -+ -+impl Wake for Handle { -+ fn wake(arc_self: Arc) { -+ Wake::wake_by_ref(&arc_self) -+ } -+ -+ /// Wake by reference -+ fn wake_by_ref(arc_self: &Arc) { -+ arc_self.shared.woken.store(true, Release); -+ arc_self.driver.unpark(); -+ } -+} -+ -+// ===== CoreGuard ===== -+ -+/// Used to ensure we always place the `Core` value back into its slot in -+/// `CurrentThread`, even if the future panics. -+struct CoreGuard<'a> { -+ context: Context, -+ scheduler: &'a CurrentThread, -+} -+ -+impl CoreGuard<'_> { -+ #[track_caller] -+ fn block_on(self, future: F) -> F::Output { -+ let ret = self.enter(|mut core, context| { -+ let waker = Handle::waker_ref(&context.handle); -+ let mut cx = std::task::Context::from_waker(&waker); -+ -+ pin!(future); -+ -+ 'outer: loop { -+ let handle = &context.handle; -+ -+ if handle.reset_woken() { -+ let (c, res) = context.enter(core, || { -+ crate::runtime::coop::budget(|| future.as_mut().poll(&mut cx)) -+ }); -+ -+ core = c; -+ -+ if let Ready(v) = res { -+ return (core, Some(v)); -+ } -+ } -+ -+ for _ in 0..handle.shared.config.event_interval { -+ // Make sure we didn't hit an unhandled_panic -+ if core.unhandled_panic { -+ return (core, None); -+ } -+ -+ // Get and increment the current tick -+ let tick = core.tick; -+ core.tick = core.tick.wrapping_add(1); -+ -+ let entry = if tick % handle.shared.config.global_queue_interval == 0 { -+ handle.pop().or_else(|| core.tasks.pop_front()) -+ } else { -+ core.tasks.pop_front().or_else(|| handle.pop()) -+ }; -+ -+ let task = match entry { -+ Some(entry) => entry, -+ None => { -+ core = if did_defer_tasks() { -+ context.park_yield(core, handle) -+ } else { -+ context.park(core, handle) -+ }; -+ -+ // Try polling the `block_on` future next -+ continue 'outer; -+ } -+ }; -+ -+ let task = context.handle.shared.owned.assert_owner(task); -+ -+ let (c, _) = context.run_task(core, || { -+ task.run(); -+ }); -+ -+ core = c; -+ } -+ -+ // Yield to the driver, this drives the timer and pulls any -+ // pending I/O events. -+ core = context.park_yield(core, handle); -+ } -+ }); -+ -+ match ret { -+ Some(ret) => ret, -+ None => { -+ // `block_on` panicked. -+ panic!("a spawned task panicked and the runtime is configured to shut down on unhandled panic"); -+ } -+ } -+ } -+ -+ /// Enters the scheduler context. This sets the queue and other necessary -+ /// scheduler state in the thread-local. -+ fn enter(self, f: F) -> R -+ where -+ F: FnOnce(Box, &Context) -> (Box, R), -+ { -+ // Remove `core` from `context` to pass into the closure. -+ let core = self.context.core.borrow_mut().take().expect("core missing"); -+ -+ // Call the closure and place `core` back -+ let (core, ret) = CURRENT.set(&self.context, || f(core, &self.context)); -+ -+ *self.context.core.borrow_mut() = Some(core); -+ -+ ret -+ } -+} -+ -+impl Drop for CoreGuard<'_> { -+ fn drop(&mut self) { -+ if let Some(core) = self.context.core.borrow_mut().take() { -+ // Replace old scheduler back into the state to allow -+ // other threads to pick it up and drive it. -+ self.scheduler.core.set(core); -+ -+ // Wake up other possible threads that could steal the driver. -+ self.scheduler.notify.notify_one() -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/mod.rs -new file mode 100644 -index 00000000..f45d8a80 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/mod.rs -@@ -0,0 +1,194 @@ -+cfg_rt! { -+ pub(crate) mod current_thread; -+ pub(crate) use current_thread::CurrentThread; -+} -+ -+cfg_rt_multi_thread! { -+ pub(crate) mod multi_thread; -+ pub(crate) use multi_thread::MultiThread; -+} -+ -+use crate::runtime::driver; -+ -+#[derive(Debug, Clone)] -+pub(crate) enum Handle { -+ #[cfg(feature = "rt")] -+ CurrentThread(Arc), -+ -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ MultiThread(Arc), -+ -+ // TODO: This is to avoid triggering "dead code" warnings many other places -+ // in the codebase. Remove this during a later cleanup -+ #[cfg(not(feature = "rt"))] -+ #[allow(dead_code)] -+ Disabled, -+} -+ -+impl Handle { -+ #[cfg_attr(not(feature = "full"), allow(dead_code))] -+ pub(crate) fn driver(&self) -> &driver::Handle { -+ match *self { -+ #[cfg(feature = "rt")] -+ Handle::CurrentThread(ref h) => &h.driver, -+ -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(ref h) => &h.driver, -+ -+ #[cfg(not(feature = "rt"))] -+ Handle::Disabled => unreachable!(), -+ } -+ } -+} -+ -+cfg_rt! { -+ use crate::future::Future; -+ use crate::loom::sync::Arc; -+ use crate::runtime::{blocking, task::Id}; -+ use crate::runtime::context; -+ use crate::task::JoinHandle; -+ use crate::util::RngSeedGenerator; -+ -+ impl Handle { -+ #[track_caller] -+ pub(crate) fn current() -> Handle { -+ match context::try_current() { -+ Ok(handle) => handle, -+ Err(e) => panic!("{}", e), -+ } -+ } -+ -+ pub(crate) fn blocking_spawner(&self) -> &blocking::Spawner { -+ match self { -+ Handle::CurrentThread(h) => &h.blocking_spawner, -+ -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(h) => &h.blocking_spawner, -+ } -+ } -+ -+ pub(crate) fn spawn(&self, future: F, id: Id) -> JoinHandle -+ where -+ F: Future + Send + 'static, -+ F::Output: Send + 'static, -+ { -+ match self { -+ Handle::CurrentThread(h) => current_thread::Handle::spawn(h, future, id), -+ -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(h) => multi_thread::Handle::spawn(h, future, id), -+ } -+ } -+ -+ pub(crate) fn shutdown(&self) { -+ match *self { -+ Handle::CurrentThread(_) => {}, -+ -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(ref h) => h.shutdown(), -+ } -+ } -+ -+ pub(crate) fn seed_generator(&self) -> &RngSeedGenerator { -+ match self { -+ Handle::CurrentThread(h) => &h.seed_generator, -+ -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(h) => &h.seed_generator, -+ } -+ } -+ -+ pub(crate) fn as_current_thread(&self) -> &Arc { -+ match self { -+ Handle::CurrentThread(handle) => handle, -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ _ => panic!("not a CurrentThread handle"), -+ } -+ } -+ } -+ -+ cfg_metrics! { -+ use crate::runtime::{SchedulerMetrics, WorkerMetrics}; -+ -+ impl Handle { -+ pub(crate) fn num_workers(&self) -> usize { -+ match self { -+ Handle::CurrentThread(_) => 1, -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(handle) => handle.num_workers(), -+ } -+ } -+ -+ pub(crate) fn num_blocking_threads(&self) -> usize { -+ match self { -+ Handle::CurrentThread(handle) => handle.num_blocking_threads(), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(handle) => handle.num_blocking_threads(), -+ } -+ } -+ -+ pub(crate) fn num_idle_blocking_threads(&self) -> usize { -+ match self { -+ Handle::CurrentThread(handle) => handle.num_idle_blocking_threads(), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(handle) => handle.num_idle_blocking_threads(), -+ } -+ } -+ -+ pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics { -+ match self { -+ Handle::CurrentThread(handle) => handle.scheduler_metrics(), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(handle) => handle.scheduler_metrics(), -+ } -+ } -+ -+ pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics { -+ match self { -+ Handle::CurrentThread(handle) => handle.worker_metrics(worker), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(handle) => handle.worker_metrics(worker), -+ } -+ } -+ -+ pub(crate) fn injection_queue_depth(&self) -> usize { -+ match self { -+ Handle::CurrentThread(handle) => handle.injection_queue_depth(), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(handle) => handle.injection_queue_depth(), -+ } -+ } -+ -+ pub(crate) fn worker_local_queue_depth(&self, worker: usize) -> usize { -+ match self { -+ Handle::CurrentThread(handle) => handle.worker_metrics(worker).queue_depth(), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(handle) => handle.worker_local_queue_depth(worker), -+ } -+ } -+ -+ pub(crate) fn blocking_queue_depth(&self) -> usize { -+ match self { -+ Handle::CurrentThread(handle) => handle.blocking_queue_depth(), -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ Handle::MultiThread(handle) => handle.blocking_queue_depth(), -+ } -+ } -+ } -+ } -+} -+ -+cfg_not_rt! { -+ #[cfg(any( -+ feature = "net", -+ all(unix, feature = "process"), -+ all(unix, feature = "signal"), -+ feature = "time", -+ ))] -+ impl Handle { -+ #[track_caller] -+ pub(crate) fn current() -> Handle { -+ panic!("{}", crate::util::error::CONTEXT_MISSING_ERROR) -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/handle.rs b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/handle.rs -new file mode 100644 -index 00000000..69a4620c ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/handle.rs -@@ -0,0 +1,98 @@ -+use crate::future::Future; -+use crate::loom::sync::Arc; -+use crate::runtime::scheduler::multi_thread::worker; -+use crate::runtime::{ -+ blocking, driver, -+ task::{self, JoinHandle}, -+}; -+use crate::util::RngSeedGenerator; -+ -+use std::fmt; -+ -+/// Handle to the multi thread scheduler -+pub(crate) struct Handle { -+ /// Task spawner -+ pub(super) shared: worker::Shared, -+ -+ /// Resource driver handles -+ pub(crate) driver: driver::Handle, -+ -+ /// Blocking pool spawner -+ pub(crate) blocking_spawner: blocking::Spawner, -+ -+ /// Current random number generator seed -+ pub(crate) seed_generator: RngSeedGenerator, -+} -+ -+impl Handle { -+ /// Spawns a future onto the thread pool -+ pub(crate) fn spawn(me: &Arc, future: F, id: task::Id) -> JoinHandle -+ where -+ F: crate::future::Future + Send + 'static, -+ F::Output: Send + 'static, -+ { -+ Self::bind_new_task(me, future, id) -+ } -+ -+ pub(crate) fn shutdown(&self) { -+ self.close(); -+ } -+ -+ pub(super) fn bind_new_task(me: &Arc, future: T, id: task::Id) -> JoinHandle -+ where -+ T: Future + Send + 'static, -+ T::Output: Send + 'static, -+ { -+ let (handle, notified) = me.shared.owned.bind(future, me.clone(), id); -+ -+ if let Some(notified) = notified { -+ me.schedule_task(notified, false); -+ } -+ -+ handle -+ } -+} -+ -+cfg_metrics! { -+ use crate::runtime::{SchedulerMetrics, WorkerMetrics}; -+ -+ impl Handle { -+ pub(crate) fn num_workers(&self) -> usize { -+ self.shared.worker_metrics.len() -+ } -+ -+ pub(crate) fn num_blocking_threads(&self) -> usize { -+ self.blocking_spawner.num_threads() -+ } -+ -+ pub(crate) fn num_idle_blocking_threads(&self) -> usize { -+ self.blocking_spawner.num_idle_threads() -+ } -+ -+ pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics { -+ &self.shared.scheduler_metrics -+ } -+ -+ pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics { -+ &self.shared.worker_metrics[worker] -+ } -+ -+ pub(crate) fn injection_queue_depth(&self) -> usize { -+ self.shared.injection_queue_depth() -+ } -+ -+ pub(crate) fn worker_local_queue_depth(&self, worker: usize) -> usize { -+ self.shared.worker_local_queue_depth(worker) -+ } -+ -+ pub(crate) fn blocking_queue_depth(&self) -> usize { -+ self.blocking_spawner.queue_depth() -+ } -+ } -+} -+ -+impl fmt::Debug for Handle { -+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt.debug_struct("multi_thread::Handle { ... }").finish() -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/idle.rs b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/idle.rs -similarity index 93% -rename from KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/idle.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/idle.rs -index 6b7ee128..a57bf6a0 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/idle.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/idle.rs -@@ -64,7 +64,7 @@ impl Idle { - - // A worker should be woken up, atomically increment the number of - // searching workers as well as the number of unparked workers. -- State::unpark_one(&self.state); -+ State::unpark_one(&self.state, 1); - - // Get the worker to unpark - let ret = sleepers.pop(); -@@ -111,7 +111,9 @@ impl Idle { - - /// Unpark a specific worker. This happens if tasks are submitted from - /// within the worker's park routine. -- pub(super) fn unpark_worker_by_id(&self, worker_id: usize) { -+ /// -+ /// Returns `true` if the worker was parked before calling the method. -+ pub(super) fn unpark_worker_by_id(&self, worker_id: usize) -> bool { - let mut sleepers = self.sleepers.lock(); - - for index in 0..sleepers.len() { -@@ -119,11 +121,13 @@ impl Idle { - sleepers.swap_remove(index); - - // Update the state accordingly while the lock is held. -- State::unpark_one(&self.state); -+ State::unpark_one(&self.state, 0); - -- return; -+ return true; - } - } -+ -+ false - } - - /// Returns `true` if `worker_id` is contained in the sleep set. -@@ -151,8 +155,8 @@ impl State { - State(cell.load(ordering)) - } - -- fn unpark_one(cell: &AtomicUsize) { -- cell.fetch_add(1 | (1 << UNPARK_SHIFT), SeqCst); -+ fn unpark_one(cell: &AtomicUsize, num_searching: usize) { -+ cell.fetch_add(num_searching | (1 << UNPARK_SHIFT), SeqCst); - } - - fn inc_num_searching(cell: &AtomicUsize, ordering: Ordering) { -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/mod.rs -new file mode 100644 -index 00000000..47cd1f3d ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/mod.rs -@@ -0,0 +1,84 @@ -+//! Multi-threaded runtime -+ -+mod handle; -+pub(crate) use handle::Handle; -+ -+mod idle; -+use self::idle::Idle; -+ -+mod park; -+pub(crate) use park::{Parker, Unparker}; -+ -+pub(crate) mod queue; -+ -+mod worker; -+pub(crate) use worker::Launch; -+ -+pub(crate) use worker::block_in_place; -+ -+use crate::loom::sync::Arc; -+use crate::runtime::{ -+ blocking, -+ driver::{self, Driver}, -+ scheduler, Config, -+}; -+use crate::util::RngSeedGenerator; -+ -+use std::fmt; -+use std::future::Future; -+ -+/// Work-stealing based thread pool for executing futures. -+pub(crate) struct MultiThread; -+ -+// ===== impl MultiThread ===== -+ -+impl MultiThread { -+ pub(crate) fn new( -+ size: usize, -+ driver: Driver, -+ driver_handle: driver::Handle, -+ blocking_spawner: blocking::Spawner, -+ seed_generator: RngSeedGenerator, -+ config: Config, -+ ) -> (MultiThread, Arc, Launch) { -+ let parker = Parker::new(driver); -+ let (handle, launch) = worker::create( -+ size, -+ parker, -+ driver_handle, -+ blocking_spawner, -+ seed_generator, -+ config, -+ ); -+ -+ (MultiThread, handle, launch) -+ } -+ -+ /// Blocks the current thread waiting for the future to complete. -+ /// -+ /// The future will execute on the current thread, but all spawned tasks -+ /// will be executed on the thread pool. -+ pub(crate) fn block_on(&self, handle: &scheduler::Handle, future: F) -> F::Output -+ where -+ F: Future, -+ { -+ let mut enter = crate::runtime::context::enter_runtime(handle, true); -+ enter -+ .blocking -+ .block_on(future) -+ .expect("failed to park thread") -+ } -+ -+ pub(crate) fn shutdown(&mut self, handle: &scheduler::Handle) { -+ match handle { -+ scheduler::Handle::MultiThread(handle) => handle.shutdown(), -+ _ => panic!("expected MultiThread scheduler"), -+ } -+ } -+} -+ -+impl fmt::Debug for MultiThread { -+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt.debug_struct("MultiThread").finish() -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/park.rs b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/park.rs -new file mode 100644 -index 00000000..6bdbff96 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/park.rs -@@ -0,0 +1,237 @@ -+//! Parks the runtime. -+//! -+//! A combination of the various resource driver park handles. -+ -+use crate::loom::sync::atomic::AtomicUsize; -+use crate::loom::sync::{Arc, Condvar, Mutex}; -+use crate::loom::thread; -+use crate::runtime::driver::{self, Driver}; -+use crate::util::TryLock; -+ -+use std::sync::atomic::Ordering::SeqCst; -+use std::time::Duration; -+ -+pub(crate) struct Parker { -+ inner: Arc, -+} -+ -+pub(crate) struct Unparker { -+ inner: Arc, -+} -+ -+struct Inner { -+ /// Avoids entering the park if possible -+ state: AtomicUsize, -+ -+ /// Used to coordinate access to the driver / condvar -+ mutex: Mutex<()>, -+ -+ /// Condvar to block on if the driver is unavailable. -+ condvar: Condvar, -+ -+ /// Resource (I/O, time, ...) driver -+ shared: Arc, -+} -+ -+const EMPTY: usize = 0; -+const PARKED_CONDVAR: usize = 1; -+const PARKED_DRIVER: usize = 2; -+const NOTIFIED: usize = 3; -+ -+/// Shared across multiple Parker handles -+struct Shared { -+ /// Shared driver. Only one thread at a time can use this -+ driver: TryLock, -+} -+ -+impl Parker { -+ pub(crate) fn new(driver: Driver) -> Parker { -+ Parker { -+ inner: Arc::new(Inner { -+ state: AtomicUsize::new(EMPTY), -+ mutex: Mutex::new(()), -+ condvar: Condvar::new(), -+ shared: Arc::new(Shared { -+ driver: TryLock::new(driver), -+ }), -+ }), -+ } -+ } -+ -+ pub(crate) fn unpark(&self) -> Unparker { -+ Unparker { -+ inner: self.inner.clone(), -+ } -+ } -+ -+ pub(crate) fn park(&mut self, handle: &driver::Handle) { -+ self.inner.park(handle); -+ } -+ -+ pub(crate) fn park_timeout(&mut self, handle: &driver::Handle, duration: Duration) { -+ // Only parking with zero is supported... -+ assert_eq!(duration, Duration::from_millis(0)); -+ -+ if let Some(mut driver) = self.inner.shared.driver.try_lock() { -+ driver.park_timeout(handle, duration) -+ } -+ } -+ -+ pub(crate) fn shutdown(&mut self, handle: &driver::Handle) { -+ self.inner.shutdown(handle); -+ } -+} -+ -+impl Clone for Parker { -+ fn clone(&self) -> Parker { -+ Parker { -+ inner: Arc::new(Inner { -+ state: AtomicUsize::new(EMPTY), -+ mutex: Mutex::new(()), -+ condvar: Condvar::new(), -+ shared: self.inner.shared.clone(), -+ }), -+ } -+ } -+} -+ -+impl Unparker { -+ pub(crate) fn unpark(&self, driver: &driver::Handle) { -+ self.inner.unpark(driver); -+ } -+} -+ -+impl Inner { -+ /// Parks the current thread for at most `dur`. -+ fn park(&self, handle: &driver::Handle) { -+ for _ in 0..3 { -+ // If we were previously notified then we consume this notification and -+ // return quickly. -+ if self -+ .state -+ .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) -+ .is_ok() -+ { -+ return; -+ } -+ -+ thread::yield_now(); -+ } -+ -+ if let Some(mut driver) = self.shared.driver.try_lock() { -+ self.park_driver(&mut driver, handle); -+ } else { -+ self.park_condvar(); -+ } -+ } -+ -+ fn park_condvar(&self) { -+ // Otherwise we need to coordinate going to sleep -+ let mut m = self.mutex.lock(); -+ -+ match self -+ .state -+ .compare_exchange(EMPTY, PARKED_CONDVAR, SeqCst, SeqCst) -+ { -+ Ok(_) => {} -+ Err(NOTIFIED) => { -+ // We must read here, even though we know it will be `NOTIFIED`. -+ // This is because `unpark` may have been called again since we read -+ // `NOTIFIED` in the `compare_exchange` above. We must perform an -+ // acquire operation that synchronizes with that `unpark` to observe -+ // any writes it made before the call to unpark. To do that we must -+ // read from the write it made to `state`. -+ let old = self.state.swap(EMPTY, SeqCst); -+ debug_assert_eq!(old, NOTIFIED, "park state changed unexpectedly"); -+ -+ return; -+ } -+ Err(actual) => panic!("inconsistent park state; actual = {}", actual), -+ } -+ -+ loop { -+ m = self.condvar.wait(m).unwrap(); -+ -+ if self -+ .state -+ .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) -+ .is_ok() -+ { -+ // got a notification -+ return; -+ } -+ -+ // spurious wakeup, go back to sleep -+ } -+ } -+ -+ fn park_driver(&self, driver: &mut Driver, handle: &driver::Handle) { -+ match self -+ .state -+ .compare_exchange(EMPTY, PARKED_DRIVER, SeqCst, SeqCst) -+ { -+ Ok(_) => {} -+ Err(NOTIFIED) => { -+ // We must read here, even though we know it will be `NOTIFIED`. -+ // This is because `unpark` may have been called again since we read -+ // `NOTIFIED` in the `compare_exchange` above. We must perform an -+ // acquire operation that synchronizes with that `unpark` to observe -+ // any writes it made before the call to unpark. To do that we must -+ // read from the write it made to `state`. -+ let old = self.state.swap(EMPTY, SeqCst); -+ debug_assert_eq!(old, NOTIFIED, "park state changed unexpectedly"); -+ -+ return; -+ } -+ Err(actual) => panic!("inconsistent park state; actual = {}", actual), -+ } -+ -+ driver.park(handle); -+ -+ match self.state.swap(EMPTY, SeqCst) { -+ NOTIFIED => {} // got a notification, hurray! -+ PARKED_DRIVER => {} // no notification, alas -+ n => panic!("inconsistent park_timeout state: {}", n), -+ } -+ } -+ -+ fn unpark(&self, driver: &driver::Handle) { -+ // To ensure the unparked thread will observe any writes we made before -+ // this call, we must perform a release operation that `park` can -+ // synchronize with. To do that we must write `NOTIFIED` even if `state` -+ // is already `NOTIFIED`. That is why this must be a swap rather than a -+ // compare-and-swap that returns if it reads `NOTIFIED` on failure. -+ match self.state.swap(NOTIFIED, SeqCst) { -+ EMPTY => {} // no one was waiting -+ NOTIFIED => {} // already unparked -+ PARKED_CONDVAR => self.unpark_condvar(), -+ PARKED_DRIVER => driver.unpark(), -+ actual => panic!("inconsistent state in unpark; actual = {}", actual), -+ } -+ } -+ -+ fn unpark_condvar(&self) { -+ // There is a period between when the parked thread sets `state` to -+ // `PARKED` (or last checked `state` in the case of a spurious wake -+ // up) and when it actually waits on `cvar`. If we were to notify -+ // during this period it would be ignored and then when the parked -+ // thread went to sleep it would never wake up. Fortunately, it has -+ // `lock` locked at this stage so we can acquire `lock` to wait until -+ // it is ready to receive the notification. -+ // -+ // Releasing `lock` before the call to `notify_one` means that when the -+ // parked thread wakes it doesn't get woken only to have to wait for us -+ // to release `lock`. -+ drop(self.mutex.lock()); -+ -+ self.condvar.notify_one() -+ } -+ -+ fn shutdown(&self, handle: &driver::Handle) { -+ if let Some(mut driver) = self.shared.driver.try_lock() { -+ driver.shutdown(handle); -+ } -+ -+ self.condvar.notify_all(); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/queue.rs b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/queue.rs -similarity index 80% -rename from KubeOS-Rust/vendor/tokio/src/runtime/queue.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/queue.rs -index a88dffca..faf56db2 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/queue.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/queue.rs -@@ -1,39 +1,56 @@ - //! Run-queue structures to support a work-stealing scheduler - - use crate::loom::cell::UnsafeCell; --use crate::loom::sync::atomic::{AtomicU16, AtomicU32}; - use crate::loom::sync::Arc; --use crate::runtime::stats::WorkerStatsBatcher; - use crate::runtime::task::{self, Inject}; -+use crate::runtime::MetricsBatch; - --use std::mem::MaybeUninit; -+use std::mem::{self, MaybeUninit}; - use std::ptr; - use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed, Release}; - -+// Use wider integers when possible to increase ABA resilience. -+// -+// See issue #5041: . -+cfg_has_atomic_u64! { -+ type UnsignedShort = u32; -+ type UnsignedLong = u64; -+ type AtomicUnsignedShort = crate::loom::sync::atomic::AtomicU32; -+ type AtomicUnsignedLong = crate::loom::sync::atomic::AtomicU64; -+} -+cfg_not_has_atomic_u64! { -+ type UnsignedShort = u16; -+ type UnsignedLong = u32; -+ type AtomicUnsignedShort = crate::loom::sync::atomic::AtomicU16; -+ type AtomicUnsignedLong = crate::loom::sync::atomic::AtomicU32; -+} -+ - /// Producer handle. May only be used from a single thread. --pub(super) struct Local { -+pub(crate) struct Local { - inner: Arc>, - } - - /// Consumer handle. May be used from many threads. --pub(super) struct Steal(Arc>); -+pub(crate) struct Steal(Arc>); - --pub(super) struct Inner { -+pub(crate) struct Inner { - /// Concurrently updated by many threads. - /// -- /// Contains two `u16` values. The LSB byte is the "real" head of the queue. -- /// The `u16` in the MSB is set by a stealer in process of stealing values. -- /// It represents the first value being stolen in the batch. `u16` is used -- /// in order to distinguish between `head == tail` and `head == tail - -- /// capacity`. -+ /// Contains two `UnsignedShort` values. The LSB byte is the "real" head of -+ /// the queue. The `UnsignedShort` in the MSB is set by a stealer in process -+ /// of stealing values. It represents the first value being stolen in the -+ /// batch. The `UnsignedShort` indices are intentionally wider than strictly -+ /// required for buffer indexing in order to provide ABA mitigation and make -+ /// it possible to distinguish between full and empty buffers. - /// -- /// When both `u16` values are the same, there is no active stealer. -+ /// When both `UnsignedShort` values are the same, there is no active -+ /// stealer. - /// - /// Tracking an in-progress stealer prevents a wrapping scenario. -- head: AtomicU32, -+ head: AtomicUnsignedLong, - - /// Only updated by producer thread but read by many threads. -- tail: AtomicU16, -+ tail: AtomicUnsignedShort, - - /// Elements - buffer: Box<[UnsafeCell>>; LOCAL_QUEUE_CAPACITY]>, -@@ -65,7 +82,7 @@ fn make_fixed_size(buffer: Box<[T]>) -> Box<[T; LOCAL_QUEUE_CAPACITY]> { - } - - /// Create a new local run-queue --pub(super) fn local() -> (Steal, Local) { -+pub(crate) fn local() -> (Steal, Local) { - let mut buffer = Vec::with_capacity(LOCAL_QUEUE_CAPACITY); - - for _ in 0..LOCAL_QUEUE_CAPACITY { -@@ -73,8 +90,8 @@ pub(super) fn local() -> (Steal, Local) { - } - - let inner = Arc::new(Inner { -- head: AtomicU32::new(0), -- tail: AtomicU16::new(0), -+ head: AtomicUnsignedLong::new(0), -+ tail: AtomicUnsignedShort::new(0), - buffer: make_fixed_size(buffer.into_boxed_slice()), - }); - -@@ -88,8 +105,8 @@ pub(super) fn local() -> (Steal, Local) { - } - - impl Local { -- /// Returns true if the queue has entries that can be stealed. -- pub(super) fn is_stealable(&self) -> bool { -+ /// Returns true if the queue has entries that can be stolen. -+ pub(crate) fn is_stealable(&self) -> bool { - !self.inner.is_empty() - } - -@@ -97,12 +114,17 @@ impl Local { - /// - /// Separate to is_stealable so that refactors of is_stealable to "protect" - /// some tasks from stealing won't affect this -- pub(super) fn has_tasks(&self) -> bool { -+ pub(crate) fn has_tasks(&self) -> bool { - !self.inner.is_empty() - } - - /// Pushes a task to the back of the local queue, skipping the LIFO slot. -- pub(super) fn push_back(&mut self, mut task: task::Notified, inject: &Inject) { -+ pub(crate) fn push_back( -+ &mut self, -+ mut task: task::Notified, -+ inject: &Inject, -+ metrics: &mut MetricsBatch, -+ ) { - let tail = loop { - let head = self.inner.head.load(Acquire); - let (steal, real) = unpack(head); -@@ -110,7 +132,7 @@ impl Local { - // safety: this is the **only** thread that updates this cell. - let tail = unsafe { self.inner.tail.unsync_load() }; - -- if tail.wrapping_sub(steal) < LOCAL_QUEUE_CAPACITY as u16 { -+ if tail.wrapping_sub(steal) < LOCAL_QUEUE_CAPACITY as UnsignedShort { - // There is capacity for the task - break tail; - } else if steal != real { -@@ -121,7 +143,7 @@ impl Local { - } else { - // Push the current task and half of the queue into the - // inject queue. -- match self.push_overflow(task, real, tail, inject) { -+ match self.push_overflow(task, real, tail, inject, metrics) { - Ok(_) => return, - // Lost the race, try again - Err(v) => { -@@ -160,15 +182,16 @@ impl Local { - fn push_overflow( - &mut self, - task: task::Notified, -- head: u16, -- tail: u16, -+ head: UnsignedShort, -+ tail: UnsignedShort, - inject: &Inject, -+ metrics: &mut MetricsBatch, - ) -> Result<(), task::Notified> { - /// How many elements are we taking from the local queue. - /// - /// This is one less than the number of tasks pushed to the inject - /// queue as we are also inserting the `task` argument. -- const NUM_TASKS_TAKEN: u16 = (LOCAL_QUEUE_CAPACITY / 2) as u16; -+ const NUM_TASKS_TAKEN: UnsignedShort = (LOCAL_QUEUE_CAPACITY / 2) as UnsignedShort; - - assert_eq!( - tail.wrapping_sub(head) as usize, -@@ -213,15 +236,15 @@ impl Local { - /// An iterator that takes elements out of the run queue. - struct BatchTaskIter<'a, T: 'static> { - buffer: &'a [UnsafeCell>>; LOCAL_QUEUE_CAPACITY], -- head: u32, -- i: u32, -+ head: UnsignedLong, -+ i: UnsignedLong, - } - impl<'a, T: 'static> Iterator for BatchTaskIter<'a, T> { - type Item = task::Notified; - - #[inline] - fn next(&mut self) -> Option> { -- if self.i == u32::from(NUM_TASKS_TAKEN) { -+ if self.i == UnsignedLong::from(NUM_TASKS_TAKEN) { - None - } else { - let i_idx = self.i.wrapping_add(self.head) as usize & MASK; -@@ -240,17 +263,20 @@ impl Local { - // safety: The CAS above ensures that no consumer will look at these - // values again, and we are the only producer. - let batch_iter = BatchTaskIter { -- buffer: &*self.inner.buffer, -- head: head as u32, -+ buffer: &self.inner.buffer, -+ head: head as UnsignedLong, - i: 0, - }; - inject.push_batch(batch_iter.chain(std::iter::once(task))); - -+ // Add 1 to factor in the task currently being scheduled. -+ metrics.incr_overflow_count(); -+ - Ok(()) - } - - /// Pops a task from the local queue. -- pub(super) fn pop(&mut self) -> Option> { -+ pub(crate) fn pop(&mut self) -> Option> { - let mut head = self.inner.head.load(Acquire); - - let idx = loop { -@@ -292,15 +318,15 @@ impl Local { - } - - impl Steal { -- pub(super) fn is_empty(&self) -> bool { -+ pub(crate) fn is_empty(&self) -> bool { - self.0.is_empty() - } - - /// Steals half the tasks from self and place them into `dst`. -- pub(super) fn steal_into( -+ pub(crate) fn steal_into( - &self, - dst: &mut Local, -- stats: &mut WorkerStatsBatcher, -+ dst_metrics: &mut MetricsBatch, - ) -> Option> { - // Safety: the caller is the only thread that mutates `dst.tail` and - // holds a mutable reference. -@@ -311,7 +337,7 @@ impl Steal { - // from `dst` there may not be enough capacity to steal. - let (steal, _) = unpack(dst.inner.head.load(Acquire)); - -- if dst_tail.wrapping_sub(steal) > LOCAL_QUEUE_CAPACITY as u16 / 2 { -+ if dst_tail.wrapping_sub(steal) > LOCAL_QUEUE_CAPACITY as UnsignedShort / 2 { - // we *could* try to steal less here, but for simplicity, we're just - // going to abort. - return None; -@@ -320,13 +346,15 @@ impl Steal { - // Steal the tasks into `dst`'s buffer. This does not yet expose the - // tasks in `dst`. - let mut n = self.steal_into2(dst, dst_tail); -- stats.incr_steal_count(n); - - if n == 0 { - // No tasks were stolen - return None; - } - -+ dst_metrics.incr_steal_count(n as u16); -+ dst_metrics.incr_steal_operations(); -+ - // We are returning a task here - n -= 1; - -@@ -350,7 +378,7 @@ impl Steal { - - // Steal tasks from `self`, placing them into `dst`. Returns the number of - // tasks that were stolen. -- fn steal_into2(&self, dst: &mut Local, dst_tail: u16) -> u16 { -+ fn steal_into2(&self, dst: &mut Local, dst_tail: UnsignedShort) -> UnsignedShort { - let mut prev_packed = self.0.head.load(Acquire); - let mut next_packed; - -@@ -392,7 +420,11 @@ impl Steal { - } - }; - -- assert!(n <= LOCAL_QUEUE_CAPACITY as u16 / 2, "actual = {}", n); -+ assert!( -+ n <= LOCAL_QUEUE_CAPACITY as UnsignedShort / 2, -+ "actual = {}", -+ n -+ ); - - let (first, _) = unpack(next_packed); - -@@ -446,6 +478,14 @@ impl Steal { - } - } - -+cfg_metrics! { -+ impl Steal { -+ pub(crate) fn len(&self) -> usize { -+ self.0.len() as _ -+ } -+ } -+} -+ - impl Clone for Steal { - fn clone(&self) -> Steal { - Steal(self.0.clone()) -@@ -461,26 +501,30 @@ impl Drop for Local { - } - - impl Inner { -- fn is_empty(&self) -> bool { -+ fn len(&self) -> UnsignedShort { - let (_, head) = unpack(self.head.load(Acquire)); - let tail = self.tail.load(Acquire); - -- head == tail -+ tail.wrapping_sub(head) -+ } -+ -+ fn is_empty(&self) -> bool { -+ self.len() == 0 - } - } - - /// Split the head value into the real head and the index a stealer is working - /// on. --fn unpack(n: u32) -> (u16, u16) { -- let real = n & u16::MAX as u32; -- let steal = n >> 16; -+fn unpack(n: UnsignedLong) -> (UnsignedShort, UnsignedShort) { -+ let real = n & UnsignedShort::MAX as UnsignedLong; -+ let steal = n >> (mem::size_of::() * 8); - -- (steal as u16, real as u16) -+ (steal as UnsignedShort, real as UnsignedShort) - } - - /// Join the two head values --fn pack(steal: u16, real: u16) -> u32 { -- (real as u32) | ((steal as u32) << 16) -+fn pack(steal: UnsignedShort, real: UnsignedShort) -> UnsignedLong { -+ (real as UnsignedLong) | ((steal as UnsignedLong) << (mem::size_of::() * 8)) - } - - #[test] -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/worker.rs b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/worker.rs -similarity index 66% -rename from KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/worker.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/worker.rs -index ae8efe67..148255a8 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/worker.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/scheduler/multi_thread/worker.rs -@@ -56,27 +56,24 @@ - //! the inject queue indefinitely. This would be a ref-count cycle and a memory - //! leak. - --use crate::coop; --use crate::future::Future; --use crate::loom::rand::seed; - use crate::loom::sync::{Arc, Mutex}; --use crate::park::{Park, Unpark}; - use crate::runtime; --use crate::runtime::enter::EnterContext; --use crate::runtime::park::{Parker, Unparker}; --use crate::runtime::stats::{RuntimeStats, WorkerStatsBatcher}; --use crate::runtime::task::{Inject, JoinHandle, OwnedTasks}; --use crate::runtime::thread_pool::{AtomicCell, Idle}; --use crate::runtime::{queue, task, Callback}; --use crate::util::FastRand; -+use crate::runtime::context; -+use crate::runtime::scheduler::multi_thread::{queue, Handle, Idle, Parker, Unparker}; -+use crate::runtime::task::{Inject, OwnedTasks}; -+use crate::runtime::{ -+ blocking, coop, driver, scheduler, task, Config, MetricsBatch, SchedulerMetrics, WorkerMetrics, -+}; -+use crate::util::atomic_cell::AtomicCell; -+use crate::util::rand::{FastRand, RngSeedGenerator}; - - use std::cell::RefCell; - use std::time::Duration; - - /// A scheduler worker - pub(super) struct Worker { -- /// Reference to shared state -- shared: Arc, -+ /// Reference to scheduler's handle -+ handle: Arc, - - /// Index holding this worker's remote state - index: usize, -@@ -88,7 +85,7 @@ pub(super) struct Worker { - /// Core data - struct Core { - /// Used to schedule bookkeeping tasks every so often. -- tick: u8, -+ tick: u32, - - /// When a task is scheduled from a worker, it is stored in this slot. The - /// worker will check this slot for a task **before** checking the run -@@ -98,7 +95,7 @@ struct Core { - lifo_slot: Option, - - /// The worker-local run queue. -- run_queue: queue::Local>, -+ run_queue: queue::Local>, - - /// True if the worker is currently searching for more work. Searching - /// involves attempting to steal from other workers. -@@ -113,8 +110,8 @@ struct Core { - /// borrow checker happy. - park: Option, - -- /// Batching stats so they can be submitted to RuntimeStats. -- stats: WorkerStatsBatcher, -+ /// Batching metrics so they can be submitted to RuntimeMetrics. -+ metrics: MetricsBatch, - - /// Fast random number generator. - rand: FastRand, -@@ -126,14 +123,16 @@ pub(super) struct Shared { - /// how they communicate between each other. - remotes: Box<[Remote]>, - -- /// Submits work to the scheduler while **not** currently on a worker thread. -- inject: Inject>, -+ /// Global task queue used for: -+ /// 1. Submit work to the scheduler while **not** currently on a worker thread. -+ /// 2. Submit work to the scheduler when a worker run queue is saturated -+ inject: Inject>, - - /// Coordinates idle workers - idle: Idle, - - /// Collection of all active tasks spawned onto this executor. -- owned: OwnedTasks>, -+ pub(super) owned: OwnedTasks>, - - /// Cores that have observed the shutdown signal - /// -@@ -142,19 +141,19 @@ pub(super) struct Shared { - #[allow(clippy::vec_box)] // we're moving an already-boxed value - shutdown_cores: Mutex>>, - -- /// Callback for a worker parking itself -- before_park: Option, -- /// Callback for a worker unparking itself -- after_unpark: Option, -+ /// Scheduler configuration options -+ config: Config, - -- /// Collects stats from the runtime. -- stats: RuntimeStats, -+ /// Collects metrics from the runtime. -+ pub(super) scheduler_metrics: SchedulerMetrics, -+ -+ pub(super) worker_metrics: Box<[WorkerMetrics]>, - } - - /// Used to communicate with a worker from other threads. - struct Remote { - /// Steals tasks from this worker. -- steal: queue::Steal>, -+ steal: queue::Steal>, - - /// Unparks the associated worker thread - unpark: Unparker, -@@ -178,10 +177,10 @@ pub(crate) struct Launch(Vec>); - type RunResult = Result, ()>; - - /// A task handle --type Task = task::Task>; -+type Task = task::Task>; - - /// A notified task handle --type Notified = task::Notified>; -+type Notified = task::Notified>; - - // Tracks thread-local state - scoped_thread_local!(static CURRENT: Context); -@@ -189,14 +188,17 @@ scoped_thread_local!(static CURRENT: Context); - pub(super) fn create( - size: usize, - park: Parker, -- before_park: Option, -- after_unpark: Option, --) -> (Arc, Launch) { -- let mut cores = vec![]; -- let mut remotes = vec![]; -+ driver_handle: driver::Handle, -+ blocking_spawner: blocking::Spawner, -+ seed_generator: RngSeedGenerator, -+ config: Config, -+) -> (Arc, Launch) { -+ let mut cores = Vec::with_capacity(size); -+ let mut remotes = Vec::with_capacity(size); -+ let mut worker_metrics = Vec::with_capacity(size); - - // Create the local queues -- for i in 0..size { -+ for _ in 0..size { - let (steal, run_queue) = queue::local(); - - let park = park.clone(); -@@ -209,37 +211,44 @@ pub(super) fn create( - is_searching: false, - is_shutdown: false, - park: Some(park), -- stats: WorkerStatsBatcher::new(i), -- rand: FastRand::new(seed()), -+ metrics: MetricsBatch::new(), -+ rand: FastRand::new(config.seed_generator.next_seed()), - })); - - remotes.push(Remote { steal, unpark }); -- } -- -- let shared = Arc::new(Shared { -- remotes: remotes.into_boxed_slice(), -- inject: Inject::new(), -- idle: Idle::new(size), -- owned: OwnedTasks::new(), -- shutdown_cores: Mutex::new(vec![]), -- before_park, -- after_unpark, -- stats: RuntimeStats::new(size), -+ worker_metrics.push(WorkerMetrics::new()); -+ } -+ -+ let handle = Arc::new(Handle { -+ shared: Shared { -+ remotes: remotes.into_boxed_slice(), -+ inject: Inject::new(), -+ idle: Idle::new(size), -+ owned: OwnedTasks::new(), -+ shutdown_cores: Mutex::new(vec![]), -+ config, -+ scheduler_metrics: SchedulerMetrics::new(), -+ worker_metrics: worker_metrics.into_boxed_slice(), -+ }, -+ driver: driver_handle, -+ blocking_spawner, -+ seed_generator, - }); - - let mut launch = Launch(vec![]); - - for (index, core) in cores.drain(..).enumerate() { - launch.0.push(Arc::new(Worker { -- shared: shared.clone(), -+ handle: handle.clone(), - index, - core: AtomicCell::new(Some(core)), - })); - } - -- (shared, launch) -+ (handle, launch) - } - -+#[track_caller] - pub(crate) fn block_in_place(f: F) -> R - where - F: FnOnce() -> R, -@@ -266,35 +275,45 @@ where - - let mut had_entered = false; - -- CURRENT.with(|maybe_cx| { -- match (crate::runtime::enter::context(), maybe_cx.is_some()) { -- (EnterContext::Entered { .. }, true) => { -+ let setup_result = CURRENT.with(|maybe_cx| { -+ match ( -+ crate::runtime::context::current_enter_context(), -+ maybe_cx.is_some(), -+ ) { -+ (context::EnterRuntime::Entered { .. }, true) => { - // We are on a thread pool runtime thread, so we just need to - // set up blocking. - had_entered = true; - } -- (EnterContext::Entered { allow_blocking }, false) => { -+ ( -+ context::EnterRuntime::Entered { -+ allow_block_in_place, -+ }, -+ false, -+ ) => { - // We are on an executor, but _not_ on the thread pool. That is - // _only_ okay if we are in a thread pool runtime's block_on - // method: -- if allow_blocking { -+ if allow_block_in_place { - had_entered = true; -- return; -+ return Ok(()); - } else { -- // This probably means we are on the basic_scheduler or in a -+ // This probably means we are on the current_thread runtime or in a - // LocalSet, where it is _not_ okay to block. -- panic!("can call blocking only when running on the multi-threaded runtime"); -+ return Err( -+ "can call blocking only when running on the multi-threaded runtime", -+ ); - } - } -- (EnterContext::NotEntered, true) => { -+ (context::EnterRuntime::NotEntered, true) => { - // This is a nested call to block_in_place (we already exited). - // All the necessary setup has already been done. -- return; -+ return Ok(()); - } -- (EnterContext::NotEntered, false) => { -+ (context::EnterRuntime::NotEntered, false) => { - // We are outside of the tokio runtime, so blocking is fine. - // We can also skip all of the thread pool blocking setup steps. -- return; -+ return Ok(()); - } - } - -@@ -303,7 +322,7 @@ where - // Get the worker core. If none is set, then blocking is fine! - let core = match cx.core.borrow_mut().take() { - Some(core) => core, -- None => return, -+ None => return Ok(()), - }; - - // The parker should be set here -@@ -322,25 +341,24 @@ where - // steal the core back. - let worker = cx.worker.clone(); - runtime::spawn_blocking(move || run(worker)); -+ Ok(()) - }); - -+ if let Err(panic_message) = setup_result { -+ panic!("{}", panic_message); -+ } -+ - if had_entered { - // Unset the current task's budget. Blocking sections are not - // constrained by task budgets. - let _reset = Reset(coop::stop()); - -- crate::runtime::enter::exit(f) -+ crate::runtime::context::exit_runtime(f) - } else { - f() - } - } - --/// After how many ticks is the global queue polled. This helps to ensure --/// fairness. --/// --/// The number is fairly arbitrary. I believe this value was copied from golang. --const GLOBAL_POLL_INTERVAL: u8 = 61; -- - impl Launch { - pub(crate) fn launch(mut self) { - for worker in self.0.drain(..) { -@@ -350,6 +368,22 @@ impl Launch { - } - - fn run(worker: Arc) { -+ struct AbortOnPanic; -+ -+ impl Drop for AbortOnPanic { -+ fn drop(&mut self) { -+ if std::thread::panicking() { -+ eprintln!("worker thread panicking; aborting process"); -+ std::process::abort(); -+ } -+ } -+ } -+ -+ // Catching panics on worker threads in tests is quite tricky. Instead, when -+ // debug assertions are enabled, we just abort the process. -+ #[cfg(debug_assertions)] -+ let _abort_on_panic = AbortOnPanic; -+ - // Acquire a core. If this fails, then another thread is running this - // worker and there is nothing further to do. - let core = match worker.core.take() { -@@ -357,18 +391,24 @@ fn run(worker: Arc) { - None => return, - }; - -+ let handle = scheduler::Handle::MultiThread(worker.handle.clone()); -+ let _enter = crate::runtime::context::enter_runtime(&handle, true); -+ - // Set the worker context. - let cx = Context { - worker, - core: RefCell::new(None), - }; - -- let _enter = crate::runtime::enter(true); -- - CURRENT.set(&cx, || { - // This should always be an error. It only returns a `Result` to support - // using `?` to short circuit. - assert!(cx.run(core).is_err()); -+ -+ // Check if there are any deferred tasks to notify. This can happen when -+ // the worker core is lost due to `block_in_place()` being called from -+ // within the task. -+ wake_deferred_tasks(); - }); - } - -@@ -393,26 +433,30 @@ impl Context { - core = self.run_task(task, core)?; - } else { - // Wait for work -- core = self.park(core); -+ core = if did_defer_tasks() { -+ self.park_timeout(core, Some(Duration::from_millis(0))) -+ } else { -+ self.park(core) -+ }; - } - } - - core.pre_shutdown(&self.worker); - - // Signal shutdown -- self.worker.shared.shutdown(core); -+ self.worker.handle.shutdown_core(core); - Err(()) - } - - fn run_task(&self, task: Notified, mut core: Box) -> RunResult { -- let task = self.worker.shared.owned.assert_owner(task); -+ let task = self.worker.handle.shared.owned.assert_owner(task); - - // Make sure the worker is not in the **searching** state. This enables - // another idle worker to try to steal work. - core.transition_from_searching(&self.worker); - - // Make the core available to the runtime context -- core.stats.incr_poll_count(); -+ core.metrics.incr_poll_count(); - *self.core.borrow_mut() = Some(core); - - // Run the task -@@ -437,14 +481,15 @@ impl Context { - - if coop::has_budget_remaining() { - // Run the LIFO task, then loop -- core.stats.incr_poll_count(); -+ core.metrics.incr_poll_count(); - *self.core.borrow_mut() = Some(core); -- let task = self.worker.shared.owned.assert_owner(task); -+ let task = self.worker.handle.shared.owned.assert_owner(task); - task.run(); - } else { - // Not enough budget left to run the LIFO task, push it to - // the back of the queue and return. -- core.run_queue.push_back(task, self.worker.inject()); -+ core.run_queue -+ .push_back(task, self.worker.inject(), &mut core.metrics); - return Ok(core); - } - } -@@ -452,7 +497,7 @@ impl Context { - } - - fn maintenance(&self, mut core: Box) -> Box { -- if core.tick % GLOBAL_POLL_INTERVAL == 0 { -+ if core.tick % self.worker.handle.shared.config.event_interval == 0 { - // Call `park` with a 0 timeout. This enables the I/O driver, timer, ... - // to run without actually putting the thread to sleep. - core = self.park_timeout(core, Some(Duration::from_millis(0))); -@@ -464,14 +509,27 @@ impl Context { - core - } - -+ /// Parks the worker thread while waiting for tasks to execute. -+ /// -+ /// This function checks if indeed there's no more work left to be done before parking. -+ /// Also important to notice that, before parking, the worker thread will try to take -+ /// ownership of the Driver (IO/Time) and dispatch any events that might have fired. -+ /// Whenever a worker thread executes the Driver loop, all waken tasks are scheduled -+ /// in its own local queue until the queue saturates (ntasks > LOCAL_QUEUE_CAPACITY). -+ /// When the local queue is saturated, the overflow tasks are added to the injection queue -+ /// from where other workers can pick them up. -+ /// Also, we rely on the workstealing algorithm to spread the tasks amongst workers -+ /// after all the IOs get dispatched - fn park(&self, mut core: Box) -> Box { -- if let Some(f) = &self.worker.shared.before_park { -+ if let Some(f) = &self.worker.handle.shared.config.before_park { - f(); - } - - if core.transition_to_parked(&self.worker) { - while !core.is_shutdown { -+ core.metrics.about_to_park(); - core = self.park_timeout(core, None); -+ core.metrics.returned_from_park(); - - // Run regularly scheduled maintenance - core.maintenance(&self.worker); -@@ -482,7 +540,7 @@ impl Context { - } - } - -- if let Some(f) = &self.worker.shared.after_unpark { -+ if let Some(f) = &self.worker.handle.shared.config.after_unpark { - f(); - } - core -@@ -492,31 +550,30 @@ impl Context { - // Take the parker out of core - let mut park = core.park.take().expect("park missing"); - -- core.stats.about_to_park(); -- - // Store `core` in context - *self.core.borrow_mut() = Some(core); - - // Park thread - if let Some(timeout) = duration { -- park.park_timeout(timeout).expect("park failed"); -+ park.park_timeout(&self.worker.handle.driver, timeout); - } else { -- park.park().expect("park failed"); -+ park.park(&self.worker.handle.driver); - } - -+ wake_deferred_tasks(); -+ - // Remove `core` from context - core = self.core.borrow_mut().take().expect("core missing"); - - // Place `park` back in `core` - core.park = Some(park); - -- // If there are tasks available to steal, notify a worker -- if core.run_queue.is_stealable() { -- self.worker.shared.notify_parked(); -+ // If there are tasks available to steal, but this worker is not -+ // looking for tasks to steal, notify another worker. -+ if !core.is_searching && core.run_queue.is_stealable() { -+ self.worker.handle.notify_parked(); - } - -- core.stats.returned_from_park(); -- - core - } - } -@@ -529,7 +586,7 @@ impl Core { - - /// Return the next notified task available to this worker. - fn next_task(&mut self, worker: &Worker) -> Option { -- if self.tick % GLOBAL_POLL_INTERVAL == 0 { -+ if self.tick % worker.handle.shared.config.global_queue_interval == 0 { - worker.inject().pop().or_else(|| self.next_local_task()) - } else { - self.next_local_task().or_else(|| worker.inject().pop()) -@@ -540,12 +597,17 @@ impl Core { - self.lifo_slot.take().or_else(|| self.run_queue.pop()) - } - -+ /// Function responsible for stealing tasks from another worker -+ /// -+ /// Note: Only if less than half the workers are searching for tasks to steal -+ /// a new worker will actually try to steal. The idea is to make sure not all -+ /// workers will be trying to steal at the same time. - fn steal_work(&mut self, worker: &Worker) -> Option { - if !self.transition_to_searching(worker) { - return None; - } - -- let num = worker.shared.remotes.len(); -+ let num = worker.handle.shared.remotes.len(); - // Start from a random worker - let start = self.rand.fastrand_n(num as u32) as usize; - -@@ -557,22 +619,22 @@ impl Core { - continue; - } - -- let target = &worker.shared.remotes[i]; -+ let target = &worker.handle.shared.remotes[i]; - if let Some(task) = target - .steal -- .steal_into(&mut self.run_queue, &mut self.stats) -+ .steal_into(&mut self.run_queue, &mut self.metrics) - { - return Some(task); - } - } - - // Fallback on checking the global queue -- worker.shared.inject.pop() -+ worker.handle.shared.inject.pop() - } - - fn transition_to_searching(&mut self, worker: &Worker) -> bool { - if !self.is_searching { -- self.is_searching = worker.shared.idle.transition_worker_to_searching(); -+ self.is_searching = worker.handle.shared.idle.transition_worker_to_searching(); - } - - self.is_searching -@@ -584,12 +646,12 @@ impl Core { - } - - self.is_searching = false; -- worker.shared.transition_worker_from_searching(); -+ worker.handle.transition_worker_from_searching(); - } - - /// Prepares the worker state for parking. - /// -- /// Returns true if the transition happend, false if there is work to do first. -+ /// Returns true if the transition happened, false if there is work to do first. - fn transition_to_parked(&mut self, worker: &Worker) -> bool { - // Workers should not park if they have work to do - if self.lifo_slot.is_some() || self.run_queue.has_tasks() { -@@ -600,6 +662,7 @@ impl Core { - // must check all the queues one last time in case work materialized - // between the last work scan and transitioning out of searching. - let is_last_searcher = worker -+ .handle - .shared - .idle - .transition_worker_to_parked(worker.index, self.is_searching); -@@ -609,7 +672,7 @@ impl Core { - self.is_searching = false; - - if is_last_searcher { -- worker.shared.notify_if_work_pending(); -+ worker.handle.notify_if_work_pending(); - } - - true -@@ -620,12 +683,15 @@ impl Core { - // If a task is in the lifo slot, then we must unpark regardless of - // being notified - if self.lifo_slot.is_some() { -- worker.shared.idle.unpark_worker_by_id(worker.index); -- self.is_searching = true; -+ // When a worker wakes, it should only transition to the "searching" -+ // state when the wake originates from another worker *or* a new task -+ // is pushed. We do *not* want the worker to transition to "searching" -+ // when it wakes when the I/O driver receives new events. -+ self.is_searching = !worker.handle.shared.idle.unpark_worker_by_id(worker.index); - return true; - } - -- if worker.shared.idle.is_parked(worker.index) { -+ if worker.handle.shared.idle.is_parked(worker.index) { - return false; - } - -@@ -636,7 +702,8 @@ impl Core { - - /// Runs maintenance work such as checking the pool's state. - fn maintenance(&mut self, worker: &Worker) { -- self.stats.submit(&worker.shared.stats); -+ self.metrics -+ .submit(&worker.handle.shared.worker_metrics[worker.index]); - - if !self.is_shutdown { - // Check if the scheduler has been shutdown -@@ -648,68 +715,52 @@ impl Core { - /// before we enter the single-threaded phase of shutdown processing. - fn pre_shutdown(&mut self, worker: &Worker) { - // Signal to all tasks to shut down. -- worker.shared.owned.close_and_shutdown_all(); -+ worker.handle.shared.owned.close_and_shutdown_all(); - -- self.stats.submit(&worker.shared.stats); -+ self.metrics -+ .submit(&worker.handle.shared.worker_metrics[worker.index]); - } - - /// Shuts down the core. -- fn shutdown(&mut self) { -+ fn shutdown(&mut self, handle: &Handle) { - // Take the core - let mut park = self.park.take().expect("park missing"); - - // Drain the queue - while self.next_local_task().is_some() {} - -- park.shutdown(); -+ park.shutdown(&handle.driver); - } - } - - impl Worker { - /// Returns a reference to the scheduler's injection queue. -- fn inject(&self) -> &Inject> { -- &self.shared.inject -+ fn inject(&self) -> &Inject> { -+ &self.handle.shared.inject - } - } - --impl task::Schedule for Arc { -+// TODO: Move `Handle` impls into handle.rs -+impl task::Schedule for Arc { - fn release(&self, task: &Task) -> Option { -- self.owned.remove(task) -+ self.shared.owned.remove(task) - } - - fn schedule(&self, task: Notified) { -- (**self).schedule(task, false); -+ self.schedule_task(task, false); - } - - fn yield_now(&self, task: Notified) { -- (**self).schedule(task, true); -+ self.schedule_task(task, true); - } - } - --impl Shared { -- pub(super) fn bind_new_task(me: &Arc, future: T) -> JoinHandle -- where -- T: Future + Send + 'static, -- T::Output: Send + 'static, -- { -- let (handle, notified) = me.owned.bind(future, me.clone()); -- -- if let Some(notified) = notified { -- me.schedule(notified, false); -- } -- -- handle -- } -- -- pub(crate) fn stats(&self) -> &RuntimeStats { -- &self.stats -- } -- -- pub(super) fn schedule(&self, task: Notified, is_yield: bool) { -+impl Handle { -+ pub(super) fn schedule_task(&self, task: Notified, is_yield: bool) { - CURRENT.with(|maybe_cx| { - if let Some(cx) = maybe_cx { - // Make sure the task is part of the **current** scheduler. -- if self.ptr_eq(&cx.worker.shared) { -+ if self.ptr_eq(&cx.worker.handle) { - // And the current thread still holds a core - if let Some(core) = cx.core.borrow_mut().as_mut() { - self.schedule_local(core, task, is_yield); -@@ -719,18 +770,22 @@ impl Shared { - } - - // Otherwise, use the inject queue. -- self.inject.push(task); -+ self.shared.inject.push(task); -+ self.shared.scheduler_metrics.inc_remote_schedule_count(); - self.notify_parked(); - }) - } - - fn schedule_local(&self, core: &mut Core, task: Notified, is_yield: bool) { -+ core.metrics.inc_local_schedule_count(); -+ - // Spawning from the worker thread. If scheduling a "yield" then the - // task must always be pushed to the back of the queue, enabling other - // tasks to be executed. If **not** a yield, then there is more - // flexibility and the task may go to the front of the queue. -- let should_notify = if is_yield { -- core.run_queue.push_back(task, &self.inject); -+ let should_notify = if is_yield || self.shared.config.disable_lifo_slot { -+ core.run_queue -+ .push_back(task, &self.shared.inject, &mut core.metrics); - true - } else { - // Push to the LIFO slot -@@ -738,7 +793,8 @@ impl Shared { - let ret = prev.is_some(); - - if let Some(prev) = prev { -- core.run_queue.push_back(prev, &self.inject); -+ core.run_queue -+ .push_back(prev, &self.shared.inject, &mut core.metrics); - } - - core.lifo_slot = Some(task); -@@ -755,38 +811,38 @@ impl Shared { - } - - pub(super) fn close(&self) { -- if self.inject.close() { -+ if self.shared.inject.close() { - self.notify_all(); - } - } - - fn notify_parked(&self) { -- if let Some(index) = self.idle.worker_to_notify() { -- self.remotes[index].unpark.unpark(); -+ if let Some(index) = self.shared.idle.worker_to_notify() { -+ self.shared.remotes[index].unpark.unpark(&self.driver); - } - } - - fn notify_all(&self) { -- for remote in &self.remotes[..] { -- remote.unpark.unpark(); -+ for remote in &self.shared.remotes[..] { -+ remote.unpark.unpark(&self.driver); - } - } - - fn notify_if_work_pending(&self) { -- for remote in &self.remotes[..] { -+ for remote in &self.shared.remotes[..] { - if !remote.steal.is_empty() { - self.notify_parked(); - return; - } - } - -- if !self.inject.is_empty() { -+ if !self.shared.inject.is_empty() { - self.notify_parked(); - } - } - - fn transition_worker_from_searching(&self) { -- if self.idle.transition_worker_from_searching() { -+ if self.shared.idle.transition_worker_from_searching() { - // We are the final searching worker. Because work was found, we - // need to notify another worker. - self.notify_parked(); -@@ -797,29 +853,49 @@ impl Shared { - /// its core back into its handle. - /// - /// If all workers have reached this point, the final cleanup is performed. -- fn shutdown(&self, core: Box) { -- let mut cores = self.shutdown_cores.lock(); -+ fn shutdown_core(&self, core: Box) { -+ let mut cores = self.shared.shutdown_cores.lock(); - cores.push(core); - -- if cores.len() != self.remotes.len() { -+ if cores.len() != self.shared.remotes.len() { - return; - } - -- debug_assert!(self.owned.is_empty()); -+ debug_assert!(self.shared.owned.is_empty()); - - for mut core in cores.drain(..) { -- core.shutdown(); -+ core.shutdown(self); - } - - // Drain the injection queue - // - // We already shut down every task, so we can simply drop the tasks. -- while let Some(task) = self.inject.pop() { -+ while let Some(task) = self.shared.inject.pop() { - drop(task); - } - } - -- fn ptr_eq(&self, other: &Shared) -> bool { -+ fn ptr_eq(&self, other: &Handle) -> bool { - std::ptr::eq(self, other) - } - } -+ -+fn did_defer_tasks() -> bool { -+ context::with_defer(|deferred| !deferred.is_empty()).unwrap() -+} -+ -+fn wake_deferred_tasks() { -+ context::with_defer(|deferred| deferred.wake()); -+} -+ -+cfg_metrics! { -+ impl Shared { -+ pub(super) fn injection_queue_depth(&self) -> usize { -+ self.inject.len() -+ } -+ -+ pub(super) fn worker_local_queue_depth(&self, worker: usize) -> usize { -+ self.remotes[worker].steal.len() -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/signal/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/signal/mod.rs -new file mode 100644 -index 00000000..24f2f4c6 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/signal/mod.rs -@@ -0,0 +1,142 @@ -+#![cfg_attr(not(feature = "rt"), allow(dead_code))] -+ -+//! Signal driver -+ -+use crate::runtime::{driver, io}; -+use crate::signal::registry::globals; -+ -+use mio::net::UnixStream; -+use std::io::{self as std_io, Read}; -+use std::sync::{Arc, Weak}; -+use std::time::Duration; -+ -+/// Responsible for registering wakeups when an OS signal is received, and -+/// subsequently dispatching notifications to any signal listeners as appropriate. -+/// -+/// Note: this driver relies on having an enabled IO driver in order to listen to -+/// pipe write wakeups. -+#[derive(Debug)] -+pub(crate) struct Driver { -+ /// Thread parker. The `Driver` park implementation delegates to this. -+ io: io::Driver, -+ -+ /// A pipe for receiving wake events from the signal handler -+ receiver: UnixStream, -+ -+ /// Shared state. The driver keeps a strong ref and the handle keeps a weak -+ /// ref. The weak ref is used to check if the driver is still active before -+ /// trying to register a signal handler. -+ inner: Arc<()>, -+} -+ -+#[derive(Debug, Default)] -+pub(crate) struct Handle { -+ /// Paired w/ the `Arc` above and is used to check if the driver is still -+ /// around before attempting to register a signal handler. -+ inner: Weak<()>, -+} -+ -+// ===== impl Driver ===== -+ -+impl Driver { -+ /// Creates a new signal `Driver` instance that delegates wakeups to `park`. -+ pub(crate) fn new(io: io::Driver, io_handle: &io::Handle) -> std_io::Result { -+ use std::mem::ManuallyDrop; -+ use std::os::unix::io::{AsRawFd, FromRawFd}; -+ -+ // NB: We give each driver a "fresh" receiver file descriptor to avoid -+ // the issues described in alexcrichton/tokio-process#42. -+ // -+ // In the past we would reuse the actual receiver file descriptor and -+ // swallow any errors around double registration of the same descriptor. -+ // I'm not sure if the second (failed) registration simply doesn't end -+ // up receiving wake up notifications, or there could be some race -+ // condition when consuming readiness events, but having distinct -+ // descriptors appears to mitigate this. -+ // -+ // Unfortunately we cannot just use a single global UnixStream instance -+ // either, since we can't assume they will always be registered with the -+ // exact same reactor. -+ // -+ // Mio 0.7 removed `try_clone()` as an API due to unexpected behavior -+ // with registering dups with the same reactor. In this case, duping is -+ // safe as each dup is registered with separate reactors **and** we -+ // only expect at least one dup to receive the notification. -+ -+ // Manually drop as we don't actually own this instance of UnixStream. -+ let receiver_fd = globals().receiver.as_raw_fd(); -+ -+ // safety: there is nothing unsafe about this, but the `from_raw_fd` fn is marked as unsafe. -+ let original = -+ ManuallyDrop::new(unsafe { std::os::unix::net::UnixStream::from_raw_fd(receiver_fd) }); -+ let mut receiver = UnixStream::from_std(original.try_clone()?); -+ -+ io_handle.register_signal_receiver(&mut receiver)?; -+ -+ Ok(Self { -+ io, -+ receiver, -+ inner: Arc::new(()), -+ }) -+ } -+ -+ /// Returns a handle to this event loop which can be sent across threads -+ /// and can be used as a proxy to the event loop itself. -+ pub(crate) fn handle(&self) -> Handle { -+ Handle { -+ inner: Arc::downgrade(&self.inner), -+ } -+ } -+ -+ pub(crate) fn park(&mut self, handle: &driver::Handle) { -+ self.io.park(handle); -+ self.process(); -+ } -+ -+ pub(crate) fn park_timeout(&mut self, handle: &driver::Handle, duration: Duration) { -+ self.io.park_timeout(handle, duration); -+ self.process(); -+ } -+ -+ pub(crate) fn shutdown(&mut self, handle: &driver::Handle) { -+ self.io.shutdown(handle) -+ } -+ -+ fn process(&mut self) { -+ // If the signal pipe has not received a readiness event, then there is -+ // nothing else to do. -+ if !self.io.consume_signal_ready() { -+ return; -+ } -+ -+ // Drain the pipe completely so we can receive a new readiness event -+ // if another signal has come in. -+ let mut buf = [0; 128]; -+ loop { -+ match self.receiver.read(&mut buf) { -+ Ok(0) => panic!("EOF on self-pipe"), -+ Ok(_) => continue, // Keep reading -+ Err(e) if e.kind() == std_io::ErrorKind::WouldBlock => break, -+ Err(e) => panic!("Bad read on self-pipe: {}", e), -+ } -+ } -+ -+ // Broadcast any signals which were received -+ globals().broadcast(); -+ } -+} -+ -+// ===== impl Handle ===== -+ -+impl Handle { -+ pub(crate) fn check_inner(&self) -> std_io::Result<()> { -+ if self.inner.strong_count() > 0 { -+ Ok(()) -+ } else { -+ Err(std_io::Error::new( -+ std_io::ErrorKind::Other, -+ "signal driver gone", -+ )) -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/spawner.rs b/KubeOS-Rust/vendor/tokio/src/runtime/spawner.rs -deleted file mode 100644 -index 9a3d465a..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/spawner.rs -+++ /dev/null -@@ -1,47 +0,0 @@ --use crate::future::Future; --use crate::runtime::basic_scheduler; --use crate::runtime::stats::RuntimeStats; --use crate::task::JoinHandle; -- --cfg_rt_multi_thread! { -- use crate::runtime::thread_pool; --} -- --#[derive(Debug, Clone)] --pub(crate) enum Spawner { -- Basic(basic_scheduler::Spawner), -- #[cfg(feature = "rt-multi-thread")] -- ThreadPool(thread_pool::Spawner), --} -- --impl Spawner { -- pub(crate) fn shutdown(&mut self) { -- #[cfg(feature = "rt-multi-thread")] -- { -- if let Spawner::ThreadPool(spawner) = self { -- spawner.shutdown(); -- } -- } -- } -- -- pub(crate) fn spawn(&self, future: F) -> JoinHandle -- where -- F: Future + Send + 'static, -- F::Output: Send + 'static, -- { -- match self { -- Spawner::Basic(spawner) => spawner.spawn(future), -- #[cfg(feature = "rt-multi-thread")] -- Spawner::ThreadPool(spawner) => spawner.spawn(future), -- } -- } -- -- #[cfg_attr(not(all(tokio_unstable, feature = "stats")), allow(dead_code))] -- pub(crate) fn stats(&self) -> &RuntimeStats { -- match self { -- Spawner::Basic(spawner) => spawner.stats(), -- #[cfg(feature = "rt-multi-thread")] -- Spawner::ThreadPool(spawner) => spawner.stats(), -- } -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/stats/mock.rs b/KubeOS-Rust/vendor/tokio/src/runtime/stats/mock.rs -deleted file mode 100644 -index 3bda8bff..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/stats/mock.rs -+++ /dev/null -@@ -1,27 +0,0 @@ --//! This file contains mocks of the types in src/runtime/stats/stats.rs -- --pub(crate) struct RuntimeStats {} -- --impl RuntimeStats { -- pub(crate) fn new(_worker_threads: usize) -> Self { -- Self {} -- } --} -- --pub(crate) struct WorkerStatsBatcher {} -- --impl WorkerStatsBatcher { -- pub(crate) fn new(_my_index: usize) -> Self { -- Self {} -- } -- -- pub(crate) fn submit(&mut self, _to: &RuntimeStats) {} -- -- pub(crate) fn about_to_park(&mut self) {} -- pub(crate) fn returned_from_park(&mut self) {} -- -- #[cfg(feature = "rt-multi-thread")] -- pub(crate) fn incr_steal_count(&mut self, _by: u16) {} -- -- pub(crate) fn incr_poll_count(&mut self) {} --} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/stats/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/stats/mod.rs -deleted file mode 100644 -index 5e08e8ec..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/stats/mod.rs -+++ /dev/null -@@ -1,17 +0,0 @@ --//! This module contains information need to view information about how the --//! runtime is performing. --#![allow(clippy::module_inception)] -- --cfg_stats! { -- mod stats; -- -- pub use self::stats::{RuntimeStats, WorkerStats}; -- pub(crate) use self::stats::WorkerStatsBatcher; --} -- --cfg_not_stats! { -- #[path = "mock.rs"] -- mod stats; -- -- pub(crate) use self::stats::{RuntimeStats, WorkerStatsBatcher}; --} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/stats/stats.rs b/KubeOS-Rust/vendor/tokio/src/runtime/stats/stats.rs -deleted file mode 100644 -index b2bcacca..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/stats/stats.rs -+++ /dev/null -@@ -1,122 +0,0 @@ --//! This file contains the types necessary to collect various types of stats. --use crate::loom::sync::atomic::{AtomicU64, Ordering::Relaxed}; -- --use std::convert::TryFrom; --use std::time::{Duration, Instant}; -- --/// This type contains methods to retrieve stats from a Tokio runtime. --#[derive(Debug)] --pub struct RuntimeStats { -- workers: Box<[WorkerStats]>, --} -- --/// This type contains methods to retrieve stats from a worker thread on a Tokio runtime. --#[derive(Debug)] --#[repr(align(128))] --pub struct WorkerStats { -- park_count: AtomicU64, -- steal_count: AtomicU64, -- poll_count: AtomicU64, -- busy_duration_total: AtomicU64, --} -- --impl RuntimeStats { -- pub(crate) fn new(worker_threads: usize) -> Self { -- let mut workers = Vec::with_capacity(worker_threads); -- for _ in 0..worker_threads { -- workers.push(WorkerStats { -- park_count: AtomicU64::new(0), -- steal_count: AtomicU64::new(0), -- poll_count: AtomicU64::new(0), -- busy_duration_total: AtomicU64::new(0), -- }); -- } -- -- Self { -- workers: workers.into_boxed_slice(), -- } -- } -- -- /// Returns a slice containing the worker stats for each worker thread. -- pub fn workers(&self) -> impl Iterator { -- self.workers.iter() -- } --} -- --impl WorkerStats { -- /// Returns the total number of times this worker thread has parked. -- pub fn park_count(&self) -> u64 { -- self.park_count.load(Relaxed) -- } -- -- /// Returns the number of tasks this worker has stolen from other worker -- /// threads. -- pub fn steal_count(&self) -> u64 { -- self.steal_count.load(Relaxed) -- } -- -- /// Returns the number of times this worker has polled a task. -- pub fn poll_count(&self) -> u64 { -- self.poll_count.load(Relaxed) -- } -- -- /// Returns the total amount of time this worker has been busy for. -- pub fn total_busy_duration(&self) -> Duration { -- Duration::from_nanos(self.busy_duration_total.load(Relaxed)) -- } --} -- --pub(crate) struct WorkerStatsBatcher { -- my_index: usize, -- park_count: u64, -- steal_count: u64, -- poll_count: u64, -- /// The total busy duration in nanoseconds. -- busy_duration_total: u64, -- last_resume_time: Instant, --} -- --impl WorkerStatsBatcher { -- pub(crate) fn new(my_index: usize) -> Self { -- Self { -- my_index, -- park_count: 0, -- steal_count: 0, -- poll_count: 0, -- busy_duration_total: 0, -- last_resume_time: Instant::now(), -- } -- } -- pub(crate) fn submit(&mut self, to: &RuntimeStats) { -- let worker = &to.workers[self.my_index]; -- -- worker.park_count.store(self.park_count, Relaxed); -- worker.steal_count.store(self.steal_count, Relaxed); -- worker.poll_count.store(self.poll_count, Relaxed); -- -- worker -- .busy_duration_total -- .store(self.busy_duration_total, Relaxed); -- } -- -- pub(crate) fn about_to_park(&mut self) { -- self.park_count += 1; -- -- let busy_duration = self.last_resume_time.elapsed(); -- let busy_duration = u64::try_from(busy_duration.as_nanos()).unwrap_or(u64::MAX); -- self.busy_duration_total += busy_duration; -- } -- -- pub(crate) fn returned_from_park(&mut self) { -- self.last_resume_time = Instant::now(); -- } -- -- #[cfg(feature = "rt-multi-thread")] -- pub(crate) fn incr_steal_count(&mut self, by: u16) { -- self.steal_count += u64::from(by); -- } -- -- pub(crate) fn incr_poll_count(&mut self) { -- self.poll_count += 1; -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/abort.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/abort.rs -new file mode 100644 -index 00000000..6edca100 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/abort.rs -@@ -0,0 +1,87 @@ -+use crate::runtime::task::{Header, RawTask}; -+use std::fmt; -+use std::panic::{RefUnwindSafe, UnwindSafe}; -+ -+/// An owned permission to abort a spawned task, without awaiting its completion. -+/// -+/// Unlike a [`JoinHandle`], an `AbortHandle` does *not* represent the -+/// permission to await the task's completion, only to terminate it. -+/// -+/// The task may be aborted by calling the [`AbortHandle::abort`] method. -+/// Dropping an `AbortHandle` releases the permission to terminate the task -+/// --- it does *not* abort the task. -+/// -+/// [`JoinHandle`]: crate::task::JoinHandle -+#[cfg_attr(docsrs, doc(cfg(feature = "rt")))] -+pub struct AbortHandle { -+ raw: RawTask, -+} -+ -+impl AbortHandle { -+ pub(super) fn new(raw: RawTask) -> Self { -+ Self { raw } -+ } -+ -+ /// Abort the task associated with the handle. -+ /// -+ /// Awaiting a cancelled task might complete as usual if the task was -+ /// already completed at the time it was cancelled, but most likely it -+ /// will fail with a [cancelled] `JoinError`. -+ /// -+ /// If the task was already cancelled, such as by [`JoinHandle::abort`], -+ /// this method will do nothing. -+ /// -+ /// [cancelled]: method@super::error::JoinError::is_cancelled -+ /// [`JoinHandle::abort`]: method@super::JoinHandle::abort -+ pub fn abort(&self) { -+ self.raw.remote_abort(); -+ } -+ -+ /// Checks if the task associated with this `AbortHandle` has finished. -+ /// -+ /// Please note that this method can return `false` even if `abort` has been -+ /// called on the task. This is because the cancellation process may take -+ /// some time, and this method does not return `true` until it has -+ /// completed. -+ pub fn is_finished(&self) -> bool { -+ let state = self.raw.state().load(); -+ state.is_complete() -+ } -+ -+ /// Returns a [task ID] that uniquely identifies this task relative to other -+ /// currently spawned tasks. -+ /// -+ /// **Note**: This is an [unstable API][unstable]. The public API of this type -+ /// may break in 1.x releases. See [the documentation on unstable -+ /// features][unstable] for details. -+ /// -+ /// [task ID]: crate::task::Id -+ /// [unstable]: crate#unstable-features -+ #[cfg(tokio_unstable)] -+ #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))] -+ pub fn id(&self) -> super::Id { -+ // Safety: The header pointer is valid. -+ unsafe { Header::get_id(self.raw.header_ptr()) } -+ } -+} -+ -+unsafe impl Send for AbortHandle {} -+unsafe impl Sync for AbortHandle {} -+ -+impl UnwindSafe for AbortHandle {} -+impl RefUnwindSafe for AbortHandle {} -+ -+impl fmt::Debug for AbortHandle { -+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -+ // Safety: The header pointer is valid. -+ let id_ptr = unsafe { Header::get_id_ptr(self.raw.header_ptr()) }; -+ let id = unsafe { id_ptr.as_ref() }; -+ fmt.debug_struct("AbortHandle").field("id", id).finish() -+ } -+} -+ -+impl Drop for AbortHandle { -+ fn drop(&mut self) { -+ self.raw.drop_abort_handle(); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/core.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/core.rs -index 776e8341..bcccc698 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/core.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/core.rs -@@ -11,9 +11,10 @@ - - use crate::future::Future; - use crate::loom::cell::UnsafeCell; -+use crate::runtime::context; - use crate::runtime::task::raw::{self, Vtable}; - use crate::runtime::task::state::State; --use crate::runtime::task::Schedule; -+use crate::runtime::task::{Id, Schedule}; - use crate::util::linked_list; - - use std::pin::Pin; -@@ -24,6 +25,9 @@ use std::task::{Context, Poll, Waker}; - /// - /// It is critical for `Header` to be the first field as the task structure will - /// be referenced by both *mut Cell and *mut Header. -+/// -+/// Any changes to the layout of this struct _must_ also be reflected in the -+/// const fns in raw.rs. - #[repr(C)] - pub(super) struct Cell { - /// Hot task state data -@@ -43,10 +47,17 @@ pub(super) struct CoreStage { - /// The core of the task. - /// - /// Holds the future or output, depending on the stage of execution. -+/// -+/// Any changes to the layout of this struct _must_ also be reflected in the -+/// const fns in raw.rs. -+#[repr(C)] - pub(super) struct Core { - /// Scheduler used to drive this future. - pub(super) scheduler: S, - -+ /// The task's ID, used for populating `JoinError`s. -+ pub(super) task_id: Id, -+ - /// Either the future or the output. - pub(super) stage: CoreStage, - } -@@ -57,8 +68,6 @@ pub(crate) struct Header { - /// Task state. - pub(super) state: State, - -- pub(super) owned: UnsafeCell>, -- - /// Pointer to next task, used with the injection queue. - pub(super) queue_next: UnsafeCell>>, - -@@ -80,18 +89,29 @@ pub(crate) struct Header { - - /// The tracing ID for this instrumented task. - #[cfg(all(tokio_unstable, feature = "tracing"))] -- pub(super) id: Option, -+ pub(super) tracing_id: Option, - } - - unsafe impl Send for Header {} - unsafe impl Sync for Header {} - --/// Cold data is stored after the future. -+/// Cold data is stored after the future. Data is considered cold if it is only -+/// used during creation or shutdown of the task. - pub(super) struct Trailer { -+ /// Pointers for the linked list in the `OwnedTasks` that owns this task. -+ pub(super) owned: linked_list::Pointers

, - /// Consumer task waiting on completion of this task. - pub(super) waker: UnsafeCell>, - } - -+generate_addr_of_methods! { -+ impl<> Trailer { -+ pub(super) unsafe fn addr_of_owned(self: NonNull) -> NonNull> { -+ &self.owned -+ } -+ } -+} -+ - /// Either the future or the output. - pub(super) enum Stage { - Running(T), -@@ -102,29 +122,48 @@ pub(super) enum Stage { - impl Cell { - /// Allocates a new task cell, containing the header, trailer, and core - /// structures. -- pub(super) fn new(future: T, scheduler: S, state: State) -> Box> { -+ pub(super) fn new(future: T, scheduler: S, state: State, task_id: Id) -> Box> { - #[cfg(all(tokio_unstable, feature = "tracing"))] -- let id = future.id(); -- Box::new(Cell { -+ let tracing_id = future.id(); -+ let result = Box::new(Cell { - header: Header { - state, -- owned: UnsafeCell::new(linked_list::Pointers::new()), - queue_next: UnsafeCell::new(None), - vtable: raw::vtable::(), - owner_id: UnsafeCell::new(0), - #[cfg(all(tokio_unstable, feature = "tracing"))] -- id, -+ tracing_id, - }, - core: Core { - scheduler, - stage: CoreStage { - stage: UnsafeCell::new(Stage::Running(future)), - }, -+ task_id, - }, - trailer: Trailer { - waker: UnsafeCell::new(None), -+ owned: linked_list::Pointers::new(), - }, -- }) -+ }); -+ -+ #[cfg(debug_assertions)] -+ { -+ let trailer_addr = (&result.trailer) as *const Trailer as usize; -+ let trailer_ptr = unsafe { Header::get_trailer(NonNull::from(&result.header)) }; -+ assert_eq!(trailer_addr, trailer_ptr.as_ptr() as usize); -+ -+ let scheduler_addr = (&result.core.scheduler) as *const S as usize; -+ let scheduler_ptr = -+ unsafe { Header::get_scheduler::(NonNull::from(&result.header)) }; -+ assert_eq!(scheduler_addr, scheduler_ptr.as_ptr() as usize); -+ -+ let id_addr = (&result.core.task_id) as *const Id as usize; -+ let id_ptr = unsafe { Header::get_id_ptr(NonNull::from(&result.header)) }; -+ assert_eq!(id_addr, id_ptr.as_ptr() as usize); -+ } -+ -+ result - } - } - -@@ -132,7 +171,29 @@ impl CoreStage { - pub(super) fn with_mut(&self, f: impl FnOnce(*mut Stage) -> R) -> R { - self.stage.with_mut(f) - } -+} - -+/// Set and clear the task id in the context when the future is executed or -+/// dropped, or when the output produced by the future is dropped. -+pub(crate) struct TaskIdGuard { -+ parent_task_id: Option, -+} -+ -+impl TaskIdGuard { -+ fn enter(id: Id) -> Self { -+ TaskIdGuard { -+ parent_task_id: context::set_current_task_id(Some(id)), -+ } -+ } -+} -+ -+impl Drop for TaskIdGuard { -+ fn drop(&mut self) { -+ context::set_current_task_id(self.parent_task_id); -+ } -+} -+ -+impl Core { - /// Polls the future. - /// - /// # Safety -@@ -148,7 +209,7 @@ impl CoreStage { - /// heap. - pub(super) fn poll(&self, mut cx: Context<'_>) -> Poll { - let res = { -- self.stage.with_mut(|ptr| { -+ self.stage.stage.with_mut(|ptr| { - // Safety: The caller ensures mutual exclusion to the field. - let future = match unsafe { &mut *ptr } { - Stage::Running(future) => future, -@@ -158,6 +219,7 @@ impl CoreStage { - // Safety: The caller ensures the future is pinned. - let future = unsafe { Pin::new_unchecked(future) }; - -+ let _guard = TaskIdGuard::enter(self.task_id); - future.poll(&mut cx) - }) - }; -@@ -201,7 +263,7 @@ impl CoreStage { - pub(super) fn take_output(&self) -> super::Result { - use std::mem; - -- self.stage.with_mut(|ptr| { -+ self.stage.stage.with_mut(|ptr| { - // Safety:: the caller ensures mutual exclusion to the field. - match mem::replace(unsafe { &mut *ptr }, Stage::Consumed) { - Stage::Finished(output) => output, -@@ -211,7 +273,8 @@ impl CoreStage { - } - - unsafe fn set_stage(&self, stage: Stage) { -- self.stage.with_mut(|ptr| *ptr = stage) -+ let _guard = TaskIdGuard::enter(self.task_id); -+ self.stage.stage.with_mut(|ptr| *ptr = stage) - } - } - -@@ -236,6 +299,62 @@ impl Header { - // the safety requirements on `set_owner_id`. - unsafe { self.owner_id.with(|ptr| *ptr) } - } -+ -+ /// Gets a pointer to the `Trailer` of the task containing this `Header`. -+ /// -+ /// # Safety -+ /// -+ /// The provided raw pointer must point at the header of a task. -+ pub(super) unsafe fn get_trailer(me: NonNull
) -> NonNull { -+ let offset = me.as_ref().vtable.trailer_offset; -+ let trailer = me.as_ptr().cast::().add(offset).cast::(); -+ NonNull::new_unchecked(trailer) -+ } -+ -+ /// Gets a pointer to the scheduler of the task containing this `Header`. -+ /// -+ /// # Safety -+ /// -+ /// The provided raw pointer must point at the header of a task. -+ /// -+ /// The generic type S must be set to the correct scheduler type for this -+ /// task. -+ pub(super) unsafe fn get_scheduler(me: NonNull
) -> NonNull { -+ let offset = me.as_ref().vtable.scheduler_offset; -+ let scheduler = me.as_ptr().cast::().add(offset).cast::(); -+ NonNull::new_unchecked(scheduler) -+ } -+ -+ /// Gets a pointer to the id of the task containing this `Header`. -+ /// -+ /// # Safety -+ /// -+ /// The provided raw pointer must point at the header of a task. -+ pub(super) unsafe fn get_id_ptr(me: NonNull
) -> NonNull { -+ let offset = me.as_ref().vtable.id_offset; -+ let id = me.as_ptr().cast::().add(offset).cast::(); -+ NonNull::new_unchecked(id) -+ } -+ -+ /// Gets the id of the task containing this `Header`. -+ /// -+ /// # Safety -+ /// -+ /// The provided raw pointer must point at the header of a task. -+ pub(super) unsafe fn get_id(me: NonNull
) -> Id { -+ let ptr = Header::get_id_ptr(me).as_ptr(); -+ *ptr -+ } -+ -+ /// Gets the tracing id of the task containing this `Header`. -+ /// -+ /// # Safety -+ /// -+ /// The provided raw pointer must point at the header of a task. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ pub(super) unsafe fn get_tracing_id(me: &NonNull
) -> Option<&tracing::Id> { -+ me.as_ref().tracing_id.as_ref() -+ } - } - - impl Trailer { -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/error.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/error.rs -index 1a8129b2..f7ead77b 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/error.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/error.rs -@@ -2,12 +2,13 @@ use std::any::Any; - use std::fmt; - use std::io; - -+use super::Id; - use crate::util::SyncWrapper; -- - cfg_rt! { - /// Task failed to execute to completion. - pub struct JoinError { - repr: Repr, -+ id: Id, - } - } - -@@ -17,15 +18,17 @@ enum Repr { - } - - impl JoinError { -- pub(crate) fn cancelled() -> JoinError { -+ pub(crate) fn cancelled(id: Id) -> JoinError { - JoinError { - repr: Repr::Cancelled, -+ id, - } - } - -- pub(crate) fn panic(err: Box) -> JoinError { -+ pub(crate) fn panic(id: Id, err: Box) -> JoinError { - JoinError { - repr: Repr::Panic(SyncWrapper::new(err)), -+ id, - } - } - -@@ -79,6 +82,7 @@ impl JoinError { - /// } - /// } - /// ``` -+ #[track_caller] - pub fn into_panic(self) -> Box { - self.try_into_panic() - .expect("`JoinError` reason is not a panic.") -@@ -111,13 +115,28 @@ impl JoinError { - _ => Err(self), - } - } -+ -+ /// Returns a [task ID] that identifies the task which errored relative to -+ /// other currently spawned tasks. -+ /// -+ /// **Note**: This is an [unstable API][unstable]. The public API of this type -+ /// may break in 1.x releases. See [the documentation on unstable -+ /// features][unstable] for details. -+ /// -+ /// [task ID]: crate::task::Id -+ /// [unstable]: crate#unstable-features -+ #[cfg(tokio_unstable)] -+ #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))] -+ pub fn id(&self) -> Id { -+ self.id -+ } - } - - impl fmt::Display for JoinError { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - match &self.repr { -- Repr::Cancelled => write!(fmt, "cancelled"), -- Repr::Panic(_) => write!(fmt, "panic"), -+ Repr::Cancelled => write!(fmt, "task {} was cancelled", self.id), -+ Repr::Panic(_) => write!(fmt, "task {} panicked", self.id), - } - } - } -@@ -125,8 +144,8 @@ impl fmt::Display for JoinError { - impl fmt::Debug for JoinError { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - match &self.repr { -- Repr::Cancelled => write!(fmt, "JoinError::Cancelled"), -- Repr::Panic(_) => write!(fmt, "JoinError::Panic(...)"), -+ Repr::Cancelled => write!(fmt, "JoinError::Cancelled({:?})", self.id), -+ Repr::Panic(_) => write!(fmt, "JoinError::Panic({:?}, ...)", self.id), - } - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/harness.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/harness.rs -index 0996e523..8e3c3d14 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/harness.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/harness.rs -@@ -1,8 +1,8 @@ - use crate::future::Future; --use crate::runtime::task::core::{Cell, Core, CoreStage, Header, Trailer}; --use crate::runtime::task::state::Snapshot; -+use crate::runtime::task::core::{Cell, Core, Header, Trailer}; -+use crate::runtime::task::state::{Snapshot, State}; - use crate::runtime::task::waker::waker_ref; --use crate::runtime::task::{JoinError, Notified, Schedule, Task}; -+use crate::runtime::task::{JoinError, Notified, RawTask, Schedule, Task}; - - use std::mem; - use std::mem::ManuallyDrop; -@@ -26,8 +26,16 @@ where - } - } - -+ fn header_ptr(&self) -> NonNull
{ -+ self.cell.cast() -+ } -+ - fn header(&self) -> &Header { -- unsafe { &self.cell.as_ref().header } -+ unsafe { &*self.header_ptr().as_ptr() } -+ } -+ -+ fn state(&self) -> &State { -+ &self.header().state - } - - fn trailer(&self) -> &Trailer { -@@ -39,11 +47,102 @@ where - } - } - -+/// Task operations that can be implemented without being generic over the -+/// scheduler or task. Only one version of these methods should exist in the -+/// final binary. -+impl RawTask { -+ pub(super) fn drop_reference(self) { -+ if self.state().ref_dec() { -+ self.dealloc(); -+ } -+ } -+ -+ /// This call consumes a ref-count and notifies the task. This will create a -+ /// new Notified and submit it if necessary. -+ /// -+ /// The caller does not need to hold a ref-count besides the one that was -+ /// passed to this call. -+ pub(super) fn wake_by_val(&self) { -+ use super::state::TransitionToNotifiedByVal; -+ -+ match self.state().transition_to_notified_by_val() { -+ TransitionToNotifiedByVal::Submit => { -+ // The caller has given us a ref-count, and the transition has -+ // created a new ref-count, so we now hold two. We turn the new -+ // ref-count Notified and pass it to the call to `schedule`. -+ // -+ // The old ref-count is retained for now to ensure that the task -+ // is not dropped during the call to `schedule` if the call -+ // drops the task it was given. -+ self.schedule(); -+ -+ // Now that we have completed the call to schedule, we can -+ // release our ref-count. -+ self.drop_reference(); -+ } -+ TransitionToNotifiedByVal::Dealloc => { -+ self.dealloc(); -+ } -+ TransitionToNotifiedByVal::DoNothing => {} -+ } -+ } -+ -+ /// This call notifies the task. It will not consume any ref-counts, but the -+ /// caller should hold a ref-count. This will create a new Notified and -+ /// submit it if necessary. -+ pub(super) fn wake_by_ref(&self) { -+ use super::state::TransitionToNotifiedByRef; -+ -+ match self.state().transition_to_notified_by_ref() { -+ TransitionToNotifiedByRef::Submit => { -+ // The transition above incremented the ref-count for a new task -+ // and the caller also holds a ref-count. The caller's ref-count -+ // ensures that the task is not destroyed even if the new task -+ // is dropped before `schedule` returns. -+ self.schedule(); -+ } -+ TransitionToNotifiedByRef::DoNothing => {} -+ } -+ } -+ -+ /// Remotely aborts the task. -+ /// -+ /// The caller should hold a ref-count, but we do not consume it. -+ /// -+ /// This is similar to `shutdown` except that it asks the runtime to perform -+ /// the shutdown. This is necessary to avoid the shutdown happening in the -+ /// wrong thread for non-Send tasks. -+ pub(super) fn remote_abort(&self) { -+ if self.state().transition_to_notified_and_cancel() { -+ // The transition has created a new ref-count, which we turn into -+ // a Notified and pass to the task. -+ // -+ // Since the caller holds a ref-count, the task cannot be destroyed -+ // before the call to `schedule` returns even if the call drops the -+ // `Notified` internally. -+ self.schedule(); -+ } -+ } -+ -+ /// Try to set the waker notified when the task is complete. Returns true if -+ /// the task has already completed. If this call returns false, then the -+ /// waker will not be notified. -+ pub(super) fn try_set_join_waker(&self, waker: &Waker) -> bool { -+ can_read_output(self.header(), self.trailer(), waker) -+ } -+} -+ - impl Harness - where - T: Future, - S: Schedule, - { -+ pub(super) fn drop_reference(self) { -+ if self.state().ref_dec() { -+ self.dealloc(); -+ } -+ } -+ - /// Polls the inner future. A ref-count is consumed. - /// - /// All necessary state checks and transitions are performed. -@@ -91,32 +190,32 @@ where - fn poll_inner(&self) -> PollFuture { - use super::state::{TransitionToIdle, TransitionToRunning}; - -- match self.header().state.transition_to_running() { -+ match self.state().transition_to_running() { - TransitionToRunning::Success => { -- let waker_ref = waker_ref::(self.header()); -- let cx = Context::from_waker(&*waker_ref); -- let res = poll_future(&self.core().stage, cx); -+ let header_ptr = self.header_ptr(); -+ let waker_ref = waker_ref::(&header_ptr); -+ let cx = Context::from_waker(&waker_ref); -+ let res = poll_future(self.core(), cx); - - if res == Poll::Ready(()) { - // The future completed. Move on to complete the task. - return PollFuture::Complete; - } - -- match self.header().state.transition_to_idle() { -+ match self.state().transition_to_idle() { - TransitionToIdle::Ok => PollFuture::Done, - TransitionToIdle::OkNotified => PollFuture::Notified, - TransitionToIdle::OkDealloc => PollFuture::Dealloc, - TransitionToIdle::Cancelled => { - // The transition to idle failed because the task was - // cancelled during the poll. -- -- cancel_task(&self.core().stage); -+ cancel_task(self.core()); - PollFuture::Complete - } - } - } - TransitionToRunning::Cancelled => { -- cancel_task(&self.core().stage); -+ cancel_task(self.core()); - PollFuture::Complete - } - TransitionToRunning::Failed => PollFuture::Done, -@@ -131,7 +230,7 @@ where - /// there is nothing further to do. When the task completes running, it will - /// notice the `CANCELLED` bit and finalize the task. - pub(super) fn shutdown(self) { -- if !self.header().state.transition_to_shutdown() { -+ if !self.state().transition_to_shutdown() { - // The task is concurrently running. No further work needed. - self.drop_reference(); - return; -@@ -139,7 +238,7 @@ where - - // By transitioning the lifecycle to `Running`, we have permission to - // drop the future. -- cancel_task(&self.core().stage); -+ cancel_task(self.core()); - self.complete(); - } - -@@ -150,6 +249,19 @@ where - // Check causality - self.core().stage.with_mut(drop); - -+ // Safety: The caller of this method just transitioned our ref-count to -+ // zero, so it is our responsibility to release the allocation. -+ // -+ // We don't hold any references into the allocation at this point, but -+ // it is possible for another thread to still hold a `&State` into the -+ // allocation if that other thread has decremented its last ref-count, -+ // but has not yet returned from the relevant method on `State`. -+ // -+ // However, the `State` type consists of just an `AtomicUsize`, and an -+ // `AtomicUsize` wraps the entirety of its contents in an `UnsafeCell`. -+ // As explained in the documentation for `UnsafeCell`, such references -+ // are allowed to be dangling after their last use, even if the -+ // reference has not yet gone out of scope. - unsafe { - drop(Box::from_raw(self.cell.as_ptr())); - } -@@ -160,122 +272,30 @@ where - /// Read the task output into `dst`. - pub(super) fn try_read_output(self, dst: &mut Poll>, waker: &Waker) { - if can_read_output(self.header(), self.trailer(), waker) { -- *dst = Poll::Ready(self.core().stage.take_output()); -+ *dst = Poll::Ready(self.core().take_output()); - } - } - - pub(super) fn drop_join_handle_slow(self) { -- let mut maybe_panic = None; -- - // Try to unset `JOIN_INTEREST`. This must be done as a first step in - // case the task concurrently completed. -- if self.header().state.unset_join_interested().is_err() { -+ if self.state().unset_join_interested().is_err() { - // It is our responsibility to drop the output. This is critical as - // the task output may not be `Send` and as such must remain with - // the scheduler or `JoinHandle`. i.e. if the output remains in the - // task structure until the task is deallocated, it may be dropped - // by a Waker on any arbitrary thread. -- let panic = panic::catch_unwind(panic::AssertUnwindSafe(|| { -- self.core().stage.drop_future_or_output(); -+ // -+ // Panics are delivered to the user via the `JoinHandle`. Given that -+ // they are dropping the `JoinHandle`, we assume they are not -+ // interested in the panic and swallow it. -+ let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { -+ self.core().drop_future_or_output(); - })); -- -- if let Err(panic) = panic { -- maybe_panic = Some(panic); -- } - } - - // Drop the `JoinHandle` reference, possibly deallocating the task - self.drop_reference(); -- -- if let Some(panic) = maybe_panic { -- panic::resume_unwind(panic); -- } -- } -- -- /// Remotely aborts the task. -- /// -- /// The caller should hold a ref-count, but we do not consume it. -- /// -- /// This is similar to `shutdown` except that it asks the runtime to perform -- /// the shutdown. This is necessary to avoid the shutdown happening in the -- /// wrong thread for non-Send tasks. -- pub(super) fn remote_abort(self) { -- if self.header().state.transition_to_notified_and_cancel() { -- // The transition has created a new ref-count, which we turn into -- // a Notified and pass to the task. -- // -- // Since the caller holds a ref-count, the task cannot be destroyed -- // before the call to `schedule` returns even if the call drops the -- // `Notified` internally. -- self.core() -- .scheduler -- .schedule(Notified(self.get_new_task())); -- } -- } -- -- // ===== waker behavior ===== -- -- /// This call consumes a ref-count and notifies the task. This will create a -- /// new Notified and submit it if necessary. -- /// -- /// The caller does not need to hold a ref-count besides the one that was -- /// passed to this call. -- pub(super) fn wake_by_val(self) { -- use super::state::TransitionToNotifiedByVal; -- -- match self.header().state.transition_to_notified_by_val() { -- TransitionToNotifiedByVal::Submit => { -- // The caller has given us a ref-count, and the transition has -- // created a new ref-count, so we now hold two. We turn the new -- // ref-count Notified and pass it to the call to `schedule`. -- // -- // The old ref-count is retained for now to ensure that the task -- // is not dropped during the call to `schedule` if the call -- // drops the task it was given. -- self.core() -- .scheduler -- .schedule(Notified(self.get_new_task())); -- -- // Now that we have completed the call to schedule, we can -- // release our ref-count. -- self.drop_reference(); -- } -- TransitionToNotifiedByVal::Dealloc => { -- self.dealloc(); -- } -- TransitionToNotifiedByVal::DoNothing => {} -- } -- } -- -- /// This call notifies the task. It will not consume any ref-counts, but the -- /// caller should hold a ref-count. This will create a new Notified and -- /// submit it if necessary. -- pub(super) fn wake_by_ref(&self) { -- use super::state::TransitionToNotifiedByRef; -- -- match self.header().state.transition_to_notified_by_ref() { -- TransitionToNotifiedByRef::Submit => { -- // The transition above incremented the ref-count for a new task -- // and the caller also holds a ref-count. The caller's ref-count -- // ensures that the task is not destroyed even if the new task -- // is dropped before `schedule` returns. -- self.core() -- .scheduler -- .schedule(Notified(self.get_new_task())); -- } -- TransitionToNotifiedByRef::DoNothing => {} -- } -- } -- -- pub(super) fn drop_reference(self) { -- if self.header().state.ref_dec() { -- self.dealloc(); -- } -- } -- -- #[cfg(all(tokio_unstable, feature = "tracing"))] -- pub(super) fn id(&self) -> Option<&tracing::Id> { -- self.header().id.as_ref() - } - - // ====== internal ====== -@@ -285,7 +305,7 @@ where - // The future has completed and its output has been written to the task - // stage. We transition from running to complete. - -- let snapshot = self.header().state.transition_to_complete(); -+ let snapshot = self.state().transition_to_complete(); - - // We catch panics here in case dropping the future or waking the - // JoinHandle panics. -@@ -294,10 +314,11 @@ where - // The `JoinHandle` is not interested in the output of - // this task. It is our responsibility to drop the - // output. -- self.core().stage.drop_future_or_output(); -- } else if snapshot.has_join_waker() { -- // Notify the join handle. The previous transition obtains the -- // lock on the waker cell. -+ self.core().drop_future_or_output(); -+ } else if snapshot.is_join_waker_set() { -+ // Notify the waker. Reading the waker field is safe per rule 4 -+ // in task/mod.rs, since the JOIN_WAKER bit is set and the call -+ // to transition_to_complete() above set the COMPLETE bit. - self.trailer().wake_join(); - } - })); -@@ -305,7 +326,7 @@ where - // The task has completed execution and will no longer be scheduled. - let num_release = self.release(); - -- if self.header().state.transition_to_terminal(num_release) { -+ if self.state().transition_to_terminal(num_release) { - self.dealloc(); - } - } -@@ -347,36 +368,30 @@ fn can_read_output(header: &Header, trailer: &Trailer, waker: &Waker) -> bool { - debug_assert!(snapshot.is_join_interested()); - - if !snapshot.is_complete() { -- // The waker must be stored in the task struct. -- let res = if snapshot.has_join_waker() { -- // There already is a waker stored in the struct. If it matches -- // the provided waker, then there is no further work to do. -- // Otherwise, the waker must be swapped. -- let will_wake = unsafe { -- // Safety: when `JOIN_INTEREST` is set, only `JOIN_HANDLE` -- // may mutate the `waker` field. -- trailer.will_wake(waker) -- }; -- -- if will_wake { -- // The task is not complete **and** the waker is up to date, -- // there is nothing further that needs to be done. -+ // If the task is not complete, try storing the provided waker in the -+ // task's waker field. -+ -+ let res = if snapshot.is_join_waker_set() { -+ // If JOIN_WAKER is set, then JoinHandle has previously stored a -+ // waker in the waker field per step (iii) of rule 5 in task/mod.rs. -+ -+ // Optimization: if the stored waker and the provided waker wake the -+ // same task, then return without touching the waker field. (Reading -+ // the waker field below is safe per rule 3 in task/mod.rs.) -+ if unsafe { trailer.will_wake(waker) } { - return false; - } - -- // Unset the `JOIN_WAKER` to gain mutable access to the `waker` -- // field then update the field with the new join worker. -- // -- // This requires two atomic operations, unsetting the bit and -- // then resetting it. If the task transitions to complete -- // concurrently to either one of those operations, then setting -- // the join waker fails and we proceed to reading the task -- // output. -+ // Otherwise swap the stored waker with the provided waker by -+ // following the rule 5 in task/mod.rs. - header - .state - .unset_waker() - .and_then(|snapshot| set_join_waker(header, trailer, waker.clone(), snapshot)) - } else { -+ // If JOIN_WAKER is unset, then JoinHandle has mutable access to the -+ // waker field per rule 2 in task/mod.rs; therefore, skip step (i) -+ // of rule 5 and try to store the provided waker in the waker field. - set_join_waker(header, trailer, waker.clone(), snapshot) - }; - -@@ -397,7 +412,7 @@ fn set_join_waker( - snapshot: Snapshot, - ) -> Result { - assert!(snapshot.is_join_interested()); -- assert!(!snapshot.has_join_waker()); -+ assert!(!snapshot.is_join_waker_set()); - - // Safety: Only the `JoinHandle` may set the `waker` field. When - // `JOIN_INTEREST` is **not** set, nothing else will touch the field. -@@ -426,31 +441,31 @@ enum PollFuture { - } - - /// Cancels the task and store the appropriate error in the stage field. --fn cancel_task(stage: &CoreStage) { -+fn cancel_task(core: &Core) { - // Drop the future from a panic guard. - let res = panic::catch_unwind(panic::AssertUnwindSafe(|| { -- stage.drop_future_or_output(); -+ core.drop_future_or_output(); - })); - - match res { - Ok(()) => { -- stage.store_output(Err(JoinError::cancelled())); -+ core.store_output(Err(JoinError::cancelled(core.task_id))); - } - Err(panic) => { -- stage.store_output(Err(JoinError::panic(panic))); -+ core.store_output(Err(JoinError::panic(core.task_id, panic))); - } - } - } - - /// Polls the future. If the future completes, the output is written to the - /// stage field. --fn poll_future(core: &CoreStage, cx: Context<'_>) -> Poll<()> { -+fn poll_future(core: &Core, cx: Context<'_>) -> Poll<()> { - // Poll the future. - let output = panic::catch_unwind(panic::AssertUnwindSafe(|| { -- struct Guard<'a, T: Future> { -- core: &'a CoreStage, -+ struct Guard<'a, T: Future, S: Schedule> { -+ core: &'a Core, - } -- impl<'a, T: Future> Drop for Guard<'a, T> { -+ impl<'a, T: Future, S: Schedule> Drop for Guard<'a, T, S> { - fn drop(&mut self) { - // If the future panics on poll, we drop it inside the panic - // guard. -@@ -467,13 +482,20 @@ fn poll_future(core: &CoreStage, cx: Context<'_>) -> Poll<()> { - let output = match output { - Ok(Poll::Pending) => return Poll::Pending, - Ok(Poll::Ready(output)) => Ok(output), -- Err(panic) => Err(JoinError::panic(panic)), -+ Err(panic) => { -+ core.scheduler.unhandled_panic(); -+ Err(JoinError::panic(core.task_id, panic)) -+ } - }; - - // Catch and ignore panics if the future panics on drop. -- let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { -+ let res = panic::catch_unwind(panic::AssertUnwindSafe(|| { - core.store_output(output); - })); - -+ if res.is_err() { -+ core.scheduler.unhandled_panic(); -+ } -+ - Poll::Ready(()) - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/id.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/id.rs -new file mode 100644 -index 00000000..2b0d95c0 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/id.rs -@@ -0,0 +1,87 @@ -+use crate::runtime::context; -+ -+use std::fmt; -+ -+/// An opaque ID that uniquely identifies a task relative to all other currently -+/// running tasks. -+/// -+/// # Notes -+/// -+/// - Task IDs are unique relative to other *currently running* tasks. When a -+/// task completes, the same ID may be used for another task. -+/// - Task IDs are *not* sequential, and do not indicate the order in which -+/// tasks are spawned, what runtime a task is spawned on, or any other data. -+/// - The task ID of the currently running task can be obtained from inside the -+/// task via the [`task::try_id()`](crate::task::try_id()) and -+/// [`task::id()`](crate::task::id()) functions and from outside the task via -+/// the [`JoinHandle::id()`](crate::task::JoinHandle::id()) function. -+/// -+/// **Note**: This is an [unstable API][unstable]. The public API of this type -+/// may break in 1.x releases. See [the documentation on unstable -+/// features][unstable] for details. -+/// -+/// [unstable]: crate#unstable-features -+#[cfg_attr(docsrs, doc(cfg(all(feature = "rt", tokio_unstable))))] -+#[cfg_attr(not(tokio_unstable), allow(unreachable_pub))] -+#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq)] -+pub struct Id(u64); -+ -+/// Returns the [`Id`] of the currently running task. -+/// -+/// # Panics -+/// -+/// This function panics if called from outside a task. Please note that calls -+/// to `block_on` do not have task IDs, so the method will panic if called from -+/// within a call to `block_on`. For a version of this function that doesn't -+/// panic, see [`task::try_id()`](crate::runtime::task::try_id()). -+/// -+/// **Note**: This is an [unstable API][unstable]. The public API of this type -+/// may break in 1.x releases. See [the documentation on unstable -+/// features][unstable] for details. -+/// -+/// [task ID]: crate::task::Id -+/// [unstable]: crate#unstable-features -+#[cfg_attr(not(tokio_unstable), allow(unreachable_pub))] -+#[track_caller] -+pub fn id() -> Id { -+ context::current_task_id().expect("Can't get a task id when not inside a task") -+} -+ -+/// Returns the [`Id`] of the currently running task, or `None` if called outside -+/// of a task. -+/// -+/// This function is similar to [`task::id()`](crate::runtime::task::id()), except -+/// that it returns `None` rather than panicking if called outside of a task -+/// context. -+/// -+/// **Note**: This is an [unstable API][unstable]. The public API of this type -+/// may break in 1.x releases. See [the documentation on unstable -+/// features][unstable] for details. -+/// -+/// [task ID]: crate::task::Id -+/// [unstable]: crate#unstable-features -+#[cfg_attr(not(tokio_unstable), allow(unreachable_pub))] -+#[track_caller] -+pub fn try_id() -> Option { -+ context::current_task_id() -+} -+ -+impl fmt::Display for Id { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ self.0.fmt(f) -+ } -+} -+ -+impl Id { -+ pub(crate) fn next() -> Self { -+ use crate::loom::sync::atomic::{Ordering::Relaxed, StaticAtomicU64}; -+ -+ static NEXT_ID: StaticAtomicU64 = StaticAtomicU64::new(1); -+ -+ Self(NEXT_ID.fetch_add(1, Relaxed)) -+ } -+ -+ pub(crate) fn as_u64(&self) -> u64 { -+ self.0 -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/join.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/join.rs -index 0abbff20..11c6bcdb 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/join.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/join.rs -@@ -1,16 +1,19 @@ --use crate::runtime::task::RawTask; -+use crate::runtime::task::{Header, RawTask}; - - use std::fmt; - use std::future::Future; - use std::marker::PhantomData; -+use std::panic::{RefUnwindSafe, UnwindSafe}; - use std::pin::Pin; --use std::task::{Context, Poll}; -+use std::task::{Context, Poll, Waker}; - - cfg_rt! { - /// An owned permission to join on a task (await its termination). - /// -- /// This can be thought of as the equivalent of [`std::thread::JoinHandle`] for -- /// a task rather than a thread. -+ /// This can be thought of as the equivalent of [`std::thread::JoinHandle`] -+ /// for a Tokio task rather than a thread. Note that the background task -+ /// associated with this `JoinHandle` started running immediately when you -+ /// called spawn, even if you have not yet awaited the `JoinHandle`. - /// - /// A `JoinHandle` *detaches* the associated task when it is dropped, which - /// means that there is no longer any handle to the task, and no way to `join` -@@ -19,6 +22,15 @@ cfg_rt! { - /// This `struct` is created by the [`task::spawn`] and [`task::spawn_blocking`] - /// functions. - /// -+ /// # Cancel safety -+ /// -+ /// The `&mut JoinHandle` type is cancel safe. If it is used as the event -+ /// in a `tokio::select!` statement and some other branch completes first, -+ /// then it is guaranteed that the output of the task is not lost. -+ /// -+ /// If a `JoinHandle` is dropped, then the task continues running in the -+ /// background and its return value is lost. -+ /// - /// # Examples - /// - /// Creation from [`task::spawn`]: -@@ -142,7 +154,7 @@ cfg_rt! { - /// [`std::thread::JoinHandle`]: std::thread::JoinHandle - /// [`JoinError`]: crate::task::JoinError - pub struct JoinHandle { -- raw: Option, -+ raw: RawTask, - _p: PhantomData, - } - } -@@ -150,10 +162,13 @@ cfg_rt! { - unsafe impl Send for JoinHandle {} - unsafe impl Sync for JoinHandle {} - -+impl UnwindSafe for JoinHandle {} -+impl RefUnwindSafe for JoinHandle {} -+ - impl JoinHandle { - pub(super) fn new(raw: RawTask) -> JoinHandle { - JoinHandle { -- raw: Some(raw), -+ raw, - _p: PhantomData, - } - } -@@ -167,35 +182,129 @@ impl JoinHandle { - /// ```rust - /// use tokio::time; - /// -- /// #[tokio::main] -- /// async fn main() { -- /// let mut handles = Vec::new(); -- /// -- /// handles.push(tokio::spawn(async { -- /// time::sleep(time::Duration::from_secs(10)).await; -- /// true -- /// })); -- /// -- /// handles.push(tokio::spawn(async { -- /// time::sleep(time::Duration::from_secs(10)).await; -- /// false -- /// })); -- /// -- /// for handle in &handles { -- /// handle.abort(); -- /// } -- /// -- /// for handle in handles { -- /// assert!(handle.await.unwrap_err().is_cancelled()); -- /// } -+ /// # #[tokio::main(flavor = "current_thread", start_paused = true)] -+ /// # async fn main() { -+ /// let mut handles = Vec::new(); -+ /// -+ /// handles.push(tokio::spawn(async { -+ /// time::sleep(time::Duration::from_secs(10)).await; -+ /// true -+ /// })); -+ /// -+ /// handles.push(tokio::spawn(async { -+ /// time::sleep(time::Duration::from_secs(10)).await; -+ /// false -+ /// })); -+ /// -+ /// for handle in &handles { -+ /// handle.abort(); -+ /// } -+ /// -+ /// for handle in handles { -+ /// assert!(handle.await.unwrap_err().is_cancelled()); - /// } -+ /// # } - /// ``` - /// [cancelled]: method@super::error::JoinError::is_cancelled - pub fn abort(&self) { -- if let Some(raw) = self.raw { -- raw.remote_abort(); -+ self.raw.remote_abort(); -+ } -+ -+ /// Checks if the task associated with this `JoinHandle` has finished. -+ /// -+ /// Please note that this method can return `false` even if [`abort`] has been -+ /// called on the task. This is because the cancellation process may take -+ /// some time, and this method does not return `true` until it has -+ /// completed. -+ /// -+ /// ```rust -+ /// use tokio::time; -+ /// -+ /// # #[tokio::main(flavor = "current_thread", start_paused = true)] -+ /// # async fn main() { -+ /// let handle1 = tokio::spawn(async { -+ /// // do some stuff here -+ /// }); -+ /// let handle2 = tokio::spawn(async { -+ /// // do some other stuff here -+ /// time::sleep(time::Duration::from_secs(10)).await; -+ /// }); -+ /// // Wait for the task to finish -+ /// handle2.abort(); -+ /// time::sleep(time::Duration::from_secs(1)).await; -+ /// assert!(handle1.is_finished()); -+ /// assert!(handle2.is_finished()); -+ /// # } -+ /// ``` -+ /// [`abort`]: method@JoinHandle::abort -+ pub fn is_finished(&self) -> bool { -+ let state = self.raw.header().state.load(); -+ state.is_complete() -+ } -+ -+ /// Set the waker that is notified when the task completes. -+ pub(crate) fn set_join_waker(&mut self, waker: &Waker) { -+ if self.raw.try_set_join_waker(waker) { -+ // In this case the task has already completed. We wake the waker immediately. -+ waker.wake_by_ref(); - } - } -+ -+ /// Returns a new `AbortHandle` that can be used to remotely abort this task. -+ /// -+ /// Awaiting a task cancelled by the `AbortHandle` might complete as usual if the task was -+ /// already completed at the time it was cancelled, but most likely it -+ /// will fail with a [cancelled] `JoinError`. -+ /// -+ /// ```rust -+ /// use tokio::{time, task}; -+ /// -+ /// # #[tokio::main(flavor = "current_thread", start_paused = true)] -+ /// # async fn main() { -+ /// let mut handles = Vec::new(); -+ /// -+ /// handles.push(tokio::spawn(async { -+ /// time::sleep(time::Duration::from_secs(10)).await; -+ /// true -+ /// })); -+ /// -+ /// handles.push(tokio::spawn(async { -+ /// time::sleep(time::Duration::from_secs(10)).await; -+ /// false -+ /// })); -+ /// -+ /// let abort_handles: Vec = handles.iter().map(|h| h.abort_handle()).collect(); -+ /// -+ /// for handle in abort_handles { -+ /// handle.abort(); -+ /// } -+ /// -+ /// for handle in handles { -+ /// assert!(handle.await.unwrap_err().is_cancelled()); -+ /// } -+ /// # } -+ /// ``` -+ /// [cancelled]: method@super::error::JoinError::is_cancelled -+ pub fn abort_handle(&self) -> super::AbortHandle { -+ self.raw.ref_inc(); -+ super::AbortHandle::new(self.raw) -+ } -+ -+ /// Returns a [task ID] that uniquely identifies this task relative to other -+ /// currently spawned tasks. -+ /// -+ /// **Note**: This is an [unstable API][unstable]. The public API of this type -+ /// may break in 1.x releases. See [the documentation on unstable -+ /// features][unstable] for details. -+ /// -+ /// [task ID]: crate::task::Id -+ /// [unstable]: crate#unstable-features -+ #[cfg(tokio_unstable)] -+ #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))] -+ pub fn id(&self) -> super::Id { -+ // Safety: The header pointer is valid. -+ unsafe { Header::get_id(self.raw.header_ptr()) } -+ } - } - - impl Unpin for JoinHandle {} -@@ -207,14 +316,7 @@ impl Future for JoinHandle { - let mut ret = Poll::Pending; - - // Keep track of task budget -- let coop = ready!(crate::coop::poll_proceed(cx)); -- -- // Raw should always be set. If it is not, this is due to polling after -- // completion -- let raw = self -- .raw -- .as_ref() -- .expect("polling after `JoinHandle` already completed"); -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); - - // Try to read the task output. If the task is not yet complete, the - // waker is stored and is notified once the task does complete. -@@ -228,7 +330,8 @@ impl Future for JoinHandle { - // - // The type of `T` must match the task's output type. - unsafe { -- raw.try_read_output(&mut ret as *mut _ as *mut (), cx.waker()); -+ self.raw -+ .try_read_output(&mut ret as *mut _ as *mut (), cx.waker()); - } - - if ret.is_ready() { -@@ -241,13 +344,11 @@ impl Future for JoinHandle { - - impl Drop for JoinHandle { - fn drop(&mut self) { -- if let Some(raw) = self.raw.take() { -- if raw.header().state.drop_join_handle_fast().is_ok() { -- return; -- } -- -- raw.drop_join_handle_slow(); -+ if self.raw.state().drop_join_handle_fast().is_ok() { -+ return; - } -+ -+ self.raw.drop_join_handle_slow(); - } - } - -@@ -256,6 +357,9 @@ where - T: fmt::Debug, - { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- fmt.debug_struct("JoinHandle").finish() -+ // Safety: The header pointer is valid. -+ let id_ptr = unsafe { Header::get_id_ptr(self.raw.header_ptr()) }; -+ let id = unsafe { id_ptr.as_ref() }; -+ fmt.debug_struct("JoinHandle").field("id", id).finish() - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/list.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/list.rs -index 7758f8db..159c13e1 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/list.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/list.rs -@@ -84,13 +84,14 @@ impl OwnedTasks { - &self, - task: T, - scheduler: S, -+ id: super::Id, - ) -> (JoinHandle, Option>) - where - S: Schedule, - T: Future + Send + 'static, - T::Output: Send + 'static, - { -- let (task, notified, join) = super::new_task(task, scheduler); -+ let (task, notified, join) = super::new_task(task, scheduler, id); - - unsafe { - // safety: We just created the task, so we have exclusive access -@@ -163,7 +164,7 @@ impl OwnedTasks { - - // safety: We just checked that the provided task is not in some other - // linked list. -- unsafe { self.inner.lock().list.remove(task.header().into()) } -+ unsafe { self.inner.lock().list.remove(task.header_ptr()) } - } - - pub(crate) fn is_empty(&self) -> bool { -@@ -187,13 +188,14 @@ impl LocalOwnedTasks { - &self, - task: T, - scheduler: S, -+ id: super::Id, - ) -> (JoinHandle, Option>) - where - S: Schedule, - T: Future + 'static, - T::Output: 'static, - { -- let (task, notified, join) = super::new_task(task, scheduler); -+ let (task, notified, join) = super::new_task(task, scheduler, id); - - unsafe { - // safety: We just created the task, so we have exclusive access -@@ -238,7 +240,7 @@ impl LocalOwnedTasks { - self.with_inner(|inner| - // safety: We just checked that the provided task is not in some - // other linked list. -- unsafe { inner.list.remove(task.header().into()) }) -+ unsafe { inner.list.remove(task.header_ptr()) }) - } - - /// Asserts that the given task is owned by this LocalOwnedTasks and convert -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/mod.rs -index 1f18209a..55131ac5 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/mod.rs -@@ -25,7 +25,7 @@ - //! - //! The task uses a reference count to keep track of how many active references - //! exist. The Unowned reference type takes up two ref-counts. All other --//! reference types take pu a single ref-count. -+//! reference types take up a single ref-count. - //! - //! Besides the waker type, each task has at most one of each reference type. - //! -@@ -47,7 +47,8 @@ - //! - //! * JOIN_INTEREST - Is set to one if there exists a JoinHandle. - //! --//! * JOIN_WAKER - Is set to one if the JoinHandle has set a waker. -+//! * JOIN_WAKER - Acts as an access control bit for the join handle waker. The -+//! protocol for its usage is described below. - //! - //! The rest of the bits are used for the ref-count. - //! -@@ -71,10 +72,38 @@ - //! a lock for the stage field, and it can be accessed only by the thread - //! that set RUNNING to one. - //! --//! * If JOIN_WAKER is zero, then the JoinHandle has exclusive access to the --//! join handle waker. If JOIN_WAKER and COMPLETE are both one, then the --//! thread that set COMPLETE to one has exclusive access to the join handle --//! waker. -+//! * The waker field may be concurrently accessed by different threads: in one -+//! thread the runtime may complete a task and *read* the waker field to -+//! invoke the waker, and in another thread the task's JoinHandle may be -+//! polled, and if the task hasn't yet completed, the JoinHandle may *write* -+//! a waker to the waker field. The JOIN_WAKER bit ensures safe access by -+//! multiple threads to the waker field using the following rules: -+//! -+//! 1. JOIN_WAKER is initialized to zero. -+//! -+//! 2. If JOIN_WAKER is zero, then the JoinHandle has exclusive (mutable) -+//! access to the waker field. -+//! -+//! 3. If JOIN_WAKER is one, then the JoinHandle has shared (read-only) -+//! access to the waker field. -+//! -+//! 4. If JOIN_WAKER is one and COMPLETE is one, then the runtime has shared -+//! (read-only) access to the waker field. -+//! -+//! 5. If the JoinHandle needs to write to the waker field, then the -+//! JoinHandle needs to (i) successfully set JOIN_WAKER to zero if it is -+//! not already zero to gain exclusive access to the waker field per rule -+//! 2, (ii) write a waker, and (iii) successfully set JOIN_WAKER to one. -+//! -+//! 6. The JoinHandle can change JOIN_WAKER only if COMPLETE is zero (i.e. -+//! the task hasn't yet completed). -+//! -+//! Rule 6 implies that the steps (i) or (iii) of rule 5 may fail due to a -+//! race. If step (i) fails, then the attempt to write a waker is aborted. If -+//! step (iii) fails because COMPLETE is set to one by another thread after -+//! step (i), then the waker field is cleared. Once COMPLETE is one (i.e. -+//! task has completed), the JoinHandle will not modify JOIN_WAKER. After the -+//! runtime sets COMPLETE to one, it invokes the waker if there is one. - //! - //! All other fields are immutable and can be accessed immutably without - //! synchronization by anyone. -@@ -121,7 +150,7 @@ - //! 1. The output is created on the thread that the future was polled on. Since - //! only non-Send futures can have non-Send output, the future was polled on - //! the thread that the future was spawned from. --//! 2. Since JoinHandle is not Send if Output is not Send, the -+//! 2. Since `JoinHandle` is not Send if Output is not Send, the - //! JoinHandle is also on the thread that the future was spawned from. - //! 3. Thus, the JoinHandle will not move the output across threads when it - //! takes or drops the output. -@@ -135,24 +164,36 @@ - //! poll call will notice it when the poll finishes, and the task is cancelled - //! at that point. - -+// Some task infrastructure is here to support `JoinSet`, which is currently -+// unstable. This should be removed once `JoinSet` is stabilized. -+#![cfg_attr(not(tokio_unstable), allow(dead_code))] -+ - mod core; - use self::core::Cell; - use self::core::Header; - - mod error; --#[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411 - pub use self::error::JoinError; - - mod harness; - use self::harness::Harness; - -+mod id; -+#[cfg_attr(not(tokio_unstable), allow(unreachable_pub))] -+pub use id::{id, try_id, Id}; -+ - cfg_rt_multi_thread! { - mod inject; - pub(super) use self::inject::Inject; - } - -+#[cfg(feature = "rt")] -+mod abort; - mod join; --#[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411 -+ -+#[cfg(feature = "rt")] -+pub use self::abort::AbortHandle; -+ - pub use self::join::JoinHandle; - - mod list; -@@ -230,6 +271,11 @@ pub(crate) trait Schedule: Sync + Sized + 'static { - fn yield_now(&self, task: Notified) { - self.schedule(task); - } -+ -+ /// Polling the task resulted in a panic. Should the runtime shutdown? -+ fn unhandled_panic(&self) { -+ // By default, do nothing. This maintains the 1.0 behavior. -+ } - } - - cfg_rt! { -@@ -239,14 +285,15 @@ cfg_rt! { - /// notification. - fn new_task( - task: T, -- scheduler: S -+ scheduler: S, -+ id: Id, - ) -> (Task, Notified, JoinHandle) - where - S: Schedule, - T: Future + 'static, - T::Output: 'static, - { -- let raw = RawTask::new::(task, scheduler); -+ let raw = RawTask::new::(task, scheduler, id); - let task = Task { - raw, - _p: PhantomData, -@@ -264,13 +311,13 @@ cfg_rt! { - /// only when the task is not going to be stored in an `OwnedTasks` list. - /// - /// Currently only blocking tasks use this method. -- pub(crate) fn unowned(task: T, scheduler: S) -> (UnownedTask, JoinHandle) -+ pub(crate) fn unowned(task: T, scheduler: S, id: Id) -> (UnownedTask, JoinHandle) - where - S: Schedule, - T: Send + Future + 'static, - T::Output: Send + 'static, - { -- let (task, notified, join) = new_task(task, scheduler); -+ let (task, notified, join) = new_task(task, scheduler, id); - - // This transfers the ref-count of task and notified into an UnownedTask. - // This is valid because an UnownedTask holds two ref-counts. -@@ -296,6 +343,10 @@ impl Task { - fn header(&self) -> &Header { - self.raw.header() - } -+ -+ fn header_ptr(&self) -> NonNull
{ -+ self.raw.header_ptr() -+ } - } - - impl Notified { -@@ -313,7 +364,7 @@ cfg_rt_multi_thread! { - - impl Task { - fn into_raw(self) -> NonNull
{ -- let ret = self.header().into(); -+ let ret = self.raw.header_ptr(); - mem::forget(self); - ret - } -@@ -327,7 +378,7 @@ cfg_rt_multi_thread! { - } - - impl Task { -- /// Pre-emptively cancels the task as part of the shutdown process. -+ /// Preemptively cancels the task as part of the shutdown process. - pub(crate) fn shutdown(self) { - let raw = self.raw; - mem::forget(self); -@@ -347,6 +398,7 @@ impl LocalNotified { - impl UnownedTask { - // Used in test of the inject queue. - #[cfg(test)] -+ #[cfg_attr(tokio_wasm, allow(dead_code))] - pub(super) fn into_notified(self) -> Notified { - Notified(self.into_task()) - } -@@ -426,7 +478,7 @@ unsafe impl linked_list::Link for Task { - type Target = Header; - - fn as_raw(handle: &Task) -> NonNull
{ -- handle.header().into() -+ handle.raw.header_ptr() - } - - unsafe fn from_raw(ptr: NonNull
) -> Task { -@@ -434,7 +486,6 @@ unsafe impl linked_list::Link for Task { - } - - unsafe fn pointers(target: NonNull
) -> NonNull> { -- // Not super great as it avoids some of looms checking... -- NonNull::from(target.as_ref().owned.with_mut(|ptr| &mut *ptr)) -+ self::core::Trailer::addr_of_owned(Header::get_trailer(target)) - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/raw.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/raw.rs -index fbc9574f..b9700ae5 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/raw.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/raw.rs -@@ -1,5 +1,6 @@ - use crate::future::Future; --use crate::runtime::task::{Cell, Harness, Header, Schedule, State}; -+use crate::runtime::task::core::{Core, Trailer}; -+use crate::runtime::task::{Cell, Harness, Header, Id, Schedule, State}; - - use std::ptr::NonNull; - use std::task::{Poll, Waker}; -@@ -13,6 +14,9 @@ pub(super) struct Vtable { - /// Polls the future. - pub(super) poll: unsafe fn(NonNull
), - -+ /// Schedules the task for execution on the runtime. -+ pub(super) schedule: unsafe fn(NonNull
), -+ - /// Deallocates the memory. - pub(super) dealloc: unsafe fn(NonNull
), - -@@ -22,32 +26,142 @@ pub(super) struct Vtable { - /// The join handle has been dropped. - pub(super) drop_join_handle_slow: unsafe fn(NonNull
), - -- /// The task is remotely aborted. -- pub(super) remote_abort: unsafe fn(NonNull
), -+ /// An abort handle has been dropped. -+ pub(super) drop_abort_handle: unsafe fn(NonNull
), - - /// Scheduler is being shutdown. - pub(super) shutdown: unsafe fn(NonNull
), -+ -+ /// The number of bytes that the `trailer` field is offset from the header. -+ pub(super) trailer_offset: usize, -+ -+ /// The number of bytes that the `scheduler` field is offset from the header. -+ pub(super) scheduler_offset: usize, -+ -+ /// The number of bytes that the `id` field is offset from the header. -+ pub(super) id_offset: usize, - } - - /// Get the vtable for the requested `T` and `S` generics. - pub(super) fn vtable() -> &'static Vtable { - &Vtable { - poll: poll::, -+ schedule: schedule::, - dealloc: dealloc::, - try_read_output: try_read_output::, - drop_join_handle_slow: drop_join_handle_slow::, -- remote_abort: remote_abort::, -+ drop_abort_handle: drop_abort_handle::, - shutdown: shutdown::, -+ trailer_offset: OffsetHelper::::TRAILER_OFFSET, -+ scheduler_offset: OffsetHelper::::SCHEDULER_OFFSET, -+ id_offset: OffsetHelper::::ID_OFFSET, - } - } - -+/// Calling `get_trailer_offset` directly in vtable doesn't work because it -+/// prevents the vtable from being promoted to a static reference. -+/// -+/// See this thread for more info: -+/// -+struct OffsetHelper(T, S); -+impl OffsetHelper { -+ // Pass `size_of`/`align_of` as arguments rather than calling them directly -+ // inside `get_trailer_offset` because trait bounds on generic parameters -+ // of const fn are unstable on our MSRV. -+ const TRAILER_OFFSET: usize = get_trailer_offset( -+ std::mem::size_of::
(), -+ std::mem::size_of::>(), -+ std::mem::align_of::>(), -+ std::mem::align_of::(), -+ ); -+ -+ // The `scheduler` is the first field of `Core`, so it has the same -+ // offset as `Core`. -+ const SCHEDULER_OFFSET: usize = get_core_offset( -+ std::mem::size_of::
(), -+ std::mem::align_of::>(), -+ ); -+ -+ const ID_OFFSET: usize = get_id_offset( -+ std::mem::size_of::
(), -+ std::mem::align_of::>(), -+ std::mem::size_of::(), -+ std::mem::align_of::(), -+ ); -+} -+ -+/// Compute the offset of the `Trailer` field in `Cell` using the -+/// `#[repr(C)]` algorithm. -+/// -+/// Pseudo-code for the `#[repr(C)]` algorithm can be found here: -+/// -+const fn get_trailer_offset( -+ header_size: usize, -+ core_size: usize, -+ core_align: usize, -+ trailer_align: usize, -+) -> usize { -+ let mut offset = header_size; -+ -+ let core_misalign = offset % core_align; -+ if core_misalign > 0 { -+ offset += core_align - core_misalign; -+ } -+ offset += core_size; -+ -+ let trailer_misalign = offset % trailer_align; -+ if trailer_misalign > 0 { -+ offset += trailer_align - trailer_misalign; -+ } -+ -+ offset -+} -+ -+/// Compute the offset of the `Core` field in `Cell` using the -+/// `#[repr(C)]` algorithm. -+/// -+/// Pseudo-code for the `#[repr(C)]` algorithm can be found here: -+/// -+const fn get_core_offset(header_size: usize, core_align: usize) -> usize { -+ let mut offset = header_size; -+ -+ let core_misalign = offset % core_align; -+ if core_misalign > 0 { -+ offset += core_align - core_misalign; -+ } -+ -+ offset -+} -+ -+/// Compute the offset of the `Id` field in `Cell` using the -+/// `#[repr(C)]` algorithm. -+/// -+/// Pseudo-code for the `#[repr(C)]` algorithm can be found here: -+/// -+const fn get_id_offset( -+ header_size: usize, -+ core_align: usize, -+ scheduler_size: usize, -+ id_align: usize, -+) -> usize { -+ let mut offset = get_core_offset(header_size, core_align); -+ offset += scheduler_size; -+ -+ let id_misalign = offset % id_align; -+ if id_misalign > 0 { -+ offset += id_align - id_misalign; -+ } -+ -+ offset -+} -+ - impl RawTask { -- pub(super) fn new(task: T, scheduler: S) -> RawTask -+ pub(super) fn new(task: T, scheduler: S, id: Id) -> RawTask - where - T: Future, - S: Schedule, - { -- let ptr = Box::into_raw(Cell::<_, S>::new(task, scheduler, State::new())); -+ let ptr = Box::into_raw(Cell::<_, S>::new(task, scheduler, State::new(), id)); - let ptr = unsafe { NonNull::new_unchecked(ptr as *mut Header) }; - - RawTask { ptr } -@@ -57,19 +171,40 @@ impl RawTask { - RawTask { ptr } - } - -- /// Returns a reference to the task's meta structure. -- /// -- /// Safe as `Header` is `Sync`. -+ pub(super) fn header_ptr(&self) -> NonNull
{ -+ self.ptr -+ } -+ -+ pub(super) fn trailer_ptr(&self) -> NonNull { -+ unsafe { Header::get_trailer(self.ptr) } -+ } -+ -+ /// Returns a reference to the task's header. - pub(super) fn header(&self) -> &Header { - unsafe { self.ptr.as_ref() } - } - -+ /// Returns a reference to the task's trailer. -+ pub(super) fn trailer(&self) -> &Trailer { -+ unsafe { &*self.trailer_ptr().as_ptr() } -+ } -+ -+ /// Returns a reference to the task's state. -+ pub(super) fn state(&self) -> &State { -+ &self.header().state -+ } -+ - /// Safety: mutual exclusion is required to call this function. - pub(super) fn poll(self) { - let vtable = self.header().vtable; - unsafe { (vtable.poll)(self.ptr) } - } - -+ pub(super) fn schedule(self) { -+ let vtable = self.header().vtable; -+ unsafe { (vtable.schedule)(self.ptr) } -+ } -+ - pub(super) fn dealloc(self) { - let vtable = self.header().vtable; - unsafe { -@@ -89,14 +224,21 @@ impl RawTask { - unsafe { (vtable.drop_join_handle_slow)(self.ptr) } - } - -+ pub(super) fn drop_abort_handle(self) { -+ let vtable = self.header().vtable; -+ unsafe { (vtable.drop_abort_handle)(self.ptr) } -+ } -+ - pub(super) fn shutdown(self) { - let vtable = self.header().vtable; - unsafe { (vtable.shutdown)(self.ptr) } - } - -- pub(super) fn remote_abort(self) { -- let vtable = self.header().vtable; -- unsafe { (vtable.remote_abort)(self.ptr) } -+ /// Increment the task's reference count. -+ /// -+ /// Currently, this is used only when creating an `AbortHandle`. -+ pub(super) fn ref_inc(self) { -+ self.header().state.ref_inc(); - } - } - -@@ -113,6 +255,15 @@ unsafe fn poll(ptr: NonNull
) { - harness.poll(); - } - -+unsafe fn schedule(ptr: NonNull
) { -+ use crate::runtime::task::{Notified, Task}; -+ -+ let scheduler = Header::get_scheduler::(ptr); -+ scheduler -+ .as_ref() -+ .schedule(Notified(Task::from_raw(ptr.cast()))); -+} -+ - unsafe fn dealloc(ptr: NonNull
) { - let harness = Harness::::from_raw(ptr); - harness.dealloc(); -@@ -134,9 +285,9 @@ unsafe fn drop_join_handle_slow(ptr: NonNull
) { - harness.drop_join_handle_slow() - } - --unsafe fn remote_abort(ptr: NonNull
) { -+unsafe fn drop_abort_handle(ptr: NonNull
) { - let harness = Harness::::from_raw(ptr); -- harness.remote_abort() -+ harness.drop_reference(); - } - - unsafe fn shutdown(ptr: NonNull
) { -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/state.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/state.rs -index c2d5b28e..77283125 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/state.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/state.rs -@@ -378,7 +378,7 @@ impl State { - pub(super) fn set_join_waker(&self) -> UpdateResult { - self.fetch_update(|curr| { - assert!(curr.is_join_interested()); -- assert!(!curr.has_join_waker()); -+ assert!(!curr.is_join_waker_set()); - - if curr.is_complete() { - return None; -@@ -398,7 +398,7 @@ impl State { - pub(super) fn unset_waker(&self) -> UpdateResult { - self.fetch_update(|curr| { - assert!(curr.is_join_interested()); -- assert!(curr.has_join_waker()); -+ assert!(curr.is_join_waker_set()); - - if curr.is_complete() { - return None; -@@ -546,7 +546,7 @@ impl Snapshot { - self.0 &= !JOIN_INTEREST - } - -- pub(super) fn has_join_waker(self) -> bool { -+ pub(super) fn is_join_waker_set(self) -> bool { - self.0 & JOIN_WAKER == JOIN_WAKER - } - -@@ -588,7 +588,7 @@ impl fmt::Debug for Snapshot { - .field("is_notified", &self.is_notified()) - .field("is_cancelled", &self.is_cancelled()) - .field("is_join_interested", &self.is_join_interested()) -- .field("has_join_waker", &self.has_join_waker()) -+ .field("is_join_waker_set", &self.is_join_waker_set()) - .field("ref_count", &self.ref_count()) - .finish() - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/task/waker.rs b/KubeOS-Rust/vendor/tokio/src/runtime/task/waker.rs -index b7313b4c..b5f5ace9 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/task/waker.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/task/waker.rs -@@ -1,6 +1,5 @@ - use crate::future::Future; --use crate::runtime::task::harness::Harness; --use crate::runtime::task::{Header, Schedule}; -+use crate::runtime::task::{Header, RawTask, Schedule}; - - use std::marker::PhantomData; - use std::mem::ManuallyDrop; -@@ -13,9 +12,9 @@ pub(super) struct WakerRef<'a, S: 'static> { - _p: PhantomData<(&'a Header, S)>, - } - --/// Returns a `WakerRef` which avoids having to pre-emptively increase the -+/// Returns a `WakerRef` which avoids having to preemptively increase the - /// refcount if there is no need to do so. --pub(super) fn waker_ref(header: &Header) -> WakerRef<'_, S> -+pub(super) fn waker_ref(header: &NonNull
) -> WakerRef<'_, S> - where - T: Future, - S: Schedule, -@@ -28,7 +27,7 @@ where - // point and not an *owned* waker, we must ensure that `drop` is never - // called on this waker instance. This is done by wrapping it with - // `ManuallyDrop` and then never calling drop. -- let waker = unsafe { ManuallyDrop::new(Waker::from_raw(raw_waker::(header))) }; -+ let waker = unsafe { ManuallyDrop::new(Waker::from_raw(raw_waker(*header))) }; - - WakerRef { - waker, -@@ -46,8 +45,8 @@ impl ops::Deref for WakerRef<'_, S> { - - cfg_trace! { - macro_rules! trace { -- ($harness:expr, $op:expr) => { -- if let Some(id) = $harness.id() { -+ ($header:expr, $op:expr) => { -+ if let Some(id) = Header::get_tracing_id(&$header) { - tracing::trace!( - target: "tokio::task::waker", - op = $op, -@@ -60,71 +59,46 @@ cfg_trace! { - - cfg_not_trace! { - macro_rules! trace { -- ($harness:expr, $op:expr) => { -+ ($header:expr, $op:expr) => { - // noop -- let _ = &$harness; -+ let _ = &$header; - } - } - } - --unsafe fn clone_waker(ptr: *const ()) -> RawWaker --where -- T: Future, -- S: Schedule, --{ -- let header = ptr as *const Header; -- let ptr = NonNull::new_unchecked(ptr as *mut Header); -- let harness = Harness::::from_raw(ptr); -- trace!(harness, "waker.clone"); -- (*header).state.ref_inc(); -- raw_waker::(header) -+unsafe fn clone_waker(ptr: *const ()) -> RawWaker { -+ let header = NonNull::new_unchecked(ptr as *mut Header); -+ trace!(header, "waker.clone"); -+ header.as_ref().state.ref_inc(); -+ raw_waker(header) - } - --unsafe fn drop_waker(ptr: *const ()) --where -- T: Future, -- S: Schedule, --{ -+unsafe fn drop_waker(ptr: *const ()) { - let ptr = NonNull::new_unchecked(ptr as *mut Header); -- let harness = Harness::::from_raw(ptr); -- trace!(harness, "waker.drop"); -- harness.drop_reference(); -+ trace!(ptr, "waker.drop"); -+ let raw = RawTask::from_raw(ptr); -+ raw.drop_reference(); - } - --unsafe fn wake_by_val(ptr: *const ()) --where -- T: Future, -- S: Schedule, --{ -+unsafe fn wake_by_val(ptr: *const ()) { - let ptr = NonNull::new_unchecked(ptr as *mut Header); -- let harness = Harness::::from_raw(ptr); -- trace!(harness, "waker.wake"); -- harness.wake_by_val(); -+ trace!(ptr, "waker.wake"); -+ let raw = RawTask::from_raw(ptr); -+ raw.wake_by_val(); - } - - // Wake without consuming the waker --unsafe fn wake_by_ref(ptr: *const ()) --where -- T: Future, -- S: Schedule, --{ -+unsafe fn wake_by_ref(ptr: *const ()) { - let ptr = NonNull::new_unchecked(ptr as *mut Header); -- let harness = Harness::::from_raw(ptr); -- trace!(harness, "waker.wake_by_ref"); -- harness.wake_by_ref(); -+ trace!(ptr, "waker.wake_by_ref"); -+ let raw = RawTask::from_raw(ptr); -+ raw.wake_by_ref(); - } - --fn raw_waker(header: *const Header) -> RawWaker --where -- T: Future, -- S: Schedule, --{ -- let ptr = header as *const (); -- let vtable = &RawWakerVTable::new( -- clone_waker::, -- wake_by_val::, -- wake_by_ref::, -- drop_waker::, -- ); -- RawWaker::new(ptr, vtable) -+static WAKER_VTABLE: RawWakerVTable = -+ RawWakerVTable::new(clone_waker, wake_by_val, wake_by_ref, drop_waker); -+ -+fn raw_waker(header: NonNull
) -> RawWaker { -+ let ptr = header.as_ptr() as *const (); -+ RawWaker::new(ptr, &WAKER_VTABLE) - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_blocking.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_blocking.rs -index 8fb54c56..5c4aeae3 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_blocking.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_blocking.rs -@@ -23,6 +23,77 @@ fn blocking_shutdown() { - }); - } - -+#[test] -+fn spawn_mandatory_blocking_should_always_run() { -+ use crate::runtime::tests::loom_oneshot; -+ loom::model(|| { -+ let rt = runtime::Builder::new_current_thread().build().unwrap(); -+ -+ let (tx, rx) = loom_oneshot::channel(); -+ let _enter = rt.enter(); -+ runtime::spawn_blocking(|| {}); -+ runtime::spawn_mandatory_blocking(move || { -+ let _ = tx.send(()); -+ }) -+ .unwrap(); -+ -+ drop(rt); -+ -+ // This call will deadlock if `spawn_mandatory_blocking` doesn't run. -+ let () = rx.recv(); -+ }); -+} -+ -+#[test] -+fn spawn_mandatory_blocking_should_run_even_when_shutting_down_from_other_thread() { -+ use crate::runtime::tests::loom_oneshot; -+ loom::model(|| { -+ let rt = runtime::Builder::new_current_thread().build().unwrap(); -+ let handle = rt.handle().clone(); -+ -+ // Drop the runtime in a different thread -+ { -+ loom::thread::spawn(move || { -+ drop(rt); -+ }); -+ } -+ -+ let _enter = handle.enter(); -+ let (tx, rx) = loom_oneshot::channel(); -+ let handle = runtime::spawn_mandatory_blocking(move || { -+ let _ = tx.send(()); -+ }); -+ -+ // handle.is_some() means that `spawn_mandatory_blocking` -+ // promised us to run the blocking task -+ if handle.is_some() { -+ // This call will deadlock if `spawn_mandatory_blocking` doesn't run. -+ let () = rx.recv(); -+ } -+ }); -+} -+ -+#[test] -+fn spawn_blocking_when_paused() { -+ use std::time::Duration; -+ loom::model(|| { -+ let rt = crate::runtime::Builder::new_current_thread() -+ .enable_time() -+ .start_paused(true) -+ .build() -+ .unwrap(); -+ let handle = rt.handle(); -+ let _enter = handle.enter(); -+ let a = crate::task::spawn_blocking(|| {}); -+ let b = crate::task::spawn_blocking(|| {}); -+ rt.block_on(crate::time::timeout(Duration::from_millis(1), async move { -+ a.await.expect("blocking task should finish"); -+ b.await.expect("blocking task should finish"); -+ })) -+ .expect("timeout should not trigger"); -+ }); -+} -+ - fn mk_runtime(num_threads: usize) -> Runtime { - runtime::Builder::new_multi_thread() - .worker_threads(num_threads) -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_basic_scheduler.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_current_thread_scheduler.rs -similarity index 86% -rename from KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_basic_scheduler.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_current_thread_scheduler.rs -index d2894b9b..a772603f 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_basic_scheduler.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_current_thread_scheduler.rs -@@ -34,20 +34,22 @@ fn assert_at_most_num_polls(rt: Arc, at_most_polls: usize) { - #[test] - fn block_on_num_polls() { - loom::model(|| { -- // we expect at most 3 number of polls because there are -- // three points at which we poll the future. At any of these -- // points it can be ready: -+ // we expect at most 4 number of polls because there are three points at -+ // which we poll the future and an opportunity for a false-positive.. At -+ // any of these points it can be ready: - // -- // - when we fail to steal the parker and we block on a -- // notification that it is available. -+ // - when we fail to steal the parker and we block on a notification -+ // that it is available. - // - // - when we steal the parker and we schedule the future - // -- // - when the future is woken up and we have ran the max -- // number of tasks for the current tick or there are no -- // more tasks to run. -+ // - when the future is woken up and we have ran the max number of tasks -+ // for the current tick or there are no more tasks to run. - // -- let at_most = 3; -+ // - a thread is notified that the parker is available but a third -+ // thread acquires it before the notified thread can. -+ // -+ let at_most = 4; - - let rt1 = Arc::new(Builder::new_current_thread().build().unwrap()); - let rt2 = rt1.clone(); -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_join_set.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_join_set.rs -new file mode 100644 -index 00000000..bd343876 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_join_set.rs -@@ -0,0 +1,82 @@ -+use crate::runtime::Builder; -+use crate::task::JoinSet; -+ -+#[test] -+fn test_join_set() { -+ loom::model(|| { -+ let rt = Builder::new_multi_thread() -+ .worker_threads(1) -+ .build() -+ .unwrap(); -+ let mut set = JoinSet::new(); -+ -+ rt.block_on(async { -+ assert_eq!(set.len(), 0); -+ set.spawn(async { () }); -+ assert_eq!(set.len(), 1); -+ set.spawn(async { () }); -+ assert_eq!(set.len(), 2); -+ let () = set.join_next().await.unwrap().unwrap(); -+ assert_eq!(set.len(), 1); -+ set.spawn(async { () }); -+ assert_eq!(set.len(), 2); -+ let () = set.join_next().await.unwrap().unwrap(); -+ assert_eq!(set.len(), 1); -+ let () = set.join_next().await.unwrap().unwrap(); -+ assert_eq!(set.len(), 0); -+ set.spawn(async { () }); -+ assert_eq!(set.len(), 1); -+ }); -+ -+ drop(set); -+ drop(rt); -+ }); -+} -+ -+#[test] -+fn abort_all_during_completion() { -+ use std::sync::{ -+ atomic::{AtomicBool, Ordering::SeqCst}, -+ Arc, -+ }; -+ -+ // These booleans assert that at least one execution had the task complete first, and that at -+ // least one execution had the task be cancelled before it completed. -+ let complete_happened = Arc::new(AtomicBool::new(false)); -+ let cancel_happened = Arc::new(AtomicBool::new(false)); -+ -+ { -+ let complete_happened = complete_happened.clone(); -+ let cancel_happened = cancel_happened.clone(); -+ loom::model(move || { -+ let rt = Builder::new_multi_thread() -+ .worker_threads(1) -+ .build() -+ .unwrap(); -+ -+ let mut set = JoinSet::new(); -+ -+ rt.block_on(async { -+ set.spawn(async { () }); -+ set.abort_all(); -+ -+ match set.join_next().await { -+ Some(Ok(())) => complete_happened.store(true, SeqCst), -+ Some(Err(err)) if err.is_cancelled() => cancel_happened.store(true, SeqCst), -+ Some(Err(err)) => panic!("fail: {}", err), -+ None => { -+ unreachable!("Aborting the task does not remove it from the JoinSet.") -+ } -+ } -+ -+ assert!(matches!(set.join_next().await, None)); -+ }); -+ -+ drop(set); -+ drop(rt); -+ }); -+ } -+ -+ assert!(complete_happened.load(SeqCst)); -+ assert!(cancel_happened.load(SeqCst)); -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_queue.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_queue.rs -index 2cbb0a18..fc93bf3e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_queue.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_queue.rs -@@ -1,7 +1,7 @@ --use crate::runtime::blocking::NoopSchedule; --use crate::runtime::queue; --use crate::runtime::stats::WorkerStatsBatcher; -+use crate::runtime::scheduler::multi_thread::queue; - use crate::runtime::task::Inject; -+use crate::runtime::tests::NoopSchedule; -+use crate::runtime::MetricsBatch; - - use loom::thread; - -@@ -10,14 +10,15 @@ fn basic() { - loom::model(|| { - let (steal, mut local) = queue::local(); - let inject = Inject::new(); -+ let mut metrics = MetricsBatch::new(); - - let th = thread::spawn(move || { -- let mut stats = WorkerStatsBatcher::new(0); -+ let mut metrics = MetricsBatch::new(); - let (_, mut local) = queue::local(); - let mut n = 0; - - for _ in 0..3 { -- if steal.steal_into(&mut local, &mut stats).is_some() { -+ if steal.steal_into(&mut local, &mut metrics).is_some() { - n += 1; - } - -@@ -34,7 +35,7 @@ fn basic() { - for _ in 0..2 { - for _ in 0..2 { - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); - } - - if local.pop().is_some() { -@@ -43,7 +44,7 @@ fn basic() { - - // Push another task - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); - - while local.pop().is_some() { - n += 1; -@@ -65,13 +66,14 @@ fn steal_overflow() { - loom::model(|| { - let (steal, mut local) = queue::local(); - let inject = Inject::new(); -+ let mut metrics = MetricsBatch::new(); - - let th = thread::spawn(move || { -- let mut stats = WorkerStatsBatcher::new(0); -+ let mut metrics = MetricsBatch::new(); - let (_, mut local) = queue::local(); - let mut n = 0; - -- if steal.steal_into(&mut local, &mut stats).is_some() { -+ if steal.steal_into(&mut local, &mut metrics).is_some() { - n += 1; - } - -@@ -86,7 +88,7 @@ fn steal_overflow() { - - // push a task, pop a task - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); - - if local.pop().is_some() { - n += 1; -@@ -94,7 +96,7 @@ fn steal_overflow() { - - for _ in 0..6 { - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); - } - - n += th.join().unwrap(); -@@ -116,10 +118,10 @@ fn multi_stealer() { - const NUM_TASKS: usize = 5; - - fn steal_tasks(steal: queue::Steal) -> usize { -- let mut stats = WorkerStatsBatcher::new(0); -+ let mut metrics = MetricsBatch::new(); - let (_, mut local) = queue::local(); - -- if steal.steal_into(&mut local, &mut stats).is_none() { -+ if steal.steal_into(&mut local, &mut metrics).is_none() { - return 0; - } - -@@ -135,11 +137,12 @@ fn multi_stealer() { - loom::model(|| { - let (steal, mut local) = queue::local(); - let inject = Inject::new(); -+ let mut metrics = MetricsBatch::new(); - - // Push work - for _ in 0..NUM_TASKS { - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); - } - - let th1 = { -@@ -169,7 +172,7 @@ fn multi_stealer() { - #[test] - fn chained_steal() { - loom::model(|| { -- let mut stats = WorkerStatsBatcher::new(0); -+ let mut metrics = MetricsBatch::new(); - let (s1, mut l1) = queue::local(); - let (s2, mut l2) = queue::local(); - let inject = Inject::new(); -@@ -177,17 +180,17 @@ fn chained_steal() { - // Load up some tasks - for _ in 0..4 { - let (task, _) = super::unowned(async {}); -- l1.push_back(task, &inject); -+ l1.push_back(task, &inject, &mut metrics); - - let (task, _) = super::unowned(async {}); -- l2.push_back(task, &inject); -+ l2.push_back(task, &inject, &mut metrics); - } - - // Spawn a task to steal from **our** queue - let th = thread::spawn(move || { -- let mut stats = WorkerStatsBatcher::new(0); -+ let mut metrics = MetricsBatch::new(); - let (_, mut local) = queue::local(); -- s1.steal_into(&mut local, &mut stats); -+ s1.steal_into(&mut local, &mut metrics); - - while local.pop().is_some() {} - }); -@@ -195,7 +198,7 @@ fn chained_steal() { - // Drain our tasks, then attempt to steal - while l1.pop().is_some() {} - -- s2.steal_into(&mut l1, &mut stats); -+ s2.steal_into(&mut l1, &mut metrics); - - th.join().unwrap(); - -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_yield.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_yield.rs -new file mode 100644 -index 00000000..ba506e5a ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/loom_yield.rs -@@ -0,0 +1,37 @@ -+use crate::runtime::park; -+use crate::runtime::tests::loom_oneshot as oneshot; -+use crate::runtime::{self, Runtime}; -+ -+#[test] -+fn yield_calls_park_before_scheduling_again() { -+ // Don't need to check all permutations -+ let mut loom = loom::model::Builder::default(); -+ loom.max_permutations = Some(1); -+ loom.check(|| { -+ let rt = mk_runtime(2); -+ let (tx, rx) = oneshot::channel::<()>(); -+ -+ rt.spawn(async { -+ let tid = loom::thread::current().id(); -+ let park_count = park::current_thread_park_count(); -+ -+ crate::task::yield_now().await; -+ -+ if tid == loom::thread::current().id() { -+ let new_park_count = park::current_thread_park_count(); -+ assert_eq!(park_count + 1, new_park_count); -+ } -+ -+ tx.send(()); -+ }); -+ -+ rx.recv(); -+ }); -+} -+ -+fn mk_runtime(num_threads: usize) -> Runtime { -+ runtime::Builder::new_multi_thread() -+ .worker_threads(num_threads) -+ .build() -+ .unwrap() -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/mod.rs -index be36d6ff..4e7c2453 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/tests/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/mod.rs -@@ -1,8 +1,30 @@ -+// Enable dead_code / unreachable_pub here. It has been disabled in lib.rs for -+// other code when running loom tests. -+#![cfg_attr(loom, warn(dead_code, unreachable_pub))] -+ -+use self::noop_scheduler::NoopSchedule; - use self::unowned_wrapper::unowned; - -+mod noop_scheduler { -+ use crate::runtime::task::{self, Task}; -+ -+ /// `task::Schedule` implementation that does nothing, for testing. -+ pub(crate) struct NoopSchedule; -+ -+ impl task::Schedule for NoopSchedule { -+ fn release(&self, _task: &Task) -> Option> { -+ None -+ } -+ -+ fn schedule(&self, _task: task::Notified) { -+ unreachable!(); -+ } -+ } -+} -+ - mod unowned_wrapper { -- use crate::runtime::blocking::NoopSchedule; -- use crate::runtime::task::{JoinHandle, Notified}; -+ use crate::runtime::task::{Id, JoinHandle, Notified}; -+ use crate::runtime::tests::NoopSchedule; - - #[cfg(all(tokio_unstable, feature = "tracing"))] - pub(crate) fn unowned(task: T) -> (Notified, JoinHandle) -@@ -13,7 +35,7 @@ mod unowned_wrapper { - use tracing::Instrument; - let span = tracing::trace_span!("test_span"); - let task = task.instrument(span); -- let (task, handle) = crate::runtime::task::unowned(task, NoopSchedule); -+ let (task, handle) = crate::runtime::task::unowned(task, NoopSchedule, Id::next()); - (task.into_notified(), handle) - } - -@@ -23,19 +45,21 @@ mod unowned_wrapper { - T: std::future::Future + Send + 'static, - T::Output: Send + 'static, - { -- let (task, handle) = crate::runtime::task::unowned(task, NoopSchedule); -+ let (task, handle) = crate::runtime::task::unowned(task, NoopSchedule, Id::next()); - (task.into_notified(), handle) - } - } - - cfg_loom! { -- mod loom_basic_scheduler; -- mod loom_local; - mod loom_blocking; -+ mod loom_current_thread_scheduler; -+ mod loom_local; - mod loom_oneshot; - mod loom_pool; - mod loom_queue; - mod loom_shutdown_join; -+ mod loom_join_set; -+ mod loom_yield; - } - - cfg_not_loom! { -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/queue.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/queue.rs -index 47f1b01d..68d2e892 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/tests/queue.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/queue.rs -@@ -1,18 +1,39 @@ --use crate::runtime::queue; --use crate::runtime::stats::WorkerStatsBatcher; -+use crate::runtime::scheduler::multi_thread::queue; - use crate::runtime::task::{self, Inject, Schedule, Task}; -+use crate::runtime::MetricsBatch; - - use std::thread; - use std::time::Duration; - -+#[allow(unused)] -+macro_rules! assert_metrics { -+ ($metrics:ident, $field:ident == $v:expr) => {{ -+ use crate::runtime::WorkerMetrics; -+ use std::sync::atomic::Ordering::Relaxed; -+ -+ let worker = WorkerMetrics::new(); -+ $metrics.submit(&worker); -+ -+ let expect = $v; -+ let actual = worker.$field.load(Relaxed); -+ -+ assert!(actual == expect, "expect = {}; actual = {}", expect, actual) -+ }}; -+} -+ - #[test] - fn fits_256() { - let (_, mut local) = queue::local(); - let inject = Inject::new(); -+ let mut metrics = MetricsBatch::new(); - - for _ in 0..256 { - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); -+ } -+ -+ cfg_metrics! { -+ assert_metrics!(metrics, overflow_count == 0); - } - - assert!(inject.pop().is_none()); -@@ -24,10 +45,15 @@ fn fits_256() { - fn overflow() { - let (_, mut local) = queue::local(); - let inject = Inject::new(); -+ let mut metrics = MetricsBatch::new(); - - for _ in 0..257 { - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); -+ } -+ -+ cfg_metrics! { -+ assert_metrics!(metrics, overflow_count == 1); - } - - let mut n = 0; -@@ -45,7 +71,7 @@ fn overflow() { - - #[test] - fn steal_batch() { -- let mut stats = WorkerStatsBatcher::new(0); -+ let mut metrics = MetricsBatch::new(); - - let (steal1, mut local1) = queue::local(); - let (_, mut local2) = queue::local(); -@@ -53,10 +79,14 @@ fn steal_batch() { - - for _ in 0..4 { - let (task, _) = super::unowned(async {}); -- local1.push_back(task, &inject); -+ local1.push_back(task, &inject, &mut metrics); - } - -- assert!(steal1.steal_into(&mut local2, &mut stats).is_some()); -+ assert!(steal1.steal_into(&mut local2, &mut metrics).is_some()); -+ -+ cfg_metrics! { -+ assert_metrics!(metrics, steal_count == 2); -+ } - - for _ in 0..1 { - assert!(local2.pop().is_some()); -@@ -71,25 +101,35 @@ fn steal_batch() { - assert!(local1.pop().is_none()); - } - -+const fn normal_or_miri(normal: usize, miri: usize) -> usize { -+ if cfg!(miri) { -+ miri -+ } else { -+ normal -+ } -+} -+ - #[test] - fn stress1() { -- const NUM_ITER: usize = 1; -- const NUM_STEAL: usize = 1_000; -- const NUM_LOCAL: usize = 1_000; -- const NUM_PUSH: usize = 500; -- const NUM_POP: usize = 250; -+ const NUM_ITER: usize = 5; -+ const NUM_STEAL: usize = normal_or_miri(1_000, 10); -+ const NUM_LOCAL: usize = normal_or_miri(1_000, 10); -+ const NUM_PUSH: usize = normal_or_miri(500, 10); -+ const NUM_POP: usize = normal_or_miri(250, 10); -+ -+ let mut metrics = MetricsBatch::new(); - - for _ in 0..NUM_ITER { - let (steal, mut local) = queue::local(); - let inject = Inject::new(); - - let th = thread::spawn(move || { -- let mut stats = WorkerStatsBatcher::new(0); -+ let mut metrics = MetricsBatch::new(); - let (_, mut local) = queue::local(); - let mut n = 0; - - for _ in 0..NUM_STEAL { -- if steal.steal_into(&mut local, &mut stats).is_some() { -+ if steal.steal_into(&mut local, &mut metrics).is_some() { - n += 1; - } - -@@ -100,6 +140,10 @@ fn stress1() { - thread::yield_now(); - } - -+ cfg_metrics! { -+ assert_metrics!(metrics, steal_count == n as _); -+ } -+ - n - }); - -@@ -108,7 +152,7 @@ fn stress1() { - for _ in 0..NUM_LOCAL { - for _ in 0..NUM_PUSH { - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); - } - - for _ in 0..NUM_POP { -@@ -133,15 +177,17 @@ fn stress1() { - #[test] - fn stress2() { - const NUM_ITER: usize = 1; -- const NUM_TASKS: usize = 1_000_000; -- const NUM_STEAL: usize = 1_000; -+ const NUM_TASKS: usize = normal_or_miri(1_000_000, 50); -+ const NUM_STEAL: usize = normal_or_miri(1_000, 10); -+ -+ let mut metrics = MetricsBatch::new(); - - for _ in 0..NUM_ITER { - let (steal, mut local) = queue::local(); - let inject = Inject::new(); - - let th = thread::spawn(move || { -- let mut stats = WorkerStatsBatcher::new(0); -+ let mut stats = MetricsBatch::new(); - let (_, mut local) = queue::local(); - let mut n = 0; - -@@ -164,7 +210,7 @@ fn stress2() { - - for i in 0..NUM_TASKS { - let (task, _) = super::unowned(async {}); -- local.push_back(task, &inject); -+ local.push_back(task, &inject, &mut metrics); - - if i % 128 == 0 && local.pop().is_some() { - num_pop += 1; -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/task.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/task.rs -index 04e1b56e..a79c0f50 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/tests/task.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/task.rs -@@ -1,5 +1,5 @@ --use crate::runtime::blocking::NoopSchedule; --use crate::runtime::task::{self, unowned, JoinHandle, OwnedTasks, Schedule, Task}; -+use crate::runtime::task::{self, unowned, Id, JoinHandle, OwnedTasks, Schedule, Task}; -+use crate::runtime::tests::NoopSchedule; - use crate::util::TryLock; - - use std::collections::VecDeque; -@@ -55,6 +55,7 @@ fn create_drop1() { - unreachable!() - }, - NoopSchedule, -+ Id::next(), - ); - drop(notified); - handle.assert_not_dropped(); -@@ -71,6 +72,7 @@ fn create_drop2() { - unreachable!() - }, - NoopSchedule, -+ Id::next(), - ); - drop(join); - handle.assert_not_dropped(); -@@ -78,6 +80,46 @@ fn create_drop2() { - handle.assert_dropped(); - } - -+#[test] -+fn drop_abort_handle1() { -+ let (ad, handle) = AssertDrop::new(); -+ let (notified, join) = unowned( -+ async { -+ drop(ad); -+ unreachable!() -+ }, -+ NoopSchedule, -+ Id::next(), -+ ); -+ let abort = join.abort_handle(); -+ drop(join); -+ handle.assert_not_dropped(); -+ drop(notified); -+ handle.assert_not_dropped(); -+ drop(abort); -+ handle.assert_dropped(); -+} -+ -+#[test] -+fn drop_abort_handle2() { -+ let (ad, handle) = AssertDrop::new(); -+ let (notified, join) = unowned( -+ async { -+ drop(ad); -+ unreachable!() -+ }, -+ NoopSchedule, -+ Id::next(), -+ ); -+ let abort = join.abort_handle(); -+ drop(notified); -+ handle.assert_not_dropped(); -+ drop(abort); -+ handle.assert_not_dropped(); -+ drop(join); -+ handle.assert_dropped(); -+} -+ - // Shutting down through Notified works - #[test] - fn create_shutdown1() { -@@ -88,6 +130,7 @@ fn create_shutdown1() { - unreachable!() - }, - NoopSchedule, -+ Id::next(), - ); - drop(join); - handle.assert_not_dropped(); -@@ -104,6 +147,7 @@ fn create_shutdown2() { - unreachable!() - }, - NoopSchedule, -+ Id::next(), - ); - handle.assert_not_dropped(); - notified.shutdown(); -@@ -113,7 +157,7 @@ fn create_shutdown2() { - - #[test] - fn unowned_poll() { -- let (task, _) = unowned(async {}, NoopSchedule); -+ let (task, _) = unowned(async {}, NoopSchedule, Id::next()); - task.run(); - } - -@@ -228,7 +272,7 @@ impl Runtime { - T: 'static + Send + Future, - T::Output: 'static + Send, - { -- let (handle, notified) = self.0.owned.bind(future, self.clone()); -+ let (handle, notified) = self.0.owned.bind(future, self.clone(), Id::next()); - - if let Some(notified) = notified { - self.schedule(notified); -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/tests/task_combinations.rs b/KubeOS-Rust/vendor/tokio/src/runtime/tests/task_combinations.rs -index 76ce2330..73a20d97 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/tests/task_combinations.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/tests/task_combinations.rs -@@ -1,8 +1,10 @@ -+use std::fmt; - use std::future::Future; - use std::panic; - use std::pin::Pin; - use std::task::{Context, Poll}; - -+use crate::runtime::task::AbortHandle; - use crate::runtime::Builder; - use crate::sync::oneshot; - use crate::task::JoinHandle; -@@ -56,6 +58,12 @@ enum CombiAbort { - AbortedAfterConsumeOutput = 4, - } - -+#[derive(Copy, Clone, Debug, PartialEq)] -+enum CombiAbortSource { -+ JoinHandle, -+ AbortHandle, -+} -+ - #[test] - fn test_combinations() { - let mut rt = &[ -@@ -90,6 +98,13 @@ fn test_combinations() { - CombiAbort::AbortedAfterFinish, - CombiAbort::AbortedAfterConsumeOutput, - ]; -+ let ah = [ -+ None, -+ Some(CombiJoinHandle::DropImmediately), -+ Some(CombiJoinHandle::DropFirstPoll), -+ Some(CombiJoinHandle::DropAfterNoConsume), -+ Some(CombiJoinHandle::DropAfterConsume), -+ ]; - - for rt in rt.iter().copied() { - for ls in ls.iter().copied() { -@@ -98,7 +113,34 @@ fn test_combinations() { - for ji in ji.iter().copied() { - for jh in jh.iter().copied() { - for abort in abort.iter().copied() { -- test_combination(rt, ls, task, output, ji, jh, abort); -+ // abort via join handle --- abort handles -+ // may be dropped at any point -+ for ah in ah.iter().copied() { -+ test_combination( -+ rt, -+ ls, -+ task, -+ output, -+ ji, -+ jh, -+ ah, -+ abort, -+ CombiAbortSource::JoinHandle, -+ ); -+ } -+ // if aborting via AbortHandle, it will -+ // never be dropped. -+ test_combination( -+ rt, -+ ls, -+ task, -+ output, -+ ji, -+ jh, -+ None, -+ abort, -+ CombiAbortSource::AbortHandle, -+ ); - } - } - } -@@ -108,6 +150,9 @@ fn test_combinations() { - } - } - -+fn is_debug(_: &T) {} -+ -+#[allow(clippy::too_many_arguments)] - fn test_combination( - rt: CombiRuntime, - ls: CombiLocalSet, -@@ -115,12 +160,24 @@ fn test_combination( - output: CombiOutput, - ji: CombiJoinInterest, - jh: CombiJoinHandle, -+ ah: Option, - abort: CombiAbort, -+ abort_src: CombiAbortSource, - ) { -- if (jh as usize) < (abort as usize) { -- // drop before abort not possible -- return; -+ match (abort_src, ah) { -+ (CombiAbortSource::JoinHandle, _) if (jh as usize) < (abort as usize) => { -+ // join handle dropped prior to abort -+ return; -+ } -+ (CombiAbortSource::AbortHandle, Some(_)) => { -+ // abort handle dropped, we can't abort through the -+ // abort handle -+ return; -+ } -+ -+ _ => {} - } -+ - if (task == CombiTask::PanicOnDrop) && (output == CombiOutput::PanicOnDrop) { - // this causes double panic - return; -@@ -130,7 +187,15 @@ fn test_combination( - return; - } - -- println!("Runtime {:?}, LocalSet {:?}, Task {:?}, Output {:?}, JoinInterest {:?}, JoinHandle {:?}, Abort {:?}", rt, ls, task, output, ji, jh, abort); -+ is_debug(&rt); -+ is_debug(&ls); -+ is_debug(&task); -+ is_debug(&output); -+ is_debug(&ji); -+ is_debug(&jh); -+ is_debug(&ah); -+ is_debug(&abort); -+ is_debug(&abort_src); - - // A runtime optionally with a LocalSet - struct Rt { -@@ -282,8 +347,24 @@ fn test_combination( - ); - } - -+ // If we are either aborting the task via an abort handle, or dropping via -+ // an abort handle, do that now. -+ let mut abort_handle = if ah.is_some() || abort_src == CombiAbortSource::AbortHandle { -+ handle.as_ref().map(JoinHandle::abort_handle) -+ } else { -+ None -+ }; -+ -+ let do_abort = |abort_handle: &mut Option, -+ join_handle: Option<&mut JoinHandle<_>>| { -+ match abort_src { -+ CombiAbortSource::AbortHandle => abort_handle.take().unwrap().abort(), -+ CombiAbortSource::JoinHandle => join_handle.unwrap().abort(), -+ } -+ }; -+ - if abort == CombiAbort::AbortedImmediately { -- handle.as_mut().unwrap().abort(); -+ do_abort(&mut abort_handle, handle.as_mut()); - aborted = true; - } - if jh == CombiJoinHandle::DropImmediately { -@@ -301,12 +382,15 @@ fn test_combination( - } - - if abort == CombiAbort::AbortedFirstPoll { -- handle.as_mut().unwrap().abort(); -+ do_abort(&mut abort_handle, handle.as_mut()); - aborted = true; - } - if jh == CombiJoinHandle::DropFirstPoll { - drop(handle.take().unwrap()); - } -+ if ah == Some(CombiJoinHandle::DropFirstPoll) { -+ drop(abort_handle.take().unwrap()); -+ } - - // Signal the future that it can return now - let _ = on_complete.send(()); -@@ -318,23 +402,42 @@ fn test_combination( - - if abort == CombiAbort::AbortedAfterFinish { - // Don't set aborted to true here as the task already finished -- handle.as_mut().unwrap().abort(); -+ do_abort(&mut abort_handle, handle.as_mut()); - } - if jh == CombiJoinHandle::DropAfterNoConsume { -- // The runtime will usually have dropped every ref-count at this point, -- // in which case dropping the JoinHandle drops the output. -- // -- // (But it might race and still hold a ref-count) -- let panic = panic::catch_unwind(panic::AssertUnwindSafe(|| { -+ if ah == Some(CombiJoinHandle::DropAfterNoConsume) { - drop(handle.take().unwrap()); -- })); -- if panic.is_err() { -- assert!( -- (output == CombiOutput::PanicOnDrop) -- && (!matches!(task, CombiTask::PanicOnRun | CombiTask::PanicOnRunAndDrop)) -- && !aborted, -- "Dropping JoinHandle shouldn't panic here" -- ); -+ // The runtime will usually have dropped every ref-count at this point, -+ // in which case dropping the AbortHandle drops the output. -+ // -+ // (But it might race and still hold a ref-count) -+ let panic = panic::catch_unwind(panic::AssertUnwindSafe(|| { -+ drop(abort_handle.take().unwrap()); -+ })); -+ if panic.is_err() { -+ assert!( -+ (output == CombiOutput::PanicOnDrop) -+ && (!matches!(task, CombiTask::PanicOnRun | CombiTask::PanicOnRunAndDrop)) -+ && !aborted, -+ "Dropping AbortHandle shouldn't panic here" -+ ); -+ } -+ } else { -+ // The runtime will usually have dropped every ref-count at this point, -+ // in which case dropping the JoinHandle drops the output. -+ // -+ // (But it might race and still hold a ref-count) -+ let panic = panic::catch_unwind(panic::AssertUnwindSafe(|| { -+ drop(handle.take().unwrap()); -+ })); -+ if panic.is_err() { -+ assert!( -+ (output == CombiOutput::PanicOnDrop) -+ && (!matches!(task, CombiTask::PanicOnRun | CombiTask::PanicOnRunAndDrop)) -+ && !aborted, -+ "Dropping JoinHandle shouldn't panic here" -+ ); -+ } - } - } - -@@ -362,11 +465,15 @@ fn test_combination( - _ => unreachable!(), - } - -- let handle = handle.take().unwrap(); -+ let mut handle = handle.take().unwrap(); - if abort == CombiAbort::AbortedAfterConsumeOutput { -- handle.abort(); -+ do_abort(&mut abort_handle, Some(&mut handle)); - } - drop(handle); -+ -+ if ah == Some(CombiJoinHandle::DropAfterConsume) { -+ drop(abort_handle.take()); -+ } - } - - // The output should have been dropped now. Check whether the output -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/thread_id.rs b/KubeOS-Rust/vendor/tokio/src/runtime/thread_id.rs -new file mode 100644 -index 00000000..ef392897 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/thread_id.rs -@@ -0,0 +1,31 @@ -+use std::num::NonZeroU64; -+ -+#[derive(Eq, PartialEq, Clone, Copy, Hash, Debug)] -+pub(crate) struct ThreadId(NonZeroU64); -+ -+impl ThreadId { -+ pub(crate) fn next() -> Self { -+ use crate::loom::sync::atomic::{Ordering::Relaxed, StaticAtomicU64}; -+ -+ static NEXT_ID: StaticAtomicU64 = StaticAtomicU64::new(0); -+ -+ let mut last = NEXT_ID.load(Relaxed); -+ loop { -+ let id = match last.checked_add(1) { -+ Some(id) => id, -+ None => exhausted(), -+ }; -+ -+ match NEXT_ID.compare_exchange_weak(last, id, Relaxed, Relaxed) { -+ Ok(_) => return ThreadId(NonZeroU64::new(id).unwrap()), -+ Err(id) => last = id, -+ } -+ } -+ } -+} -+ -+#[cold] -+#[allow(dead_code)] -+fn exhausted() -> ! { -+ panic!("failed to generate unique thread ID: bitspace exhausted") -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/mod.rs -deleted file mode 100644 -index 82e34c78..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/mod.rs -+++ /dev/null -@@ -1,118 +0,0 @@ --//! Threadpool -- --mod atomic_cell; --use atomic_cell::AtomicCell; -- --mod idle; --use self::idle::Idle; -- --mod worker; --pub(crate) use worker::Launch; -- --pub(crate) use worker::block_in_place; -- --use crate::loom::sync::Arc; --use crate::runtime::stats::RuntimeStats; --use crate::runtime::task::JoinHandle; --use crate::runtime::{Callback, Parker}; -- --use std::fmt; --use std::future::Future; -- --/// Work-stealing based thread pool for executing futures. --pub(crate) struct ThreadPool { -- spawner: Spawner, --} -- --/// Submits futures to the associated thread pool for execution. --/// --/// A `Spawner` instance is a handle to a single thread pool that allows the owner --/// of the handle to spawn futures onto the thread pool. --/// --/// The `Spawner` handle is *only* used for spawning new futures. It does not --/// impact the lifecycle of the thread pool in any way. The thread pool may --/// shut down while there are outstanding `Spawner` instances. --/// --/// `Spawner` instances are obtained by calling [`ThreadPool::spawner`]. --/// --/// [`ThreadPool::spawner`]: method@ThreadPool::spawner --#[derive(Clone)] --pub(crate) struct Spawner { -- shared: Arc, --} -- --// ===== impl ThreadPool ===== -- --impl ThreadPool { -- pub(crate) fn new( -- size: usize, -- parker: Parker, -- before_park: Option, -- after_unpark: Option, -- ) -> (ThreadPool, Launch) { -- let (shared, launch) = worker::create(size, parker, before_park, after_unpark); -- let spawner = Spawner { shared }; -- let thread_pool = ThreadPool { spawner }; -- -- (thread_pool, launch) -- } -- -- /// Returns reference to `Spawner`. -- /// -- /// The `Spawner` handle can be cloned and enables spawning tasks from other -- /// threads. -- pub(crate) fn spawner(&self) -> &Spawner { -- &self.spawner -- } -- -- /// Blocks the current thread waiting for the future to complete. -- /// -- /// The future will execute on the current thread, but all spawned tasks -- /// will be executed on the thread pool. -- pub(crate) fn block_on(&self, future: F) -> F::Output -- where -- F: Future, -- { -- let mut enter = crate::runtime::enter(true); -- enter.block_on(future).expect("failed to park thread") -- } --} -- --impl fmt::Debug for ThreadPool { -- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- fmt.debug_struct("ThreadPool").finish() -- } --} -- --impl Drop for ThreadPool { -- fn drop(&mut self) { -- self.spawner.shutdown(); -- } --} -- --// ==== impl Spawner ===== -- --impl Spawner { -- /// Spawns a future onto the thread pool -- pub(crate) fn spawn(&self, future: F) -> JoinHandle -- where -- F: crate::future::Future + Send + 'static, -- F::Output: Send + 'static, -- { -- worker::Shared::bind_new_task(&self.shared, future) -- } -- -- pub(crate) fn shutdown(&mut self) { -- self.shared.close(); -- } -- -- pub(crate) fn stats(&self) -> &RuntimeStats { -- self.shared.stats() -- } --} -- --impl fmt::Debug for Spawner { -- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -- fmt.debug_struct("Spawner").finish() -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/time/driver/entry.rs b/KubeOS-Rust/vendor/tokio/src/runtime/time/entry.rs -similarity index 86% -rename from KubeOS-Rust/vendor/tokio/src/time/driver/entry.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/time/entry.rs -index 9e9f0dc8..6aea2b15 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/driver/entry.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/time/entry.rs -@@ -5,9 +5,9 @@ - //! - //! # Ground rules - //! --//! The heart of the timer implementation here is the `TimerShared` structure, --//! shared between the `TimerEntry` and the driver. Generally, we permit access --//! to `TimerShared` ONLY via either 1) a mutable reference to `TimerEntry` or -+//! The heart of the timer implementation here is the [`TimerShared`] structure, -+//! shared between the [`TimerEntry`] and the driver. Generally, we permit access -+//! to [`TimerShared`] ONLY via either 1) a mutable reference to [`TimerEntry`] or - //! 2) a held driver lock. - //! - //! It follows from this that any changes made while holding BOTH 1 and 2 will -@@ -36,7 +36,7 @@ - //! point than it was originally scheduled for. - //! - //! This is accomplished by lazily rescheduling timers. That is, we update the --//! state field field with the true expiration of the timer from the holder of -+//! state field with the true expiration of the timer from the holder of - //! the [`TimerEntry`]. When the driver services timers (ie, whenever it's - //! walking lists of timers), it checks this "true when" value, and reschedules - //! based on it. -@@ -49,19 +49,20 @@ - //! There is of course a race condition between timer reset and timer - //! expiration. If the driver fails to observe the updated expiration time, it - //! could trigger expiration of the timer too early. However, because --//! `mark_pending` performs a compare-and-swap, it will identify this race and -+//! [`mark_pending`][mark_pending] performs a compare-and-swap, it will identify this race and - //! refuse to mark the timer as pending. -+//! -+//! [mark_pending]: TimerHandle::mark_pending - - use crate::loom::cell::UnsafeCell; - use crate::loom::sync::atomic::AtomicU64; - use crate::loom::sync::atomic::Ordering; - -+use crate::runtime::scheduler; - use crate::sync::AtomicWaker; - use crate::time::Instant; - use crate::util::linked_list; - --use super::Handle; -- - use std::cell::UnsafeCell as StdUnsafeCell; - use std::task::{Context, Poll, Waker}; - use std::{marker::PhantomPinned, pin::Pin, ptr::NonNull}; -@@ -93,7 +94,7 @@ pub(super) struct StateCell { - /// without holding the driver lock is undefined behavior. - result: UnsafeCell, - /// The currently-registered waker -- waker: CachePadded, -+ waker: AtomicWaker, - } - - impl Default for StateCell { -@@ -113,7 +114,7 @@ impl StateCell { - Self { - state: AtomicU64::new(STATE_DEREGISTERED), - result: UnsafeCell::new(Ok(())), -- waker: CachePadded(AtomicWaker::new()), -+ waker: AtomicWaker::new(), - } - } - -@@ -138,7 +139,7 @@ impl StateCell { - // We must register first. This ensures that either `fire` will - // observe the new waker, or we will observe a racing fire to have set - // the state, or both. -- self.waker.0.register_by_ref(waker); -+ self.waker.register_by_ref(waker); - - self.read_state() - } -@@ -171,7 +172,12 @@ impl StateCell { - let mut cur_state = self.state.load(Ordering::Relaxed); - - loop { -- debug_assert!(cur_state < STATE_MIN_VALUE); -+ // improve the error message for things like -+ // https://github.com/tokio-rs/tokio/issues/3675 -+ assert!( -+ cur_state < STATE_MIN_VALUE, -+ "mark_pending called when the timer entry is in an invalid state" -+ ); - - if cur_state > not_after { - break Err(cur_state); -@@ -221,7 +227,7 @@ impl StateCell { - - self.state.store(STATE_DEREGISTERED, Ordering::Release); - -- self.waker.0.take_waker() -+ self.waker.take_waker() - } - - /// Marks the timer as registered (poll will return None) and sets the -@@ -281,10 +287,10 @@ impl StateCell { - /// timer. As this participates in intrusive data structures, it must be pinned - /// before polling. - #[derive(Debug)] --pub(super) struct TimerEntry { -- /// Arc reference to the driver. We can only free the driver after -+pub(crate) struct TimerEntry { -+ /// Arc reference to the runtime handle. We can only free the driver after - /// deregistering everything from their respective timer wheels. -- driver: Handle, -+ driver: scheduler::Handle, - /// Shared inner structure; this is part of an intrusive linked list, and - /// therefore other references can exist to it while mutable references to - /// Entry exist. -@@ -292,9 +298,11 @@ pub(super) struct TimerEntry { - /// This is manipulated only under the inner mutex. TODO: Can we use loom - /// cells for this? - inner: StdUnsafeCell, -- /// Initial deadline for the timer. This is used to register on the first -+ /// Deadline for the timer. This is used to register on the first - /// poll, as we can't register prior to being pinned. -- initial_deadline: Option, -+ deadline: Instant, -+ /// Whether the deadline has been registered. -+ registered: bool, - /// Ensure the type is !Unpin - _m: std::marker::PhantomPinned, - } -@@ -323,24 +331,57 @@ pub(super) type EntryList = crate::util::linked_list::LinkedList, -+ -+ /// The expiration time for which this entry is currently registered. -+ /// Generally owned by the driver, but is accessed by the entry when not -+ /// registered. -+ cached_when: AtomicU64, -+ -+ /// The true expiration time. Set by the timer future, read by the driver. -+ true_when: AtomicU64, -+ - /// Current state. This records whether the timer entry is currently under - /// the ownership of the driver, and if not, its current state (not - /// complete, fired, error, etc). - state: StateCell, - -- /// Data manipulated by the driver thread itself, only. -- driver_state: CachePadded, -- - _p: PhantomPinned, - } - -+unsafe impl Send for TimerShared {} -+unsafe impl Sync for TimerShared {} -+ -+impl std::fmt::Debug for TimerShared { -+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { -+ f.debug_struct("TimerShared") -+ .field("when", &self.true_when.load(Ordering::Relaxed)) -+ .field("cached_when", &self.cached_when.load(Ordering::Relaxed)) -+ .field("state", &self.state) -+ .finish() -+ } -+} -+ -+generate_addr_of_methods! { -+ impl<> TimerShared { -+ unsafe fn addr_of_pointers(self: NonNull) -> NonNull> { -+ &self.pointers -+ } -+ } -+} -+ - impl TimerShared { - pub(super) fn new() -> Self { - Self { -+ cached_when: AtomicU64::new(0), -+ true_when: AtomicU64::new(0), -+ pointers: linked_list::Pointers::new(), - state: StateCell::default(), -- driver_state: CachePadded(TimerSharedPadded::new()), - _p: PhantomPinned, - } - } -@@ -348,7 +389,7 @@ impl TimerShared { - /// Gets the cached time-of-expiration value. - pub(super) fn cached_when(&self) -> u64 { - // Cached-when is only accessed under the driver lock, so we can use relaxed -- self.driver_state.0.cached_when.load(Ordering::Relaxed) -+ self.cached_when.load(Ordering::Relaxed) - } - - /// Gets the true time-of-expiration value, and copies it into the cached -@@ -359,10 +400,7 @@ impl TimerShared { - pub(super) unsafe fn sync_when(&self) -> u64 { - let true_when = self.true_when(); - -- self.driver_state -- .0 -- .cached_when -- .store(true_when, Ordering::Relaxed); -+ self.cached_when.store(true_when, Ordering::Relaxed); - - true_when - } -@@ -372,10 +410,7 @@ impl TimerShared { - /// SAFETY: Must be called with the driver lock held, and when this entry is - /// not in any timer wheel lists. - unsafe fn set_cached_when(&self, when: u64) { -- self.driver_state -- .0 -- .cached_when -- .store(when, Ordering::Relaxed); -+ self.cached_when.store(when, Ordering::Relaxed); - } - - /// Returns the true time-of-expiration value, with relaxed memory ordering. -@@ -390,7 +425,7 @@ impl TimerShared { - /// in the timer wheel. - pub(super) unsafe fn set_expiration(&self, t: u64) { - self.state.set_expiration(t); -- self.driver_state.0.cached_when.store(t, Ordering::Relaxed); -+ self.cached_when.store(t, Ordering::Relaxed); - } - - /// Sets the true time-of-expiration only if it is after the current. -@@ -414,48 +449,6 @@ impl TimerShared { - } - } - --/// Additional shared state between the driver and the timer which is cache --/// padded. This contains the information that the driver thread accesses most --/// frequently to minimize contention. In particular, we move it away from the --/// waker, as the waker is updated on every poll. --struct TimerSharedPadded { -- /// The expiration time for which this entry is currently registered. -- /// Generally owned by the driver, but is accessed by the entry when not -- /// registered. -- cached_when: AtomicU64, -- -- /// The true expiration time. Set by the timer future, read by the driver. -- true_when: AtomicU64, -- -- /// A link within the doubly-linked list of timers on a particular level and -- /// slot. Valid only if state is equal to Registered. -- /// -- /// Only accessed under the entry lock. -- pointers: StdUnsafeCell>, --} -- --impl std::fmt::Debug for TimerSharedPadded { -- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { -- f.debug_struct("TimerSharedPadded") -- .field("when", &self.true_when.load(Ordering::Relaxed)) -- .field("cached_when", &self.cached_when.load(Ordering::Relaxed)) -- .finish() -- } --} -- --impl TimerSharedPadded { -- fn new() -> Self { -- Self { -- cached_when: AtomicU64::new(0), -- true_when: AtomicU64::new(0), -- pointers: StdUnsafeCell::new(linked_list::Pointers::new()), -- } -- } --} -- --unsafe impl Send for TimerShared {} --unsafe impl Sync for TimerShared {} -- - unsafe impl linked_list::Link for TimerShared { - type Handle = TimerHandle; - -@@ -472,20 +465,25 @@ unsafe impl linked_list::Link for TimerShared { - unsafe fn pointers( - target: NonNull, - ) -> NonNull> { -- unsafe { NonNull::new(target.as_ref().driver_state.0.pointers.get()).unwrap() } -+ TimerShared::addr_of_pointers(target) - } - } - - // ===== impl Entry ===== - - impl TimerEntry { -- pub(crate) fn new(handle: &Handle, deadline: Instant) -> Self { -+ #[track_caller] -+ pub(crate) fn new(handle: &scheduler::Handle, deadline: Instant) -> Self { -+ // Panic if the time driver is not enabled -+ let _ = handle.driver().time(); -+ - let driver = handle.clone(); - - Self { - driver, - inner: StdUnsafeCell::new(TimerShared::new()), -- initial_deadline: Some(deadline), -+ deadline, -+ registered: false, - _m: std::marker::PhantomPinned, - } - } -@@ -494,8 +492,12 @@ impl TimerEntry { - unsafe { &*self.inner.get() } - } - -+ pub(crate) fn deadline(&self) -> Instant { -+ self.deadline -+ } -+ - pub(crate) fn is_elapsed(&self) -> bool { -- !self.inner().state.might_be_registered() && self.initial_deadline.is_none() -+ !self.inner().state.might_be_registered() && self.registered - } - - /// Cancels and deregisters the timer. This operation is irreversible. -@@ -522,20 +524,24 @@ impl TimerEntry { - // driver did so far and happens-before everything the driver does in - // the future. While we have the lock held, we also go ahead and - // deregister the entry if necessary. -- unsafe { self.driver.clear_entry(NonNull::from(self.inner())) }; -+ unsafe { self.driver().clear_entry(NonNull::from(self.inner())) }; - } - -- pub(crate) fn reset(mut self: Pin<&mut Self>, new_time: Instant) { -- unsafe { self.as_mut().get_unchecked_mut() }.initial_deadline = None; -+ pub(crate) fn reset(mut self: Pin<&mut Self>, new_time: Instant, reregister: bool) { -+ unsafe { self.as_mut().get_unchecked_mut() }.deadline = new_time; -+ unsafe { self.as_mut().get_unchecked_mut() }.registered = reregister; - -- let tick = self.driver.time_source().deadline_to_tick(new_time); -+ let tick = self.driver().time_source().deadline_to_tick(new_time); - - if self.inner().extend_expiration(tick).is_ok() { - return; - } - -- unsafe { -- self.driver.reregister(tick, self.inner().into()); -+ if reregister { -+ unsafe { -+ self.driver() -+ .reregister(&self.driver.driver().io, tick, self.inner().into()); -+ } - } - } - -@@ -543,18 +549,28 @@ impl TimerEntry { - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - ) -> Poll> { -- if self.driver.is_shutdown() { -+ if self.driver().is_shutdown() { - panic!("{}", crate::util::error::RUNTIME_SHUTTING_DOWN_ERROR); - } - -- if let Some(deadline) = self.initial_deadline { -- self.as_mut().reset(deadline); -+ if !self.registered { -+ let deadline = self.deadline; -+ self.as_mut().reset(deadline, true); - } - - let this = unsafe { self.get_unchecked_mut() }; - - this.inner().state.poll(cx.waker()) - } -+ -+ pub(crate) fn driver(&self) -> &super::Handle { -+ self.driver.driver().time() -+ } -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ pub(crate) fn clock(&self) -> &super::Clock { -+ self.driver.driver().clock() -+ } - } - - impl TimerHandle { -@@ -622,8 +638,3 @@ impl Drop for TimerEntry { - unsafe { Pin::new_unchecked(self) }.as_mut().cancel() - } - } -- --#[cfg_attr(target_arch = "x86_64", repr(align(128)))] --#[cfg_attr(not(target_arch = "x86_64"), repr(align(64)))] --#[derive(Debug, Default)] --struct CachePadded(T); -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/time/handle.rs b/KubeOS-Rust/vendor/tokio/src/runtime/time/handle.rs -new file mode 100644 -index 00000000..fce791d9 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/time/handle.rs -@@ -0,0 +1,62 @@ -+use crate::runtime::time::TimeSource; -+use std::fmt; -+ -+/// Handle to time driver instance. -+pub(crate) struct Handle { -+ pub(super) time_source: TimeSource, -+ pub(super) inner: super::Inner, -+} -+ -+impl Handle { -+ /// Returns the time source associated with this handle. -+ pub(crate) fn time_source(&self) -> &TimeSource { -+ &self.time_source -+ } -+ -+ /// Checks whether the driver has been shutdown. -+ pub(super) fn is_shutdown(&self) -> bool { -+ self.inner.is_shutdown() -+ } -+ -+ /// Track that the driver is being unparked -+ pub(crate) fn unpark(&self) { -+ #[cfg(feature = "test-util")] -+ self.inner -+ .did_wake -+ .store(true, std::sync::atomic::Ordering::SeqCst); -+ } -+} -+ -+cfg_not_rt! { -+ impl Handle { -+ /// Tries to get a handle to the current timer. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if there is no current timer set. -+ /// -+ /// It can be triggered when [`Builder::enable_time`] or -+ /// [`Builder::enable_all`] are not included in the builder. -+ /// -+ /// It can also panic whenever a timer is created outside of a -+ /// Tokio runtime. That is why `rt.block_on(sleep(...))` will panic, -+ /// since the function is executed outside of the runtime. -+ /// Whereas `rt.block_on(async {sleep(...).await})` doesn't panic. -+ /// And this is because wrapping the function on an async makes it lazy, -+ /// and so gets executed inside the runtime successfully without -+ /// panicking. -+ /// -+ /// [`Builder::enable_time`]: crate::runtime::Builder::enable_time -+ /// [`Builder::enable_all`]: crate::runtime::Builder::enable_all -+ #[track_caller] -+ pub(crate) fn current() -> Self { -+ panic!("{}", crate::util::error::CONTEXT_MISSING_ERROR) -+ } -+ } -+} -+ -+impl fmt::Debug for Handle { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ write!(f, "Handle") -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/time/driver/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/time/mod.rs -similarity index 66% -rename from KubeOS-Rust/vendor/tokio/src/time/driver/mod.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/time/mod.rs -index cf2290bc..215714dd 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/driver/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/time/mod.rs -@@ -7,22 +7,23 @@ - //! Time driver. - - mod entry; --pub(self) use self::entry::{EntryList, TimerEntry, TimerHandle, TimerShared}; -+pub(crate) use entry::TimerEntry; -+use entry::{EntryList, TimerHandle, TimerShared}; - - mod handle; - pub(crate) use self::handle::Handle; - --mod wheel; -+mod source; -+pub(crate) use source::TimeSource; - --pub(super) mod sleep; -+mod wheel; - - use crate::loom::sync::atomic::{AtomicBool, Ordering}; --use crate::loom::sync::{Arc, Mutex}; --use crate::park::{Park, Unpark}; -+use crate::loom::sync::Mutex; -+use crate::runtime::driver::{self, IoHandle, IoStack}; - use crate::time::error::Error; --use crate::time::{Clock, Duration, Instant}; -+use crate::time::{Clock, Duration}; - --use std::convert::TryInto; - use std::fmt; - use std::{num::NonZeroU64, ptr::NonNull, task::Waker}; - -@@ -82,63 +83,9 @@ use std::{num::NonZeroU64, ptr::NonNull, task::Waker}; - /// [timeout]: crate::time::Timeout - /// [interval]: crate::time::Interval - #[derive(Debug)] --pub(crate) struct Driver { -- /// Timing backend in use. -- time_source: ClockTime, -- -- /// Shared state. -- handle: Handle, -- -+pub(crate) struct Driver { - /// Parker to delegate to. -- park: P, -- -- // When `true`, a call to `park_timeout` should immediately return and time -- // should not advance. One reason for this to be `true` is if the task -- // passed to `Runtime::block_on` called `task::yield_now()`. -- // -- // While it may look racy, it only has any effect when the clock is paused -- // and pausing the clock is restricted to a single-threaded runtime. -- #[cfg(feature = "test-util")] -- did_wake: Arc, --} -- --/// A structure which handles conversion from Instants to u64 timestamps. --#[derive(Debug, Clone)] --pub(self) struct ClockTime { -- clock: super::clock::Clock, -- start_time: Instant, --} -- --impl ClockTime { -- pub(self) fn new(clock: Clock) -> Self { -- Self { -- start_time: clock.now(), -- clock, -- } -- } -- -- pub(self) fn deadline_to_tick(&self, t: Instant) -> u64 { -- // Round up to the end of a ms -- self.instant_to_tick(t + Duration::from_nanos(999_999)) -- } -- -- pub(self) fn instant_to_tick(&self, t: Instant) -> u64 { -- // round up -- let dur: Duration = t -- .checked_duration_since(self.start_time) -- .unwrap_or_else(|| Duration::from_secs(0)); -- let ms = dur.as_millis(); -- -- ms.try_into().expect("Duration too far into the future") -- } -- -- pub(self) fn tick_to_duration(&self, t: u64) -> Duration { -- Duration::from_millis(t) -- } -- -- pub(self) fn now(&self) -> u64 { -- self.instant_to_tick(self.clock.now()) -- } -+ park: IoStack, - } - - /// Timer state shared between `Driver`, `Handle`, and `Registration`. -@@ -148,13 +95,19 @@ struct Inner { - - /// True if the driver is being shutdown. - pub(super) is_shutdown: AtomicBool, -+ -+ // When `true`, a call to `park_timeout` should immediately return and time -+ // should not advance. One reason for this to be `true` is if the task -+ // passed to `Runtime::block_on` called `task::yield_now()`. -+ // -+ // While it may look racy, it only has any effect when the clock is paused -+ // and pausing the clock is restricted to a single-threaded runtime. -+ #[cfg(feature = "test-util")] -+ did_wake: AtomicBool, - } - - /// Time state shared which must be protected by a `Mutex` - struct InnerState { -- /// Timing backend in use. -- time_source: ClockTime, -- - /// The last published timer `elapsed` value. - elapsed: u64, - -@@ -163,49 +116,67 @@ struct InnerState { - - /// Timer wheel. - wheel: wheel::Wheel, -- -- /// Unparker that can be used to wake the time driver. -- unpark: Box, - } - - // ===== impl Driver ===== - --impl

Driver

--where -- P: Park + 'static, --{ -+impl Driver { - /// Creates a new `Driver` instance that uses `park` to block the current - /// thread and `time_source` to get the current time and convert to ticks. - /// - /// Specifying the source of time is useful when testing. -- pub(crate) fn new(park: P, clock: Clock) -> Driver

{ -- let time_source = ClockTime::new(clock); -- -- let inner = Inner::new(time_source.clone(), Box::new(park.unpark())); -+ pub(crate) fn new(park: IoStack, clock: &Clock) -> (Driver, Handle) { -+ let time_source = TimeSource::new(clock); - -- Driver { -+ let handle = Handle { - time_source, -- handle: Handle::new(Arc::new(inner)), -- park, -- #[cfg(feature = "test-util")] -- did_wake: Arc::new(AtomicBool::new(false)), -- } -+ inner: Inner { -+ state: Mutex::new(InnerState { -+ elapsed: 0, -+ next_wake: None, -+ wheel: wheel::Wheel::new(), -+ }), -+ is_shutdown: AtomicBool::new(false), -+ -+ #[cfg(feature = "test-util")] -+ did_wake: AtomicBool::new(false), -+ }, -+ }; -+ -+ let driver = Driver { park }; -+ -+ (driver, handle) - } - -- /// Returns a handle to the timer. -- /// -- /// The `Handle` is how `Sleep` instances are created. The `Sleep` instances -- /// can either be created directly or the `Handle` instance can be passed to -- /// `with_default`, setting the timer as the default timer for the execution -- /// context. -- pub(crate) fn handle(&self) -> Handle { -- self.handle.clone() -+ pub(crate) fn park(&mut self, handle: &driver::Handle) { -+ self.park_internal(handle, None) -+ } -+ -+ pub(crate) fn park_timeout(&mut self, handle: &driver::Handle, duration: Duration) { -+ self.park_internal(handle, Some(duration)) -+ } -+ -+ pub(crate) fn shutdown(&mut self, rt_handle: &driver::Handle) { -+ let handle = rt_handle.time(); -+ -+ if handle.is_shutdown() { -+ return; -+ } -+ -+ handle.inner.is_shutdown.store(true, Ordering::SeqCst); -+ -+ // Advance time forward to the end of time. -+ -+ handle.process_at_time(u64::MAX); -+ -+ self.park.shutdown(rt_handle); - } - -- fn park_internal(&mut self, limit: Option) -> Result<(), P::Error> { -- let mut lock = self.handle.get().state.lock(); -+ fn park_internal(&mut self, rt_handle: &driver::Handle, limit: Option) { -+ let handle = rt_handle.time(); -+ let mut lock = handle.inner.state.lock(); - -- assert!(!self.handle.is_shutdown()); -+ assert!(!handle.is_shutdown()); - - let next_wake = lock.wheel.next_expiration_time(); - lock.next_wake = -@@ -215,75 +186,72 @@ where - - match next_wake { - Some(when) => { -- let now = self.time_source.now(); -+ let now = handle.time_source.now(rt_handle.clock()); - // Note that we effectively round up to 1ms here - this avoids - // very short-duration microsecond-resolution sleeps that the OS - // might treat as zero-length. -- let mut duration = self.time_source.tick_to_duration(when.saturating_sub(now)); -+ let mut duration = handle -+ .time_source -+ .tick_to_duration(when.saturating_sub(now)); - - if duration > Duration::from_millis(0) { - if let Some(limit) = limit { - duration = std::cmp::min(limit, duration); - } - -- self.park_timeout(duration)?; -+ self.park_thread_timeout(rt_handle, duration); - } else { -- self.park.park_timeout(Duration::from_secs(0))?; -+ self.park.park_timeout(rt_handle, Duration::from_secs(0)); - } - } - None => { - if let Some(duration) = limit { -- self.park_timeout(duration)?; -+ self.park_thread_timeout(rt_handle, duration); - } else { -- self.park.park()?; -+ self.park.park(rt_handle); - } - } - } - - // Process pending timers after waking up -- self.handle.process(); -- -- Ok(()) -+ handle.process(rt_handle.clock()); - } - - cfg_test_util! { -- fn park_timeout(&mut self, duration: Duration) -> Result<(), P::Error> { -- let clock = &self.time_source.clock; -+ fn park_thread_timeout(&mut self, rt_handle: &driver::Handle, duration: Duration) { -+ let handle = rt_handle.time(); -+ let clock = rt_handle.clock(); - -- if clock.is_paused() { -- self.park.park_timeout(Duration::from_secs(0))?; -+ if clock.can_auto_advance() { -+ self.park.park_timeout(rt_handle, Duration::from_secs(0)); - - // If the time driver was woken, then the park completed - // before the "duration" elapsed (usually caused by a - // yield in `Runtime::block_on`). In this case, we don't - // advance the clock. -- if !self.did_wake() { -+ if !handle.did_wake() { - // Simulate advancing time -- clock.advance(duration); -+ if let Err(msg) = clock.advance(duration) { -+ panic!("{}", msg); -+ } - } - } else { -- self.park.park_timeout(duration)?; -+ self.park.park_timeout(rt_handle, duration); - } -- -- Ok(()) -- } -- -- fn did_wake(&self) -> bool { -- self.did_wake.swap(false, Ordering::SeqCst) - } - } - - cfg_not_test_util! { -- fn park_timeout(&mut self, duration: Duration) -> Result<(), P::Error> { -- self.park.park_timeout(duration) -+ fn park_thread_timeout(&mut self, rt_handle: &driver::Handle, duration: Duration) { -+ self.park.park_timeout(rt_handle, duration); - } - } - } - - impl Handle { - /// Runs timer related logic, and returns the next wakeup time -- pub(self) fn process(&self) { -- let now = self.time_source().now(); -+ pub(self) fn process(&self, clock: &Clock) { -+ let now = self.time_source().now(clock); - - self.process_at_time(now) - } -@@ -292,7 +260,7 @@ impl Handle { - let mut waker_list: [Option; 32] = Default::default(); - let mut waker_idx = 0; - -- let mut lock = self.get().lock(); -+ let mut lock = self.inner.lock(); - - if now < lock.elapsed { - // Time went backwards! This normally shouldn't happen as the Rust language -@@ -323,7 +291,7 @@ impl Handle { - - waker_idx = 0; - -- lock = self.get().lock(); -+ lock = self.inner.lock(); - } - } - } -@@ -354,7 +322,7 @@ impl Handle { - /// `add_entry` must not be called concurrently. - pub(self) unsafe fn clear_entry(&self, entry: NonNull) { - unsafe { -- let mut lock = self.get().lock(); -+ let mut lock = self.inner.lock(); - - if entry.as_ref().might_be_registered() { - lock.wheel.remove(entry); -@@ -370,9 +338,14 @@ impl Handle { - /// driver. No other threads are allowed to concurrently manipulate the - /// timer at all (the current thread should hold an exclusive reference to - /// the `TimerEntry`) -- pub(self) unsafe fn reregister(&self, new_tick: u64, entry: NonNull) { -+ pub(self) unsafe fn reregister( -+ &self, -+ unpark: &IoHandle, -+ new_tick: u64, -+ entry: NonNull, -+ ) { - let waker = unsafe { -- let mut lock = self.get().lock(); -+ let mut lock = self.inner.lock(); - - // We may have raced with a firing/deregistration, so check before - // deregistering. -@@ -398,12 +371,12 @@ impl Handle { - .map(|next_wake| when < next_wake.get()) - .unwrap_or(true) - { -- lock.unpark.unpark(); -+ unpark.unpark(); - } - - None - } -- Err((entry, super::error::InsertError::Elapsed)) => unsafe { -+ Err((entry, crate::time::error::InsertError::Elapsed)) => unsafe { - entry.fire(Ok(())) - }, - } -@@ -419,94 +392,17 @@ impl Handle { - waker.wake(); - } - } --} -- --impl

Park for Driver

--where -- P: Park + 'static, --{ -- type Unpark = TimerUnpark

; -- type Error = P::Error; -- -- fn unpark(&self) -> Self::Unpark { -- TimerUnpark::new(self) -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -- self.park_internal(None) -- } -- -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- self.park_internal(Some(duration)) -- } -- -- fn shutdown(&mut self) { -- if self.handle.is_shutdown() { -- return; -- } -- -- self.handle.get().is_shutdown.store(true, Ordering::SeqCst); -- -- // Advance time forward to the end of time. -- -- self.handle.process_at_time(u64::MAX); -- -- self.park.shutdown(); -- } --} -- --impl

Drop for Driver

--where -- P: Park + 'static, --{ -- fn drop(&mut self) { -- self.shutdown(); -- } --} -- --pub(crate) struct TimerUnpark { -- inner: P::Unpark, -- -- #[cfg(feature = "test-util")] -- did_wake: Arc, --} -- --impl TimerUnpark

{ -- fn new(driver: &Driver

) -> TimerUnpark

{ -- TimerUnpark { -- inner: driver.park.unpark(), - -- #[cfg(feature = "test-util")] -- did_wake: driver.did_wake.clone(), -+ cfg_test_util! { -+ fn did_wake(&self) -> bool { -+ self.inner.did_wake.swap(false, Ordering::SeqCst) - } - } - } - --impl Unpark for TimerUnpark

{ -- fn unpark(&self) { -- #[cfg(feature = "test-util")] -- self.did_wake.store(true, Ordering::SeqCst); -- -- self.inner.unpark(); -- } --} -- - // ===== impl Inner ===== - - impl Inner { -- pub(self) fn new(time_source: ClockTime, unpark: Box) -> Self { -- Inner { -- state: Mutex::new(InnerState { -- time_source, -- elapsed: 0, -- next_wake: None, -- unpark, -- wheel: wheel::Wheel::new(), -- }), -- is_shutdown: AtomicBool::new(false), -- } -- } -- - /// Locks the driver's inner structure - pub(super) fn lock(&self) -> crate::loom::sync::MutexGuard<'_, InnerState> { - self.state.lock() -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/time/source.rs b/KubeOS-Rust/vendor/tokio/src/runtime/time/source.rs -new file mode 100644 -index 00000000..412812da ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/time/source.rs -@@ -0,0 +1,38 @@ -+use crate::time::{Clock, Duration, Instant}; -+ -+/// A structure which handles conversion from Instants to u64 timestamps. -+#[derive(Debug)] -+pub(crate) struct TimeSource { -+ start_time: Instant, -+} -+ -+impl TimeSource { -+ pub(crate) fn new(clock: &Clock) -> Self { -+ Self { -+ start_time: clock.now(), -+ } -+ } -+ -+ pub(crate) fn deadline_to_tick(&self, t: Instant) -> u64 { -+ // Round up to the end of a ms -+ self.instant_to_tick(t + Duration::from_nanos(999_999)) -+ } -+ -+ pub(crate) fn instant_to_tick(&self, t: Instant) -> u64 { -+ // round up -+ let dur: Duration = t -+ .checked_duration_since(self.start_time) -+ .unwrap_or_else(|| Duration::from_secs(0)); -+ let ms = dur.as_millis(); -+ -+ ms.try_into().unwrap_or(u64::MAX) -+ } -+ -+ pub(crate) fn tick_to_duration(&self, t: u64) -> Duration { -+ Duration::from_millis(t) -+ } -+ -+ pub(crate) fn now(&self, clock: &Clock) -> u64 { -+ self.instant_to_tick(clock.now()) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/time/driver/tests/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/time/tests/mod.rs -similarity index 50% -rename from KubeOS-Rust/vendor/tokio/src/time/driver/tests/mod.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/time/tests/mod.rs -index 7c5cf1fd..155d99a3 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/driver/tests/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/time/tests/mod.rs -@@ -1,33 +1,27 @@ -+#![cfg(not(tokio_wasi))] -+ - use std::{task::Context, time::Duration}; - - #[cfg(not(loom))] - use futures::task::noop_waker_ref; - -+use crate::loom::sync::atomic::{AtomicBool, Ordering}; - use crate::loom::sync::Arc; - use crate::loom::thread; --use crate::{ -- loom::sync::atomic::{AtomicBool, Ordering}, -- park::Unpark, --}; -- --use super::{Handle, TimerEntry}; - --struct MockUnpark {} --impl Unpark for MockUnpark { -- fn unpark(&self) {} --} --impl MockUnpark { -- fn mock() -> Box { -- Box::new(Self {}) -- } --} -+use super::TimerEntry; - - fn block_on(f: impl std::future::Future) -> T { - #[cfg(loom)] - return loom::future::block_on(f); - - #[cfg(not(loom))] -- return futures::executor::block_on(f); -+ { -+ let rt = crate::runtime::Builder::new_current_thread() -+ .build() -+ .unwrap(); -+ rt.block_on(f) -+ } - } - - fn model(f: impl Fn() + Send + Sync + 'static) { -@@ -38,18 +32,26 @@ fn model(f: impl Fn() + Send + Sync + 'static) { - f(); - } - -+fn rt(start_paused: bool) -> crate::runtime::Runtime { -+ crate::runtime::Builder::new_current_thread() -+ .enable_time() -+ .start_paused(start_paused) -+ .build() -+ .unwrap() -+} -+ - #[test] - fn single_timer() { - model(|| { -- let clock = crate::time::clock::Clock::new(true, false); -- let time_source = super::ClockTime::new(clock.clone()); -- -- let inner = super::Inner::new(time_source.clone(), MockUnpark::mock()); -- let handle = Handle::new(Arc::new(inner)); -+ let rt = rt(false); -+ let handle = rt.handle(); - - let handle_ = handle.clone(); - let jh = thread::spawn(move || { -- let entry = TimerEntry::new(&handle_, clock.now() + Duration::from_secs(1)); -+ let entry = TimerEntry::new( -+ &handle_.inner, -+ handle_.inner.driver().clock().now() + Duration::from_secs(1), -+ ); - pin!(entry); - - block_on(futures::future::poll_fn(|cx| { -@@ -60,10 +62,13 @@ fn single_timer() { - - thread::yield_now(); - -+ let time = handle.inner.driver().time(); -+ let clock = handle.inner.driver().clock(); -+ - // This may or may not return Some (depending on how it races with the - // thread). If it does return None, however, the timer should complete - // synchronously. -- handle.process_at_time(time_source.now() + 2_000_000_000); -+ time.process_at_time(time.time_source().now(clock) + 2_000_000_000); - - jh.join().unwrap(); - }) -@@ -72,15 +77,15 @@ fn single_timer() { - #[test] - fn drop_timer() { - model(|| { -- let clock = crate::time::clock::Clock::new(true, false); -- let time_source = super::ClockTime::new(clock.clone()); -- -- let inner = super::Inner::new(time_source.clone(), MockUnpark::mock()); -- let handle = Handle::new(Arc::new(inner)); -+ let rt = rt(false); -+ let handle = rt.handle(); - - let handle_ = handle.clone(); - let jh = thread::spawn(move || { -- let entry = TimerEntry::new(&handle_, clock.now() + Duration::from_secs(1)); -+ let entry = TimerEntry::new( -+ &handle_.inner, -+ handle_.inner.driver().clock().now() + Duration::from_secs(1), -+ ); - pin!(entry); - - let _ = entry -@@ -93,8 +98,11 @@ fn drop_timer() { - - thread::yield_now(); - -+ let time = handle.inner.driver().time(); -+ let clock = handle.inner.driver().clock(); -+ - // advance 2s in the future. -- handle.process_at_time(time_source.now() + 2_000_000_000); -+ time.process_at_time(time.time_source().now(clock) + 2_000_000_000); - - jh.join().unwrap(); - }) -@@ -103,15 +111,15 @@ fn drop_timer() { - #[test] - fn change_waker() { - model(|| { -- let clock = crate::time::clock::Clock::new(true, false); -- let time_source = super::ClockTime::new(clock.clone()); -- -- let inner = super::Inner::new(time_source.clone(), MockUnpark::mock()); -- let handle = Handle::new(Arc::new(inner)); -+ let rt = rt(false); -+ let handle = rt.handle(); - - let handle_ = handle.clone(); - let jh = thread::spawn(move || { -- let entry = TimerEntry::new(&handle_, clock.now() + Duration::from_secs(1)); -+ let entry = TimerEntry::new( -+ &handle_.inner, -+ handle_.inner.driver().clock().now() + Duration::from_secs(1), -+ ); - pin!(entry); - - let _ = entry -@@ -126,8 +134,11 @@ fn change_waker() { - - thread::yield_now(); - -+ let time = handle.inner.driver().time(); -+ let clock = handle.inner.driver().clock(); -+ - // advance 2s -- handle.process_at_time(time_source.now() + 2_000_000_000); -+ time.process_at_time(time.time_source().now(clock) + 2_000_000_000); - - jh.join().unwrap(); - }) -@@ -138,25 +149,22 @@ fn reset_future() { - model(|| { - let finished_early = Arc::new(AtomicBool::new(false)); - -- let clock = crate::time::clock::Clock::new(true, false); -- let time_source = super::ClockTime::new(clock.clone()); -- -- let inner = super::Inner::new(time_source.clone(), MockUnpark::mock()); -- let handle = Handle::new(Arc::new(inner)); -+ let rt = rt(false); -+ let handle = rt.handle(); - - let handle_ = handle.clone(); - let finished_early_ = finished_early.clone(); -- let start = clock.now(); -+ let start = handle.inner.driver().clock().now(); - - let jh = thread::spawn(move || { -- let entry = TimerEntry::new(&handle_, start + Duration::from_secs(1)); -+ let entry = TimerEntry::new(&handle_.inner, start + Duration::from_secs(1)); - pin!(entry); - - let _ = entry - .as_mut() - .poll_elapsed(&mut Context::from_waker(futures::task::noop_waker_ref())); - -- entry.as_mut().reset(start + Duration::from_secs(2)); -+ entry.as_mut().reset(start + Duration::from_secs(2), true); - - // shouldn't complete before 2s - block_on(futures::future::poll_fn(|cx| { -@@ -169,12 +177,22 @@ fn reset_future() { - - thread::yield_now(); - -+ let handle = handle.inner.driver().time(); -+ - // This may or may not return a wakeup time. -- handle.process_at_time(time_source.instant_to_tick(start + Duration::from_millis(1500))); -+ handle.process_at_time( -+ handle -+ .time_source() -+ .instant_to_tick(start + Duration::from_millis(1500)), -+ ); - - assert!(!finished_early.load(Ordering::Relaxed)); - -- handle.process_at_time(time_source.instant_to_tick(start + Duration::from_millis(2500))); -+ handle.process_at_time( -+ handle -+ .time_source() -+ .instant_to_tick(start + Duration::from_millis(2500)), -+ ); - - jh.join().unwrap(); - -@@ -182,23 +200,27 @@ fn reset_future() { - }) - } - -+#[cfg(not(loom))] -+fn normal_or_miri(normal: T, miri: T) -> T { -+ if cfg!(miri) { -+ miri -+ } else { -+ normal -+ } -+} -+ - #[test] - #[cfg(not(loom))] - fn poll_process_levels() { -- let clock = crate::time::clock::Clock::new(true, false); -- clock.pause(); -- -- let time_source = super::ClockTime::new(clock.clone()); -- -- let inner = super::Inner::new(time_source, MockUnpark::mock()); -- let handle = Handle::new(Arc::new(inner)); -+ let rt = rt(true); -+ let handle = rt.handle(); - - let mut entries = vec![]; - -- for i in 0..1024 { -+ for i in 0..normal_or_miri(1024, 64) { - let mut entry = Box::pin(TimerEntry::new( -- &handle, -- clock.now() + Duration::from_millis(i), -+ &handle.inner, -+ handle.inner.driver().clock().now() + Duration::from_millis(i), - )); - - let _ = entry -@@ -208,8 +230,9 @@ fn poll_process_levels() { - entries.push(entry); - } - -- for t in 1..1024 { -- handle.process_at_time(t as u64); -+ for t in 1..normal_or_miri(1024, 64) { -+ handle.inner.driver().time().process_at_time(t as u64); -+ - for (deadline, future) in entries.iter_mut().enumerate() { - let mut context = Context::from_waker(noop_waker_ref()); - if deadline <= t { -@@ -226,62 +249,19 @@ fn poll_process_levels() { - fn poll_process_levels_targeted() { - let mut context = Context::from_waker(noop_waker_ref()); - -- let clock = crate::time::clock::Clock::new(true, false); -- clock.pause(); -- -- let time_source = super::ClockTime::new(clock.clone()); -+ let rt = rt(true); -+ let handle = rt.handle(); - -- let inner = super::Inner::new(time_source, MockUnpark::mock()); -- let handle = Handle::new(Arc::new(inner)); -- -- let e1 = TimerEntry::new(&handle, clock.now() + Duration::from_millis(193)); -+ let e1 = TimerEntry::new( -+ &handle.inner, -+ handle.inner.driver().clock().now() + Duration::from_millis(193), -+ ); - pin!(e1); - -+ let handle = handle.inner.driver().time(); -+ - handle.process_at_time(62); - assert!(e1.as_mut().poll_elapsed(&mut context).is_pending()); - handle.process_at_time(192); - handle.process_at_time(192); - } -- --/* --#[test] --fn balanced_incr_and_decr() { -- const OPS: usize = 5; -- -- fn incr(inner: Arc) { -- for _ in 0..OPS { -- inner.increment().expect("increment should not have failed"); -- thread::yield_now(); -- } -- } -- -- fn decr(inner: Arc) { -- let mut ops_performed = 0; -- while ops_performed < OPS { -- if inner.num(Ordering::Relaxed) > 0 { -- ops_performed += 1; -- inner.decrement(); -- } -- thread::yield_now(); -- } -- } -- -- loom::model(|| { -- let unpark = Box::new(MockUnpark); -- let instant = Instant::now(); -- -- let inner = Arc::new(Inner::new(instant, unpark)); -- -- let incr_inner = inner.clone(); -- let decr_inner = inner.clone(); -- -- let incr_hndle = thread::spawn(move || incr(incr_inner)); -- let decr_hndle = thread::spawn(move || decr(decr_inner)); -- -- incr_hndle.join().expect("should never fail"); -- decr_hndle.join().expect("should never fail"); -- -- assert_eq!(inner.num(Ordering::SeqCst), 0); -- }) --} --*/ -diff --git a/KubeOS-Rust/vendor/tokio/src/time/driver/wheel/level.rs b/KubeOS-Rust/vendor/tokio/src/runtime/time/wheel/level.rs -similarity index 96% -rename from KubeOS-Rust/vendor/tokio/src/time/driver/wheel/level.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/time/wheel/level.rs -index 34d31766..7e48ff5c 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/driver/wheel/level.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/time/wheel/level.rs -@@ -1,6 +1,4 @@ --use crate::time::driver::TimerHandle; -- --use crate::time::driver::{EntryList, TimerShared}; -+use crate::runtime::time::{EntryList, TimerHandle, TimerShared}; - - use std::{fmt, ptr::NonNull}; - -@@ -53,7 +51,7 @@ impl Level { - // However, that is only supported for arrays of size - // 32 or fewer. So in our case we have to explicitly - // invoke the constructor for each array element. -- let ctor = || EntryList::default(); -+ let ctor = EntryList::default; - - Level { - level, -@@ -143,8 +141,9 @@ impl Level { - let level_range = level_range(self.level); - let slot_range = slot_range(self.level); - -- // TODO: This can probably be simplified w/ power of 2 math -- let level_start = now - (now % level_range); -+ // Compute the start date of the current level by masking the low bits -+ // of `now` (`level_range` is a power of 2). -+ let level_start = now & !(level_range - 1); - let mut deadline = level_start + slot as u64 * slot_range; - - if deadline <= now { -diff --git a/KubeOS-Rust/vendor/tokio/src/time/driver/wheel/mod.rs b/KubeOS-Rust/vendor/tokio/src/runtime/time/wheel/mod.rs -similarity index 95% -rename from KubeOS-Rust/vendor/tokio/src/time/driver/wheel/mod.rs -rename to KubeOS-Rust/vendor/tokio/src/runtime/time/wheel/mod.rs -index f088f2cf..bf13b7b2 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/driver/wheel/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/runtime/time/wheel/mod.rs -@@ -1,4 +1,4 @@ --use crate::time::driver::{TimerHandle, TimerShared}; -+use crate::runtime::time::{TimerHandle, TimerShared}; - use crate::time::error::InsertError; - - mod level; -@@ -148,23 +148,13 @@ impl Wheel { - return Some(handle); - } - -- // under what circumstances is poll.expiration Some vs. None? -- let expiration = self.next_expiration().and_then(|expiration| { -- if expiration.deadline > now { -- None -- } else { -- Some(expiration) -- } -- }); -- -- match expiration { -- Some(ref expiration) if expiration.deadline > now => return None, -- Some(ref expiration) => { -+ match self.next_expiration() { -+ Some(ref expiration) if expiration.deadline <= now => { - self.process_expiration(expiration); - - self.set_elapsed(expiration.deadline); - } -- None => { -+ _ => { - // in this case the poll did not indicate an expiration - // _and_ we were not able to find a next expiration in - // the current list of timers. advance to the poll's -diff --git a/KubeOS-Rust/vendor/tokio/src/signal/mod.rs b/KubeOS-Rust/vendor/tokio/src/signal/mod.rs -index 882218a0..3aacc60e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/signal/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/signal/mod.rs -@@ -48,7 +48,7 @@ use std::task::{Context, Poll}; - mod ctrl_c; - pub use ctrl_c::ctrl_c; - --mod registry; -+pub(crate) mod registry; - - mod os { - #[cfg(unix)] -diff --git a/KubeOS-Rust/vendor/tokio/src/signal/registry.rs b/KubeOS-Rust/vendor/tokio/src/signal/registry.rs -index e0a2df92..48e98c83 100644 ---- a/KubeOS-Rust/vendor/tokio/src/signal/registry.rs -+++ b/KubeOS-Rust/vendor/tokio/src/signal/registry.rs -@@ -1,12 +1,10 @@ - #![allow(clippy::unit_arg)] - - use crate::signal::os::{OsExtraData, OsStorage}; -- - use crate::sync::watch; -+use crate::util::once_cell::OnceCell; - --use once_cell::sync::Lazy; - use std::ops; --use std::pin::Pin; - use std::sync::atomic::{AtomicBool, Ordering}; - - pub(crate) type EventId = usize; -@@ -152,19 +150,25 @@ impl Globals { - } - } - --pub(crate) fn globals() -> Pin<&'static Globals> -+fn globals_init() -> Globals - where - OsExtraData: 'static + Send + Sync + Init, - OsStorage: 'static + Send + Sync + Init, - { -- static GLOBALS: Lazy>> = Lazy::new(|| { -- Box::pin(Globals { -- extra: OsExtraData::init(), -- registry: Registry::new(OsStorage::init()), -- }) -- }); -- -- GLOBALS.as_ref() -+ Globals { -+ extra: OsExtraData::init(), -+ registry: Registry::new(OsStorage::init()), -+ } -+} -+ -+pub(crate) fn globals() -> &'static Globals -+where -+ OsExtraData: 'static + Send + Sync + Init, -+ OsStorage: 'static + Send + Sync + Init, -+{ -+ static GLOBALS: OnceCell = OnceCell::new(); -+ -+ GLOBALS.get(globals_init) - } - - #[cfg(all(test, not(loom)))] -@@ -202,7 +206,12 @@ mod tests { - registry.broadcast(); - - // Yield so the previous broadcast can get received -- crate::time::sleep(std::time::Duration::from_millis(10)).await; -+ // -+ // This yields many times since the block_on task is only polled every 61 -+ // ticks. -+ for _ in 0..100 { -+ crate::task::yield_now().await; -+ } - - // Send subsequent signal - registry.record_event(0); -@@ -232,7 +241,7 @@ mod tests { - #[test] - fn record_invalid_event_does_nothing() { - let registry = Registry::new(vec![EventInfo::default()]); -- registry.record_event(42); -+ registry.record_event(1302); - } - - #[test] -diff --git a/KubeOS-Rust/vendor/tokio/src/signal/unix.rs b/KubeOS-Rust/vendor/tokio/src/signal/unix.rs -index 86ea9a93..ae5c1308 100644 ---- a/KubeOS-Rust/vendor/tokio/src/signal/unix.rs -+++ b/KubeOS-Rust/vendor/tokio/src/signal/unix.rs -@@ -6,29 +6,31 @@ - #![cfg(unix)] - #![cfg_attr(docsrs, doc(cfg(all(unix, feature = "signal"))))] - -+use crate::runtime::scheduler; -+use crate::runtime::signal::Handle; - use crate::signal::registry::{globals, EventId, EventInfo, Globals, Init, Storage}; - use crate::signal::RxFuture; - use crate::sync::watch; - - use mio::net::UnixStream; - use std::io::{self, Error, ErrorKind, Write}; --use std::pin::Pin; - use std::sync::atomic::{AtomicBool, Ordering}; - use std::sync::Once; - use std::task::{Context, Poll}; - --pub(crate) mod driver; --use self::driver::Handle; -- - pub(crate) type OsStorage = Vec; - --// Number of different unix signals --// (FreeBSD has 33) --const SIGNUM: usize = 33; -- - impl Init for OsStorage { - fn init() -> Self { -- (0..SIGNUM).map(|_| SignalInfo::default()).collect() -+ // There are reliable signals ranging from 1 to 33 available on every Unix platform. -+ #[cfg(not(target_os = "linux"))] -+ let possible = 0..=33; -+ -+ // On Linux, there are additional real-time signals available. -+ #[cfg(target_os = "linux")] -+ let possible = 0..=libc::SIGRTMAX(); -+ -+ possible.map(|_| SignalInfo::default()).collect() - } - } - -@@ -48,7 +50,7 @@ impl Storage for OsStorage { - #[derive(Debug)] - pub(crate) struct OsExtraData { - sender: UnixStream, -- receiver: UnixStream, -+ pub(crate) receiver: UnixStream, - } - - impl Init for OsExtraData { -@@ -60,7 +62,7 @@ impl Init for OsExtraData { - } - - /// Represents the specific kind of signal to listen for. --#[derive(Debug, Clone, Copy)] -+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)] - pub struct SignalKind(libc::c_int); - - impl SignalKind { -@@ -80,15 +82,26 @@ impl SignalKind { - // unlikely to change to other types, but technically libc can change this - // in the future minor version. - // See https://github.com/tokio-rs/tokio/issues/3767 for more. -- pub fn from_raw(signum: std::os::raw::c_int) -> Self { -+ pub const fn from_raw(signum: std::os::raw::c_int) -> Self { - Self(signum as libc::c_int) - } - -+ /// Get the signal's numeric value. -+ /// -+ /// ```rust -+ /// # use tokio::signal::unix::SignalKind; -+ /// let kind = SignalKind::interrupt(); -+ /// assert_eq!(kind.as_raw_value(), libc::SIGINT); -+ /// ``` -+ pub const fn as_raw_value(&self) -> std::os::raw::c_int { -+ self.0 -+ } -+ - /// Represents the SIGALRM signal. - /// - /// On Unix systems this signal is sent when a real-time timer has expired. - /// By default, the process is terminated by this signal. -- pub fn alarm() -> Self { -+ pub const fn alarm() -> Self { - Self(libc::SIGALRM) - } - -@@ -96,7 +109,7 @@ impl SignalKind { - /// - /// On Unix systems this signal is sent when the status of a child process - /// has changed. By default, this signal is ignored. -- pub fn child() -> Self { -+ pub const fn child() -> Self { - Self(libc::SIGCHLD) - } - -@@ -104,7 +117,7 @@ impl SignalKind { - /// - /// On Unix systems this signal is sent when the terminal is disconnected. - /// By default, the process is terminated by this signal. -- pub fn hangup() -> Self { -+ pub const fn hangup() -> Self { - Self(libc::SIGHUP) - } - -@@ -119,7 +132,7 @@ impl SignalKind { - target_os = "netbsd", - target_os = "openbsd" - ))] -- pub fn info() -> Self { -+ pub const fn info() -> Self { - Self(libc::SIGINFO) - } - -@@ -127,7 +140,7 @@ impl SignalKind { - /// - /// On Unix systems this signal is sent to interrupt a program. - /// By default, the process is terminated by this signal. -- pub fn interrupt() -> Self { -+ pub const fn interrupt() -> Self { - Self(libc::SIGINT) - } - -@@ -135,7 +148,7 @@ impl SignalKind { - /// - /// On Unix systems this signal is sent when I/O operations are possible - /// on some file descriptor. By default, this signal is ignored. -- pub fn io() -> Self { -+ pub const fn io() -> Self { - Self(libc::SIGIO) - } - -@@ -144,7 +157,7 @@ impl SignalKind { - /// On Unix systems this signal is sent when the process attempts to write - /// to a pipe which has no reader. By default, the process is terminated by - /// this signal. -- pub fn pipe() -> Self { -+ pub const fn pipe() -> Self { - Self(libc::SIGPIPE) - } - -@@ -153,7 +166,7 @@ impl SignalKind { - /// On Unix systems this signal is sent to issue a shutdown of the - /// process, after which the OS will dump the process core. - /// By default, the process is terminated by this signal. -- pub fn quit() -> Self { -+ pub const fn quit() -> Self { - Self(libc::SIGQUIT) - } - -@@ -161,7 +174,7 @@ impl SignalKind { - /// - /// On Unix systems this signal is sent to issue a shutdown of the - /// process. By default, the process is terminated by this signal. -- pub fn terminate() -> Self { -+ pub const fn terminate() -> Self { - Self(libc::SIGTERM) - } - -@@ -169,7 +182,7 @@ impl SignalKind { - /// - /// On Unix systems this is a user defined signal. - /// By default, the process is terminated by this signal. -- pub fn user_defined1() -> Self { -+ pub const fn user_defined1() -> Self { - Self(libc::SIGUSR1) - } - -@@ -177,7 +190,7 @@ impl SignalKind { - /// - /// On Unix systems this is a user defined signal. - /// By default, the process is terminated by this signal. -- pub fn user_defined2() -> Self { -+ pub const fn user_defined2() -> Self { - Self(libc::SIGUSR2) - } - -@@ -185,11 +198,23 @@ impl SignalKind { - /// - /// On Unix systems this signal is sent when the terminal window is resized. - /// By default, this signal is ignored. -- pub fn window_change() -> Self { -+ pub const fn window_change() -> Self { - Self(libc::SIGWINCH) - } - } - -+impl From for SignalKind { -+ fn from(signum: std::os::raw::c_int) -> Self { -+ Self::from_raw(signum as libc::c_int) -+ } -+} -+ -+impl From for std::os::raw::c_int { -+ fn from(kind: SignalKind) -> Self { -+ kind.as_raw_value() -+ } -+} -+ - pub(crate) struct SignalInfo { - event_info: EventInfo, - init: Once, -@@ -214,7 +239,7 @@ impl Default for SignalInfo { - /// 2. Wake up the driver by writing a byte to a pipe - /// - /// Those two operations should both be async-signal safe. --fn action(globals: Pin<&'static Globals>, signal: libc::c_int) { -+fn action(globals: &'static Globals, signal: libc::c_int) { - globals.record_event(signal as EventId); - - // Send a wakeup, ignore any errors (anything reasonably possible is -@@ -267,7 +292,11 @@ fn signal_enable(signal: SignalKind, handle: &Handle) -> io::Result<()> { - } - } - --/// A stream of events for receiving a particular type of OS signal. -+/// An listener for receiving a particular type of OS signal. -+/// -+/// The listener can be turned into a `Stream` using [`SignalStream`]. -+/// -+/// [`SignalStream`]: https://docs.rs/tokio-stream/latest/tokio_stream/wrappers/struct.SignalStream.html - /// - /// In general signal handling on Unix is a pretty tricky topic, and this - /// structure is no exception! There are some important limitations to keep in -@@ -282,7 +311,7 @@ fn signal_enable(signal: SignalKind, handle: &Handle) -> io::Result<()> { - /// Once `poll` has been called, however, a further signal is guaranteed to - /// be yielded as an item. - /// --/// Put another way, any element pulled off the returned stream corresponds to -+/// Put another way, any element pulled off the returned listener corresponds to - /// *at least one* signal, but possibly more. - /// - /// * Signal handling in general is relatively inefficient. Although some -@@ -320,11 +349,11 @@ fn signal_enable(signal: SignalKind, handle: &Handle) -> io::Result<()> { - /// #[tokio::main] - /// async fn main() -> Result<(), Box> { - /// // An infinite stream of hangup signals. --/// let mut stream = signal(SignalKind::hangup())?; -+/// let mut sig = signal(SignalKind::hangup())?; - /// - /// // Print whenever a HUP signal is received - /// loop { --/// stream.recv().await; -+/// sig.recv().await; - /// println!("got signal HUP"); - /// } - /// } -@@ -335,7 +364,7 @@ pub struct Signal { - inner: RxFuture, - } - --/// Creates a new stream which will receive notifications when the current -+/// Creates a new listener which will receive notifications when the current - /// process receives the specified signal `kind`. - /// - /// This function will create a new stream which binds to the default reactor. -@@ -357,8 +386,15 @@ pub struct Signal { - /// * If the previous initialization of this specific signal failed. - /// * If the signal is one of - /// [`signal_hook::FORBIDDEN`](fn@signal_hook_registry::register#panics) -+/// -+/// # Panics -+/// -+/// This function panics if there is no current reactor set, or if the `rt` -+/// feature flag is not enabled. -+#[track_caller] - pub fn signal(kind: SignalKind) -> io::Result { -- let rx = signal_with_handle(kind, &Handle::current())?; -+ let handle = scheduler::Handle::current(); -+ let rx = signal_with_handle(kind, handle.driver().signal())?; - - Ok(Signal { - inner: RxFuture::new(rx), -@@ -380,6 +416,12 @@ impl Signal { - /// - /// `None` is returned if no more events can be received by this stream. - /// -+ /// # Cancel safety -+ /// -+ /// This method is cancel safe. If you use it as the event in a -+ /// [`tokio::select!`](crate::select) statement and some other branch -+ /// completes first, then it is guaranteed that no signal is lost. -+ /// - /// # Examples - /// - /// Wait for SIGHUP -@@ -474,4 +516,15 @@ mod tests { - ) - .unwrap_err(); - } -+ -+ #[test] -+ fn from_c_int() { -+ assert_eq!(SignalKind::from(2), SignalKind::interrupt()); -+ } -+ -+ #[test] -+ fn into_c_int() { -+ let value: std::os::raw::c_int = SignalKind::interrupt().into(); -+ assert_eq!(value, libc::SIGINT as _); -+ } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/signal/unix/driver.rs b/KubeOS-Rust/vendor/tokio/src/signal/unix/driver.rs -deleted file mode 100644 -index 5fe7c354..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/signal/unix/driver.rs -+++ /dev/null -@@ -1,207 +0,0 @@ --#![cfg_attr(not(feature = "rt"), allow(dead_code))] -- --//! Signal driver -- --use crate::io::driver::{Driver as IoDriver, Interest}; --use crate::io::PollEvented; --use crate::park::Park; --use crate::signal::registry::globals; -- --use mio::net::UnixStream; --use std::io::{self, Read}; --use std::ptr; --use std::sync::{Arc, Weak}; --use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker}; --use std::time::Duration; -- --/// Responsible for registering wakeups when an OS signal is received, and --/// subsequently dispatching notifications to any signal listeners as appropriate. --/// --/// Note: this driver relies on having an enabled IO driver in order to listen to --/// pipe write wakeups. --#[derive(Debug)] --pub(crate) struct Driver { -- /// Thread parker. The `Driver` park implementation delegates to this. -- park: IoDriver, -- -- /// A pipe for receiving wake events from the signal handler -- receiver: PollEvented, -- -- /// Shared state -- inner: Arc, --} -- --#[derive(Clone, Debug, Default)] --pub(crate) struct Handle { -- inner: Weak, --} -- --#[derive(Debug)] --pub(super) struct Inner(()); -- --// ===== impl Driver ===== -- --impl Driver { -- /// Creates a new signal `Driver` instance that delegates wakeups to `park`. -- pub(crate) fn new(park: IoDriver) -> io::Result { -- use std::mem::ManuallyDrop; -- use std::os::unix::io::{AsRawFd, FromRawFd}; -- -- // NB: We give each driver a "fresh" receiver file descriptor to avoid -- // the issues described in alexcrichton/tokio-process#42. -- // -- // In the past we would reuse the actual receiver file descriptor and -- // swallow any errors around double registration of the same descriptor. -- // I'm not sure if the second (failed) registration simply doesn't end -- // up receiving wake up notifications, or there could be some race -- // condition when consuming readiness events, but having distinct -- // descriptors for distinct PollEvented instances appears to mitigate -- // this. -- // -- // Unfortunately we cannot just use a single global PollEvented instance -- // either, since we can't compare Handles or assume they will always -- // point to the exact same reactor. -- // -- // Mio 0.7 removed `try_clone()` as an API due to unexpected behavior -- // with registering dups with the same reactor. In this case, duping is -- // safe as each dup is registered with separate reactors **and** we -- // only expect at least one dup to receive the notification. -- -- // Manually drop as we don't actually own this instance of UnixStream. -- let receiver_fd = globals().receiver.as_raw_fd(); -- -- // safety: there is nothing unsafe about this, but the `from_raw_fd` fn is marked as unsafe. -- let original = -- ManuallyDrop::new(unsafe { std::os::unix::net::UnixStream::from_raw_fd(receiver_fd) }); -- let receiver = UnixStream::from_std(original.try_clone()?); -- let receiver = PollEvented::new_with_interest_and_handle( -- receiver, -- Interest::READABLE | Interest::WRITABLE, -- park.handle(), -- )?; -- -- Ok(Self { -- park, -- receiver, -- inner: Arc::new(Inner(())), -- }) -- } -- -- /// Returns a handle to this event loop which can be sent across threads -- /// and can be used as a proxy to the event loop itself. -- pub(crate) fn handle(&self) -> Handle { -- Handle { -- inner: Arc::downgrade(&self.inner), -- } -- } -- -- fn process(&self) { -- // Check if the pipe is ready to read and therefore has "woken" us up -- // -- // To do so, we will `poll_read_ready` with a noop waker, since we don't -- // need to actually be notified when read ready... -- let waker = unsafe { Waker::from_raw(RawWaker::new(ptr::null(), &NOOP_WAKER_VTABLE)) }; -- let mut cx = Context::from_waker(&waker); -- -- let ev = match self.receiver.registration().poll_read_ready(&mut cx) { -- Poll::Ready(Ok(ev)) => ev, -- Poll::Ready(Err(e)) => panic!("reactor gone: {}", e), -- Poll::Pending => return, // No wake has arrived, bail -- }; -- -- // Drain the pipe completely so we can receive a new readiness event -- // if another signal has come in. -- let mut buf = [0; 128]; -- loop { -- match (&*self.receiver).read(&mut buf) { -- Ok(0) => panic!("EOF on self-pipe"), -- Ok(_) => continue, // Keep reading -- Err(e) if e.kind() == io::ErrorKind::WouldBlock => break, -- Err(e) => panic!("Bad read on self-pipe: {}", e), -- } -- } -- -- self.receiver.registration().clear_readiness(ev); -- -- // Broadcast any signals which were received -- globals().broadcast(); -- } --} -- --const NOOP_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(noop_clone, noop, noop, noop); -- --unsafe fn noop_clone(_data: *const ()) -> RawWaker { -- RawWaker::new(ptr::null(), &NOOP_WAKER_VTABLE) --} -- --unsafe fn noop(_data: *const ()) {} -- --// ===== impl Park for Driver ===== -- --impl Park for Driver { -- type Unpark = ::Unpark; -- type Error = io::Error; -- -- fn unpark(&self) -> Self::Unpark { -- self.park.unpark() -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -- self.park.park()?; -- self.process(); -- Ok(()) -- } -- -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- self.park.park_timeout(duration)?; -- self.process(); -- Ok(()) -- } -- -- fn shutdown(&mut self) { -- self.park.shutdown() -- } --} -- --// ===== impl Handle ===== -- --impl Handle { -- pub(super) fn check_inner(&self) -> io::Result<()> { -- if self.inner.strong_count() > 0 { -- Ok(()) -- } else { -- Err(io::Error::new(io::ErrorKind::Other, "signal driver gone")) -- } -- } --} -- --cfg_rt! { -- impl Handle { -- /// Returns a handle to the current driver -- /// -- /// # Panics -- /// -- /// This function panics if there is no current signal driver set. -- pub(super) fn current() -> Self { -- crate::runtime::context::signal_handle().expect( -- "there is no signal driver running, must be called from the context of Tokio runtime", -- ) -- } -- } --} -- --cfg_not_rt! { -- impl Handle { -- /// Returns a handle to the current driver -- /// -- /// # Panics -- /// -- /// This function panics if there is no current signal driver set. -- pub(super) fn current() -> Self { -- panic!( -- "there is no signal driver running, must be called from the context of Tokio runtime or with\ -- `rt` enabled.", -- ) -- } -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/signal/windows.rs b/KubeOS-Rust/vendor/tokio/src/signal/windows.rs -index 11ec6cb0..2f70f98b 100644 ---- a/KubeOS-Rust/vendor/tokio/src/signal/windows.rs -+++ b/KubeOS-Rust/vendor/tokio/src/signal/windows.rs -@@ -1,9 +1,9 @@ - //! Windows-specific types for signal handling. - //! --//! This module is only defined on Windows and allows receiving "ctrl-c" --//! and "ctrl-break" notifications. These events are listened for via the --//! `SetConsoleCtrlHandler` function which receives events of the type --//! `CTRL_C_EVENT` and `CTRL_BREAK_EVENT`. -+//! This module is only defined on Windows and allows receiving "ctrl-c", -+//! "ctrl-break", "ctrl-logoff", "ctrl-shutdown", and "ctrl-close" -+//! notifications. These events are listened for via the `SetConsoleCtrlHandler` -+//! function which receives the corresponding windows_sys event type. - - #![cfg(any(windows, docsrs))] - #![cfg_attr(docsrs, doc(cfg(all(windows, feature = "signal"))))] -@@ -22,7 +22,7 @@ pub(crate) use self::imp::{OsExtraData, OsStorage}; - #[path = "windows/stub.rs"] - mod imp; - --/// Creates a new stream which receives "ctrl-c" notifications sent to the -+/// Creates a new listener which receives "ctrl-c" notifications sent to the - /// process. - /// - /// # Examples -@@ -32,12 +32,12 @@ mod imp; - /// - /// #[tokio::main] - /// async fn main() -> Result<(), Box> { --/// // An infinite stream of CTRL-C events. --/// let mut stream = ctrl_c()?; -+/// // A listener of CTRL-C events. -+/// let mut signal = ctrl_c()?; - /// - /// // Print whenever a CTRL-C event is received. - /// for countdown in (0..3).rev() { --/// stream.recv().await; -+/// signal.recv().await; - /// println!("got CTRL-C. {} more to exit", countdown); - /// } - /// -@@ -50,14 +50,18 @@ pub fn ctrl_c() -> io::Result { - }) - } - --/// Represents a stream which receives "ctrl-c" notifications sent to the process -+/// Represents a listener which receives "ctrl-c" notifications sent to the process - /// via `SetConsoleCtrlHandler`. - /// --/// A notification to this process notifies *all* streams listening for -+/// This event can be turned into a `Stream` using [`CtrlCStream`]. -+/// -+/// [`CtrlCStream`]: https://docs.rs/tokio-stream/latest/tokio_stream/wrappers/struct.CtrlCStream.html -+/// -+/// A notification to this process notifies *all* receivers for - /// this event. Moreover, the notifications **are coalesced** if they aren't processed - /// quickly enough. This means that if two notifications are received back-to-back, --/// then the stream may only receive one item about the two notifications. --#[must_use = "streams do nothing unless polled"] -+/// then the listener may only receive one item about the two notifications. -+#[must_use = "listeners do nothing unless polled"] - #[derive(Debug)] - pub struct CtrlC { - inner: RxFuture, -@@ -66,7 +70,7 @@ pub struct CtrlC { - impl CtrlC { - /// Receives the next signal notification event. - /// -- /// `None` is returned if no more events can be received by this stream. -+ /// `None` is returned if no more events can be received by the listener. - /// - /// # Examples - /// -@@ -75,12 +79,11 @@ impl CtrlC { - /// - /// #[tokio::main] - /// async fn main() -> Result<(), Box> { -- /// // An infinite stream of CTRL-C events. -- /// let mut stream = ctrl_c()?; -+ /// let mut signal = ctrl_c()?; - /// - /// // Print whenever a CTRL-C event is received. - /// for countdown in (0..3).rev() { -- /// stream.recv().await; -+ /// signal.recv().await; - /// println!("got CTRL-C. {} more to exit", countdown); - /// } - /// -@@ -94,7 +97,7 @@ impl CtrlC { - /// Polls to receive the next signal notification event, outside of an - /// `async` context. - /// -- /// `None` is returned if no more events can be received by this stream. -+ /// `None` is returned if no more events can be received. - /// - /// # Examples - /// -@@ -124,14 +127,18 @@ impl CtrlC { - } - } - --/// Represents a stream which receives "ctrl-break" notifications sent to the process -+/// Represents a listener which receives "ctrl-break" notifications sent to the process - /// via `SetConsoleCtrlHandler`. - /// --/// A notification to this process notifies *all* streams listening for -+/// This listener can be turned into a `Stream` using [`CtrlBreakStream`]. -+/// -+/// [`CtrlBreakStream`]: https://docs.rs/tokio-stream/latest/tokio_stream/wrappers/struct.CtrlBreakStream.html -+/// -+/// A notification to this process notifies *all* receivers for - /// this event. Moreover, the notifications **are coalesced** if they aren't processed - /// quickly enough. This means that if two notifications are received back-to-back, --/// then the stream may only receive one item about the two notifications. --#[must_use = "streams do nothing unless polled"] -+/// then the listener may only receive one item about the two notifications. -+#[must_use = "listeners do nothing unless polled"] - #[derive(Debug)] - pub struct CtrlBreak { - inner: RxFuture, -@@ -140,7 +147,7 @@ pub struct CtrlBreak { - impl CtrlBreak { - /// Receives the next signal notification event. - /// -- /// `None` is returned if no more events can be received by this stream. -+ /// `None` is returned if no more events can be received by this listener. - /// - /// # Examples - /// -@@ -149,12 +156,12 @@ impl CtrlBreak { - /// - /// #[tokio::main] - /// async fn main() -> Result<(), Box> { -- /// // An infinite stream of CTRL-BREAK events. -- /// let mut stream = ctrl_break()?; -+ /// // A listener of CTRL-BREAK events. -+ /// let mut signal = ctrl_break()?; - /// - /// // Print whenever a CTRL-BREAK event is received. - /// loop { -- /// stream.recv().await; -+ /// signal.recv().await; - /// println!("got signal CTRL-BREAK"); - /// } - /// } -@@ -166,7 +173,7 @@ impl CtrlBreak { - /// Polls to receive the next signal notification event, outside of an - /// `async` context. - /// -- /// `None` is returned if no more events can be received by this stream. -+ /// `None` is returned if no more events can be received by this listener. - /// - /// # Examples - /// -@@ -196,7 +203,7 @@ impl CtrlBreak { - } - } - --/// Creates a new stream which receives "ctrl-break" notifications sent to the -+/// Creates a new listener which receives "ctrl-break" notifications sent to the - /// process. - /// - /// # Examples -@@ -206,12 +213,12 @@ impl CtrlBreak { - /// - /// #[tokio::main] - /// async fn main() -> Result<(), Box> { --/// // An infinite stream of CTRL-BREAK events. --/// let mut stream = ctrl_break()?; -+/// // A listener of CTRL-BREAK events. -+/// let mut signal = ctrl_break()?; - /// - /// // Print whenever a CTRL-BREAK event is received. - /// loop { --/// stream.recv().await; -+/// signal.recv().await; - /// println!("got signal CTRL-BREAK"); - /// } - /// } -@@ -221,3 +228,297 @@ pub fn ctrl_break() -> io::Result { - inner: self::imp::ctrl_break()?, - }) - } -+ -+/// Creates a new listener which receives "ctrl-close" notifications sent to the -+/// process. -+/// -+/// # Examples -+/// -+/// ```rust,no_run -+/// use tokio::signal::windows::ctrl_close; -+/// -+/// #[tokio::main] -+/// async fn main() -> Result<(), Box> { -+/// // A listener of CTRL-CLOSE events. -+/// let mut signal = ctrl_close()?; -+/// -+/// // Print whenever a CTRL-CLOSE event is received. -+/// for countdown in (0..3).rev() { -+/// signal.recv().await; -+/// println!("got CTRL-CLOSE. {} more to exit", countdown); -+/// } -+/// -+/// Ok(()) -+/// } -+/// ``` -+pub fn ctrl_close() -> io::Result { -+ Ok(CtrlClose { -+ inner: self::imp::ctrl_close()?, -+ }) -+} -+ -+/// Represents a listener which receives "ctrl-close" notitifications sent to the process -+/// via 'SetConsoleCtrlHandler'. -+/// -+/// A notification to this process notifies *all* listeners listening for -+/// this event. Moreover, the notifications **are coalesced** if they aren't processed -+/// quickly enough. This means that if two notifications are received back-to-back, -+/// then the listener may only receive one item about the two notifications. -+#[must_use = "listeners do nothing unless polled"] -+#[derive(Debug)] -+pub struct CtrlClose { -+ inner: RxFuture, -+} -+ -+impl CtrlClose { -+ /// Receives the next signal notification event. -+ /// -+ /// `None` is returned if no more events can be received by this listener. -+ /// -+ /// # Examples -+ /// -+ /// ```rust,no_run -+ /// use tokio::signal::windows::ctrl_close; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> Result<(), Box> { -+ /// // A listener of CTRL-CLOSE events. -+ /// let mut signal = ctrl_close()?; -+ /// -+ /// // Print whenever a CTRL-CLOSE event is received. -+ /// signal.recv().await; -+ /// println!("got CTRL-CLOSE. Cleaning up before exiting"); -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub async fn recv(&mut self) -> Option<()> { -+ self.inner.recv().await -+ } -+ -+ /// Polls to receive the next signal notification event, outside of an -+ /// `async` context. -+ /// -+ /// `None` is returned if no more events can be received by this listener. -+ /// -+ /// # Examples -+ /// -+ /// Polling from a manually implemented future -+ /// -+ /// ```rust,no_run -+ /// use std::pin::Pin; -+ /// use std::future::Future; -+ /// use std::task::{Context, Poll}; -+ /// use tokio::signal::windows::CtrlClose; -+ /// -+ /// struct MyFuture { -+ /// ctrl_close: CtrlClose, -+ /// } -+ /// -+ /// impl Future for MyFuture { -+ /// type Output = Option<()>; -+ /// -+ /// fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -+ /// println!("polling MyFuture"); -+ /// self.ctrl_close.poll_recv(cx) -+ /// } -+ /// } -+ /// ``` -+ pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll> { -+ self.inner.poll_recv(cx) -+ } -+} -+ -+/// Creates a new listener which receives "ctrl-shutdown" notifications sent to the -+/// process. -+/// -+/// # Examples -+/// -+/// ```rust,no_run -+/// use tokio::signal::windows::ctrl_shutdown; -+/// -+/// #[tokio::main] -+/// async fn main() -> Result<(), Box> { -+/// // A listener of CTRL-SHUTDOWN events. -+/// let mut signal = ctrl_shutdown()?; -+/// -+/// signal.recv().await; -+/// println!("got CTRL-SHUTDOWN. Cleaning up before exiting"); -+/// -+/// Ok(()) -+/// } -+/// ``` -+pub fn ctrl_shutdown() -> io::Result { -+ Ok(CtrlShutdown { -+ inner: self::imp::ctrl_shutdown()?, -+ }) -+} -+ -+/// Represents a listener which receives "ctrl-shutdown" notitifications sent to the process -+/// via 'SetConsoleCtrlHandler'. -+/// -+/// A notification to this process notifies *all* listeners listening for -+/// this event. Moreover, the notifications **are coalesced** if they aren't processed -+/// quickly enough. This means that if two notifications are received back-to-back, -+/// then the listener may only receive one item about the two notifications. -+#[must_use = "listeners do nothing unless polled"] -+#[derive(Debug)] -+pub struct CtrlShutdown { -+ inner: RxFuture, -+} -+ -+impl CtrlShutdown { -+ /// Receives the next signal notification event. -+ /// -+ /// `None` is returned if no more events can be received by this listener. -+ /// -+ /// # Examples -+ /// -+ /// ```rust,no_run -+ /// use tokio::signal::windows::ctrl_shutdown; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> Result<(), Box> { -+ /// // A listener of CTRL-SHUTDOWN events. -+ /// let mut signal = ctrl_shutdown()?; -+ /// -+ /// // Print whenever a CTRL-SHUTDOWN event is received. -+ /// signal.recv().await; -+ /// println!("got CTRL-SHUTDOWN. Cleaning up before exiting"); -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub async fn recv(&mut self) -> Option<()> { -+ self.inner.recv().await -+ } -+ -+ /// Polls to receive the next signal notification event, outside of an -+ /// `async` context. -+ /// -+ /// `None` is returned if no more events can be received by this listener. -+ /// -+ /// # Examples -+ /// -+ /// Polling from a manually implemented future -+ /// -+ /// ```rust,no_run -+ /// use std::pin::Pin; -+ /// use std::future::Future; -+ /// use std::task::{Context, Poll}; -+ /// use tokio::signal::windows::CtrlShutdown; -+ /// -+ /// struct MyFuture { -+ /// ctrl_shutdown: CtrlShutdown, -+ /// } -+ /// -+ /// impl Future for MyFuture { -+ /// type Output = Option<()>; -+ /// -+ /// fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -+ /// println!("polling MyFuture"); -+ /// self.ctrl_shutdown.poll_recv(cx) -+ /// } -+ /// } -+ /// ``` -+ pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll> { -+ self.inner.poll_recv(cx) -+ } -+} -+ -+/// Creates a new listener which receives "ctrl-logoff" notifications sent to the -+/// process. -+/// -+/// # Examples -+/// -+/// ```rust,no_run -+/// use tokio::signal::windows::ctrl_logoff; -+/// -+/// #[tokio::main] -+/// async fn main() -> Result<(), Box> { -+/// // A listener of CTRL-LOGOFF events. -+/// let mut signal = ctrl_logoff()?; -+/// -+/// signal.recv().await; -+/// println!("got CTRL-LOGOFF. Cleaning up before exiting"); -+/// -+/// Ok(()) -+/// } -+/// ``` -+pub fn ctrl_logoff() -> io::Result { -+ Ok(CtrlLogoff { -+ inner: self::imp::ctrl_logoff()?, -+ }) -+} -+ -+/// Represents a listener which receives "ctrl-logoff" notitifications sent to the process -+/// via 'SetConsoleCtrlHandler'. -+/// -+/// A notification to this process notifies *all* listeners listening for -+/// this event. Moreover, the notifications **are coalesced** if they aren't processed -+/// quickly enough. This means that if two notifications are received back-to-back, -+/// then the listener may only receive one item about the two notifications. -+#[must_use = "listeners do nothing unless polled"] -+#[derive(Debug)] -+pub struct CtrlLogoff { -+ inner: RxFuture, -+} -+ -+impl CtrlLogoff { -+ /// Receives the next signal notification event. -+ /// -+ /// `None` is returned if no more events can be received by this listener. -+ /// -+ /// # Examples -+ /// -+ /// ```rust,no_run -+ /// use tokio::signal::windows::ctrl_logoff; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> Result<(), Box> { -+ /// // An listener of CTRL-LOGOFF events. -+ /// let mut signal = ctrl_logoff()?; -+ /// -+ /// // Print whenever a CTRL-LOGOFF event is received. -+ /// signal.recv().await; -+ /// println!("got CTRL-LOGOFF. Cleaning up before exiting"); -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ pub async fn recv(&mut self) -> Option<()> { -+ self.inner.recv().await -+ } -+ -+ /// Polls to receive the next signal notification event, outside of an -+ /// `async` context. -+ /// -+ /// `None` is returned if no more events can be received by this listener. -+ /// -+ /// # Examples -+ /// -+ /// Polling from a manually implemented future -+ /// -+ /// ```rust,no_run -+ /// use std::pin::Pin; -+ /// use std::future::Future; -+ /// use std::task::{Context, Poll}; -+ /// use tokio::signal::windows::CtrlLogoff; -+ /// -+ /// struct MyFuture { -+ /// ctrl_logoff: CtrlLogoff, -+ /// } -+ /// -+ /// impl Future for MyFuture { -+ /// type Output = Option<()>; -+ /// -+ /// fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -+ /// println!("polling MyFuture"); -+ /// self.ctrl_logoff.poll_recv(cx) -+ /// } -+ /// } -+ /// ``` -+ pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll> { -+ self.inner.poll_recv(cx) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/signal/windows/stub.rs b/KubeOS-Rust/vendor/tokio/src/signal/windows/stub.rs -index 88630543..61df3097 100644 ---- a/KubeOS-Rust/vendor/tokio/src/signal/windows/stub.rs -+++ b/KubeOS-Rust/vendor/tokio/src/signal/windows/stub.rs -@@ -4,10 +4,22 @@ - use crate::signal::RxFuture; - use std::io; - -+pub(super) fn ctrl_break() -> io::Result { -+ panic!() -+} -+ -+pub(super) fn ctrl_close() -> io::Result { -+ panic!() -+} -+ - pub(super) fn ctrl_c() -> io::Result { - panic!() - } - --pub(super) fn ctrl_break() -> io::Result { -+pub(super) fn ctrl_logoff() -> io::Result { -+ panic!() -+} -+ -+pub(super) fn ctrl_shutdown() -> io::Result { - panic!() - } -diff --git a/KubeOS-Rust/vendor/tokio/src/signal/windows/sys.rs b/KubeOS-Rust/vendor/tokio/src/signal/windows/sys.rs -index 8d29c357..26e6bdf8 100644 ---- a/KubeOS-Rust/vendor/tokio/src/signal/windows/sys.rs -+++ b/KubeOS-Rust/vendor/tokio/src/signal/windows/sys.rs -@@ -1,23 +1,33 @@ --use std::convert::TryFrom; - use std::io; - use std::sync::Once; - - use crate::signal::registry::{globals, EventId, EventInfo, Init, Storage}; - use crate::signal::RxFuture; - --use winapi::shared::minwindef::{BOOL, DWORD, FALSE, TRUE}; --use winapi::um::consoleapi::SetConsoleCtrlHandler; --use winapi::um::wincon::{CTRL_BREAK_EVENT, CTRL_C_EVENT}; -+use windows_sys::Win32::Foundation::BOOL; -+use windows_sys::Win32::System::Console as console; -+ -+pub(super) fn ctrl_break() -> io::Result { -+ new(console::CTRL_BREAK_EVENT) -+} -+ -+pub(super) fn ctrl_close() -> io::Result { -+ new(console::CTRL_CLOSE_EVENT) -+} - - pub(super) fn ctrl_c() -> io::Result { -- new(CTRL_C_EVENT) -+ new(console::CTRL_C_EVENT) - } - --pub(super) fn ctrl_break() -> io::Result { -- new(CTRL_BREAK_EVENT) -+pub(super) fn ctrl_logoff() -> io::Result { -+ new(console::CTRL_LOGOFF_EVENT) -+} -+ -+pub(super) fn ctrl_shutdown() -> io::Result { -+ new(console::CTRL_SHUTDOWN_EVENT) - } - --fn new(signum: DWORD) -> io::Result { -+fn new(signum: u32) -> io::Result { - global_init()?; - let rx = globals().register_listener(signum as EventId); - Ok(RxFuture::new(rx)) -@@ -25,24 +35,33 @@ fn new(signum: DWORD) -> io::Result { - - #[derive(Debug)] - pub(crate) struct OsStorage { -- ctrl_c: EventInfo, - ctrl_break: EventInfo, -+ ctrl_close: EventInfo, -+ ctrl_c: EventInfo, -+ ctrl_logoff: EventInfo, -+ ctrl_shutdown: EventInfo, - } - - impl Init for OsStorage { - fn init() -> Self { - Self { -- ctrl_c: EventInfo::default(), -- ctrl_break: EventInfo::default(), -+ ctrl_break: Default::default(), -+ ctrl_close: Default::default(), -+ ctrl_c: Default::default(), -+ ctrl_logoff: Default::default(), -+ ctrl_shutdown: Default::default(), - } - } - } - - impl Storage for OsStorage { - fn event_info(&self, id: EventId) -> Option<&EventInfo> { -- match DWORD::try_from(id) { -- Ok(CTRL_C_EVENT) => Some(&self.ctrl_c), -- Ok(CTRL_BREAK_EVENT) => Some(&self.ctrl_break), -+ match u32::try_from(id) { -+ Ok(console::CTRL_BREAK_EVENT) => Some(&self.ctrl_break), -+ Ok(console::CTRL_CLOSE_EVENT) => Some(&self.ctrl_close), -+ Ok(console::CTRL_C_EVENT) => Some(&self.ctrl_c), -+ Ok(console::CTRL_LOGOFF_EVENT) => Some(&self.ctrl_logoff), -+ Ok(console::CTRL_SHUTDOWN_EVENT) => Some(&self.ctrl_shutdown), - _ => None, - } - } -@@ -51,8 +70,11 @@ impl Storage for OsStorage { - where - F: FnMut(&'a EventInfo), - { -- f(&self.ctrl_c); - f(&self.ctrl_break); -+ f(&self.ctrl_close); -+ f(&self.ctrl_c); -+ f(&self.ctrl_logoff); -+ f(&self.ctrl_shutdown); - } - } - -@@ -71,7 +93,7 @@ fn global_init() -> io::Result<()> { - let mut init = None; - - INIT.call_once(|| unsafe { -- let rc = SetConsoleCtrlHandler(Some(handler), TRUE); -+ let rc = console::SetConsoleCtrlHandler(Some(handler), 1); - let ret = if rc == 0 { - Err(io::Error::last_os_error()) - } else { -@@ -84,7 +106,7 @@ fn global_init() -> io::Result<()> { - init.unwrap_or_else(|| Ok(())) - } - --unsafe extern "system" fn handler(ty: DWORD) -> BOOL { -+unsafe extern "system" fn handler(ty: u32) -> BOOL { - let globals = globals(); - globals.record_event(ty as EventId); - -@@ -93,11 +115,11 @@ unsafe extern "system" fn handler(ty: DWORD) -> BOOL { - // have the same restrictions as in Unix signal handlers, meaning we can - // go ahead and perform the broadcast here. - if globals.broadcast() { -- TRUE -+ 1 - } else { - // No one is listening for this notification any more - // let the OS fire the next (possibly the default) handler. -- FALSE -+ 0 - } - } - -@@ -121,7 +143,7 @@ mod tests { - // like sending signals on Unix, so we'll stub out the actual OS - // integration and test that our handling works. - unsafe { -- super::handler(CTRL_C_EVENT); -+ super::handler(console::CTRL_C_EVENT); - } - - assert_ready_ok!(ctrl_c.poll()); -@@ -138,13 +160,67 @@ mod tests { - // like sending signals on Unix, so we'll stub out the actual OS - // integration and test that our handling works. - unsafe { -- super::handler(CTRL_BREAK_EVENT); -+ super::handler(console::CTRL_BREAK_EVENT); - } - - ctrl_break.recv().await.unwrap(); - }); - } - -+ #[test] -+ fn ctrl_close() { -+ let rt = rt(); -+ -+ rt.block_on(async { -+ let mut ctrl_close = assert_ok!(crate::signal::windows::ctrl_close()); -+ -+ // Windows doesn't have a good programmatic way of sending events -+ // like sending signals on Unix, so we'll stub out the actual OS -+ // integration and test that our handling works. -+ unsafe { -+ super::handler(console::CTRL_CLOSE_EVENT); -+ } -+ -+ ctrl_close.recv().await.unwrap(); -+ }); -+ } -+ -+ #[test] -+ fn ctrl_shutdown() { -+ let rt = rt(); -+ -+ rt.block_on(async { -+ let mut ctrl_shutdown = assert_ok!(crate::signal::windows::ctrl_shutdown()); -+ -+ // Windows doesn't have a good programmatic way of sending events -+ // like sending signals on Unix, so we'll stub out the actual OS -+ // integration and test that our handling works. -+ unsafe { -+ super::handler(console::CTRL_SHUTDOWN_EVENT); -+ } -+ -+ ctrl_shutdown.recv().await.unwrap(); -+ }); -+ } -+ -+ #[test] -+ fn ctrl_logoff() { -+ let rt = rt(); -+ -+ rt.block_on(async { -+ let mut ctrl_logoff = assert_ok!(crate::signal::windows::ctrl_logoff()); -+ -+ // Windows doesn't have a good programmatic way of sending events -+ // like sending signals on Unix, so we'll stub out the actual OS -+ // integration and test that our handling works. -+ unsafe { -+ super::handler(console::CTRL_LOGOFF_EVENT); -+ } -+ -+ ctrl_logoff.recv().await.unwrap(); -+ }); -+ } -+ - fn rt() -> Runtime { - crate::runtime::Builder::new_current_thread() - .build() -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/barrier.rs b/KubeOS-Rust/vendor/tokio/src/sync/barrier.rs -index 0e39dac8..2ce1d731 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/barrier.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/barrier.rs -@@ -1,5 +1,7 @@ - use crate::loom::sync::Mutex; - use crate::sync::watch; -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+use crate::util::trace; - - /// A barrier enables multiple tasks to synchronize the beginning of some computation. - /// -@@ -41,6 +43,8 @@ pub struct Barrier { - state: Mutex, - wait: watch::Receiver, - n: usize, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - } - - #[derive(Debug)] -@@ -55,6 +59,7 @@ impl Barrier { - /// - /// A barrier will block `n`-1 tasks which call [`Barrier::wait`] and then wake up all - /// tasks at once when the `n`th task calls `wait`. -+ #[track_caller] - pub fn new(mut n: usize) -> Barrier { - let (waker, wait) = crate::sync::watch::channel(0); - -@@ -65,6 +70,32 @@ impl Barrier { - n = 1; - } - -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = { -+ let location = std::panic::Location::caller(); -+ let resource_span = tracing::trace_span!( -+ "runtime.resource", -+ concrete_type = "Barrier", -+ kind = "Sync", -+ loc.file = location.file(), -+ loc.line = location.line(), -+ loc.col = location.column(), -+ ); -+ -+ resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ size = n, -+ ); -+ -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ arrived = 0, -+ ) -+ }); -+ resource_span -+ }; -+ - Barrier { - state: Mutex::new(BarrierState { - waker, -@@ -73,6 +104,8 @@ impl Barrier { - }), - n, - wait, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span, - } - } - -@@ -85,10 +118,24 @@ impl Barrier { - /// [`BarrierWaitResult::is_leader`] when returning from this function, and all other tasks - /// will receive a result that will return `false` from `is_leader`. - pub async fn wait(&self) -> BarrierWaitResult { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ return trace::async_op( -+ || self.wait_internal(), -+ self.resource_span.clone(), -+ "Barrier::wait", -+ "poll", -+ false, -+ ) -+ .await; -+ -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ return self.wait_internal().await; -+ } -+ async fn wait_internal(&self) -> BarrierWaitResult { - // NOTE: we are taking a _synchronous_ lock here. - // It is okay to do so because the critical section is fast and never yields, so it cannot - // deadlock even if another future is concurrently holding the lock. -- // It is _desireable_ to do so as synchronous Mutexes are, at least in theory, faster than -+ // It is _desirable_ to do so as synchronous Mutexes are, at least in theory, faster than - // the asynchronous counter-parts, so we should use them where possible [citation needed]. - // NOTE: the extra scope here is so that the compiler doesn't think `state` is held across - // a yield point, and thus marks the returned future as !Send. -@@ -96,7 +143,23 @@ impl Barrier { - let mut state = self.state.lock(); - let generation = state.generation; - state.arrived += 1; -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ arrived = 1, -+ arrived.op = "add", -+ ); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ tracing::trace!( -+ target: "runtime::resource::async_op::state_update", -+ arrived = true, -+ ); - if state.arrived == self.n { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ tracing::trace!( -+ target: "runtime::resource::async_op::state_update", -+ is_leader = true, -+ ); - // we are the leader for this generation - // wake everyone, increment the generation, and return - state -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/batch_semaphore.rs b/KubeOS-Rust/vendor/tokio/src/sync/batch_semaphore.rs -index b5c39d2a..a7885bdf 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/batch_semaphore.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/batch_semaphore.rs -@@ -19,6 +19,8 @@ use crate::loom::cell::UnsafeCell; - use crate::loom::sync::atomic::AtomicUsize; - use crate::loom::sync::{Mutex, MutexGuard}; - use crate::util::linked_list::{self, LinkedList}; -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+use crate::util::trace; - use crate::util::WakeList; - - use std::future::Future; -@@ -35,6 +37,8 @@ pub(crate) struct Semaphore { - waiters: Mutex, - /// The current number of available permits in the semaphore. - permits: AtomicUsize, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - } - - struct Waitlist { -@@ -45,7 +49,7 @@ struct Waitlist { - /// Error returned from the [`Semaphore::try_acquire`] function. - /// - /// [`Semaphore::try_acquire`]: crate::sync::Semaphore::try_acquire --#[derive(Debug, PartialEq)] -+#[derive(Debug, PartialEq, Eq)] - pub enum TryAcquireError { - /// The semaphore has been [closed] and cannot issue new permits. - /// -@@ -101,10 +105,21 @@ struct Waiter { - /// use `UnsafeCell` internally. - pointers: linked_list::Pointers, - -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ ctx: trace::AsyncOpTracingCtx, -+ - /// Should not be `Unpin`. - _p: PhantomPinned, - } - -+generate_addr_of_methods! { -+ impl<> Waiter { -+ unsafe fn addr_of_pointers(self: NonNull) -> NonNull> { -+ &self.pointers -+ } -+ } -+} -+ - impl Semaphore { - /// The maximum number of permits which a semaphore can hold. - /// -@@ -129,12 +144,34 @@ impl Semaphore { - "a semaphore may not have more than MAX_PERMITS permits ({})", - Self::MAX_PERMITS - ); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = { -+ let resource_span = tracing::trace_span!( -+ "runtime.resource", -+ concrete_type = "Semaphore", -+ kind = "Sync", -+ is_internal = true -+ ); -+ -+ resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ permits = permits, -+ permits.op = "override", -+ ) -+ }); -+ resource_span -+ }; -+ - Self { - permits: AtomicUsize::new(permits << Self::PERMIT_SHIFT), - waiters: Mutex::new(Waitlist { - queue: LinkedList::new(), - closed: false, - }), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span, - } - } - -@@ -156,6 +193,8 @@ impl Semaphore { - queue: LinkedList::new(), - closed: false, - }), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span::none(), - } - } - -@@ -224,7 +263,10 @@ impl Semaphore { - let next = curr - num_permits; - - match self.permits.compare_exchange(curr, next, AcqRel, Acquire) { -- Ok(_) => return Ok(()), -+ Ok(_) => { -+ // TODO: Instrument once issue has been solved} -+ return Ok(()); -+ } - Err(actual) => curr = actual, - } - } -@@ -283,6 +325,17 @@ impl Semaphore { - rem, - Self::MAX_PERMITS - ); -+ -+ // add remaining permits back -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ permits = rem, -+ permits.op = "add", -+ ) -+ }); -+ - rem = 0; - } - -@@ -347,6 +400,20 @@ impl Semaphore { - acquired += acq; - if remaining == 0 { - if !queued { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ permits = acquired, -+ permits.op = "sub", -+ ); -+ tracing::trace!( -+ target: "runtime::resource::async_op::state_update", -+ permits_obtained = acquired, -+ permits.op = "add", -+ ) -+ }); -+ - return Ready(Ok(())); - } else if lock.is_none() { - break self.waiters.lock(); -@@ -362,12 +429,22 @@ impl Semaphore { - return Ready(Err(AcquireError::closed())); - } - -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ permits = acquired, -+ permits.op = "sub", -+ ) -+ }); -+ - if node.assign_permits(&mut acquired) { - self.add_permits_locked(acquired, waiters); - return Ready(Ok(())); - } - - assert_eq!(acquired, 0); -+ let mut old_waker = None; - - // Otherwise, register the waker & enqueue the node. - node.waker.with_mut(|waker| { -@@ -379,7 +456,7 @@ impl Semaphore { - .map(|waker| !waker.will_wake(cx.waker())) - .unwrap_or(true) - { -- *waker = Some(cx.waker().clone()); -+ old_waker = std::mem::replace(waker, Some(cx.waker().clone())); - } - }); - -@@ -392,6 +469,8 @@ impl Semaphore { - - waiters.queue.push_front(node); - } -+ drop(waiters); -+ drop(old_waker); - - Pending - } -@@ -406,11 +485,16 @@ impl fmt::Debug for Semaphore { - } - - impl Waiter { -- fn new(num_permits: u32) -> Self { -+ fn new( -+ num_permits: u32, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] ctx: trace::AsyncOpTracingCtx, -+ ) -> Self { - Waiter { - waker: UnsafeCell::new(None), - state: AtomicUsize::new(num_permits as usize), - pointers: linked_list::Pointers::new(), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ ctx, - _p: PhantomPinned, - } - } -@@ -426,6 +510,14 @@ impl Waiter { - match self.state.compare_exchange(curr, next, AcqRel, Acquire) { - Ok(_) => { - *n -= assign; -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.ctx.async_op_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::async_op::state_update", -+ permits_obtained = assign, -+ permits.op = "add", -+ ); -+ }); - return next == 0; - } - Err(actual) => curr = actual, -@@ -438,12 +530,26 @@ impl Future for Acquire<'_> { - type Output = Result<(), AcquireError>; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -- // First, ensure the current task has enough budget to proceed. -- let coop = ready!(crate::coop::poll_proceed(cx)); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let _resource_span = self.node.ctx.resource_span.clone().entered(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let _async_op_span = self.node.ctx.async_op_span.clone().entered(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let _async_op_poll_span = self.node.ctx.async_op_poll_span.clone().entered(); - - let (node, semaphore, needed, queued) = self.project(); - -- match semaphore.poll_acquire(cx, needed, node, *queued) { -+ // First, ensure the current task has enough budget to proceed. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let coop = ready!(trace_poll_op!( -+ "poll_acquire", -+ crate::runtime::coop::poll_proceed(cx), -+ )); -+ -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); -+ -+ let result = match semaphore.poll_acquire(cx, needed, node, *queued) { - Pending => { - *queued = true; - Pending -@@ -454,18 +560,59 @@ impl Future for Acquire<'_> { - *queued = false; - Ready(Ok(())) - } -- } -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ return trace_poll_op!("poll_acquire", result); -+ -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ return result; - } - } - - impl<'a> Acquire<'a> { - fn new(semaphore: &'a Semaphore, num_permits: u32) -> Self { -- Self { -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ return Self { - node: Waiter::new(num_permits), - semaphore, - num_permits, - queued: false, -- } -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ return semaphore.resource_span.in_scope(|| { -+ let async_op_span = -+ tracing::trace_span!("runtime.resource.async_op", source = "Acquire::new"); -+ let async_op_poll_span = async_op_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::async_op::state_update", -+ permits_requested = num_permits, -+ permits.op = "override", -+ ); -+ -+ tracing::trace!( -+ target: "runtime::resource::async_op::state_update", -+ permits_obtained = 0usize, -+ permits.op = "override", -+ ); -+ -+ tracing::trace_span!("runtime.resource.async_op.poll") -+ }); -+ -+ let ctx = trace::AsyncOpTracingCtx { -+ async_op_span, -+ async_op_poll_span, -+ resource_span: semaphore.resource_span.clone(), -+ }; -+ -+ Self { -+ node: Waiter::new(num_permits, ctx), -+ semaphore, -+ num_permits, -+ queued: false, -+ } -+ }); - } - - fn project(self: Pin<&mut Self>) -> (Pin<&mut Waiter>, &Semaphore, u32, &mut bool) { -@@ -568,12 +715,6 @@ impl std::error::Error for TryAcquireError {} - /// - /// `Waiter` is forced to be !Unpin. - unsafe impl linked_list::Link for Waiter { -- // XXX: ideally, we would be able to use `Pin` here, to enforce the -- // invariant that list entries may not move while in the list. However, we -- // can't do this currently, as using `Pin<&'a mut Waiter>` as the `Handle` -- // type would require `Semaphore` to be generic over a lifetime. We can't -- // use `Pin<*mut Waiter>`, as raw pointers are `Unpin` regardless of whether -- // or not they dereference to an `!Unpin` target. - type Handle = NonNull; - type Target = Waiter; - -@@ -585,7 +726,7 @@ unsafe impl linked_list::Link for Waiter { - ptr - } - -- unsafe fn pointers(mut target: NonNull) -> NonNull> { -- NonNull::from(&mut target.as_mut().pointers) -+ unsafe fn pointers(target: NonNull) -> NonNull> { -+ Waiter::addr_of_pointers(target) - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/broadcast.rs b/KubeOS-Rust/vendor/tokio/src/sync/broadcast.rs -index 0d9cd3bc..175a7edf 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/broadcast.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/broadcast.rs -@@ -4,7 +4,7 @@ - //! A [`Sender`] is used to broadcast values to **all** connected [`Receiver`] - //! values. [`Sender`] handles are clone-able, allowing concurrent send and - //! receive actions. [`Sender`] and [`Receiver`] are both `Send` and `Sync` as --//! long as `T` is also `Send` or `Sync` respectively. -+//! long as `T` is `Send`. - //! - //! When a value is sent, **all** [`Receiver`] handles are notified and will - //! receive the value. The value is stored once inside the channel and cloned on -@@ -18,6 +18,9 @@ - //! returned [`Receiver`] will receive values sent **after** the call to - //! `subscribe`. - //! -+//! This channel is also suitable for the single-producer multi-consumer -+//! use-case, where a single sender broadcasts values to many receivers. -+//! - //! ## Lagging - //! - //! As sent messages must be retained until **all** [`Receiver`] handles receive -@@ -51,6 +54,10 @@ - //! all values retained by the channel, the next call to [`recv`] will return - //! with [`RecvError::Closed`]. - //! -+//! When a [`Receiver`] handle is dropped, any messages not read by the receiver -+//! will be marked as read. If this receiver was the only one not to have read -+//! that message, the message will be dropped at this point. -+//! - //! [`Sender`]: crate::sync::broadcast::Sender - //! [`Sender::subscribe`]: crate::sync::broadcast::Sender::subscribe - //! [`Receiver`]: crate::sync::broadcast::Receiver -@@ -111,8 +118,9 @@ - - use crate::loom::cell::UnsafeCell; - use crate::loom::sync::atomic::AtomicUsize; --use crate::loom::sync::{Arc, Mutex, RwLock, RwLockReadGuard}; -+use crate::loom::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockReadGuard}; - use crate::util::linked_list::{self, LinkedList}; -+use crate::util::WakeList; - - use std::fmt; - use std::future::Future; -@@ -230,7 +238,7 @@ pub mod error { - /// - /// [`recv`]: crate::sync::broadcast::Receiver::recv - /// [`Receiver`]: crate::sync::broadcast::Receiver -- #[derive(Debug, PartialEq)] -+ #[derive(Debug, PartialEq, Eq, Clone)] - pub enum RecvError { - /// There are no more active senders implying no further messages will ever - /// be sent. -@@ -258,7 +266,7 @@ pub mod error { - /// - /// [`try_recv`]: crate::sync::broadcast::Receiver::try_recv - /// [`Receiver`]: crate::sync::broadcast::Receiver -- #[derive(Debug, PartialEq)] -+ #[derive(Debug, PartialEq, Eq, Clone)] - pub enum TryRecvError { - /// The channel is currently empty. There are still active - /// [`Sender`] handles, so data may yet become available. -@@ -336,9 +344,6 @@ struct Slot { - /// Uniquely identifies the `send` stored in the slot. - pos: u64, - -- /// True signals the channel is closed. -- closed: bool, -- - /// The value being broadcast. - /// - /// The value is set by `send` when the write lock is held. When a reader -@@ -361,6 +366,14 @@ struct Waiter { - _p: PhantomPinned, - } - -+generate_addr_of_methods! { -+ impl<> Waiter { -+ unsafe fn addr_of_pointers(self: NonNull) -> NonNull> { -+ &self.pointers -+ } -+ } -+} -+ - struct RecvGuard<'a, T> { - slot: RwLockReadGuard<'a, Slot>, - } -@@ -425,6 +438,12 @@ const MAX_RECEIVERS: usize = usize::MAX >> 2; - /// tx.send(20).unwrap(); - /// } - /// ``` -+/// -+/// # Panics -+/// -+/// This will panic if `capacity` is equal to `0` or larger -+/// than `usize::MAX / 2`. -+#[track_caller] - pub fn channel(mut capacity: usize) -> (Sender, Receiver) { - assert!(capacity > 0, "capacity is empty"); - assert!(capacity <= usize::MAX >> 1, "requested capacity too large"); -@@ -438,7 +457,6 @@ pub fn channel(mut capacity: usize) -> (Sender, Receiver) { - buffer.push(RwLock::new(Slot { - rem: AtomicUsize::new(0), - pos: (i as u64).wrapping_sub(capacity as u64), -- closed: false, - val: UnsafeCell::new(None), - })); - } -@@ -523,8 +541,41 @@ impl Sender { - /// } - /// ``` - pub fn send(&self, value: T) -> Result> { -- self.send2(Some(value)) -- .map_err(|SendError(maybe_v)| SendError(maybe_v.unwrap())) -+ let mut tail = self.shared.tail.lock(); -+ -+ if tail.rx_cnt == 0 { -+ return Err(SendError(value)); -+ } -+ -+ // Position to write into -+ let pos = tail.pos; -+ let rem = tail.rx_cnt; -+ let idx = (pos & self.shared.mask as u64) as usize; -+ -+ // Update the tail position -+ tail.pos = tail.pos.wrapping_add(1); -+ -+ // Get the slot -+ let mut slot = self.shared.buffer[idx].write().unwrap(); -+ -+ // Track the position -+ slot.pos = pos; -+ -+ // Set remaining receivers -+ slot.rem.with_mut(|v| *v = rem); -+ -+ // Write the value -+ slot.val = UnsafeCell::new(Some(value)); -+ -+ // Release the slot lock before notifying the receivers. -+ drop(slot); -+ -+ // Notify and release the mutex. This must happen after the slot lock is -+ // released, otherwise the writer lock bit could be cleared while another -+ // thread is in the critical section. -+ self.shared.notify_rx(tail); -+ -+ Ok(rem) - } - - /// Creates a new [`Receiver`] handle that will receive values sent **after** -@@ -555,6 +606,97 @@ impl Sender { - new_receiver(shared) - } - -+ /// Returns the number of queued values. -+ /// -+ /// A value is queued until it has either been seen by all receivers that were alive at the time -+ /// it was sent, or has been evicted from the queue by subsequent sends that exceeded the -+ /// queue's capacity. -+ /// -+ /// # Note -+ /// -+ /// In contrast to [`Receiver::len`], this method only reports queued values and not values that -+ /// have been evicted from the queue before being seen by all receivers. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::broadcast; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, mut rx1) = broadcast::channel(16); -+ /// let mut rx2 = tx.subscribe(); -+ /// -+ /// tx.send(10).unwrap(); -+ /// tx.send(20).unwrap(); -+ /// tx.send(30).unwrap(); -+ /// -+ /// assert_eq!(tx.len(), 3); -+ /// -+ /// rx1.recv().await.unwrap(); -+ /// -+ /// // The len is still 3 since rx2 hasn't seen the first value yet. -+ /// assert_eq!(tx.len(), 3); -+ /// -+ /// rx2.recv().await.unwrap(); -+ /// -+ /// assert_eq!(tx.len(), 2); -+ /// } -+ /// ``` -+ pub fn len(&self) -> usize { -+ let tail = self.shared.tail.lock(); -+ -+ let base_idx = (tail.pos & self.shared.mask as u64) as usize; -+ let mut low = 0; -+ let mut high = self.shared.buffer.len(); -+ while low < high { -+ let mid = low + (high - low) / 2; -+ let idx = base_idx.wrapping_add(mid) & self.shared.mask; -+ if self.shared.buffer[idx].read().unwrap().rem.load(SeqCst) == 0 { -+ low = mid + 1; -+ } else { -+ high = mid; -+ } -+ } -+ -+ self.shared.buffer.len() - low -+ } -+ -+ /// Returns true if there are no queued values. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::broadcast; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, mut rx1) = broadcast::channel(16); -+ /// let mut rx2 = tx.subscribe(); -+ /// -+ /// assert!(tx.is_empty()); -+ /// -+ /// tx.send(10).unwrap(); -+ /// -+ /// assert!(!tx.is_empty()); -+ /// -+ /// rx1.recv().await.unwrap(); -+ /// -+ /// // The queue is still not empty since rx2 hasn't seen the value. -+ /// assert!(!tx.is_empty()); -+ /// -+ /// rx2.recv().await.unwrap(); -+ /// -+ /// assert!(tx.is_empty()); -+ /// } -+ /// ``` -+ pub fn is_empty(&self) -> bool { -+ let tail = self.shared.tail.lock(); -+ -+ let idx = (tail.pos.wrapping_sub(1) & self.shared.mask as u64) as usize; -+ self.shared.buffer[idx].read().unwrap().rem.load(SeqCst) == 0 -+ } -+ - /// Returns the number of active receivers - /// - /// An active receiver is a [`Receiver`] handle returned from [`channel`] or -@@ -596,52 +738,38 @@ impl Sender { - tail.rx_cnt - } - -- fn send2(&self, value: Option) -> Result>> { -- let mut tail = self.shared.tail.lock(); -- -- if tail.rx_cnt == 0 { -- return Err(SendError(value)); -- } -- -- // Position to write into -- let pos = tail.pos; -- let rem = tail.rx_cnt; -- let idx = (pos & self.shared.mask as u64) as usize; -- -- // Update the tail position -- tail.pos = tail.pos.wrapping_add(1); -- -- // Get the slot -- let mut slot = self.shared.buffer[idx].write().unwrap(); -- -- // Track the position -- slot.pos = pos; -- -- // Set remaining receivers -- slot.rem.with_mut(|v| *v = rem); -- -- // Set the closed bit if the value is `None`; otherwise write the value -- if value.is_none() { -- tail.closed = true; -- slot.closed = true; -- } else { -- slot.val.with_mut(|ptr| unsafe { *ptr = value }); -- } -- -- // Release the slot lock before notifying the receivers. -- drop(slot); -- -- tail.notify_rx(); -+ /// Returns `true` if senders belong to the same channel. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::broadcast; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, _rx) = broadcast::channel::<()>(16); -+ /// let tx2 = tx.clone(); -+ /// -+ /// assert!(tx.same_channel(&tx2)); -+ /// -+ /// let (tx3, _rx3) = broadcast::channel::<()>(16); -+ /// -+ /// assert!(!tx3.same_channel(&tx2)); -+ /// } -+ /// ``` -+ pub fn same_channel(&self, other: &Self) -> bool { -+ Arc::ptr_eq(&self.shared, &other.shared) -+ } - -- // Release the mutex. This must happen after the slot lock is released, -- // otherwise the writer lock bit could be cleared while another thread -- // is in the critical section. -- drop(tail); -+ fn close_channel(&self) { -+ let mut tail = self.shared.tail.lock(); -+ tail.closed = true; - -- Ok(rem) -+ self.shared.notify_rx(tail); - } - } - -+/// Create a new `Receiver` which reads starting from the tail. - fn new_receiver(shared: Arc>) -> Receiver { - let mut tail = shared.tail.lock(); - -@@ -658,18 +786,47 @@ fn new_receiver(shared: Arc>) -> Receiver { - Receiver { shared, next } - } - --impl Tail { -- fn notify_rx(&mut self) { -- while let Some(mut waiter) = self.waiters.pop_back() { -- // Safety: `waiters` lock is still held. -- let waiter = unsafe { waiter.as_mut() }; -+impl Shared { -+ fn notify_rx<'a, 'b: 'a>(&'b self, mut tail: MutexGuard<'a, Tail>) { -+ let mut wakers = WakeList::new(); -+ 'outer: loop { -+ while wakers.can_push() { -+ match tail.waiters.pop_back() { -+ Some(mut waiter) => { -+ // Safety: `tail` lock is still held. -+ let waiter = unsafe { waiter.as_mut() }; -+ -+ assert!(waiter.queued); -+ waiter.queued = false; -+ -+ if let Some(waker) = waiter.waker.take() { -+ wakers.push(waker); -+ } -+ } -+ None => { -+ break 'outer; -+ } -+ } -+ } -+ -+ // Release the lock before waking. -+ drop(tail); -+ -+ // Before we acquire the lock again all sorts of things can happen: -+ // some waiters may remove themselves from the list and new waiters -+ // may be added. This is fine since at worst we will unnecessarily -+ // wake up waiters which will then queue themselves again. - -- assert!(waiter.queued); -- waiter.queued = false; -+ wakers.wake_all(); - -- let waker = waiter.waker.take().unwrap(); -- waker.wake(); -+ // Acquire the lock again. -+ tail = self.tail.lock(); - } -+ -+ // Release the lock before waking. -+ drop(tail); -+ -+ wakers.wake_all(); - } - } - -@@ -685,12 +842,102 @@ impl Clone for Sender { - impl Drop for Sender { - fn drop(&mut self) { - if 1 == self.shared.num_tx.fetch_sub(1, SeqCst) { -- let _ = self.send2(None); -+ self.close_channel(); - } - } - } - - impl Receiver { -+ /// Returns the number of messages that were sent into the channel and that -+ /// this [`Receiver`] has yet to receive. -+ /// -+ /// If the returned value from `len` is larger than the next largest power of 2 -+ /// of the capacity of the channel any call to [`recv`] will return an -+ /// `Err(RecvError::Lagged)` and any call to [`try_recv`] will return an -+ /// `Err(TryRecvError::Lagged)`, e.g. if the capacity of the channel is 10, -+ /// [`recv`] will start to return `Err(RecvError::Lagged)` once `len` returns -+ /// values larger than 16. -+ /// -+ /// [`Receiver`]: crate::sync::broadcast::Receiver -+ /// [`recv`]: crate::sync::broadcast::Receiver::recv -+ /// [`try_recv`]: crate::sync::broadcast::Receiver::try_recv -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::broadcast; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, mut rx1) = broadcast::channel(16); -+ /// -+ /// tx.send(10).unwrap(); -+ /// tx.send(20).unwrap(); -+ /// -+ /// assert_eq!(rx1.len(), 2); -+ /// assert_eq!(rx1.recv().await.unwrap(), 10); -+ /// assert_eq!(rx1.len(), 1); -+ /// assert_eq!(rx1.recv().await.unwrap(), 20); -+ /// assert_eq!(rx1.len(), 0); -+ /// } -+ /// ``` -+ pub fn len(&self) -> usize { -+ let next_send_pos = self.shared.tail.lock().pos; -+ (next_send_pos - self.next) as usize -+ } -+ -+ /// Returns true if there aren't any messages in the channel that the [`Receiver`] -+ /// has yet to receive. -+ /// -+ /// [`Receiver]: create::sync::broadcast::Receiver -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::broadcast; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, mut rx1) = broadcast::channel(16); -+ /// -+ /// assert!(rx1.is_empty()); -+ /// -+ /// tx.send(10).unwrap(); -+ /// tx.send(20).unwrap(); -+ /// -+ /// assert!(!rx1.is_empty()); -+ /// assert_eq!(rx1.recv().await.unwrap(), 10); -+ /// assert_eq!(rx1.recv().await.unwrap(), 20); -+ /// assert!(rx1.is_empty()); -+ /// } -+ /// ``` -+ pub fn is_empty(&self) -> bool { -+ self.len() == 0 -+ } -+ -+ /// Returns `true` if receivers belong to the same channel. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::broadcast; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, rx) = broadcast::channel::<()>(16); -+ /// let rx2 = tx.subscribe(); -+ /// -+ /// assert!(rx.same_channel(&rx2)); -+ /// -+ /// let (_tx3, rx3) = broadcast::channel::<()>(16); -+ /// -+ /// assert!(!rx3.same_channel(&rx2)); -+ /// } -+ /// ``` -+ pub fn same_channel(&self, other: &Self) -> bool { -+ Arc::ptr_eq(&self.shared, &other.shared) -+ } -+ - /// Locks the next value if there is one. - fn recv_ref( - &mut self, -@@ -702,14 +949,6 @@ impl Receiver { - let mut slot = self.shared.buffer[idx].read().unwrap(); - - if slot.pos != self.next { -- let next_pos = slot.pos.wrapping_add(self.shared.buffer.len() as u64); -- -- // The receiver has read all current values in the channel and there -- // is no waiter to register -- if waiter.is_none() && next_pos == self.next { -- return Err(TryRecvError::Empty); -- } -- - // Release the `slot` lock before attempting to acquire the `tail` - // lock. This is required because `send2` acquires the tail lock - // first followed by the slot lock. Acquiring the locks in reverse -@@ -719,6 +958,8 @@ impl Receiver { - // the slot lock. - drop(slot); - -+ let mut old_waker = None; -+ - let mut tail = self.shared.tail.lock(); - - // Acquire slot lock again -@@ -731,6 +972,13 @@ impl Receiver { - let next_pos = slot.pos.wrapping_add(self.shared.buffer.len() as u64); - - if next_pos == self.next { -+ // At this point the channel is empty for *this* receiver. If -+ // it's been closed, then that's what we return, otherwise we -+ // set a waker and return empty. -+ if tail.closed { -+ return Err(TryRecvError::Closed); -+ } -+ - // Store the waker - if let Some((waiter, waker)) = waiter { - // Safety: called while locked. -@@ -744,7 +992,10 @@ impl Receiver { - match (*ptr).waker { - Some(ref w) if w.will_wake(waker) => {} - _ => { -- (*ptr).waker = Some(waker.clone()); -+ old_waker = std::mem::replace( -+ &mut (*ptr).waker, -+ Some(waker.clone()), -+ ); - } - } - -@@ -756,6 +1007,11 @@ impl Receiver { - } - } - -+ // Drop the old waker after releasing the locks. -+ drop(slot); -+ drop(tail); -+ drop(old_waker); -+ - return Err(TryRecvError::Empty); - } - -@@ -764,22 +1020,7 @@ impl Receiver { - // catch up by skipping dropped messages and setting the - // internal cursor to the **oldest** message stored by the - // channel. -- // -- // However, finding the oldest position is a bit more -- // complicated than `tail-position - buffer-size`. When -- // the channel is closed, the tail position is incremented to -- // signal a new `None` message, but `None` is not stored in the -- // channel itself (see issue #2425 for why). -- // -- // To account for this, if the channel is closed, the tail -- // position is decremented by `buffer-size + 1`. -- let mut adjust = 0; -- if tail.closed { -- adjust = 1 -- } -- let next = tail -- .pos -- .wrapping_sub(self.shared.buffer.len() as u64 + adjust); -+ let next = tail.pos.wrapping_sub(self.shared.buffer.len() as u64); - - let missed = next.wrapping_sub(self.next); - -@@ -800,15 +1041,38 @@ impl Receiver { - - self.next = self.next.wrapping_add(1); - -- if slot.closed { -- return Err(TryRecvError::Closed); -- } -- - Ok(RecvGuard { slot }) - } - } - - impl Receiver { -+ /// Re-subscribes to the channel starting from the current tail element. -+ /// -+ /// This [`Receiver`] handle will receive a clone of all values sent -+ /// **after** it has resubscribed. This will not include elements that are -+ /// in the queue of the current receiver. Consider the following example. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::broadcast; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, mut rx) = broadcast::channel(2); -+ /// -+ /// tx.send(1).unwrap(); -+ /// let mut rx2 = rx.resubscribe(); -+ /// tx.send(2).unwrap(); -+ /// -+ /// assert_eq!(rx2.recv().await.unwrap(), 2); -+ /// assert_eq!(rx.recv().await.unwrap(), 1); -+ /// } -+ /// ``` -+ pub fn resubscribe(&self) -> Self { -+ let shared = self.shared.clone(); -+ new_receiver(shared) -+ } - /// Receives the next value for this receiver. - /// - /// Each [`Receiver`] handle will receive a clone of all values sent -@@ -1039,8 +1303,8 @@ unsafe impl linked_list::Link for Waiter { - ptr - } - -- unsafe fn pointers(mut target: NonNull) -> NonNull> { -- NonNull::from(&mut target.as_mut().pointers) -+ unsafe fn pointers(target: NonNull) -> NonNull> { -+ Waiter::addr_of_pointers(target) - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mod.rs b/KubeOS-Rust/vendor/tokio/src/sync/mod.rs -index 457e6ab2..70fd9b9e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mod.rs -@@ -94,6 +94,10 @@ - //! producers to a single consumer. This channel is often used to send work to a - //! task or to receive the result of many computations. - //! -+//! This is also the channel you should use if you want to send many messages -+//! from a single producer to a single consumer. There is no dedicated spsc -+//! channel. -+//! - //! **Example:** using an mpsc to incrementally stream the results of a series - //! of computations. - //! -@@ -244,6 +248,10 @@ - //! This channel tends to be used less often than `oneshot` and `mpsc` but still - //! has its use cases. - //! -+//! This is also the channel you should use if you want to broadcast values from -+//! a single producer to many consumers. There is no dedicated spmc broadcast -+//! channel. -+//! - //! Basic usage - //! - //! ``` -@@ -441,7 +449,7 @@ cfg_sync! { - pub mod mpsc; - - mod mutex; -- pub use mutex::{Mutex, MutexGuard, TryLockError, OwnedMutexGuard, MappedMutexGuard}; -+ pub use mutex::{Mutex, MutexGuard, TryLockError, OwnedMutexGuard, MappedMutexGuard, OwnedMappedMutexGuard}; - - pub(crate) mod notify; - pub use notify::Notify; -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/block.rs b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/block.rs -index 58f4a9f6..39c3e1be 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/block.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/block.rs -@@ -1,6 +1,7 @@ - use crate::loom::cell::UnsafeCell; - use crate::loom::sync::atomic::{AtomicPtr, AtomicUsize}; - -+use std::alloc::Layout; - use std::mem::MaybeUninit; - use std::ops; - use std::ptr::{self, NonNull}; -@@ -10,6 +11,17 @@ use std::sync::atomic::Ordering::{self, AcqRel, Acquire, Release}; - /// - /// Each block in the list can hold up to `BLOCK_CAP` messages. - pub(crate) struct Block { -+ /// The header fields. -+ header: BlockHeader, -+ -+ /// Array containing values pushed into the block. Values are stored in a -+ /// continuous array in order to improve cache line behavior when reading. -+ /// The values must be manually dropped. -+ values: Values, -+} -+ -+/// Extra fields for a `Block`. -+struct BlockHeader { - /// The start index of this block. - /// - /// Slots in this block have indices in `start_index .. start_index + BLOCK_CAP`. -@@ -24,11 +36,6 @@ pub(crate) struct Block { - /// The observed `tail_position` value *after* the block has been passed by - /// `block_tail`. - observed_tail_position: UnsafeCell, -- -- /// Array containing values pushed into the block. Values are stored in a -- /// continuous array in order to improve cache line behavior when reading. -- /// The values must be manually dropped. -- values: Values, - } - - pub(crate) enum Read { -@@ -36,6 +43,7 @@ pub(crate) enum Read { - Closed, - } - -+#[repr(transparent)] - struct Values([UnsafeCell>; BLOCK_CAP]); - - use super::BLOCK_CAP; -@@ -71,28 +79,56 @@ pub(crate) fn offset(slot_index: usize) -> usize { - SLOT_MASK & slot_index - } - -+generate_addr_of_methods! { -+ impl Block { -+ unsafe fn addr_of_header(self: NonNull) -> NonNull> { -+ &self.header -+ } -+ -+ unsafe fn addr_of_values(self: NonNull) -> NonNull> { -+ &self.values -+ } -+ } -+} -+ - impl Block { -- pub(crate) fn new(start_index: usize) -> Block { -- Block { -- // The absolute index in the channel of the first slot in the block. -- start_index, -+ pub(crate) fn new(start_index: usize) -> Box> { -+ unsafe { -+ // Allocate the block on the heap. -+ // SAFETY: The size of the Block is non-zero, since it is at least the size of the header. -+ let block = std::alloc::alloc(Layout::new::>()) as *mut Block; -+ let block = match NonNull::new(block) { -+ Some(block) => block, -+ None => std::alloc::handle_alloc_error(Layout::new::>()), -+ }; -+ -+ // Write the header to the block. -+ Block::addr_of_header(block).as_ptr().write(BlockHeader { -+ // The absolute index in the channel of the first slot in the block. -+ start_index, - -- // Pointer to the next block in the linked list. -- next: AtomicPtr::new(ptr::null_mut()), -+ // Pointer to the next block in the linked list. -+ next: AtomicPtr::new(ptr::null_mut()), - -- ready_slots: AtomicUsize::new(0), -+ ready_slots: AtomicUsize::new(0), - -- observed_tail_position: UnsafeCell::new(0), -+ observed_tail_position: UnsafeCell::new(0), -+ }); - -- // Value storage -- values: unsafe { Values::uninitialized() }, -+ // Initialize the values array. -+ Values::initialize(Block::addr_of_values(block)); -+ -+ // Convert the pointer to a `Box`. -+ // Safety: The raw pointer was allocated using the global allocator, and with -+ // the layout for a `Block`, so it's valid to convert it to box. -+ Box::from_raw(block.as_ptr()) - } - } - - /// Returns `true` if the block matches the given index. - pub(crate) fn is_at_index(&self, index: usize) -> bool { - debug_assert!(offset(index) == 0); -- self.start_index == index -+ self.header.start_index == index - } - - /// Returns the number of blocks between `self` and the block at the -@@ -101,7 +137,7 @@ impl Block { - /// `start_index` must represent a block *after* `self`. - pub(crate) fn distance(&self, other_index: usize) -> usize { - debug_assert!(offset(other_index) == 0); -- other_index.wrapping_sub(self.start_index) / BLOCK_CAP -+ other_index.wrapping_sub(self.header.start_index) / BLOCK_CAP - } - - /// Reads the value at the given offset. -@@ -116,7 +152,7 @@ impl Block { - pub(crate) unsafe fn read(&self, slot_index: usize) -> Option> { - let offset = offset(slot_index); - -- let ready_bits = self.ready_slots.load(Acquire); -+ let ready_bits = self.header.ready_slots.load(Acquire); - - if !is_ready(ready_bits, offset) { - if is_tx_closed(ready_bits) { -@@ -156,7 +192,7 @@ impl Block { - - /// Signal to the receiver that the sender half of the list is closed. - pub(crate) unsafe fn tx_close(&self) { -- self.ready_slots.fetch_or(TX_CLOSED, Release); -+ self.header.ready_slots.fetch_or(TX_CLOSED, Release); - } - - /// Resets the block to a blank state. This enables reusing blocks in the -@@ -169,9 +205,9 @@ impl Block { - /// * All slots are empty. - /// * The caller holds a unique pointer to the block. - pub(crate) unsafe fn reclaim(&mut self) { -- self.start_index = 0; -- self.next = AtomicPtr::new(ptr::null_mut()); -- self.ready_slots = AtomicUsize::new(0); -+ self.header.start_index = 0; -+ self.header.next = AtomicPtr::new(ptr::null_mut()); -+ self.header.ready_slots = AtomicUsize::new(0); - } - - /// Releases the block to the rx half for freeing. -@@ -187,19 +223,20 @@ impl Block { - pub(crate) unsafe fn tx_release(&self, tail_position: usize) { - // Track the observed tail_position. Any sender targeting a greater - // tail_position is guaranteed to not access this block. -- self.observed_tail_position -+ self.header -+ .observed_tail_position - .with_mut(|ptr| *ptr = tail_position); - - // Set the released bit, signalling to the receiver that it is safe to - // free the block's memory as soon as all slots **prior** to - // `observed_tail_position` have been filled. -- self.ready_slots.fetch_or(RELEASED, Release); -+ self.header.ready_slots.fetch_or(RELEASED, Release); - } - - /// Mark a slot as ready - fn set_ready(&self, slot: usize) { - let mask = 1 << slot; -- self.ready_slots.fetch_or(mask, Release); -+ self.header.ready_slots.fetch_or(mask, Release); - } - - /// Returns `true` when all slots have their `ready` bits set. -@@ -214,25 +251,31 @@ impl Block { - /// single atomic cell. However, this could have negative impact on cache - /// behavior as there would be many more mutations to a single slot. - pub(crate) fn is_final(&self) -> bool { -- self.ready_slots.load(Acquire) & READY_MASK == READY_MASK -+ self.header.ready_slots.load(Acquire) & READY_MASK == READY_MASK - } - - /// Returns the `observed_tail_position` value, if set - pub(crate) fn observed_tail_position(&self) -> Option { -- if 0 == RELEASED & self.ready_slots.load(Acquire) { -+ if 0 == RELEASED & self.header.ready_slots.load(Acquire) { - None - } else { -- Some(self.observed_tail_position.with(|ptr| unsafe { *ptr })) -+ Some( -+ self.header -+ .observed_tail_position -+ .with(|ptr| unsafe { *ptr }), -+ ) - } - } - - /// Loads the next block - pub(crate) fn load_next(&self, ordering: Ordering) -> Option>> { -- let ret = NonNull::new(self.next.load(ordering)); -+ let ret = NonNull::new(self.header.next.load(ordering)); - - debug_assert!(unsafe { -- ret.map(|block| block.as_ref().start_index == self.start_index.wrapping_add(BLOCK_CAP)) -- .unwrap_or(true) -+ ret.map(|block| { -+ block.as_ref().header.start_index == self.header.start_index.wrapping_add(BLOCK_CAP) -+ }) -+ .unwrap_or(true) - }); - - ret -@@ -260,9 +303,10 @@ impl Block { - success: Ordering, - failure: Ordering, - ) -> Result<(), NonNull>> { -- block.as_mut().start_index = self.start_index.wrapping_add(BLOCK_CAP); -+ block.as_mut().header.start_index = self.header.start_index.wrapping_add(BLOCK_CAP); - - let next_ptr = self -+ .header - .next - .compare_exchange(ptr::null_mut(), block.as_ptr(), success, failure) - .unwrap_or_else(|x| x); -@@ -291,7 +335,7 @@ impl Block { - // Create the new block. It is assumed that the block will become the - // next one after `&self`. If this turns out to not be the case, - // `start_index` is updated accordingly. -- let new_block = Box::new(Block::new(self.start_index + BLOCK_CAP)); -+ let new_block = Block::new(self.header.start_index + BLOCK_CAP); - - let mut new_block = unsafe { NonNull::new_unchecked(Box::into_raw(new_block)) }; - -@@ -308,7 +352,8 @@ impl Block { - // `Release` ensures that the newly allocated block is available to - // other threads acquiring the next pointer. - let next = NonNull::new( -- self.next -+ self.header -+ .next - .compare_exchange(ptr::null_mut(), new_block.as_ptr(), AcqRel, Acquire) - .unwrap_or_else(|x| x), - ); -@@ -360,19 +405,20 @@ fn is_tx_closed(bits: usize) -> bool { - } - - impl Values { -- unsafe fn uninitialized() -> Values { -- let mut vals = MaybeUninit::uninit(); -- -+ /// Initialize a `Values` struct from a pointer. -+ /// -+ /// # Safety -+ /// -+ /// The raw pointer must be valid for writing a `Values`. -+ unsafe fn initialize(_value: NonNull>) { - // When fuzzing, `UnsafeCell` needs to be initialized. - if_loom! { -- let p = vals.as_mut_ptr() as *mut UnsafeCell>; -+ let p = _value.as_ptr() as *mut UnsafeCell>; - for i in 0..BLOCK_CAP { - p.add(i) - .write(UnsafeCell::new(MaybeUninit::uninit())); - } - } -- -- Values(vals.assume_init()) - } - } - -@@ -383,3 +429,20 @@ impl ops::Index for Values { - self.0.index(index) - } - } -+ -+#[cfg(all(test, not(loom)))] -+#[test] -+fn assert_no_stack_overflow() { -+ // https://github.com/tokio-rs/tokio/issues/5293 -+ -+ struct Foo { -+ _a: [u8; 2_000_000], -+ } -+ -+ assert_eq!( -+ Layout::new::>>(), -+ Layout::new::>() -+ ); -+ -+ let _block = Block::::new(0); -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/bounded.rs b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/bounded.rs -index 5a2bfa6e..30bad6aa 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/bounded.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/bounded.rs -@@ -1,3 +1,4 @@ -+use crate::loom::sync::Arc; - use crate::sync::batch_semaphore::{self as semaphore, TryAcquireError}; - use crate::sync::mpsc::chan; - use crate::sync::mpsc::error::{SendError, TryRecvError, TrySendError}; -@@ -22,6 +23,40 @@ pub struct Sender { - chan: chan::Tx, - } - -+/// A sender that does not prevent the channel from being closed. -+/// -+/// If all [`Sender`] instances of a channel were dropped and only `WeakSender` -+/// instances remain, the channel is closed. -+/// -+/// In order to send messages, the `WeakSender` needs to be upgraded using -+/// [`WeakSender::upgrade`], which returns `Option`. It returns `None` -+/// if all `Sender`s have been dropped, and otherwise it returns a `Sender`. -+/// -+/// [`Sender`]: Sender -+/// [`WeakSender::upgrade`]: WeakSender::upgrade -+/// -+/// #Examples -+/// -+/// ``` -+/// use tokio::sync::mpsc::channel; -+/// -+/// #[tokio::main] -+/// async fn main() { -+/// let (tx, _rx) = channel::(15); -+/// let tx_weak = tx.downgrade(); -+/// -+/// // Upgrading will succeed because `tx` still exists. -+/// assert!(tx_weak.upgrade().is_some()); -+/// -+/// // If we drop `tx`, then it will fail. -+/// drop(tx); -+/// assert!(tx_weak.clone().upgrade().is_none()); -+/// } -+/// ``` -+pub struct WeakSender { -+ chan: Arc>, -+} -+ - /// Permits to send one value into the channel. - /// - /// `Permit` values are returned by [`Sender::reserve()`] and [`Sender::try_reserve()`] -@@ -105,9 +140,13 @@ pub struct Receiver { - /// } - /// } - /// ``` -+#[track_caller] - pub fn channel(buffer: usize) -> (Sender, Receiver) { - assert!(buffer > 0, "mpsc bounded channel requires buffer > 0"); -- let semaphore = (semaphore::Semaphore::new(buffer), buffer); -+ let semaphore = Semaphore { -+ semaphore: semaphore::Semaphore::new(buffer), -+ bound: buffer, -+ }; - let (tx, rx) = chan::channel(semaphore); - - let tx = Sender::new(tx); -@@ -118,7 +157,11 @@ pub fn channel(buffer: usize) -> (Sender, Receiver) { - - /// Channel semaphore is a tuple of the semaphore implementation and a `usize` - /// representing the channel bound. --type Semaphore = (semaphore::Semaphore, usize); -+#[derive(Debug)] -+pub(crate) struct Semaphore { -+ pub(crate) semaphore: semaphore::Semaphore, -+ pub(crate) bound: usize, -+} - - impl Receiver { - pub(crate) fn new(chan: chan::Rx) -> Receiver { -@@ -281,7 +324,9 @@ impl Receiver { - /// sync_code.join().unwrap() - /// } - /// ``` -+ #[track_caller] - #[cfg(feature = "sync")] -+ #[cfg_attr(docsrs, doc(alias = "recv_blocking"))] - pub fn blocking_recv(&mut self) -> Option { - crate::future::block_on(self.recv()) - } -@@ -535,7 +580,7 @@ impl Sender { - /// } - /// ``` - pub fn try_send(&self, message: T) -> Result<(), TrySendError> { -- match self.chan.semaphore().0.try_acquire(1) { -+ match self.chan.semaphore().semaphore.try_acquire(1) { - Ok(_) => {} - Err(TryAcquireError::Closed) => return Err(TrySendError::Closed(message)), - Err(TryAcquireError::NoPermits) => return Err(TrySendError::Full(message)), -@@ -563,6 +608,11 @@ impl Sender { - /// [`close`]: Receiver::close - /// [`Receiver`]: Receiver - /// -+ /// # Panics -+ /// -+ /// This function panics if it is called outside the context of a Tokio -+ /// runtime [with time enabled](crate::runtime::Builder::enable_time). -+ /// - /// # Examples - /// - /// In the following example, each call to `send_timeout` will block until the -@@ -645,7 +695,9 @@ impl Sender { - /// sync_code.join().unwrap() - /// } - /// ``` -+ #[track_caller] - #[cfg(feature = "sync")] -+ #[cfg_attr(docsrs, doc(alias = "send_blocking"))] - pub fn blocking_send(&self, value: T) -> Result<(), SendError> { - crate::future::block_on(self.send(value)) - } -@@ -809,7 +861,7 @@ impl Sender { - } - - async fn reserve_inner(&self) -> Result<(), SendError<()>> { -- match self.chan.semaphore().0.acquire(1).await { -+ match self.chan.semaphore().semaphore.acquire(1).await { - Ok(_) => Ok(()), - Err(_) => Err(SendError(())), - } -@@ -859,7 +911,7 @@ impl Sender { - /// } - /// ``` - pub fn try_reserve(&self) -> Result, TrySendError<()>> { -- match self.chan.semaphore().0.try_acquire(1) { -+ match self.chan.semaphore().semaphore.try_acquire(1) { - Ok(_) => {} - Err(TryAcquireError::Closed) => return Err(TrySendError::Closed(())), - Err(TryAcquireError::NoPermits) => return Err(TrySendError::Full(())), -@@ -924,7 +976,7 @@ impl Sender { - /// } - /// ``` - pub fn try_reserve_owned(self) -> Result, TrySendError> { -- match self.chan.semaphore().0.try_acquire(1) { -+ match self.chan.semaphore().semaphore.try_acquire(1) { - Ok(_) => {} - Err(TryAcquireError::Closed) => return Err(TrySendError::Closed(self)), - Err(TryAcquireError::NoPermits) => return Err(TrySendError::Full(self)), -@@ -955,6 +1007,8 @@ impl Sender { - /// - /// The capacity goes down when sending a value by calling [`send`] or by reserving capacity - /// with [`reserve`]. The capacity goes up when values are received by the [`Receiver`]. -+ /// This is distinct from [`max_capacity`], which always returns buffer capacity initially -+ /// specified when calling [`channel`] - /// - /// # Examples - /// -@@ -980,8 +1034,56 @@ impl Sender { - /// - /// [`send`]: Sender::send - /// [`reserve`]: Sender::reserve -+ /// [`channel`]: channel -+ /// [`max_capacity`]: Sender::max_capacity - pub fn capacity(&self) -> usize { -- self.chan.semaphore().0.available_permits() -+ self.chan.semaphore().semaphore.available_permits() -+ } -+ -+ /// Converts the `Sender` to a [`WeakSender`] that does not count -+ /// towards RAII semantics, i.e. if all `Sender` instances of the -+ /// channel were dropped and only `WeakSender` instances remain, -+ /// the channel is closed. -+ pub fn downgrade(&self) -> WeakSender { -+ WeakSender { -+ chan: self.chan.downgrade(), -+ } -+ } -+ -+ /// Returns the maximum buffer capacity of the channel. -+ /// -+ /// The maximum capacity is the buffer capacity initially specified when calling -+ /// [`channel`]. This is distinct from [`capacity`], which returns the *current* -+ /// available buffer capacity: as messages are sent and received, the -+ /// value returned by [`capacity`] will go up or down, whereas the value -+ /// returned by `max_capacity` will remain constant. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::mpsc; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, _rx) = mpsc::channel::<()>(5); -+ /// -+ /// // both max capacity and capacity are the same at first -+ /// assert_eq!(tx.max_capacity(), 5); -+ /// assert_eq!(tx.capacity(), 5); -+ /// -+ /// // Making a reservation doesn't change the max capacity. -+ /// let permit = tx.reserve().await.unwrap(); -+ /// assert_eq!(tx.max_capacity(), 5); -+ /// // but drops the capacity by one -+ /// assert_eq!(tx.capacity(), 4); -+ /// } -+ /// ``` -+ /// -+ /// [`channel`]: channel -+ /// [`max_capacity`]: Sender::max_capacity -+ /// [`capacity`]: Sender::capacity -+ pub fn max_capacity(&self) -> usize { -+ self.chan.semaphore().bound - } - } - -@@ -1001,6 +1103,29 @@ impl fmt::Debug for Sender { - } - } - -+impl Clone for WeakSender { -+ fn clone(&self) -> Self { -+ WeakSender { -+ chan: self.chan.clone(), -+ } -+ } -+} -+ -+impl WeakSender { -+ /// Tries to convert a WeakSender into a [`Sender`]. This will return `Some` -+ /// if there are other `Sender` instances alive and the channel wasn't -+ /// previously dropped, otherwise `None` is returned. -+ pub fn upgrade(&self) -> Option> { -+ chan::Tx::upgrade(self.chan.clone()).map(Sender::new) -+ } -+} -+ -+impl fmt::Debug for WeakSender { -+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt.debug_struct("WeakSender").finish() -+ } -+} -+ - // ===== impl Permit ===== - - impl Permit<'_, T> { -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/chan.rs b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/chan.rs -index c3007de8..edd3e952 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/chan.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/chan.rs -@@ -2,15 +2,14 @@ use crate::loom::cell::UnsafeCell; - use crate::loom::future::AtomicWaker; - use crate::loom::sync::atomic::AtomicUsize; - use crate::loom::sync::Arc; --use crate::park::thread::CachedParkThread; --use crate::park::Park; -+use crate::runtime::park::CachedParkThread; - use crate::sync::mpsc::error::TryRecvError; --use crate::sync::mpsc::list; -+use crate::sync::mpsc::{bounded, list, unbounded}; - use crate::sync::notify::Notify; - - use std::fmt; - use std::process; --use std::sync::atomic::Ordering::{AcqRel, Relaxed}; -+use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed, Release}; - use std::task::Poll::{Pending, Ready}; - use std::task::{Context, Poll}; - -@@ -46,7 +45,7 @@ pub(crate) trait Semaphore { - fn is_closed(&self) -> bool; - } - --struct Chan { -+pub(super) struct Chan { - /// Notifies all tasks listening for the receiver being dropped. - notify_rx_closed: Notify, - -@@ -129,6 +128,30 @@ impl Tx { - Tx { inner: chan } - } - -+ pub(super) fn downgrade(&self) -> Arc> { -+ self.inner.clone() -+ } -+ -+ // Returns the upgraded channel or None if the upgrade failed. -+ pub(super) fn upgrade(chan: Arc>) -> Option { -+ let mut tx_count = chan.tx_count.load(Acquire); -+ -+ loop { -+ if tx_count == 0 { -+ // channel is closed -+ return None; -+ } -+ -+ match chan -+ .tx_count -+ .compare_exchange_weak(tx_count, tx_count + 1, AcqRel, Acquire) -+ { -+ Ok(_) => return Some(Tx { inner: chan }), -+ Err(prev_count) => tx_count = prev_count, -+ } -+ } -+ } -+ - pub(super) fn semaphore(&self) -> &S { - &self.inner.semaphore - } -@@ -220,7 +243,7 @@ impl Rx { - use super::block::Read::*; - - // Keep track of task budget -- let coop = ready!(crate::coop::poll_proceed(cx)); -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); - - self.inner.rx_fields.with_mut(|rx_fields_ptr| { - let rx_fields = unsafe { &mut *rx_fields_ptr }; -@@ -301,13 +324,13 @@ impl Rx { - - // Park the thread until the problematic send has completed. - let mut park = CachedParkThread::new(); -- let waker = park.unpark().into_waker(); -+ let waker = park.waker().unwrap(); - loop { - self.inner.rx_waker.register_by_ref(&waker); - // It is possible that the problematic send has now completed, - // so we have to check for messages again. - try_recv!(); -- park.park().expect("park failed"); -+ park.park(); - } - }) - } -@@ -345,7 +368,7 @@ impl Drop for Chan { - fn drop(&mut self) { - use super::block::Read::Value; - -- // Safety: the only owner of the rx fields is Chan, and eing -+ // Safety: the only owner of the rx fields is Chan, and being - // inside its own Drop means we're the last ones to touch it. - self.rx_fields.with_mut(|rx_fields_ptr| { - let rx_fields = unsafe { &mut *rx_fields_ptr }; -@@ -358,32 +381,29 @@ impl Drop for Chan { - - // ===== impl Semaphore for (::Semaphore, capacity) ===== - --impl Semaphore for (crate::sync::batch_semaphore::Semaphore, usize) { -+impl Semaphore for bounded::Semaphore { - fn add_permit(&self) { -- self.0.release(1) -+ self.semaphore.release(1) - } - - fn is_idle(&self) -> bool { -- self.0.available_permits() == self.1 -+ self.semaphore.available_permits() == self.bound - } - - fn close(&self) { -- self.0.close(); -+ self.semaphore.close(); - } - - fn is_closed(&self) -> bool { -- self.0.is_closed() -+ self.semaphore.is_closed() - } - } - - // ===== impl Semaphore for AtomicUsize ===== - --use std::sync::atomic::Ordering::{Acquire, Release}; --use std::usize; -- --impl Semaphore for AtomicUsize { -+impl Semaphore for unbounded::Semaphore { - fn add_permit(&self) { -- let prev = self.fetch_sub(2, Release); -+ let prev = self.0.fetch_sub(2, Release); - - if prev >> 1 == 0 { - // Something went wrong -@@ -392,14 +412,14 @@ impl Semaphore for AtomicUsize { - } - - fn is_idle(&self) -> bool { -- self.load(Acquire) >> 1 == 0 -+ self.0.load(Acquire) >> 1 == 0 - } - - fn close(&self) { -- self.fetch_or(1, Release); -+ self.0.fetch_or(1, Release); - } - - fn is_closed(&self) -> bool { -- self.load(Acquire) & 1 == 1 -+ self.0.load(Acquire) & 1 == 1 - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/error.rs b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/error.rs -index b7b9cf7a..1c789da0 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/error.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/error.rs -@@ -19,7 +19,7 @@ impl std::error::Error for SendError {} - - /// This enumeration is the list of the possible error outcomes for the - /// [try_send](super::Sender::try_send) method. --#[derive(Debug)] -+#[derive(Debug, Eq, PartialEq)] - pub enum TrySendError { - /// The data could not be sent on the channel because the channel is - /// currently full and sending would require blocking. -@@ -78,7 +78,7 @@ impl Error for TryRecvError {} - // ===== RecvError ===== - - /// Error returned by `Receiver`. --#[derive(Debug)] -+#[derive(Debug, Clone)] - #[doc(hidden)] - #[deprecated(note = "This type is unused because recv returns an Option.")] - pub struct RecvError(()); -@@ -96,7 +96,7 @@ impl Error for RecvError {} - cfg_time! { - // ===== SendTimeoutError ===== - -- #[derive(Debug)] -+ #[derive(Debug, Eq, PartialEq)] - /// Error returned by [`Sender::send_timeout`](super::Sender::send_timeout)]. - pub enum SendTimeoutError { - /// The data could not be sent on the channel because the channel is -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/list.rs b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/list.rs -index e4eeb454..10b29575 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/list.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/list.rs -@@ -44,7 +44,7 @@ pub(crate) enum TryPopResult { - - pub(crate) fn channel() -> (Tx, Rx) { - // Create the initial block shared between the tx and rx halves. -- let initial_block = Box::new(Block::new(0)); -+ let initial_block = Block::new(0); - let initial_block_ptr = Box::into_raw(initial_block); - - let tx = Tx { -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/mod.rs b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/mod.rs -index 879e3dcf..b2af084b 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/mod.rs -@@ -21,6 +21,9 @@ - //! when additional capacity is available. In other words, the channel provides - //! backpressure. - //! -+//! This channel is also suitable for the single-producer single-consumer -+//! use-case. (Unless you only need to send one message, in which case you -+//! should use the [oneshot] channel.) - //! - //! # Disconnection - //! -@@ -30,7 +33,8 @@ - //! - //! If the [`Receiver`] handle is dropped, then messages can no longer - //! be read out of the channel. In this case, all further attempts to send will --//! result in an error. -+//! result in an error. Additionally, all unread messages will be drained from the -+//! channel and dropped. - //! - //! # Clean Shutdown - //! -@@ -58,6 +62,22 @@ - //! [crossbeam][crossbeam-unbounded]. Similarly, for sending a message _from sync - //! to async_, you should use an unbounded Tokio `mpsc` channel. - //! -+//! Please be aware that the above remarks were written with the `mpsc` channel -+//! in mind, but they can also be generalized to other kinds of channels. In -+//! general, any channel method that isn't marked async can be called anywhere, -+//! including outside of the runtime. For example, sending a message on a -+//! [oneshot] channel from outside the runtime is perfectly fine. -+//! -+//! # Multiple runtimes -+//! -+//! The mpsc channel does not care about which runtime you use it in, and can be -+//! used to send messages from one runtime to another. It can also be used in -+//! non-Tokio runtimes. -+//! -+//! There is one exception to the above: the [`send_timeout`] must be used from -+//! within a Tokio runtime, however it is still not tied to one specific Tokio -+//! runtime, and the sender may be moved from one Tokio runtime to another. -+//! - //! [`Sender`]: crate::sync::mpsc::Sender - //! [`Receiver`]: crate::sync::mpsc::Receiver - //! [bounded-send]: crate::sync::mpsc::Sender::send() -@@ -66,21 +86,25 @@ - //! [blocking-recv]: crate::sync::mpsc::Receiver::blocking_recv() - //! [`UnboundedSender`]: crate::sync::mpsc::UnboundedSender - //! [`UnboundedReceiver`]: crate::sync::mpsc::UnboundedReceiver -+//! [oneshot]: crate::sync::oneshot - //! [`Handle::block_on`]: crate::runtime::Handle::block_on() - //! [std-unbounded]: std::sync::mpsc::channel - //! [crossbeam-unbounded]: https://docs.rs/crossbeam/*/crossbeam/channel/fn.unbounded.html -+//! [`send_timeout`]: crate::sync::mpsc::Sender::send_timeout - - pub(super) mod block; - - mod bounded; --pub use self::bounded::{channel, OwnedPermit, Permit, Receiver, Sender}; -+pub use self::bounded::{channel, OwnedPermit, Permit, Receiver, Sender, WeakSender}; - - mod chan; - - pub(super) mod list; - - mod unbounded; --pub use self::unbounded::{unbounded_channel, UnboundedReceiver, UnboundedSender}; -+pub use self::unbounded::{ -+ unbounded_channel, UnboundedReceiver, UnboundedSender, WeakUnboundedSender, -+}; - - pub mod error; - -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/unbounded.rs b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/unbounded.rs -index b133f9f3..cd83fc12 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mpsc/unbounded.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mpsc/unbounded.rs -@@ -1,4 +1,4 @@ --use crate::loom::sync::atomic::AtomicUsize; -+use crate::loom::sync::{atomic::AtomicUsize, Arc}; - use crate::sync::mpsc::chan; - use crate::sync::mpsc::error::{SendError, TryRecvError}; - -@@ -13,6 +13,40 @@ pub struct UnboundedSender { - chan: chan::Tx, - } - -+/// An unbounded sender that does not prevent the channel from being closed. -+/// -+/// If all [`UnboundedSender`] instances of a channel were dropped and only -+/// `WeakUnboundedSender` instances remain, the channel is closed. -+/// -+/// In order to send messages, the `WeakUnboundedSender` needs to be upgraded using -+/// [`WeakUnboundedSender::upgrade`], which returns `Option`. It returns `None` -+/// if all `UnboundedSender`s have been dropped, and otherwise it returns an `UnboundedSender`. -+/// -+/// [`UnboundedSender`]: UnboundedSender -+/// [`WeakUnboundedSender::upgrade`]: WeakUnboundedSender::upgrade -+/// -+/// #Examples -+/// -+/// ``` -+/// use tokio::sync::mpsc::unbounded_channel; -+/// -+/// #[tokio::main] -+/// async fn main() { -+/// let (tx, _rx) = unbounded_channel::(); -+/// let tx_weak = tx.downgrade(); -+/// -+/// // Upgrading will succeed because `tx` still exists. -+/// assert!(tx_weak.upgrade().is_some()); -+/// -+/// // If we drop `tx`, then it will fail. -+/// drop(tx); -+/// assert!(tx_weak.clone().upgrade().is_none()); -+/// } -+/// ``` -+pub struct WeakUnboundedSender { -+ chan: Arc>, -+} -+ - impl Clone for UnboundedSender { - fn clone(&self) -> Self { - UnboundedSender { -@@ -61,7 +95,7 @@ impl fmt::Debug for UnboundedReceiver { - /// the channel. Using an `unbounded` channel has the ability of causing the - /// process to run out of memory. In this case, the process will be aborted. - pub fn unbounded_channel() -> (UnboundedSender, UnboundedReceiver) { -- let (tx, rx) = chan::channel(AtomicUsize::new(0)); -+ let (tx, rx) = chan::channel(Semaphore(AtomicUsize::new(0))); - - let tx = UnboundedSender::new(tx); - let rx = UnboundedReceiver::new(rx); -@@ -70,7 +104,8 @@ pub fn unbounded_channel() -> (UnboundedSender, UnboundedReceiver) { - } - - /// No capacity --type Semaphore = AtomicUsize; -+#[derive(Debug)] -+pub(crate) struct Semaphore(pub(crate) AtomicUsize); - - impl UnboundedReceiver { - pub(crate) fn new(chan: chan::Rx) -> UnboundedReceiver { -@@ -79,8 +114,14 @@ impl UnboundedReceiver { - - /// Receives the next value for this receiver. - /// -- /// `None` is returned when all `Sender` halves have dropped, indicating -- /// that no further values can be sent on the channel. -+ /// This method returns `None` if the channel has been closed and there are -+ /// no remaining messages in the channel's buffer. This indicates that no -+ /// further values can ever be received from this `Receiver`. The channel is -+ /// closed when all senders have been dropped, or when [`close`] is called. -+ /// -+ /// If there are no messages in the channel's buffer, but the channel has -+ /// not yet been closed, this method will sleep until a message is sent or -+ /// the channel is closed. - /// - /// # Cancel safety - /// -@@ -89,6 +130,8 @@ impl UnboundedReceiver { - /// completes first, it is guaranteed that no messages were received on this - /// channel. - /// -+ /// [`close`]: Self::close -+ /// - /// # Examples - /// - /// ``` -@@ -198,7 +241,9 @@ impl UnboundedReceiver { - /// sync_code.join().unwrap(); - /// } - /// ``` -+ #[track_caller] - #[cfg(feature = "sync")] -+ #[cfg_attr(docsrs, doc(alias = "recv_blocking"))] - pub fn blocking_recv(&mut self) -> Option { - crate::future::block_on(self.recv()) - } -@@ -207,6 +252,9 @@ impl UnboundedReceiver { - /// - /// This prevents any further messages from being sent on the channel while - /// still enabling the receiver to drain messages that are buffered. -+ /// -+ /// To guarantee that no messages are dropped, after calling `close()`, -+ /// `recv()` must be called until `None` is returned. - pub fn close(&mut self) { - self.chan.close(); - } -@@ -267,7 +315,7 @@ impl UnboundedSender { - use std::process; - use std::sync::atomic::Ordering::{AcqRel, Acquire}; - -- let mut curr = self.chan.semaphore().load(Acquire); -+ let mut curr = self.chan.semaphore().0.load(Acquire); - - loop { - if curr & 1 == 1 { -@@ -283,6 +331,7 @@ impl UnboundedSender { - match self - .chan - .semaphore() -+ .0 - .compare_exchange(curr, curr + 2, AcqRel, Acquire) - { - Ok(_) => return true, -@@ -370,4 +419,37 @@ impl UnboundedSender { - pub fn same_channel(&self, other: &Self) -> bool { - self.chan.same_channel(&other.chan) - } -+ -+ /// Converts the `UnboundedSender` to a [`WeakUnboundedSender`] that does not count -+ /// towards RAII semantics, i.e. if all `UnboundedSender` instances of the -+ /// channel were dropped and only `WeakUnboundedSender` instances remain, -+ /// the channel is closed. -+ pub fn downgrade(&self) -> WeakUnboundedSender { -+ WeakUnboundedSender { -+ chan: self.chan.downgrade(), -+ } -+ } -+} -+ -+impl Clone for WeakUnboundedSender { -+ fn clone(&self) -> Self { -+ WeakUnboundedSender { -+ chan: self.chan.clone(), -+ } -+ } -+} -+ -+impl WeakUnboundedSender { -+ /// Tries to convert a WeakUnboundedSender into an [`UnboundedSender`]. -+ /// This will return `Some` if there are other `Sender` instances alive and -+ /// the channel wasn't previously dropped, otherwise `None` is returned. -+ pub fn upgrade(&self) -> Option> { -+ chan::Tx::upgrade(self.chan.clone()).map(UnboundedSender::new) -+ } -+} -+ -+impl fmt::Debug for WeakUnboundedSender { -+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt.debug_struct("WeakUnboundedSender").finish() -+ } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/mutex.rs b/KubeOS-Rust/vendor/tokio/src/sync/mutex.rs -index 4d9f9886..a378116f 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/mutex.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/mutex.rs -@@ -1,12 +1,15 @@ - #![cfg_attr(not(feature = "sync"), allow(unreachable_pub, dead_code))] - - use crate::sync::batch_semaphore as semaphore; -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+use crate::util::trace; - - use std::cell::UnsafeCell; - use std::error::Error; -+use std::marker::PhantomData; - use std::ops::{Deref, DerefMut}; - use std::sync::Arc; --use std::{fmt, marker, mem}; -+use std::{fmt, mem, ptr}; - - /// An asynchronous `Mutex`-like type. - /// -@@ -124,6 +127,8 @@ use std::{fmt, marker, mem}; - /// [`Send`]: trait@std::marker::Send - /// [`lock`]: method@Mutex::lock - pub struct Mutex { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - s: semaphore::Semaphore, - c: UnsafeCell, - } -@@ -137,7 +142,13 @@ pub struct Mutex { - /// - /// The lock is automatically released whenever the guard is dropped, at which - /// point `lock` will succeed yet again. -+#[clippy::has_significant_drop] -+#[must_use = "if unused the Mutex will immediately unlock"] - pub struct MutexGuard<'a, T: ?Sized> { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - lock: &'a Mutex, - } - -@@ -156,7 +167,12 @@ pub struct MutexGuard<'a, T: ?Sized> { - /// point `lock` will succeed yet again. - /// - /// [`Arc`]: std::sync::Arc -+#[clippy::has_significant_drop] - pub struct OwnedMutexGuard { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - lock: Arc>, - } - -@@ -165,12 +181,71 @@ pub struct OwnedMutexGuard { - /// This can be used to hold a subfield of the protected data. - /// - /// [`MutexGuard::map`]: method@MutexGuard::map -+#[clippy::has_significant_drop] - #[must_use = "if unused the Mutex will immediately unlock"] - pub struct MappedMutexGuard<'a, T: ?Sized> { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - s: &'a semaphore::Semaphore, - data: *mut T, - // Needed to tell the borrow checker that we are holding a `&mut T` -- marker: marker::PhantomData<&'a mut T>, -+ marker: PhantomData<&'a mut T>, -+} -+ -+/// A owned handle to a held `Mutex` that has had a function applied to it via -+/// [`OwnedMutexGuard::map`]. -+/// -+/// This can be used to hold a subfield of the protected data. -+/// -+/// [`OwnedMutexGuard::map`]: method@OwnedMutexGuard::map -+#[clippy::has_significant_drop] -+#[must_use = "if unused the Mutex will immediately unlock"] -+pub struct OwnedMappedMutexGuard { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ data: *mut U, -+ lock: Arc>, -+} -+ -+/// A helper type used when taking apart a `MutexGuard` without running its -+/// Drop implementation. -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct MutexGuardInner<'a, T: ?Sized> { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ lock: &'a Mutex, -+} -+ -+/// A helper type used when taking apart a `OwnedMutexGuard` without running -+/// its Drop implementation. -+struct OwnedMutexGuardInner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ lock: Arc>, -+} -+ -+/// A helper type used when taking apart a `MappedMutexGuard` without running -+/// its Drop implementation. -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct MappedMutexGuardInner<'a, T: ?Sized> { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ s: &'a semaphore::Semaphore, -+ data: *mut T, -+} -+ -+/// A helper type used when taking apart a `OwnedMappedMutexGuard` without running -+/// its Drop implementation. -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct OwnedMappedMutexGuardInner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ data: *mut U, -+ lock: Arc>, - } - - // As long as T: Send, it's fine to send and share Mutex between threads. -@@ -183,6 +258,19 @@ unsafe impl Sync for OwnedMutexGuard where T: ?Sized + Send + Sync {} - unsafe impl<'a, T> Sync for MappedMutexGuard<'a, T> where T: ?Sized + Sync + 'a {} - unsafe impl<'a, T> Send for MappedMutexGuard<'a, T> where T: ?Sized + Send + 'a {} - -+unsafe impl Sync for OwnedMappedMutexGuard -+where -+ T: ?Sized + Send + Sync, -+ U: ?Sized + Send + Sync, -+{ -+} -+unsafe impl Send for OwnedMappedMutexGuard -+where -+ T: ?Sized + Send, -+ U: ?Sized + Send, -+{ -+} -+ - /// Error returned from the [`Mutex::try_lock`], [`RwLock::try_read`] and - /// [`RwLock::try_write`] functions. - /// -@@ -191,8 +279,8 @@ unsafe impl<'a, T> Send for MappedMutexGuard<'a, T> where T: ?Sized + Send + 'a - /// `RwLock::try_read` operation will only fail if the lock is currently held - /// by an exclusive writer. - /// --/// `RwLock::try_write` operation will if lock is held by any reader or by an --/// exclusive writer. -+/// `RwLock::try_write` operation will only fail if the lock is currently held -+/// by any reader or by an exclusive writer. - /// - /// [`Mutex::try_lock`]: Mutex::try_lock - /// [`RwLock::try_read`]: fn@super::RwLock::try_read -@@ -242,13 +330,42 @@ impl Mutex { - /// - /// let lock = Mutex::new(5); - /// ``` -+ #[track_caller] - pub fn new(t: T) -> Self - where - T: Sized, - { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = { -+ let location = std::panic::Location::caller(); -+ -+ tracing::trace_span!( -+ "runtime.resource", -+ concrete_type = "Mutex", -+ kind = "Sync", -+ loc.file = location.file(), -+ loc.line = location.line(), -+ loc.col = location.column(), -+ ) -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let s = resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = false, -+ ); -+ semaphore::Semaphore::new(1) -+ }); -+ -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ let s = semaphore::Semaphore::new(1); -+ - Self { - c: UnsafeCell::new(t), -- s: semaphore::Semaphore::new(1), -+ s, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span, - } - } - -@@ -270,6 +387,8 @@ impl Mutex { - Self { - c: UnsafeCell::new(t), - s: semaphore::Semaphore::const_new(1), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span::none(), - } - } - -@@ -297,16 +416,55 @@ impl Mutex { - /// } - /// ``` - pub async fn lock(&self) -> MutexGuard<'_, T> { -- self.acquire().await; -- MutexGuard { lock: self } -+ let acquire_fut = async { -+ self.acquire().await; -+ -+ MutexGuard { -+ lock: self, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ } -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let acquire_fut = trace::async_op( -+ move || acquire_fut, -+ self.resource_span.clone(), -+ "Mutex::lock", -+ "poll", -+ false, -+ ); -+ -+ #[allow(clippy::let_and_return)] // this lint triggers when disabling tracing -+ let guard = acquire_fut.await; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = true, -+ ); -+ }); -+ -+ guard - } - -- /// Blocking lock this mutex. When the lock has been acquired, function returns a -+ /// Blockingly locks this `Mutex`. When the lock has been acquired, function returns a - /// [`MutexGuard`]. - /// - /// This method is intended for use cases where you - /// need to use this mutex in asynchronous code as well as in synchronous code. - /// -+ /// # Panics -+ /// -+ /// This function panics if called within an asynchronous execution context. -+ /// -+ /// - If you find yourself in an asynchronous execution context and needing -+ /// to call some (synchronous) function which performs one of these -+ /// `blocking_` operations, then consider wrapping that call inside -+ /// [`spawn_blocking()`][crate::runtime::Handle::spawn_blocking] -+ /// (or [`block_in_place()`][crate::task::block_in_place]). -+ /// - /// # Examples - /// - /// ``` -@@ -316,25 +474,91 @@ impl Mutex { - /// #[tokio::main] - /// async fn main() { - /// let mutex = Arc::new(Mutex::new(1)); -+ /// let lock = mutex.lock().await; - /// - /// let mutex1 = Arc::clone(&mutex); -- /// let sync_code = tokio::task::spawn_blocking(move || { -+ /// let blocking_task = tokio::task::spawn_blocking(move || { -+ /// // This shall block until the `lock` is released. - /// let mut n = mutex1.blocking_lock(); - /// *n = 2; - /// }); - /// -- /// sync_code.await.unwrap(); -+ /// assert_eq!(*lock, 1); -+ /// // Release the lock. -+ /// drop(lock); -+ /// -+ /// // Await the completion of the blocking task. -+ /// blocking_task.await.unwrap(); - /// -- /// let n = mutex.lock().await; -+ /// // Assert uncontended. -+ /// let n = mutex.try_lock().unwrap(); - /// assert_eq!(*n, 2); - /// } - /// - /// ``` -+ #[track_caller] - #[cfg(feature = "sync")] -+ #[cfg_attr(docsrs, doc(alias = "lock_blocking"))] - pub fn blocking_lock(&self) -> MutexGuard<'_, T> { - crate::future::block_on(self.lock()) - } - -+ /// Blockingly locks this `Mutex`. When the lock has been acquired, function returns an -+ /// [`OwnedMutexGuard`]. -+ /// -+ /// This method is identical to [`Mutex::blocking_lock`], except that the returned -+ /// guard references the `Mutex` with an [`Arc`] rather than by borrowing -+ /// it. Therefore, the `Mutex` must be wrapped in an `Arc` to call this -+ /// method, and the guard will live for the `'static` lifetime, as it keeps -+ /// the `Mutex` alive by holding an `Arc`. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if called within an asynchronous execution context. -+ /// -+ /// - If you find yourself in an asynchronous execution context and needing -+ /// to call some (synchronous) function which performs one of these -+ /// `blocking_` operations, then consider wrapping that call inside -+ /// [`spawn_blocking()`][crate::runtime::Handle::spawn_blocking] -+ /// (or [`block_in_place()`][crate::task::block_in_place]). -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use std::sync::Arc; -+ /// use tokio::sync::Mutex; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let mutex = Arc::new(Mutex::new(1)); -+ /// let lock = mutex.lock().await; -+ /// -+ /// let mutex1 = Arc::clone(&mutex); -+ /// let blocking_task = tokio::task::spawn_blocking(move || { -+ /// // This shall block until the `lock` is released. -+ /// let mut n = mutex1.blocking_lock_owned(); -+ /// *n = 2; -+ /// }); -+ /// -+ /// assert_eq!(*lock, 1); -+ /// // Release the lock. -+ /// drop(lock); -+ /// -+ /// // Await the completion of the blocking task. -+ /// blocking_task.await.unwrap(); -+ /// -+ /// // Assert uncontended. -+ /// let n = mutex.try_lock().unwrap(); -+ /// assert_eq!(*n, 2); -+ /// } -+ /// -+ /// ``` -+ #[track_caller] -+ #[cfg(feature = "sync")] -+ pub fn blocking_lock_owned(self: Arc) -> OwnedMutexGuard { -+ crate::future::block_on(self.lock_owned()) -+ } -+ - /// Locks this mutex, causing the current task to yield until the lock has - /// been acquired. When the lock has been acquired, this returns an - /// [`OwnedMutexGuard`]. -@@ -368,8 +592,40 @@ impl Mutex { - /// - /// [`Arc`]: std::sync::Arc - pub async fn lock_owned(self: Arc) -> OwnedMutexGuard { -- self.acquire().await; -- OwnedMutexGuard { lock: self } -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = self.resource_span.clone(); -+ -+ let acquire_fut = async { -+ self.acquire().await; -+ -+ OwnedMutexGuard { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ lock: self, -+ } -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let acquire_fut = trace::async_op( -+ move || acquire_fut, -+ resource_span, -+ "Mutex::lock_owned", -+ "poll", -+ false, -+ ); -+ -+ #[allow(clippy::let_and_return)] // this lint triggers when disabling tracing -+ let guard = acquire_fut.await; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = true, -+ ); -+ }); -+ -+ guard - } - - async fn acquire(&self) { -@@ -399,7 +655,23 @@ impl Mutex { - /// ``` - pub fn try_lock(&self) -> Result, TryLockError> { - match self.s.try_acquire(1) { -- Ok(_) => Ok(MutexGuard { lock: self }), -+ Ok(_) => { -+ let guard = MutexGuard { -+ lock: self, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = true, -+ ); -+ }); -+ -+ Ok(guard) -+ } - Err(_) => Err(TryLockError(())), - } - } -@@ -454,7 +726,23 @@ impl Mutex { - /// # } - pub fn try_lock_owned(self: Arc) -> Result, TryLockError> { - match self.s.try_acquire(1) { -- Ok(_) => Ok(OwnedMutexGuard { lock: self }), -+ Ok(_) => { -+ let guard = OwnedMutexGuard { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ lock: self, -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = true, -+ ); -+ }); -+ -+ Ok(guard) -+ } - Err(_) => Err(TryLockError(())), - } - } -@@ -513,6 +801,17 @@ where - // === impl MutexGuard === - - impl<'a, T: ?Sized> MutexGuard<'a, T> { -+ fn skip_drop(self) -> MutexGuardInner<'a, T> { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the `resource_span` and then forgets the -+ // original. In the end, we have not duplicated or forgotten any values. -+ MutexGuardInner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: unsafe { std::ptr::read(&me.resource_span) }, -+ lock: me.lock, -+ } -+ } -+ - /// Makes a new [`MappedMutexGuard`] for a component of the locked data. - /// - /// This operation cannot fail as the [`MutexGuard`] passed in already locked the mutex. -@@ -549,12 +848,13 @@ impl<'a, T: ?Sized> MutexGuard<'a, T> { - F: FnOnce(&mut T) -> &mut U, - { - let data = f(&mut *this) as *mut U; -- let s = &this.lock.s; -- mem::forget(this); -+ let inner = this.skip_drop(); - MappedMutexGuard { -- s, -+ s: &inner.lock.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: inner.resource_span, - } - } - -@@ -599,12 +899,13 @@ impl<'a, T: ?Sized> MutexGuard<'a, T> { - Some(data) => data as *mut U, - None => return Err(this), - }; -- let s = &this.lock.s; -- mem::forget(this); -+ let inner = this.skip_drop(); - Ok(MappedMutexGuard { -- s, -+ s: &inner.lock.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: inner.resource_span, - }) - } - -@@ -626,7 +927,7 @@ impl<'a, T: ?Sized> MutexGuard<'a, T> { - /// # async fn main() { - /// # let mutex = Mutex::new(0u32); - /// # let guard = mutex.lock().await; -- /// # unlock_and_relock(guard).await; -+ /// # let _guard = unlock_and_relock(guard).await; - /// # } - /// ``` - #[inline] -@@ -637,7 +938,15 @@ impl<'a, T: ?Sized> MutexGuard<'a, T> { - - impl Drop for MutexGuard<'_, T> { - fn drop(&mut self) { -- self.lock.s.release(1) -+ self.lock.s.release(1); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = false, -+ ); -+ }); - } - } - -@@ -669,6 +978,116 @@ impl fmt::Display for MutexGuard<'_, T> { - // === impl OwnedMutexGuard === - - impl OwnedMutexGuard { -+ fn skip_drop(self) -> OwnedMutexGuardInner { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the values in every field of the guard, then -+ // forgets the originals, so in the end no value is duplicated. -+ unsafe { -+ OwnedMutexGuardInner { -+ lock: ptr::read(&me.lock), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: ptr::read(&me.resource_span), -+ } -+ } -+ } -+ -+ /// Makes a new [`OwnedMappedMutexGuard`] for a component of the locked data. -+ /// -+ /// This operation cannot fail as the [`OwnedMutexGuard`] passed in already locked the mutex. -+ /// -+ /// This is an associated function that needs to be used as `OwnedMutexGuard::map(...)`. A method -+ /// would interfere with methods of the same name on the contents of the locked data. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::{Mutex, OwnedMutexGuard}; -+ /// use std::sync::Arc; -+ /// -+ /// #[derive(Debug, Clone, Copy, PartialEq, Eq)] -+ /// struct Foo(u32); -+ /// -+ /// # #[tokio::main] -+ /// # async fn main() { -+ /// let foo = Arc::new(Mutex::new(Foo(1))); -+ /// -+ /// { -+ /// let mut mapped = OwnedMutexGuard::map(foo.clone().lock_owned().await, |f| &mut f.0); -+ /// *mapped = 2; -+ /// } -+ /// -+ /// assert_eq!(Foo(2), *foo.lock().await); -+ /// # } -+ /// ``` -+ /// -+ /// [`OwnedMutexGuard`]: struct@OwnedMutexGuard -+ /// [`OwnedMappedMutexGuard`]: struct@OwnedMappedMutexGuard -+ #[inline] -+ pub fn map(mut this: Self, f: F) -> OwnedMappedMutexGuard -+ where -+ F: FnOnce(&mut T) -> &mut U, -+ { -+ let data = f(&mut *this) as *mut U; -+ let inner = this.skip_drop(); -+ OwnedMappedMutexGuard { -+ data, -+ lock: inner.lock, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: inner.resource_span, -+ } -+ } -+ -+ /// Attempts to make a new [`OwnedMappedMutexGuard`] for a component of the locked data. The -+ /// original guard is returned if the closure returns `None`. -+ /// -+ /// This operation cannot fail as the [`OwnedMutexGuard`] passed in already locked the mutex. -+ /// -+ /// This is an associated function that needs to be used as `OwnedMutexGuard::try_map(...)`. A -+ /// method would interfere with methods of the same name on the contents of the locked data. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::{Mutex, OwnedMutexGuard}; -+ /// use std::sync::Arc; -+ /// -+ /// #[derive(Debug, Clone, Copy, PartialEq, Eq)] -+ /// struct Foo(u32); -+ /// -+ /// # #[tokio::main] -+ /// # async fn main() { -+ /// let foo = Arc::new(Mutex::new(Foo(1))); -+ /// -+ /// { -+ /// let mut mapped = OwnedMutexGuard::try_map(foo.clone().lock_owned().await, |f| Some(&mut f.0)) -+ /// .expect("should not fail"); -+ /// *mapped = 2; -+ /// } -+ /// -+ /// assert_eq!(Foo(2), *foo.lock().await); -+ /// # } -+ /// ``` -+ /// -+ /// [`OwnedMutexGuard`]: struct@OwnedMutexGuard -+ /// [`OwnedMappedMutexGuard`]: struct@OwnedMappedMutexGuard -+ #[inline] -+ pub fn try_map(mut this: Self, f: F) -> Result, Self> -+ where -+ F: FnOnce(&mut T) -> Option<&mut U>, -+ { -+ let data = match f(&mut *this) { -+ Some(data) => data as *mut U, -+ None => return Err(this), -+ }; -+ let inner = this.skip_drop(); -+ Ok(OwnedMappedMutexGuard { -+ data, -+ lock: inner.lock, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: inner.resource_span, -+ }) -+ } -+ - /// Returns a reference to the original `Arc`. - /// - /// ``` -@@ -699,7 +1118,15 @@ impl OwnedMutexGuard { - - impl Drop for OwnedMutexGuard { - fn drop(&mut self) { -- self.lock.s.release(1) -+ self.lock.s.release(1); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = false, -+ ); -+ }); - } - } - -@@ -731,6 +1158,16 @@ impl fmt::Display for OwnedMutexGuard { - // === impl MappedMutexGuard === - - impl<'a, T: ?Sized> MappedMutexGuard<'a, T> { -+ fn skip_drop(self) -> MappedMutexGuardInner<'a, T> { -+ let me = mem::ManuallyDrop::new(self); -+ MappedMutexGuardInner { -+ s: me.s, -+ data: me.data, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: unsafe { std::ptr::read(&me.resource_span) }, -+ } -+ } -+ - /// Makes a new [`MappedMutexGuard`] for a component of the locked data. - /// - /// This operation cannot fail as the [`MappedMutexGuard`] passed in already locked the mutex. -@@ -745,12 +1182,13 @@ impl<'a, T: ?Sized> MappedMutexGuard<'a, T> { - F: FnOnce(&mut T) -> &mut U, - { - let data = f(&mut *this) as *mut U; -- let s = this.s; -- mem::forget(this); -+ let inner = this.skip_drop(); - MappedMutexGuard { -- s, -+ s: inner.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: inner.resource_span, - } - } - -@@ -772,19 +1210,28 @@ impl<'a, T: ?Sized> MappedMutexGuard<'a, T> { - Some(data) => data as *mut U, - None => return Err(this), - }; -- let s = this.s; -- mem::forget(this); -+ let inner = this.skip_drop(); - Ok(MappedMutexGuard { -- s, -+ s: inner.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: inner.resource_span, - }) - } - } - - impl<'a, T: ?Sized> Drop for MappedMutexGuard<'a, T> { - fn drop(&mut self) { -- self.s.release(1) -+ self.s.release(1); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = false, -+ ); -+ }); - } - } - -@@ -812,3 +1259,111 @@ impl<'a, T: ?Sized + fmt::Display> fmt::Display for MappedMutexGuard<'a, T> { - fmt::Display::fmt(&**self, f) - } - } -+ -+// === impl OwnedMappedMutexGuard === -+ -+impl OwnedMappedMutexGuard { -+ fn skip_drop(self) -> OwnedMappedMutexGuardInner { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the values in every field of the guard, then -+ // forgets the originals, so in the end no value is duplicated. -+ unsafe { -+ OwnedMappedMutexGuardInner { -+ data: me.data, -+ lock: ptr::read(&me.lock), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: ptr::read(&me.resource_span), -+ } -+ } -+ } -+ -+ /// Makes a new [`OwnedMappedMutexGuard`] for a component of the locked data. -+ /// -+ /// This operation cannot fail as the [`OwnedMappedMutexGuard`] passed in already locked the mutex. -+ /// -+ /// This is an associated function that needs to be used as `OwnedMappedMutexGuard::map(...)`. A method -+ /// would interfere with methods of the same name on the contents of the locked data. -+ /// -+ /// [`OwnedMappedMutexGuard`]: struct@OwnedMappedMutexGuard -+ #[inline] -+ pub fn map(mut this: Self, f: F) -> OwnedMappedMutexGuard -+ where -+ F: FnOnce(&mut U) -> &mut S, -+ { -+ let data = f(&mut *this) as *mut S; -+ let inner = this.skip_drop(); -+ OwnedMappedMutexGuard { -+ data, -+ lock: inner.lock, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: inner.resource_span, -+ } -+ } -+ -+ /// Attempts to make a new [`OwnedMappedMutexGuard`] for a component of the locked data. The -+ /// original guard is returned if the closure returns `None`. -+ /// -+ /// This operation cannot fail as the [`OwnedMutexGuard`] passed in already locked the mutex. -+ /// -+ /// This is an associated function that needs to be used as `OwnedMutexGuard::try_map(...)`. A -+ /// method would interfere with methods of the same name on the contents of the locked data. -+ /// -+ /// [`OwnedMutexGuard`]: struct@OwnedMutexGuard -+ /// [`OwnedMappedMutexGuard`]: struct@OwnedMappedMutexGuard -+ #[inline] -+ pub fn try_map(mut this: Self, f: F) -> Result, Self> -+ where -+ F: FnOnce(&mut U) -> Option<&mut S>, -+ { -+ let data = match f(&mut *this) { -+ Some(data) => data as *mut S, -+ None => return Err(this), -+ }; -+ let inner = this.skip_drop(); -+ Ok(OwnedMappedMutexGuard { -+ data, -+ lock: inner.lock, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: inner.resource_span, -+ }) -+ } -+} -+ -+impl Drop for OwnedMappedMutexGuard { -+ fn drop(&mut self) { -+ self.lock.s.release(1); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ locked = false, -+ ); -+ }); -+ } -+} -+ -+impl Deref for OwnedMappedMutexGuard { -+ type Target = U; -+ fn deref(&self) -> &Self::Target { -+ unsafe { &*self.data } -+ } -+} -+ -+impl DerefMut for OwnedMappedMutexGuard { -+ fn deref_mut(&mut self) -> &mut Self::Target { -+ unsafe { &mut *self.data } -+ } -+} -+ -+impl fmt::Debug for OwnedMappedMutexGuard { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt::Debug::fmt(&**self, f) -+ } -+} -+ -+impl fmt::Display for OwnedMappedMutexGuard { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ fmt::Display::fmt(&**self, f) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/notify.rs b/KubeOS-Rust/vendor/tokio/src/sync/notify.rs -index c93ce3bd..058b067e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/notify.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/notify.rs -@@ -5,20 +5,22 @@ - // triggers this warning but it is safe to ignore in this case. - #![cfg_attr(not(feature = "sync"), allow(unreachable_pub, dead_code))] - -+use crate::loom::cell::UnsafeCell; - use crate::loom::sync::atomic::AtomicUsize; - use crate::loom::sync::Mutex; --use crate::util::linked_list::{self, LinkedList}; -+use crate::util::linked_list::{self, GuardedLinkedList, LinkedList}; - use crate::util::WakeList; - --use std::cell::UnsafeCell; - use std::future::Future; - use std::marker::PhantomPinned; -+use std::panic::{RefUnwindSafe, UnwindSafe}; - use std::pin::Pin; - use std::ptr::NonNull; --use std::sync::atomic::Ordering::SeqCst; -+use std::sync::atomic::Ordering::{self, Acquire, Relaxed, Release, SeqCst}; - use std::task::{Context, Poll, Waker}; - - type WaitList = LinkedList::Target>; -+type GuardedWaitList = GuardedLinkedList::Target>; - - /// Notifies a single task to wake up. - /// -@@ -26,22 +28,23 @@ type WaitList = LinkedList::Target>; - /// `Notify` itself does not carry any data. Instead, it is to be used to signal - /// another task to perform an operation. - /// --/// `Notify` can be thought of as a [`Semaphore`] starting with 0 permits. --/// [`notified().await`] waits for a permit to become available, and [`notify_one()`] --/// sets a permit **if there currently are no available permits**. -+/// A `Notify` can be thought of as a [`Semaphore`] starting with 0 permits. The -+/// [`notified().await`] method waits for a permit to become available, and -+/// [`notify_one()`] sets a permit **if there currently are no available -+/// permits**. - /// - /// The synchronization details of `Notify` are similar to - /// [`thread::park`][park] and [`Thread::unpark`][unpark] from std. A [`Notify`] - /// value contains a single permit. [`notified().await`] waits for the permit to --/// be made available, consumes the permit, and resumes. [`notify_one()`] sets the --/// permit, waking a pending task if there is one. -+/// be made available, consumes the permit, and resumes. [`notify_one()`] sets -+/// the permit, waking a pending task if there is one. - /// --/// If `notify_one()` is called **before** `notified().await`, then the next call to --/// `notified().await` will complete immediately, consuming the permit. Any --/// subsequent calls to `notified().await` will wait for a new permit. -+/// If `notify_one()` is called **before** `notified().await`, then the next -+/// call to `notified().await` will complete immediately, consuming the permit. -+/// Any subsequent calls to `notified().await` will wait for a new permit. - /// --/// If `notify_one()` is called **multiple** times before `notified().await`, only a --/// **single** permit is stored. The next call to `notified().await` will -+/// If `notify_one()` is called **multiple** times before `notified().await`, -+/// only a **single** permit is stored. The next call to `notified().await` will - /// complete immediately, but the one after will wait for a new permit. - /// - /// # Examples -@@ -70,7 +73,11 @@ type WaitList = LinkedList::Target>; - /// } - /// ``` - /// --/// Unbound mpsc channel. -+/// Unbound multi-producer single-consumer (mpsc) channel. -+/// -+/// No wakeups can be lost when using this channel because the call to -+/// `notify_one()` will store a permit in the `Notify`, which the following call -+/// to `notified()` will consume. - /// - /// ``` - /// use tokio::sync::Notify; -@@ -92,6 +99,8 @@ type WaitList = LinkedList::Target>; - /// self.notify.notify_one(); - /// } - /// -+/// // This is a single-consumer channel, so several concurrent calls to -+/// // `recv` are not allowed. - /// pub async fn recv(&self) -> T { - /// loop { - /// // Drain values -@@ -106,45 +115,250 @@ type WaitList = LinkedList::Target>; - /// } - /// ``` - /// -+/// Unbound multi-producer multi-consumer (mpmc) channel. -+/// -+/// The call to [`enable`] is important because otherwise if you have two -+/// calls to `recv` and two calls to `send` in parallel, the following could -+/// happen: -+/// -+/// 1. Both calls to `try_recv` return `None`. -+/// 2. Both new elements are added to the vector. -+/// 3. The `notify_one` method is called twice, adding only a single -+/// permit to the `Notify`. -+/// 4. Both calls to `recv` reach the `Notified` future. One of them -+/// consumes the permit, and the other sleeps forever. -+/// -+/// By adding the `Notified` futures to the list by calling `enable` before -+/// `try_recv`, the `notify_one` calls in step three would remove the -+/// futures from the list and mark them notified instead of adding a permit -+/// to the `Notify`. This ensures that both futures are woken. -+/// -+/// Notice that this failure can only happen if there are two concurrent calls -+/// to `recv`. This is why the mpsc example above does not require a call to -+/// `enable`. -+/// -+/// ``` -+/// use tokio::sync::Notify; -+/// -+/// use std::collections::VecDeque; -+/// use std::sync::Mutex; -+/// -+/// struct Channel { -+/// messages: Mutex>, -+/// notify_on_sent: Notify, -+/// } -+/// -+/// impl Channel { -+/// pub fn send(&self, msg: T) { -+/// let mut locked_queue = self.messages.lock().unwrap(); -+/// locked_queue.push_back(msg); -+/// drop(locked_queue); -+/// -+/// // Send a notification to one of the calls currently -+/// // waiting in a call to `recv`. -+/// self.notify_on_sent.notify_one(); -+/// } -+/// -+/// pub fn try_recv(&self) -> Option { -+/// let mut locked_queue = self.messages.lock().unwrap(); -+/// locked_queue.pop_front() -+/// } -+/// -+/// pub async fn recv(&self) -> T { -+/// let future = self.notify_on_sent.notified(); -+/// tokio::pin!(future); -+/// -+/// loop { -+/// // Make sure that no wakeup is lost if we get -+/// // `None` from `try_recv`. -+/// future.as_mut().enable(); -+/// -+/// if let Some(msg) = self.try_recv() { -+/// return msg; -+/// } -+/// -+/// // Wait for a call to `notify_one`. -+/// // -+/// // This uses `.as_mut()` to avoid consuming the future, -+/// // which lets us call `Pin::set` below. -+/// future.as_mut().await; -+/// -+/// // Reset the future in case another call to -+/// // `try_recv` got the message before us. -+/// future.set(self.notify_on_sent.notified()); -+/// } -+/// } -+/// } -+/// ``` -+/// - /// [park]: std::thread::park - /// [unpark]: std::thread::Thread::unpark - /// [`notified().await`]: Notify::notified() - /// [`notify_one()`]: Notify::notify_one() -+/// [`enable`]: Notified::enable() - /// [`Semaphore`]: crate::sync::Semaphore - #[derive(Debug)] - pub struct Notify { -- // This uses 2 bits to store one of `EMPTY`, -+ // `state` uses 2 bits to store one of `EMPTY`, - // `WAITING` or `NOTIFIED`. The rest of the bits - // are used to store the number of times `notify_waiters` - // was called. -+ // -+ // Throughout the code there are two assumptions: -+ // - state can be transitioned *from* `WAITING` only if -+ // `waiters` lock is held -+ // - number of times `notify_waiters` was called can -+ // be modified only if `waiters` lock is held - state: AtomicUsize, - waiters: Mutex, - } - --#[derive(Debug, Clone, Copy)] --enum NotificationType { -- // Notification triggered by calling `notify_waiters` -- AllWaiters, -- // Notification triggered by calling `notify_one` -- OneWaiter, --} -- - #[derive(Debug)] - struct Waiter { - /// Intrusive linked-list pointers. - pointers: linked_list::Pointers, - -- /// Waiting task's waker. -- waker: Option, -+ /// Waiting task's waker. Depending on the value of `notification`, -+ /// this field is either protected by the `waiters` lock in -+ /// `Notify`, or it is exclusively owned by the enclosing `Waiter`. -+ waker: UnsafeCell>, - -- /// `true` if the notification has been assigned to this waiter. -- notified: Option, -+ /// Notification for this waiter. -+ /// * if it's `None`, then `waker` is protected by the `waiters` lock. -+ /// * if it's `Some`, then `waker` is exclusively owned by the -+ /// enclosing `Waiter` and can be accessed without locking. -+ notification: AtomicNotification, - - /// Should not be `Unpin`. - _p: PhantomPinned, - } - --/// Future returned from [`Notify::notified()`] -+impl Waiter { -+ fn new() -> Waiter { -+ Waiter { -+ pointers: linked_list::Pointers::new(), -+ waker: UnsafeCell::new(None), -+ notification: AtomicNotification::none(), -+ _p: PhantomPinned, -+ } -+ } -+} -+ -+generate_addr_of_methods! { -+ impl<> Waiter { -+ unsafe fn addr_of_pointers(self: NonNull) -> NonNull> { -+ &self.pointers -+ } -+ } -+} -+ -+// No notification. -+const NOTIFICATION_NONE: usize = 0; -+ -+// Notification type used by `notify_one`. -+const NOTIFICATION_ONE: usize = 1; -+ -+// Notification type used by `notify_waiters`. -+const NOTIFICATION_ALL: usize = 2; -+ -+/// Notification for a `Waiter`. -+/// This struct is equivalent to `Option`, but uses -+/// `AtomicUsize` inside for atomic operations. -+#[derive(Debug)] -+struct AtomicNotification(AtomicUsize); -+ -+impl AtomicNotification { -+ fn none() -> Self { -+ AtomicNotification(AtomicUsize::new(NOTIFICATION_NONE)) -+ } -+ -+ /// Store-release a notification. -+ /// This method should be called exactly once. -+ fn store_release(&self, notification: Notification) { -+ self.0.store(notification as usize, Release); -+ } -+ -+ fn load(&self, ordering: Ordering) -> Option { -+ match self.0.load(ordering) { -+ NOTIFICATION_NONE => None, -+ NOTIFICATION_ONE => Some(Notification::One), -+ NOTIFICATION_ALL => Some(Notification::All), -+ _ => unreachable!(), -+ } -+ } -+ -+ /// Clears the notification. -+ /// This method is used by a `Notified` future to consume the -+ /// notification. It uses relaxed ordering and should be only -+ /// used once the atomic notification is no longer shared. -+ fn clear(&self) { -+ self.0.store(NOTIFICATION_NONE, Relaxed); -+ } -+} -+ -+#[derive(Debug, PartialEq, Eq)] -+#[repr(usize)] -+enum Notification { -+ One = NOTIFICATION_ONE, -+ All = NOTIFICATION_ALL, -+} -+ -+/// List used in `Notify::notify_waiters`. It wraps a guarded linked list -+/// and gates the access to it on `notify.waiters` mutex. It also empties -+/// the list on drop. -+struct NotifyWaitersList<'a> { -+ list: GuardedWaitList, -+ is_empty: bool, -+ notify: &'a Notify, -+} -+ -+impl<'a> NotifyWaitersList<'a> { -+ fn new( -+ unguarded_list: WaitList, -+ guard: Pin<&'a Waiter>, -+ notify: &'a Notify, -+ ) -> NotifyWaitersList<'a> { -+ let guard_ptr = NonNull::from(guard.get_ref()); -+ let list = unguarded_list.into_guarded(guard_ptr); -+ NotifyWaitersList { -+ list, -+ is_empty: false, -+ notify, -+ } -+ } -+ -+ /// Removes the last element from the guarded list. Modifying this list -+ /// requires an exclusive access to the main list in `Notify`. -+ fn pop_back_locked(&mut self, _waiters: &mut WaitList) -> Option> { -+ let result = self.list.pop_back(); -+ if result.is_none() { -+ // Save information about emptiness to avoid waiting for lock -+ // in the destructor. -+ self.is_empty = true; -+ } -+ result -+ } -+} -+ -+impl Drop for NotifyWaitersList<'_> { -+ fn drop(&mut self) { -+ // If the list is not empty, we unlink all waiters from it. -+ // We do not wake the waiters to avoid double panics. -+ if !self.is_empty { -+ let _lock_guard = self.notify.waiters.lock(); -+ while let Some(waiter) = self.list.pop_back() { -+ // Safety: we never make mutable references to waiters. -+ let waiter = unsafe { waiter.as_ref() }; -+ waiter.notification.store_release(Notification::All); -+ } -+ } -+ } -+} -+ -+/// Future returned from [`Notify::notified()`]. -+/// -+/// This future is fused, so once it has completed, any future calls to poll -+/// will immediately return `Poll::Ready`. - #[derive(Debug)] - pub struct Notified<'a> { - /// The `Notify` being received on. -@@ -153,8 +367,11 @@ pub struct Notified<'a> { - /// The current state of the receiving process. - state: State, - -+ /// Number of calls to `notify_waiters` at the time of creation. -+ notify_waiters_calls: usize, -+ - /// Entry in the waiter `LinkedList`. -- waiter: UnsafeCell, -+ waiter: Waiter, - } - - unsafe impl<'a> Send for Notified<'a> {} -@@ -162,7 +379,7 @@ unsafe impl<'a> Sync for Notified<'a> {} - - #[derive(Debug)] - enum State { -- Init(usize), -+ Init, - Waiting, - Done, - } -@@ -248,7 +465,16 @@ impl Notify { - /// immediately, consuming that permit. Otherwise, `notified().await` waits - /// for a permit to be made available by the next call to `notify_one()`. - /// -+ /// The `Notified` future is not guaranteed to receive wakeups from calls to -+ /// `notify_one()` if it has not yet been polled. See the documentation for -+ /// [`Notified::enable()`] for more details. -+ /// -+ /// The `Notified` future is guaranteed to receive wakeups from -+ /// `notify_waiters()` as soon as it has been created, even if it has not -+ /// yet been polled. -+ /// - /// [`notify_one()`]: Notify::notify_one -+ /// [`Notified::enable()`]: Notified::enable - /// - /// # Cancel safety - /// -@@ -278,17 +504,13 @@ impl Notify { - /// ``` - pub fn notified(&self) -> Notified<'_> { - // we load the number of times notify_waiters -- // was called and store that in our initial state -+ // was called and store that in the future. - let state = self.state.load(SeqCst); - Notified { - notify: self, -- state: State::Init(state >> NOTIFY_WAITERS_SHIFT), -- waiter: UnsafeCell::new(Waiter { -- pointers: linked_list::Pointers::new(), -- waker: None, -- notified: None, -- _p: PhantomPinned, -- }), -+ state: State::Init, -+ notify_waiters_calls: get_num_notify_waiters_calls(state), -+ waiter: Waiter::new(), - } - } - -@@ -395,39 +617,56 @@ impl Notify { - /// } - /// ``` - pub fn notify_waiters(&self) { -- let mut wakers = WakeList::new(); -- -- // There are waiters, the lock must be acquired to notify. - let mut waiters = self.waiters.lock(); - -- // The state must be reloaded while the lock is held. The state may only -+ // The state must be loaded while the lock is held. The state may only - // transition out of WAITING while the lock is held. - let curr = self.state.load(SeqCst); - -- if let EMPTY | NOTIFIED = get_state(curr) { -+ if matches!(get_state(curr), EMPTY | NOTIFIED) { - // There are no waiting tasks. All we need to do is increment the - // number of times this method was called. - atomic_inc_num_notify_waiters_calls(&self.state); - return; - } - -- // At this point, it is guaranteed that the state will not -- // concurrently change, as holding the lock is required to -- // transition **out** of `WAITING`. -+ // Increment the number of times this method was called -+ // and transition to empty. -+ let new_state = set_state(inc_num_notify_waiters_calls(curr), EMPTY); -+ self.state.store(new_state, SeqCst); -+ -+ // It is critical for `GuardedLinkedList` safety that the guard node is -+ // pinned in memory and is not dropped until the guarded list is dropped. -+ let guard = Waiter::new(); -+ pin!(guard); -+ -+ // We move all waiters to a secondary list. It uses a `GuardedLinkedList` -+ // underneath to allow every waiter to safely remove itself from it. -+ // -+ // * This list will be still guarded by the `waiters` lock. -+ // `NotifyWaitersList` wrapper makes sure we hold the lock to modify it. -+ // * This wrapper will empty the list on drop. It is critical for safety -+ // that we will not leave any list entry with a pointer to the local -+ // guard node after this function returns / panics. -+ let mut list = NotifyWaitersList::new(std::mem::take(&mut *waiters), guard.as_ref(), self); -+ -+ let mut wakers = WakeList::new(); - 'outer: loop { - while wakers.can_push() { -- match waiters.pop_back() { -- Some(mut waiter) => { -- // Safety: `waiters` lock is still held. -- let waiter = unsafe { waiter.as_mut() }; -- -- assert!(waiter.notified.is_none()); -- -- waiter.notified = Some(NotificationType::AllWaiters); -- -- if let Some(waker) = waiter.waker.take() { -+ match list.pop_back_locked(&mut waiters) { -+ Some(waiter) => { -+ // Safety: we never make mutable references to waiters. -+ let waiter = unsafe { waiter.as_ref() }; -+ -+ // Safety: we hold the lock, so we can access the waker. -+ if let Some(waker) = -+ unsafe { waiter.waker.with_mut(|waker| (*waker).take()) } -+ { - wakers.push(waker); - } -+ -+ // This waiter is unlinked and will not be shared ever again, release it. -+ waiter.notification.store_release(Notification::All); - } - None => { - break 'outer; -@@ -435,20 +674,17 @@ impl Notify { - } - } - -+ // Release the lock before notifying. - drop(waiters); - -+ // One of the wakers may panic, but the remaining waiters will still -+ // be unlinked from the list in `NotifyWaitersList` destructor. - wakers.wake_all(); - - // Acquire the lock again. - waiters = self.waiters.lock(); - } - -- // All waiters will be notified, the state must be transitioned to -- // `EMPTY`. As transitioning **from** `WAITING` requires the lock to be -- // held, a `store` is sufficient. -- let new = set_state(inc_num_notify_waiters_calls(curr), EMPTY); -- self.state.store(new, SeqCst); -- - // Release the lock before notifying - drop(waiters); - -@@ -462,6 +698,9 @@ impl Default for Notify { - } - } - -+impl UnwindSafe for Notify {} -+impl RefUnwindSafe for Notify {} -+ - fn notify_locked(waiters: &mut WaitList, state: &AtomicUsize, curr: usize) -> Option { - loop { - match get_state(curr) { -@@ -484,15 +723,16 @@ fn notify_locked(waiters: &mut WaitList, state: &AtomicUsize, curr: usize) -> Op - // transition **out** of `WAITING`. - // - // Get a pending waiter -- let mut waiter = waiters.pop_back().unwrap(); -+ let waiter = waiters.pop_back().unwrap(); - -- // Safety: `waiters` lock is still held. -- let waiter = unsafe { waiter.as_mut() }; -+ // Safety: we never make mutable references to waiters. -+ let waiter = unsafe { waiter.as_ref() }; - -- assert!(waiter.notified.is_none()); -+ // Safety: we hold the lock, so we can access the waker. -+ let waker = unsafe { waiter.waker.with_mut(|waker| (*waker).take()) }; - -- waiter.notified = Some(NotificationType::OneWaiter); -- let waker = waiter.waker.take(); -+ // This waiter is unlinked and will not be shared ever again, release it. -+ waiter.notification.store_release(Notification::One); - - if waiters.is_empty() { - // As this the **final** waiter in the list, the state -@@ -512,32 +752,142 @@ fn notify_locked(waiters: &mut WaitList, state: &AtomicUsize, curr: usize) -> Op - // ===== impl Notified ===== - - impl Notified<'_> { -+ /// Adds this future to the list of futures that are ready to receive -+ /// wakeups from calls to [`notify_one`]. -+ /// -+ /// Polling the future also adds it to the list, so this method should only -+ /// be used if you want to add the future to the list before the first call -+ /// to `poll`. (In fact, this method is equivalent to calling `poll` except -+ /// that no `Waker` is registered.) -+ /// -+ /// This has no effect on notifications sent using [`notify_waiters`], which -+ /// are received as long as they happen after the creation of the `Notified` -+ /// regardless of whether `enable` or `poll` has been called. -+ /// -+ /// This method returns true if the `Notified` is ready. This happens in the -+ /// following situations: -+ /// -+ /// 1. The `notify_waiters` method was called between the creation of the -+ /// `Notified` and the call to this method. -+ /// 2. This is the first call to `enable` or `poll` on this future, and the -+ /// `Notify` was holding a permit from a previous call to `notify_one`. -+ /// The call consumes the permit in that case. -+ /// 3. The future has previously been enabled or polled, and it has since -+ /// then been marked ready by either consuming a permit from the -+ /// `Notify`, or by a call to `notify_one` or `notify_waiters` that -+ /// removed it from the list of futures ready to receive wakeups. -+ /// -+ /// If this method returns true, any future calls to poll on the same future -+ /// will immediately return `Poll::Ready`. -+ /// -+ /// # Examples -+ /// -+ /// Unbound multi-producer multi-consumer (mpmc) channel. -+ /// -+ /// The call to `enable` is important because otherwise if you have two -+ /// calls to `recv` and two calls to `send` in parallel, the following could -+ /// happen: -+ /// -+ /// 1. Both calls to `try_recv` return `None`. -+ /// 2. Both new elements are added to the vector. -+ /// 3. The `notify_one` method is called twice, adding only a single -+ /// permit to the `Notify`. -+ /// 4. Both calls to `recv` reach the `Notified` future. One of them -+ /// consumes the permit, and the other sleeps forever. -+ /// -+ /// By adding the `Notified` futures to the list by calling `enable` before -+ /// `try_recv`, the `notify_one` calls in step three would remove the -+ /// futures from the list and mark them notified instead of adding a permit -+ /// to the `Notify`. This ensures that both futures are woken. -+ /// -+ /// ``` -+ /// use tokio::sync::Notify; -+ /// -+ /// use std::collections::VecDeque; -+ /// use std::sync::Mutex; -+ /// -+ /// struct Channel { -+ /// messages: Mutex>, -+ /// notify_on_sent: Notify, -+ /// } -+ /// -+ /// impl Channel { -+ /// pub fn send(&self, msg: T) { -+ /// let mut locked_queue = self.messages.lock().unwrap(); -+ /// locked_queue.push_back(msg); -+ /// drop(locked_queue); -+ /// -+ /// // Send a notification to one of the calls currently -+ /// // waiting in a call to `recv`. -+ /// self.notify_on_sent.notify_one(); -+ /// } -+ /// -+ /// pub fn try_recv(&self) -> Option { -+ /// let mut locked_queue = self.messages.lock().unwrap(); -+ /// locked_queue.pop_front() -+ /// } -+ /// -+ /// pub async fn recv(&self) -> T { -+ /// let future = self.notify_on_sent.notified(); -+ /// tokio::pin!(future); -+ /// -+ /// loop { -+ /// // Make sure that no wakeup is lost if we get -+ /// // `None` from `try_recv`. -+ /// future.as_mut().enable(); -+ /// -+ /// if let Some(msg) = self.try_recv() { -+ /// return msg; -+ /// } -+ /// -+ /// // Wait for a call to `notify_one`. -+ /// // -+ /// // This uses `.as_mut()` to avoid consuming the future, -+ /// // which lets us call `Pin::set` below. -+ /// future.as_mut().await; -+ /// -+ /// // Reset the future in case another call to -+ /// // `try_recv` got the message before us. -+ /// future.set(self.notify_on_sent.notified()); -+ /// } -+ /// } -+ /// } -+ /// ``` -+ /// -+ /// [`notify_one`]: Notify::notify_one() -+ /// [`notify_waiters`]: Notify::notify_waiters() -+ pub fn enable(self: Pin<&mut Self>) -> bool { -+ self.poll_notified(None).is_ready() -+ } -+ - /// A custom `project` implementation is used in place of `pin-project-lite` - /// as a custom drop implementation is needed. -- fn project(self: Pin<&mut Self>) -> (&Notify, &mut State, &UnsafeCell) { -+ fn project(self: Pin<&mut Self>) -> (&Notify, &mut State, &usize, &Waiter) { - unsafe { -- // Safety: both `notify` and `state` are `Unpin`. -+ // Safety: `notify`, `state` and `notify_waiters_calls` are `Unpin`. - - is_unpin::<&Notify>(); -- is_unpin::(); -+ is_unpin::(); -+ is_unpin::(); - - let me = self.get_unchecked_mut(); -- (me.notify, &mut me.state, &me.waiter) -+ ( -+ me.notify, -+ &mut me.state, -+ &me.notify_waiters_calls, -+ &me.waiter, -+ ) - } - } --} -- --impl Future for Notified<'_> { -- type Output = (); - -- fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> { -+ fn poll_notified(self: Pin<&mut Self>, waker: Option<&Waker>) -> Poll<()> { - use State::*; - -- let (notify, state, waiter) = self.project(); -+ let (notify, state, notify_waiters_calls, waiter) = self.project(); - - loop { - match *state { -- Init(initial_notify_waiters_calls) => { -+ Init => { - let curr = notify.state.load(SeqCst); - - // Optimistically try acquiring a pending notification -@@ -556,7 +906,7 @@ impl Future for Notified<'_> { - - // Clone the waker before locking, a waker clone can be - // triggering arbitrary code. -- let waker = cx.waker().clone(); -+ let waker = waker.cloned(); - - // Acquire the lock and attempt to transition to the waiting - // state. -@@ -567,7 +917,7 @@ impl Future for Notified<'_> { - - // if notify_waiters has been called after the future - // was created, then we are done -- if get_num_notify_waiters_calls(curr) != initial_notify_waiters_calls { -+ if get_num_notify_waiters_calls(curr) != *notify_waiters_calls { - *state = Done; - return Poll::Ready(()); - } -@@ -617,44 +967,103 @@ impl Future for Notified<'_> { - } - } - -- // Safety: called while locked. -- unsafe { -- (*waiter.get()).waker = Some(waker); -+ let mut old_waker = None; -+ if waker.is_some() { -+ // Safety: called while locked. -+ // -+ // The use of `old_waiter` here is not necessary, as the field is always -+ // None when we reach this line. -+ unsafe { -+ old_waker = -+ waiter.waker.with_mut(|v| std::mem::replace(&mut *v, waker)); -+ } - } - - // Insert the waiter into the linked list -- // -- // safety: pointers from `UnsafeCell` are never null. -- waiters.push_front(unsafe { NonNull::new_unchecked(waiter.get()) }); -+ waiters.push_front(NonNull::from(waiter)); - - *state = Waiting; - -+ drop(waiters); -+ drop(old_waker); -+ - return Poll::Pending; - } - Waiting => { -- // Currently in the "Waiting" state, implying the caller has -- // a waiter stored in the waiter list (guarded by -- // `notify.waiters`). In order to access the waker fields, -- // we must hold the lock. -+ if waiter.notification.load(Acquire).is_some() { -+ // Safety: waiter is already unlinked and will not be shared again, -+ // so we have an exclusive access to `waker`. -+ drop(unsafe { waiter.waker.with_mut(|waker| (*waker).take()) }); -+ -+ waiter.notification.clear(); -+ *state = Done; -+ return Poll::Ready(()); -+ } -+ -+ // Our waiter was not notified, implying it is still stored in a waiter -+ // list (guarded by `notify.waiters`). In order to access the waker -+ // fields, we must acquire the lock. -+ -+ let mut old_waker = None; -+ let mut waiters = notify.waiters.lock(); -+ -+ // We hold the lock and notifications are set only with the lock held, -+ // so this can be relaxed, because the happens-before relationship is -+ // established through the mutex. -+ if waiter.notification.load(Relaxed).is_some() { -+ // Safety: waiter is already unlinked and will not be shared again, -+ // so we have an exclusive access to `waker`. -+ old_waker = unsafe { waiter.waker.with_mut(|waker| (*waker).take()) }; -+ -+ waiter.notification.clear(); -+ -+ // Drop the old waker after releasing the lock. -+ drop(waiters); -+ drop(old_waker); - -- let waiters = notify.waiters.lock(); -+ *state = Done; -+ return Poll::Ready(()); -+ } -+ -+ // Load the state with the lock held. -+ let curr = notify.state.load(SeqCst); - -- // Safety: called while locked -- let w = unsafe { &mut *waiter.get() }; -+ if get_num_notify_waiters_calls(curr) != *notify_waiters_calls { -+ // Before we add a waiter to the list we check if these numbers are -+ // different while holding the lock. If these numbers are different now, -+ // it means that there is a call to `notify_waiters` in progress and this -+ // waiter must be contained by a guarded list used in `notify_waiters`. -+ // We can treat the waiter as notified and remove it from the list, as -+ // it would have been notified in the `notify_waiters` call anyways. - -- if w.notified.is_some() { -- // Our waker has been notified. Reset the fields and -- // remove it from the list. -- w.waker = None; -- w.notified = None; -+ // Safety: we hold the lock, so we can modify the waker. -+ old_waker = unsafe { waiter.waker.with_mut(|waker| (*waker).take()) }; -+ -+ // Safety: we hold the lock, so we have an exclusive access to the list. -+ // The list is used in `notify_waiters`, so it must be guarded. -+ unsafe { waiters.remove(NonNull::from(waiter)) }; - - *state = Done; - } else { -- // Update the waker, if necessary. -- if !w.waker.as_ref().unwrap().will_wake(cx.waker()) { -- w.waker = Some(cx.waker().clone()); -+ // Safety: we hold the lock, so we can modify the waker. -+ unsafe { -+ waiter.waker.with_mut(|v| { -+ if let Some(waker) = waker { -+ let should_update = match &*v { -+ Some(current_waker) => !current_waker.will_wake(waker), -+ None => true, -+ }; -+ if should_update { -+ old_waker = std::mem::replace(&mut *v, Some(waker.clone())); -+ } -+ } -+ }); - } - -+ // Drop the old waker after releasing the lock. -+ drop(waiters); -+ drop(old_waker); -+ - return Poll::Pending; - } - -@@ -664,6 +1073,9 @@ impl Future for Notified<'_> { - // is helpful to visualize the scope of the critical - // section. - drop(waiters); -+ -+ // Drop the old waker after releasing the lock. -+ drop(old_waker); - } - Done => { - return Poll::Ready(()); -@@ -673,40 +1085,48 @@ impl Future for Notified<'_> { - } - } - -+impl Future for Notified<'_> { -+ type Output = (); -+ -+ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> { -+ self.poll_notified(Some(cx.waker())) -+ } -+} -+ - impl Drop for Notified<'_> { - fn drop(&mut self) { - use State::*; - - // Safety: The type only transitions to a "Waiting" state when pinned. -- let (notify, state, waiter) = unsafe { Pin::new_unchecked(self).project() }; -+ let (notify, state, _, waiter) = unsafe { Pin::new_unchecked(self).project() }; - - // This is where we ensure safety. The `Notified` value is being - // dropped, which means we must ensure that the waiter entry is no - // longer stored in the linked list. -- if let Waiting = *state { -+ if matches!(*state, Waiting) { - let mut waiters = notify.waiters.lock(); - let mut notify_state = notify.state.load(SeqCst); - -+ // We hold the lock, so this field is not concurrently accessed by -+ // `notify_*` functions and we can use the relaxed ordering. -+ let notification = waiter.notification.load(Relaxed); -+ - // remove the entry from the list (if not already removed) - // -- // safety: the waiter is only added to `waiters` by virtue of it -- // being the only `LinkedList` available to the type. -- unsafe { waiters.remove(NonNull::new_unchecked(waiter.get())) }; -- -- if waiters.is_empty() { -- if let WAITING = get_state(notify_state) { -- notify_state = set_state(notify_state, EMPTY); -- notify.state.store(notify_state, SeqCst); -- } -+ // Safety: we hold the lock, so we have an exclusive access to every list the -+ // waiter may be contained in. If the node is not contained in the `waiters` -+ // list, then it is contained by a guarded list used by `notify_waiters`. -+ unsafe { waiters.remove(NonNull::from(waiter)) }; -+ -+ if waiters.is_empty() && get_state(notify_state) == WAITING { -+ notify_state = set_state(notify_state, EMPTY); -+ notify.state.store(notify_state, SeqCst); - } - - // See if the node was notified but not received. In this case, if - // the notification was triggered via `notify_one`, it must be sent - // to the next waiter. -- // -- // Safety: with the entry removed from the linked list, there can be -- // no concurrent access to the entry -- if let Some(NotificationType::OneWaiter) = unsafe { (*waiter.get()).notified } { -+ if notification == Some(Notification::One) { - if let Some(waker) = notify_locked(&mut waiters, ¬ify.state, notify_state) { - drop(waiters); - waker.wake(); -@@ -731,8 +1151,8 @@ unsafe impl linked_list::Link for Waiter { - ptr - } - -- unsafe fn pointers(mut target: NonNull) -> NonNull> { -- NonNull::from(&mut target.as_mut().pointers) -+ unsafe fn pointers(target: NonNull) -> NonNull> { -+ Waiter::addr_of_pointers(target) - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/once_cell.rs b/KubeOS-Rust/vendor/tokio/src/sync/once_cell.rs -index d31a40e2..081efae3 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/once_cell.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/once_cell.rs -@@ -106,7 +106,7 @@ impl Drop for OnceCell { - if self.initialized_mut() { - unsafe { - self.value -- .with_mut(|ptr| ptr::drop_in_place((&mut *ptr).as_mut_ptr())); -+ .with_mut(|ptr| ptr::drop_in_place((*ptr).as_mut_ptr())); - }; - } - } -@@ -416,7 +416,7 @@ unsafe impl Send for OnceCell {} - /// Errors that can be returned from [`OnceCell::set`]. - /// - /// [`OnceCell::set`]: crate::sync::OnceCell::set --#[derive(Debug, PartialEq)] -+#[derive(Debug, PartialEq, Eq)] - pub enum SetError { - /// The cell was already initialized when [`OnceCell::set`] was called. - /// -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/oneshot.rs b/KubeOS-Rust/vendor/tokio/src/sync/oneshot.rs -index 4fb22ecf..da64899d 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/oneshot.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/oneshot.rs -@@ -9,6 +9,13 @@ - //! - //! Each handle can be used on separate tasks. - //! -+//! Since the `send` method is not async, it can be used anywhere. This includes -+//! sending between two runtimes, and using it from non-async code. -+//! -+//! If the [`Receiver`] is closed before receiving a message which has already -+//! been sent, the message will remain in the channel until the receiver is -+//! dropped, at which point the message will be dropped immediately. -+//! - //! # Examples - //! - //! ``` -@@ -119,6 +126,8 @@ - use crate::loom::cell::UnsafeCell; - use crate::loom::sync::atomic::AtomicUsize; - use crate::loom::sync::Arc; -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+use crate::util::trace; - - use std::fmt; - use std::future::Future; -@@ -212,6 +221,8 @@ use std::task::{Context, Poll, Waker}; - #[derive(Debug)] - pub struct Sender { - inner: Option>>, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - } - - /// Receives a value from the associated [`Sender`]. -@@ -220,7 +231,15 @@ pub struct Sender { - /// [`channel`](fn@channel) function. - /// - /// This channel has no `recv` method because the receiver itself implements the --/// [`Future`] trait. To receive a value, `.await` the `Receiver` object directly. -+/// [`Future`] trait. To receive a `Result`, `.await` the `Receiver` object directly. -+/// -+/// The `poll` method on the `Future` trait is allowed to spuriously return -+/// `Poll::Pending` even if the message has been sent. If such a spurious -+/// failure happens, then the caller will be woken when the spurious failure has -+/// been resolved so that the caller can attempt to receive the message again. -+/// Note that receiving such a wakeup does not guarantee that the next call will -+/// succeed — it could fail with another spurious failure. (A spurious failure -+/// does not mean that the message is lost. It is just delayed.) - /// - /// [`Future`]: trait@std::future::Future - /// -@@ -302,6 +321,12 @@ pub struct Sender { - #[derive(Debug)] - pub struct Receiver { - inner: Option>>, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ async_op_span: tracing::Span, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ async_op_poll_span: tracing::Span, - } - - pub mod error { -@@ -310,11 +335,13 @@ pub mod error { - use std::fmt; - - /// Error returned by the `Future` implementation for `Receiver`. -- #[derive(Debug, Eq, PartialEq)] -+ /// -+ /// This error is returned by the receiver when the sender is dropped without sending. -+ #[derive(Debug, Eq, PartialEq, Clone)] - pub struct RecvError(pub(super) ()); - - /// Error returned by the `try_recv` function on `Receiver`. -- #[derive(Debug, Eq, PartialEq)] -+ #[derive(Debug, Eq, PartialEq, Clone)] - pub enum TryRecvError { - /// The send half of the channel has not yet sent a value. - Empty, -@@ -386,21 +413,21 @@ impl Task { - F: FnOnce(&Waker) -> R, - { - self.0.with(|ptr| { -- let waker: *const Waker = (&*ptr).as_ptr(); -+ let waker: *const Waker = (*ptr).as_ptr(); - f(&*waker) - }) - } - - unsafe fn drop_task(&self) { - self.0.with_mut(|ptr| { -- let ptr: *mut Waker = (&mut *ptr).as_mut_ptr(); -+ let ptr: *mut Waker = (*ptr).as_mut_ptr(); - ptr.drop_in_place(); - }); - } - - unsafe fn set_task(&self, cx: &mut Context<'_>) { - self.0.with_mut(|ptr| { -- let ptr: *mut Waker = (&mut *ptr).as_mut_ptr(); -+ let ptr: *mut Waker = (*ptr).as_mut_ptr(); - ptr.write(cx.waker().clone()); - }); - } -@@ -439,7 +466,56 @@ struct State(usize); - /// } - /// } - /// ``` -+#[track_caller] - pub fn channel() -> (Sender, Receiver) { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = { -+ let location = std::panic::Location::caller(); -+ -+ let resource_span = tracing::trace_span!( -+ "runtime.resource", -+ concrete_type = "Sender|Receiver", -+ kind = "Sync", -+ loc.file = location.file(), -+ loc.line = location.line(), -+ loc.col = location.column(), -+ ); -+ -+ resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ tx_dropped = false, -+ tx_dropped.op = "override", -+ ) -+ }); -+ -+ resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ rx_dropped = false, -+ rx_dropped.op = "override", -+ ) -+ }); -+ -+ resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ value_sent = false, -+ value_sent.op = "override", -+ ) -+ }); -+ -+ resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ value_received = false, -+ value_received.op = "override", -+ ) -+ }); -+ -+ resource_span -+ }; -+ - let inner = Arc::new(Inner { - state: AtomicUsize::new(State::new().as_usize()), - value: UnsafeCell::new(None), -@@ -449,8 +525,27 @@ pub fn channel() -> (Sender, Receiver) { - - let tx = Sender { - inner: Some(inner.clone()), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: resource_span.clone(), -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let async_op_span = resource_span -+ .in_scope(|| tracing::trace_span!("runtime.resource.async_op", source = "Receiver::await")); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let async_op_poll_span = -+ async_op_span.in_scope(|| tracing::trace_span!("runtime.resource.async_op.poll")); -+ -+ let rx = Receiver { -+ inner: Some(inner), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ async_op_span, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ async_op_poll_span, - }; -- let rx = Receiver { inner: Some(inner) }; - - (tx, rx) - } -@@ -522,6 +617,15 @@ impl Sender { - } - } - -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ value_sent = true, -+ value_sent.op = "override", -+ ) -+ }); -+ - Ok(()) - } - -@@ -595,7 +699,20 @@ impl Sender { - pub async fn closed(&mut self) { - use crate::future::poll_fn; - -- poll_fn(|cx| self.poll_closed(cx)).await -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = self.resource_span.clone(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let closed = trace::async_op( -+ || poll_fn(|cx| self.poll_closed(cx)), -+ resource_span, -+ "Sender::closed", -+ "poll_closed", -+ false, -+ ); -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ let closed = poll_fn(|cx| self.poll_closed(cx)); -+ -+ closed.await - } - - /// Returns `true` if the associated [`Receiver`] handle has been dropped. -@@ -674,7 +791,7 @@ impl Sender { - /// ``` - pub fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll<()> { - // Keep track of task budget -- let coop = ready!(crate::coop::poll_proceed(cx)); -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); - - let inner = self.inner.as_ref().unwrap(); - -@@ -725,6 +842,14 @@ impl Drop for Sender { - fn drop(&mut self) { - if let Some(inner) = self.inner.as_ref() { - inner.complete(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ tx_dropped = true, -+ tx_dropped.op = "override", -+ ) -+ }); - } - } - } -@@ -792,6 +917,14 @@ impl Receiver { - pub fn close(&mut self) { - if let Some(inner) = self.inner.as_ref() { - inner.close(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ rx_dropped = true, -+ rx_dropped.op = "override", -+ ) -+ }); - } - } - -@@ -804,12 +937,16 @@ impl Receiver { - /// This function is useful to call from outside the context of an - /// asynchronous task. - /// -+ /// Note that unlike the `poll` method, the `try_recv` method cannot fail -+ /// spuriously. Any send or close event that happens before this call to -+ /// `try_recv` will be correctly returned to the caller. -+ /// - /// # Return - /// - /// - `Ok(T)` if a value is pending in the channel. - /// - `Err(TryRecvError::Empty)` if no value has been sent yet. - /// - `Err(TryRecvError::Closed)` if the sender has dropped without sending -- /// a value. -+ /// a value, or if the message has already been received. - /// - /// # Examples - /// -@@ -869,7 +1006,17 @@ impl Receiver { - // `UnsafeCell`. Therefore, it is now safe for us to access the - // cell. - match unsafe { inner.consume_value() } { -- Some(value) => Ok(value), -+ Some(value) => { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ value_received = true, -+ value_received.op = "override", -+ ) -+ }); -+ Ok(value) -+ } - None => Err(TryRecvError::Closed), - } - } else if state.is_closed() { -@@ -885,12 +1032,52 @@ impl Receiver { - self.inner = None; - result - } -+ -+ /// Blocking receive to call outside of asynchronous contexts. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if called within an asynchronous execution -+ /// context. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use std::thread; -+ /// use tokio::sync::oneshot; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, rx) = oneshot::channel::(); -+ /// -+ /// let sync_code = thread::spawn(move || { -+ /// assert_eq!(Ok(10), rx.blocking_recv()); -+ /// }); -+ /// -+ /// let _ = tx.send(10); -+ /// sync_code.join().unwrap(); -+ /// } -+ /// ``` -+ #[track_caller] -+ #[cfg(feature = "sync")] -+ #[cfg_attr(docsrs, doc(alias = "recv_blocking"))] -+ pub fn blocking_recv(self) -> Result { -+ crate::future::block_on(self) -+ } - } - - impl Drop for Receiver { - fn drop(&mut self) { - if let Some(inner) = self.inner.as_ref() { - inner.close(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ rx_dropped = true, -+ rx_dropped.op = "override", -+ ) -+ }); - } - } - } -@@ -900,8 +1087,21 @@ impl Future for Receiver { - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - // If `inner` is `None`, then `poll()` has already completed. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let _res_span = self.resource_span.clone().entered(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let _ao_span = self.async_op_span.clone().entered(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let _ao_poll_span = self.async_op_poll_span.clone().entered(); -+ - let ret = if let Some(inner) = self.as_ref().get_ref().inner.as_ref() { -- ready!(inner.poll_recv(cx))? -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let res = ready!(trace_poll_op!("poll_recv", inner.poll_recv(cx)))?; -+ -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ let res = ready!(inner.poll_recv(cx))?; -+ -+ res - } else { - panic!("called after complete"); - }; -@@ -931,7 +1131,7 @@ impl Inner { - - fn poll_recv(&self, cx: &mut Context<'_>) -> Poll> { - // Keep track of task budget -- let coop = ready!(crate::coop::poll_proceed(cx)); -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); - - // Load the state - let mut state = State::load(&self.state, Acquire); -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/rwlock.rs b/KubeOS-Rust/vendor/tokio/src/sync/rwlock.rs -index 120bc72b..dd492854 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/rwlock.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/rwlock.rs -@@ -1,9 +1,10 @@ - use crate::sync::batch_semaphore::{Semaphore, TryAcquireError}; - use crate::sync::mutex::TryLockError; -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+use crate::util::trace; - use std::cell::UnsafeCell; - use std::marker; - use std::marker::PhantomData; --use std::mem::ManuallyDrop; - use std::sync::Arc; - - pub(crate) mod owned_read_guard; -@@ -84,8 +85,10 @@ const MAX_READS: u32 = 10; - /// [`RwLockWriteGuard`]: struct@RwLockWriteGuard - /// [`Send`]: trait@std::marker::Send - /// [_write-preferring_]: https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock#Priority_policies --#[derive(Debug)] - pub struct RwLock { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ - // maximum number of concurrent readers - mr: u32, - -@@ -197,14 +200,55 @@ impl RwLock { - /// - /// let lock = RwLock::new(5); - /// ``` -+ #[track_caller] - pub fn new(value: T) -> RwLock - where - T: Sized, - { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = { -+ let location = std::panic::Location::caller(); -+ let resource_span = tracing::trace_span!( -+ "runtime.resource", -+ concrete_type = "RwLock", -+ kind = "Sync", -+ loc.file = location.file(), -+ loc.line = location.line(), -+ loc.col = location.column(), -+ ); -+ -+ resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ max_readers = MAX_READS, -+ ); -+ -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ ); -+ -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 0, -+ ); -+ }); -+ -+ resource_span -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let s = resource_span.in_scope(|| Semaphore::new(MAX_READS as usize)); -+ -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ let s = Semaphore::new(MAX_READS as usize); -+ - RwLock { - mr: MAX_READS, - c: UnsafeCell::new(value), -- s: Semaphore::new(MAX_READS as usize), -+ s, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span, - } - } - -@@ -222,6 +266,7 @@ impl RwLock { - /// # Panics - /// - /// Panics if `max_reads` is more than `u32::MAX >> 3`. -+ #[track_caller] - pub fn with_max_readers(value: T, max_reads: u32) -> RwLock - where - T: Sized, -@@ -231,10 +276,52 @@ impl RwLock { - "a RwLock may not be created with more than {} readers", - MAX_READS - ); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = { -+ let location = std::panic::Location::caller(); -+ -+ let resource_span = tracing::trace_span!( -+ "runtime.resource", -+ concrete_type = "RwLock", -+ kind = "Sync", -+ loc.file = location.file(), -+ loc.line = location.line(), -+ loc.col = location.column(), -+ ); -+ -+ resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ max_readers = max_reads, -+ ); -+ -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ ); -+ -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 0, -+ ); -+ }); -+ -+ resource_span -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let s = resource_span.in_scope(|| Semaphore::new(max_reads as usize)); -+ -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ let s = Semaphore::new(max_reads as usize); -+ - RwLock { - mr: max_reads, - c: UnsafeCell::new(value), -- s: Semaphore::new(max_reads as usize), -+ s, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span, - } - } - -@@ -257,6 +344,8 @@ impl RwLock { - mr: MAX_READS, - c: UnsafeCell::new(value), - s: Semaphore::const_new(MAX_READS as usize), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span::none(), - } - } - -@@ -281,6 +370,8 @@ impl RwLock { - mr: max_reads, - c: UnsafeCell::new(value), - s: Semaphore::const_new(max_reads as usize), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span::none(), - } - } - -@@ -327,19 +418,100 @@ impl RwLock { - /// - /// // Drop the guard after the spawned task finishes. - /// drop(n); -- ///} -+ /// } - /// ``` - pub async fn read(&self) -> RwLockReadGuard<'_, T> { -- self.s.acquire(1).await.unwrap_or_else(|_| { -- // The semaphore was closed. but, we never explicitly close it, and we have a -- // handle to it through the Arc, which means that this can never happen. -- unreachable!() -+ let acquire_fut = async { -+ self.s.acquire(1).await.unwrap_or_else(|_| { -+ // The semaphore was closed. but, we never explicitly close it, and we have a -+ // handle to it through the Arc, which means that this can never happen. -+ unreachable!() -+ }); -+ -+ RwLockReadGuard { -+ s: &self.s, -+ data: self.c.get(), -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ } -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let acquire_fut = trace::async_op( -+ move || acquire_fut, -+ self.resource_span.clone(), -+ "RwLock::read", -+ "poll", -+ false, -+ ); -+ -+ #[allow(clippy::let_and_return)] // this lint triggers when disabling tracing -+ let guard = acquire_fut.await; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) - }); -- RwLockReadGuard { -- s: &self.s, -- data: self.c.get(), -- marker: marker::PhantomData, -- } -+ -+ guard -+ } -+ -+ /// Blockingly locks this `RwLock` with shared read access. -+ /// -+ /// This method is intended for use cases where you -+ /// need to use this rwlock in asynchronous code as well as in synchronous code. -+ /// -+ /// Returns an RAII guard which will drop the read access of this `RwLock` when dropped. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if called within an asynchronous execution context. -+ /// -+ /// - If you find yourself in an asynchronous execution context and needing -+ /// to call some (synchronous) function which performs one of these -+ /// `blocking_` operations, then consider wrapping that call inside -+ /// [`spawn_blocking()`][crate::runtime::Handle::spawn_blocking] -+ /// (or [`block_in_place()`][crate::task::block_in_place]). -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use std::sync::Arc; -+ /// use tokio::sync::RwLock; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let rwlock = Arc::new(RwLock::new(1)); -+ /// let mut write_lock = rwlock.write().await; -+ /// -+ /// let blocking_task = tokio::task::spawn_blocking({ -+ /// let rwlock = Arc::clone(&rwlock); -+ /// move || { -+ /// // This shall block until the `write_lock` is released. -+ /// let read_lock = rwlock.blocking_read(); -+ /// assert_eq!(*read_lock, 0); -+ /// } -+ /// }); -+ /// -+ /// *write_lock -= 1; -+ /// drop(write_lock); // release the lock. -+ /// -+ /// // Await the completion of the blocking task. -+ /// blocking_task.await.unwrap(); -+ /// -+ /// // Assert uncontended. -+ /// assert!(rwlock.try_write().is_ok()); -+ /// } -+ /// ``` -+ #[track_caller] -+ #[cfg(feature = "sync")] -+ pub fn blocking_read(&self) -> RwLockReadGuard<'_, T> { -+ crate::future::block_on(self.read()) - } - - /// Locks this `RwLock` with shared read access, causing the current task -@@ -394,16 +566,47 @@ impl RwLock { - ///} - /// ``` - pub async fn read_owned(self: Arc) -> OwnedRwLockReadGuard { -- self.s.acquire(1).await.unwrap_or_else(|_| { -- // The semaphore was closed. but, we never explicitly close it, and we have a -- // handle to it through the Arc, which means that this can never happen. -- unreachable!() -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = self.resource_span.clone(); -+ -+ let acquire_fut = async { -+ self.s.acquire(1).await.unwrap_or_else(|_| { -+ // The semaphore was closed. but, we never explicitly close it, and we have a -+ // handle to it through the Arc, which means that this can never happen. -+ unreachable!() -+ }); -+ -+ OwnedRwLockReadGuard { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ data: self.c.get(), -+ lock: self, -+ _p: PhantomData, -+ } -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let acquire_fut = trace::async_op( -+ move || acquire_fut, -+ resource_span, -+ "RwLock::read_owned", -+ "poll", -+ false, -+ ); -+ -+ #[allow(clippy::let_and_return)] // this lint triggers when disabling tracing -+ let guard = acquire_fut.await; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) - }); -- OwnedRwLockReadGuard { -- data: self.c.get(), -- lock: ManuallyDrop::new(self), -- _p: PhantomData, -- } -+ -+ guard - } - - /// Attempts to acquire this `RwLock` with shared read access. -@@ -445,11 +648,24 @@ impl RwLock { - Err(TryAcquireError::Closed) => unreachable!(), - } - -- Ok(RwLockReadGuard { -+ let guard = RwLockReadGuard { - s: &self.s, - data: self.c.get(), - marker: marker::PhantomData, -- }) -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) -+ }); -+ -+ Ok(guard) - } - - /// Attempts to acquire this `RwLock` with shared read access. -@@ -497,11 +713,24 @@ impl RwLock { - Err(TryAcquireError::Closed) => unreachable!(), - } - -- Ok(OwnedRwLockReadGuard { -+ let guard = OwnedRwLockReadGuard { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), - data: self.c.get(), -- lock: ManuallyDrop::new(self), -+ lock: self, - _p: PhantomData, -- }) -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) -+ }); -+ -+ Ok(guard) - } - - /// Locks this `RwLock` with exclusive write access, causing the current -@@ -533,17 +762,100 @@ impl RwLock { - ///} - /// ``` - pub async fn write(&self) -> RwLockWriteGuard<'_, T> { -- self.s.acquire(self.mr).await.unwrap_or_else(|_| { -- // The semaphore was closed. but, we never explicitly close it, and we have a -- // handle to it through the Arc, which means that this can never happen. -- unreachable!() -+ let acquire_fut = async { -+ self.s.acquire(self.mr).await.unwrap_or_else(|_| { -+ // The semaphore was closed. but, we never explicitly close it, and we have a -+ // handle to it through the Arc, which means that this can never happen. -+ unreachable!() -+ }); -+ -+ RwLockWriteGuard { -+ permits_acquired: self.mr, -+ s: &self.s, -+ data: self.c.get(), -+ marker: marker::PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ } -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let acquire_fut = trace::async_op( -+ move || acquire_fut, -+ self.resource_span.clone(), -+ "RwLock::write", -+ "poll", -+ false, -+ ); -+ -+ #[allow(clippy::let_and_return)] // this lint triggers when disabling tracing -+ let guard = acquire_fut.await; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = true, -+ write_locked.op = "override", -+ ) - }); -- RwLockWriteGuard { -- permits_acquired: self.mr, -- s: &self.s, -- data: self.c.get(), -- marker: marker::PhantomData, -- } -+ -+ guard -+ } -+ -+ /// Blockingly locks this `RwLock` with exclusive write access. -+ /// -+ /// This method is intended for use cases where you -+ /// need to use this rwlock in asynchronous code as well as in synchronous code. -+ /// -+ /// Returns an RAII guard which will drop the write access of this `RwLock` when dropped. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if called within an asynchronous execution context. -+ /// -+ /// - If you find yourself in an asynchronous execution context and needing -+ /// to call some (synchronous) function which performs one of these -+ /// `blocking_` operations, then consider wrapping that call inside -+ /// [`spawn_blocking()`][crate::runtime::Handle::spawn_blocking] -+ /// (or [`block_in_place()`][crate::task::block_in_place]). -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use std::sync::Arc; -+ /// use tokio::{sync::RwLock}; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let rwlock = Arc::new(RwLock::new(1)); -+ /// let read_lock = rwlock.read().await; -+ /// -+ /// let blocking_task = tokio::task::spawn_blocking({ -+ /// let rwlock = Arc::clone(&rwlock); -+ /// move || { -+ /// // This shall block until the `read_lock` is released. -+ /// let mut write_lock = rwlock.blocking_write(); -+ /// *write_lock = 2; -+ /// } -+ /// }); -+ /// -+ /// assert_eq!(*read_lock, 1); -+ /// // Release the last outstanding read lock. -+ /// drop(read_lock); -+ /// -+ /// // Await the completion of the blocking task. -+ /// blocking_task.await.unwrap(); -+ /// -+ /// // Assert uncontended. -+ /// let read_lock = rwlock.try_read().unwrap(); -+ /// assert_eq!(*read_lock, 2); -+ /// } -+ /// ``` -+ #[track_caller] -+ #[cfg(feature = "sync")] -+ pub fn blocking_write(&self) -> RwLockWriteGuard<'_, T> { -+ crate::future::block_on(self.write()) - } - - /// Locks this `RwLock` with exclusive write access, causing the current -@@ -582,17 +894,48 @@ impl RwLock { - ///} - /// ``` - pub async fn write_owned(self: Arc) -> OwnedRwLockWriteGuard { -- self.s.acquire(self.mr).await.unwrap_or_else(|_| { -- // The semaphore was closed. but, we never explicitly close it, and we have a -- // handle to it through the Arc, which means that this can never happen. -- unreachable!() -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = self.resource_span.clone(); -+ -+ let acquire_fut = async { -+ self.s.acquire(self.mr).await.unwrap_or_else(|_| { -+ // The semaphore was closed. but, we never explicitly close it, and we have a -+ // handle to it through the Arc, which means that this can never happen. -+ unreachable!() -+ }); -+ -+ OwnedRwLockWriteGuard { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ permits_acquired: self.mr, -+ data: self.c.get(), -+ lock: self, -+ _p: PhantomData, -+ } -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let acquire_fut = trace::async_op( -+ move || acquire_fut, -+ resource_span, -+ "RwLock::write_owned", -+ "poll", -+ false, -+ ); -+ -+ #[allow(clippy::let_and_return)] // this lint triggers when disabling tracing -+ let guard = acquire_fut.await; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = true, -+ write_locked.op = "override", -+ ) - }); -- OwnedRwLockWriteGuard { -- permits_acquired: self.mr, -- data: self.c.get(), -- lock: ManuallyDrop::new(self), -- _p: PhantomData, -- } -+ -+ guard - } - - /// Attempts to acquire this `RwLock` with exclusive write access. -@@ -625,12 +968,25 @@ impl RwLock { - Err(TryAcquireError::Closed) => unreachable!(), - } - -- Ok(RwLockWriteGuard { -+ let guard = RwLockWriteGuard { - permits_acquired: self.mr, - s: &self.s, - data: self.c.get(), - marker: marker::PhantomData, -- }) -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = true, -+ write_locked.op = "override", -+ ) -+ }); -+ -+ Ok(guard) - } - - /// Attempts to acquire this `RwLock` with exclusive write access. -@@ -670,12 +1026,25 @@ impl RwLock { - Err(TryAcquireError::Closed) => unreachable!(), - } - -- Ok(OwnedRwLockWriteGuard { -+ let guard = OwnedRwLockWriteGuard { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: self.resource_span.clone(), - permits_acquired: self.mr, - data: self.c.get(), -- lock: ManuallyDrop::new(self), -+ lock: self, - _p: PhantomData, -- }) -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = true, -+ write_locked.op = "override", -+ ) -+ }); -+ -+ Ok(guard) - } - - /// Returns a mutable reference to the underlying data. -@@ -725,3 +1094,17 @@ where - Self::new(T::default()) - } - } -+ -+impl std::fmt::Debug for RwLock -+where -+ T: std::fmt::Debug, -+{ -+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { -+ let mut d = f.debug_struct("RwLock"); -+ match self.try_read() { -+ Ok(inner) => d.field("data", &&*inner), -+ Err(_) => d.field("data", &format_args!("")), -+ }; -+ d.finish() -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_read_guard.rs b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_read_guard.rs -index 18812958..273e7b86 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_read_guard.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_read_guard.rs -@@ -1,10 +1,7 @@ - use crate::sync::rwlock::RwLock; --use std::fmt; - use std::marker::PhantomData; --use std::mem; --use std::mem::ManuallyDrop; --use std::ops; - use std::sync::Arc; -+use std::{fmt, mem, ops, ptr}; - - /// Owned RAII structure used to release the shared read access of a lock when - /// dropped. -@@ -14,14 +11,40 @@ use std::sync::Arc; - /// - /// [`read_owned`]: method@crate::sync::RwLock::read_owned - /// [`RwLock`]: struct@crate::sync::RwLock -+#[clippy::has_significant_drop] - pub struct OwnedRwLockReadGuard { -- // ManuallyDrop allows us to destructure into this field without running the destructor. -- pub(super) lock: ManuallyDrop>>, -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ pub(super) resource_span: tracing::Span, -+ pub(super) lock: Arc>, - pub(super) data: *const U, - pub(super) _p: PhantomData, - } - -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ lock: Arc>, -+ data: *const U, -+} -+ - impl OwnedRwLockReadGuard { -+ fn skip_drop(self) -> Inner { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the values in every field of the guard, then -+ // forgets the originals, so in the end no value is duplicated. -+ unsafe { -+ Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: ptr::read(&me.resource_span), -+ lock: ptr::read(&me.lock), -+ data: me.data, -+ } -+ } -+ } -+ - /// Makes a new `OwnedRwLockReadGuard` for a component of the locked data. - /// This operation cannot fail as the `OwnedRwLockReadGuard` passed in - /// already locked the data. -@@ -50,18 +73,19 @@ impl OwnedRwLockReadGuard { - /// # } - /// ``` - #[inline] -- pub fn map(mut this: Self, f: F) -> OwnedRwLockReadGuard -+ pub fn map(this: Self, f: F) -> OwnedRwLockReadGuard - where - F: FnOnce(&U) -> &V, - { - let data = f(&*this) as *const V; -- let lock = unsafe { ManuallyDrop::take(&mut this.lock) }; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - OwnedRwLockReadGuard { -- lock: ManuallyDrop::new(lock), -+ lock: this.lock, - data, - _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - } - } - -@@ -96,7 +120,7 @@ impl OwnedRwLockReadGuard { - /// # } - /// ``` - #[inline] -- pub fn try_map(mut this: Self, f: F) -> Result, Self> -+ pub fn try_map(this: Self, f: F) -> Result, Self> - where - F: FnOnce(&U) -> Option<&V>, - { -@@ -104,13 +128,14 @@ impl OwnedRwLockReadGuard { - Some(data) => data as *const V, - None => return Err(this), - }; -- let lock = unsafe { ManuallyDrop::take(&mut this.lock) }; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - Ok(OwnedRwLockReadGuard { -- lock: ManuallyDrop::new(lock), -+ lock: this.lock, - data, - _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - }) - } - } -@@ -144,6 +169,14 @@ where - impl Drop for OwnedRwLockReadGuard { - fn drop(&mut self) { - self.lock.s.release(1); -- unsafe { ManuallyDrop::drop(&mut self.lock) }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "sub", -+ ) -+ }); - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_write_guard.rs b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_write_guard.rs -index 0a78d28e..a8ce4a16 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_write_guard.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_write_guard.rs -@@ -1,11 +1,9 @@ - use crate::sync::rwlock::owned_read_guard::OwnedRwLockReadGuard; - use crate::sync::rwlock::owned_write_guard_mapped::OwnedRwLockMappedWriteGuard; - use crate::sync::rwlock::RwLock; --use std::fmt; - use std::marker::PhantomData; --use std::mem::{self, ManuallyDrop}; --use std::ops; - use std::sync::Arc; -+use std::{fmt, mem, ops, ptr}; - - /// Owned RAII structure used to release the exclusive write access of a lock when - /// dropped. -@@ -15,15 +13,43 @@ use std::sync::Arc; - /// - /// [`write_owned`]: method@crate::sync::RwLock::write_owned - /// [`RwLock`]: struct@crate::sync::RwLock -+#[clippy::has_significant_drop] - pub struct OwnedRwLockWriteGuard { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ pub(super) resource_span: tracing::Span, - pub(super) permits_acquired: u32, -- // ManuallyDrop allows us to destructure into this field without running the destructor. -- pub(super) lock: ManuallyDrop>>, -+ pub(super) lock: Arc>, - pub(super) data: *mut T, - pub(super) _p: PhantomData, - } - -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ permits_acquired: u32, -+ lock: Arc>, -+ data: *const T, -+} -+ - impl OwnedRwLockWriteGuard { -+ fn skip_drop(self) -> Inner { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the values in every field of the guard, then -+ // forgets the originals, so in the end no value is duplicated. -+ unsafe { -+ Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: ptr::read(&me.resource_span), -+ permits_acquired: me.permits_acquired, -+ lock: ptr::read(&me.lock), -+ data: me.data, -+ } -+ } -+ } -+ - /// Makes a new [`OwnedRwLockMappedWriteGuard`] for a component of the locked - /// data. - /// -@@ -62,19 +88,90 @@ impl OwnedRwLockWriteGuard { - F: FnOnce(&mut T) -> &mut U, - { - let data = f(&mut *this) as *mut U; -- let lock = unsafe { ManuallyDrop::take(&mut this.lock) }; -- let permits_acquired = this.permits_acquired; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - OwnedRwLockMappedWriteGuard { -- permits_acquired, -- lock: ManuallyDrop::new(lock), -+ permits_acquired: this.permits_acquired, -+ lock: this.lock, - data, - _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - } - } - -- /// Attempts to make a new [`OwnedRwLockMappedWriteGuard`] for a component -+ /// Makes a new [`OwnedRwLockReadGuard`] for a component of the locked data. -+ /// -+ /// This operation cannot fail as the `OwnedRwLockWriteGuard` passed in already -+ /// locked the data. -+ /// -+ /// This is an associated function that needs to be used as -+ /// `OwnedRwLockWriteGuard::downgrade_map(..)`. A method would interfere with methods of -+ /// the same name on the contents of the locked data. -+ /// -+ /// Inside of `f`, you retain exclusive access to the data, despite only being given a `&T`. Handing out a -+ /// `&mut T` would result in unsoundness, as you could use interior mutability. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use std::sync::Arc; -+ /// use tokio::sync::{RwLock, OwnedRwLockWriteGuard}; -+ /// -+ /// #[derive(Debug, Clone, Copy, PartialEq, Eq)] -+ /// struct Foo(u32); -+ /// -+ /// # #[tokio::main] -+ /// # async fn main() { -+ /// let lock = Arc::new(RwLock::new(Foo(1))); -+ /// -+ /// let guard = Arc::clone(&lock).write_owned().await; -+ /// let mapped = OwnedRwLockWriteGuard::downgrade_map(guard, |f| &f.0); -+ /// let foo = lock.read_owned().await; -+ /// assert_eq!(foo.0, *mapped); -+ /// # } -+ /// ``` -+ #[inline] -+ pub fn downgrade_map(this: Self, f: F) -> OwnedRwLockReadGuard -+ where -+ F: FnOnce(&T) -> &U, -+ { -+ let data = f(&*this) as *const U; -+ let this = this.skip_drop(); -+ let guard = OwnedRwLockReadGuard { -+ lock: this.lock, -+ data, -+ _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, -+ }; -+ -+ // Release all but one of the permits held by the write guard -+ let to_release = (this.permits_acquired - 1) as usize; -+ guard.lock.s.release(to_release); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) -+ }); -+ -+ guard -+ } -+ -+ /// Attempts to make a new [`OwnedRwLockMappedWriteGuard`] for a component - /// of the locked data. The original guard is returned if the closure - /// returns `None`. - /// -@@ -121,18 +218,99 @@ impl OwnedRwLockWriteGuard { - Some(data) => data as *mut U, - None => return Err(this), - }; -- let permits_acquired = this.permits_acquired; -- let lock = unsafe { ManuallyDrop::take(&mut this.lock) }; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - Ok(OwnedRwLockMappedWriteGuard { -- permits_acquired, -- lock: ManuallyDrop::new(lock), -+ permits_acquired: this.permits_acquired, -+ lock: this.lock, - data, - _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - }) - } - -+ /// Attempts to make a new [`OwnedRwLockReadGuard`] for a component of -+ /// the locked data. The original guard is returned if the closure returns -+ /// `None`. -+ /// -+ /// This operation cannot fail as the `OwnedRwLockWriteGuard` passed in already -+ /// locked the data. -+ /// -+ /// This is an associated function that needs to be -+ /// used as `OwnedRwLockWriteGuard::try_downgrade_map(...)`. A method would interfere with -+ /// methods of the same name on the contents of the locked data. -+ /// -+ /// Inside of `f`, you retain exclusive access to the data, despite only being given a `&T`. Handing out a -+ /// `&mut T` would result in unsoundness, as you could use interior mutability. -+ /// -+ /// If this function returns `Err(...)`, the lock is never unlocked nor downgraded. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use std::sync::Arc; -+ /// use tokio::sync::{RwLock, OwnedRwLockWriteGuard}; -+ /// -+ /// #[derive(Debug, Clone, Copy, PartialEq, Eq)] -+ /// struct Foo(u32); -+ /// -+ /// # #[tokio::main] -+ /// # async fn main() { -+ /// let lock = Arc::new(RwLock::new(Foo(1))); -+ /// -+ /// let guard = Arc::clone(&lock).write_owned().await; -+ /// let guard = OwnedRwLockWriteGuard::try_downgrade_map(guard, |f| Some(&f.0)).expect("should not fail"); -+ /// let foo = lock.read_owned().await; -+ /// assert_eq!(foo.0, *guard); -+ /// # } -+ /// ``` -+ #[inline] -+ pub fn try_downgrade_map( -+ this: Self, -+ f: F, -+ ) -> Result, Self> -+ where -+ F: FnOnce(&T) -> Option<&U>, -+ { -+ let data = match f(&*this) { -+ Some(data) => data as *const U, -+ None => return Err(this), -+ }; -+ let this = this.skip_drop(); -+ let guard = OwnedRwLockReadGuard { -+ lock: this.lock, -+ data, -+ _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, -+ }; -+ -+ // Release all but one of the permits held by the write guard -+ let to_release = (this.permits_acquired - 1) as usize; -+ guard.lock.s.release(to_release); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) -+ }); -+ -+ Ok(guard) -+ } -+ - /// Converts this `OwnedRwLockWriteGuard` into an - /// `OwnedRwLockMappedWriteGuard`. This method can be used to store a - /// non-mapped guard in a struct field that expects a mapped guard. -@@ -178,19 +356,39 @@ impl OwnedRwLockWriteGuard { - /// assert_eq!(*lock.read().await, 2, "second writer obtained write lock"); - /// # } - /// ``` -- pub fn downgrade(mut self) -> OwnedRwLockReadGuard { -- let lock = unsafe { ManuallyDrop::take(&mut self.lock) }; -- let data = self.data; -+ pub fn downgrade(self) -> OwnedRwLockReadGuard { -+ let this = self.skip_drop(); -+ let guard = OwnedRwLockReadGuard { -+ lock: this.lock, -+ data: this.data, -+ _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, -+ }; - - // Release all but one of the permits held by the write guard -- lock.s.release((self.permits_acquired - 1) as usize); -- // NB: Forget to avoid drop impl from being called. -- mem::forget(self); -- OwnedRwLockReadGuard { -- lock: ManuallyDrop::new(lock), -- data, -- _p: PhantomData, -- } -+ let to_release = (this.permits_acquired - 1) as usize; -+ guard.lock.s.release(to_release); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) -+ }); -+ -+ guard - } - } - -@@ -229,6 +427,14 @@ where - impl Drop for OwnedRwLockWriteGuard { - fn drop(&mut self) { - self.lock.s.release(self.permits_acquired as usize); -- unsafe { ManuallyDrop::drop(&mut self.lock) }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_write_guard_mapped.rs b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_write_guard_mapped.rs -index d88ee01e..9f495210 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_write_guard_mapped.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/owned_write_guard_mapped.rs -@@ -1,9 +1,7 @@ - use crate::sync::rwlock::RwLock; --use std::fmt; - use std::marker::PhantomData; --use std::mem::{self, ManuallyDrop}; --use std::ops; - use std::sync::Arc; -+use std::{fmt, mem, ops, ptr}; - - /// Owned RAII structure used to release the exclusive write access of a lock when - /// dropped. -@@ -14,15 +12,43 @@ use std::sync::Arc; - /// - /// [mapping]: method@crate::sync::OwnedRwLockWriteGuard::map - /// [`OwnedRwLockWriteGuard`]: struct@crate::sync::OwnedRwLockWriteGuard -+#[clippy::has_significant_drop] - pub struct OwnedRwLockMappedWriteGuard { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ pub(super) resource_span: tracing::Span, - pub(super) permits_acquired: u32, -- // ManuallyDrop allows us to destructure into this field without running the destructor. -- pub(super) lock: ManuallyDrop>>, -+ pub(super) lock: Arc>, - pub(super) data: *mut U, - pub(super) _p: PhantomData, - } - -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ permits_acquired: u32, -+ lock: Arc>, -+ data: *const U, -+} -+ - impl OwnedRwLockMappedWriteGuard { -+ fn skip_drop(self) -> Inner { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the values in every field of the guard, then -+ // forgets the originals, so in the end no value is duplicated. -+ unsafe { -+ Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: ptr::read(&me.resource_span), -+ permits_acquired: me.permits_acquired, -+ lock: ptr::read(&me.lock), -+ data: me.data, -+ } -+ } -+ } -+ - /// Makes a new `OwnedRwLockMappedWriteGuard` for a component of the locked - /// data. - /// -@@ -61,15 +87,15 @@ impl OwnedRwLockMappedWriteGuard { - F: FnOnce(&mut U) -> &mut V, - { - let data = f(&mut *this) as *mut V; -- let lock = unsafe { ManuallyDrop::take(&mut this.lock) }; -- let permits_acquired = this.permits_acquired; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - OwnedRwLockMappedWriteGuard { -- permits_acquired, -- lock: ManuallyDrop::new(lock), -+ permits_acquired: this.permits_acquired, -+ lock: this.lock, - data, - _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - } - } - -@@ -118,15 +144,15 @@ impl OwnedRwLockMappedWriteGuard { - Some(data) => data as *mut V, - None => return Err(this), - }; -- let lock = unsafe { ManuallyDrop::take(&mut this.lock) }; -- let permits_acquired = this.permits_acquired; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - Ok(OwnedRwLockMappedWriteGuard { -- permits_acquired, -- lock: ManuallyDrop::new(lock), -+ permits_acquired: this.permits_acquired, -+ lock: this.lock, - data, - _p: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - }) - } - } -@@ -166,6 +192,14 @@ where - impl Drop for OwnedRwLockMappedWriteGuard { - fn drop(&mut self) { - self.lock.s.release(self.permits_acquired as usize); -- unsafe { ManuallyDrop::drop(&mut self.lock) }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/read_guard.rs b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/read_guard.rs -index 090b297e..a04b5958 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/read_guard.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/read_guard.rs -@@ -1,8 +1,6 @@ - use crate::sync::batch_semaphore::Semaphore; --use std::fmt; --use std::marker; --use std::mem; --use std::ops; -+use std::marker::PhantomData; -+use std::{fmt, mem, ops}; - - /// RAII structure used to release the shared read access of a lock when - /// dropped. -@@ -12,13 +10,39 @@ use std::ops; - /// - /// [`read`]: method@crate::sync::RwLock::read - /// [`RwLock`]: struct@crate::sync::RwLock -+#[clippy::has_significant_drop] -+#[must_use = "if unused the RwLock will immediately unlock"] - pub struct RwLockReadGuard<'a, T: ?Sized> { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ pub(super) resource_span: tracing::Span, - pub(super) s: &'a Semaphore, - pub(super) data: *const T, -- pub(super) marker: marker::PhantomData<&'a T>, -+ pub(super) marker: PhantomData<&'a T>, -+} -+ -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct Inner<'a, T: ?Sized> { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ s: &'a Semaphore, -+ data: *const T, - } - - impl<'a, T: ?Sized> RwLockReadGuard<'a, T> { -+ fn skip_drop(self) -> Inner<'a, T> { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the values in every field of the guard, then -+ // forgets the originals, so in the end no value is duplicated. -+ Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: unsafe { std::ptr::read(&me.resource_span) }, -+ s: me.s, -+ data: me.data, -+ } -+ } -+ - /// Makes a new `RwLockReadGuard` for a component of the locked data. - /// - /// This operation cannot fail as the `RwLockReadGuard` passed in already -@@ -58,13 +82,14 @@ impl<'a, T: ?Sized> RwLockReadGuard<'a, T> { - F: FnOnce(&T) -> &U, - { - let data = f(&*this) as *const U; -- let s = this.s; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - RwLockReadGuard { -- s, -+ s: this.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - } - } - -@@ -112,13 +137,14 @@ impl<'a, T: ?Sized> RwLockReadGuard<'a, T> { - Some(data) => data as *const U, - None => return Err(this), - }; -- let s = this.s; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - Ok(RwLockReadGuard { -- s, -+ s: this.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - }) - } - } -@@ -152,5 +178,14 @@ where - impl<'a, T: ?Sized> Drop for RwLockReadGuard<'a, T> { - fn drop(&mut self) { - self.s.release(1); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "sub", -+ ) -+ }); - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/write_guard.rs b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/write_guard.rs -index 8c80ee70..d405fc2b 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/write_guard.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/write_guard.rs -@@ -1,10 +1,8 @@ - use crate::sync::batch_semaphore::Semaphore; - use crate::sync::rwlock::read_guard::RwLockReadGuard; - use crate::sync::rwlock::write_guard_mapped::RwLockMappedWriteGuard; --use std::fmt; --use std::marker; --use std::mem; --use std::ops; -+use std::marker::PhantomData; -+use std::{fmt, mem, ops}; - - /// RAII structure used to release the exclusive write access of a lock when - /// dropped. -@@ -14,14 +12,42 @@ use std::ops; - /// - /// [`write`]: method@crate::sync::RwLock::write - /// [`RwLock`]: struct@crate::sync::RwLock -+#[clippy::has_significant_drop] -+#[must_use = "if unused the RwLock will immediately unlock"] - pub struct RwLockWriteGuard<'a, T: ?Sized> { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ pub(super) resource_span: tracing::Span, - pub(super) permits_acquired: u32, - pub(super) s: &'a Semaphore, - pub(super) data: *mut T, -- pub(super) marker: marker::PhantomData<&'a mut T>, -+ pub(super) marker: PhantomData<&'a mut T>, -+} -+ -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct Inner<'a, T: ?Sized> { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ permits_acquired: u32, -+ s: &'a Semaphore, -+ data: *mut T, - } - - impl<'a, T: ?Sized> RwLockWriteGuard<'a, T> { -+ fn skip_drop(self) -> Inner<'a, T> { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the values in every field of the guard, then -+ // forgets the originals, so in the end no value is duplicated. -+ Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: unsafe { std::ptr::read(&me.resource_span) }, -+ permits_acquired: me.permits_acquired, -+ s: me.s, -+ data: me.data, -+ } -+ } -+ - /// Makes a new [`RwLockMappedWriteGuard`] for a component of the locked data. - /// - /// This operation cannot fail as the `RwLockWriteGuard` passed in already -@@ -64,19 +90,96 @@ impl<'a, T: ?Sized> RwLockWriteGuard<'a, T> { - F: FnOnce(&mut T) -> &mut U, - { - let data = f(&mut *this) as *mut U; -- let s = this.s; -- let permits_acquired = this.permits_acquired; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - RwLockMappedWriteGuard { -- permits_acquired, -- s, -+ permits_acquired: this.permits_acquired, -+ s: this.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - } - } - -- /// Attempts to make a new [`RwLockMappedWriteGuard`] for a component of -+ /// Makes a new [`RwLockReadGuard`] for a component of the locked data. -+ /// -+ /// This operation cannot fail as the `RwLockWriteGuard` passed in already -+ /// locked the data. -+ /// -+ /// This is an associated function that needs to be used as -+ /// `RwLockWriteGuard::downgrade_map(..)`. A method would interfere with methods of -+ /// the same name on the contents of the locked data. -+ /// -+ /// This is equivalent to a combination of asynchronous [`RwLockWriteGuard::map`] and [`RwLockWriteGuard::downgrade`] -+ /// from the [`parking_lot` crate]. -+ /// -+ /// Inside of `f`, you retain exclusive access to the data, despite only being given a `&T`. Handing out a -+ /// `&mut T` would result in unsoundness, as you could use interior mutability. -+ /// -+ /// [`RwLockMappedWriteGuard`]: struct@crate::sync::RwLockMappedWriteGuard -+ /// [`RwLockWriteGuard::map`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockWriteGuard.html#method.map -+ /// [`RwLockWriteGuard::downgrade`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockWriteGuard.html#method.downgrade -+ /// [`parking_lot` crate]: https://crates.io/crates/parking_lot -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::{RwLock, RwLockWriteGuard}; -+ /// -+ /// #[derive(Debug, Clone, Copy, PartialEq, Eq)] -+ /// struct Foo(u32); -+ /// -+ /// # #[tokio::main] -+ /// # async fn main() { -+ /// let lock = RwLock::new(Foo(1)); -+ /// -+ /// let mapped = RwLockWriteGuard::downgrade_map(lock.write().await, |f| &f.0); -+ /// let foo = lock.read().await; -+ /// assert_eq!(foo.0, *mapped); -+ /// # } -+ /// ``` -+ #[inline] -+ pub fn downgrade_map(this: Self, f: F) -> RwLockReadGuard<'a, U> -+ where -+ F: FnOnce(&T) -> &U, -+ { -+ let data = f(&*this) as *const U; -+ let this = this.skip_drop(); -+ let guard = RwLockReadGuard { -+ s: this.s, -+ data, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, -+ }; -+ -+ // Release all but one of the permits held by the write guard -+ let to_release = (this.permits_acquired - 1) as usize; -+ this.s.release(to_release); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) -+ }); -+ -+ guard -+ } -+ -+ /// Attempts to make a new [`RwLockMappedWriteGuard`] for a component of - /// the locked data. The original guard is returned if the closure returns - /// `None`. - /// -@@ -127,18 +230,102 @@ impl<'a, T: ?Sized> RwLockWriteGuard<'a, T> { - Some(data) => data as *mut U, - None => return Err(this), - }; -- let s = this.s; -- let permits_acquired = this.permits_acquired; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - Ok(RwLockMappedWriteGuard { -- permits_acquired, -- s, -+ permits_acquired: this.permits_acquired, -+ s: this.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - }) - } - -+ /// Attempts to make a new [`RwLockReadGuard`] for a component of -+ /// the locked data. The original guard is returned if the closure returns -+ /// `None`. -+ /// -+ /// This operation cannot fail as the `RwLockWriteGuard` passed in already -+ /// locked the data. -+ /// -+ /// This is an associated function that needs to be -+ /// used as `RwLockWriteGuard::try_downgrade_map(...)`. A method would interfere with -+ /// methods of the same name on the contents of the locked data. -+ /// -+ /// This is equivalent to a combination of asynchronous [`RwLockWriteGuard::try_map`] and [`RwLockWriteGuard::downgrade`] -+ /// from the [`parking_lot` crate]. -+ /// -+ /// Inside of `f`, you retain exclusive access to the data, despite only being given a `&T`. Handing out a -+ /// `&mut T` would result in unsoundness, as you could use interior mutability. -+ /// -+ /// If this function returns `Err(...)`, the lock is never unlocked nor downgraded. -+ /// -+ /// [`RwLockMappedWriteGuard`]: struct@crate::sync::RwLockMappedWriteGuard -+ /// [`RwLockWriteGuard::map`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockWriteGuard.html#method.map -+ /// [`RwLockWriteGuard::downgrade`]: https://docs.rs/lock_api/latest/lock_api/struct.RwLockWriteGuard.html#method.downgrade -+ /// [`parking_lot` crate]: https://crates.io/crates/parking_lot -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::{RwLock, RwLockWriteGuard}; -+ /// -+ /// #[derive(Debug, Clone, Copy, PartialEq, Eq)] -+ /// struct Foo(u32); -+ /// -+ /// # #[tokio::main] -+ /// # async fn main() { -+ /// let lock = RwLock::new(Foo(1)); -+ /// -+ /// let guard = RwLockWriteGuard::try_downgrade_map(lock.write().await, |f| Some(&f.0)).expect("should not fail"); -+ /// let foo = lock.read().await; -+ /// assert_eq!(foo.0, *guard); -+ /// # } -+ /// ``` -+ #[inline] -+ pub fn try_downgrade_map(this: Self, f: F) -> Result, Self> -+ where -+ F: FnOnce(&T) -> Option<&U>, -+ { -+ let data = match f(&*this) { -+ Some(data) => data as *const U, -+ None => return Err(this), -+ }; -+ let this = this.skip_drop(); -+ let guard = RwLockReadGuard { -+ s: this.s, -+ data, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, -+ }; -+ -+ // Release all but one of the permits held by the write guard -+ let to_release = (this.permits_acquired - 1) as usize; -+ this.s.release(to_release); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) -+ }); -+ -+ Ok(guard) -+ } -+ - /// Converts this `RwLockWriteGuard` into an `RwLockMappedWriteGuard`. This - /// method can be used to store a non-mapped guard in a struct field that - /// expects a mapped guard. -@@ -187,17 +374,38 @@ impl<'a, T: ?Sized> RwLockWriteGuard<'a, T> { - /// - /// [`RwLock`]: struct@crate::sync::RwLock - pub fn downgrade(self) -> RwLockReadGuard<'a, T> { -- let RwLockWriteGuard { s, data, .. } = self; -+ let this = self.skip_drop(); -+ let guard = RwLockReadGuard { -+ s: this.s, -+ data: this.data, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, -+ }; - - // Release all but one of the permits held by the write guard -- s.release((self.permits_acquired - 1) as usize); -- // NB: Forget to avoid drop impl from being called. -- mem::forget(self); -- RwLockReadGuard { -- s, -- data, -- marker: marker::PhantomData, -- } -+ let to_release = (this.permits_acquired - 1) as usize; -+ this.s.release(to_release); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ guard.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ current_readers = 1, -+ current_readers.op = "add", -+ ) -+ }); -+ -+ guard - } - } - -@@ -236,5 +444,14 @@ where - impl<'a, T: ?Sized> Drop for RwLockWriteGuard<'a, T> { - fn drop(&mut self) { - self.s.release(self.permits_acquired as usize); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/write_guard_mapped.rs b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/write_guard_mapped.rs -index 3cf69de4..7705189e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/rwlock/write_guard_mapped.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/rwlock/write_guard_mapped.rs -@@ -1,8 +1,6 @@ - use crate::sync::batch_semaphore::Semaphore; --use std::fmt; --use std::marker; --use std::mem; --use std::ops; -+use std::marker::PhantomData; -+use std::{fmt, mem, ops}; - - /// RAII structure used to release the exclusive write access of a lock when - /// dropped. -@@ -13,14 +11,41 @@ use std::ops; - /// - /// [mapping]: method@crate::sync::RwLockWriteGuard::map - /// [`RwLockWriteGuard`]: struct@crate::sync::RwLockWriteGuard -+#[clippy::has_significant_drop] - pub struct RwLockMappedWriteGuard<'a, T: ?Sized> { -+ // When changing the fields in this struct, make sure to update the -+ // `skip_drop` method. -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ pub(super) resource_span: tracing::Span, - pub(super) permits_acquired: u32, - pub(super) s: &'a Semaphore, - pub(super) data: *mut T, -- pub(super) marker: marker::PhantomData<&'a mut T>, -+ pub(super) marker: PhantomData<&'a mut T>, -+} -+ -+#[allow(dead_code)] // Unused fields are still used in Drop. -+struct Inner<'a, T: ?Sized> { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, -+ permits_acquired: u32, -+ s: &'a Semaphore, -+ data: *mut T, - } - - impl<'a, T: ?Sized> RwLockMappedWriteGuard<'a, T> { -+ fn skip_drop(self) -> Inner<'a, T> { -+ let me = mem::ManuallyDrop::new(self); -+ // SAFETY: This duplicates the values in every field of the guard, then -+ // forgets the originals, so in the end no value is duplicated. -+ Inner { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: unsafe { std::ptr::read(&me.resource_span) }, -+ permits_acquired: me.permits_acquired, -+ s: me.s, -+ data: me.data, -+ } -+ } -+ - /// Makes a new `RwLockMappedWriteGuard` for a component of the locked data. - /// - /// This operation cannot fail as the `RwLockMappedWriteGuard` passed in already -@@ -62,15 +87,15 @@ impl<'a, T: ?Sized> RwLockMappedWriteGuard<'a, T> { - F: FnOnce(&mut T) -> &mut U, - { - let data = f(&mut *this) as *mut U; -- let s = this.s; -- let permits_acquired = this.permits_acquired; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - RwLockMappedWriteGuard { -- permits_acquired, -- s, -+ permits_acquired: this.permits_acquired, -+ s: this.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - } - } - -@@ -124,17 +149,20 @@ impl<'a, T: ?Sized> RwLockMappedWriteGuard<'a, T> { - Some(data) => data as *mut U, - None => return Err(this), - }; -- let s = this.s; -- let permits_acquired = this.permits_acquired; -- // NB: Forget to avoid drop impl from being called. -- mem::forget(this); -+ let this = this.skip_drop(); -+ - Ok(RwLockMappedWriteGuard { -- permits_acquired, -- s, -+ permits_acquired: this.permits_acquired, -+ s: this.s, - data, -- marker: marker::PhantomData, -+ marker: PhantomData, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: this.resource_span, - }) - } -+ -+ // Note: No `downgrade`, `downgrade_map` nor `try_downgrade_map` because they would be unsound, as we're already -+ // potentially been mapped with internal mutability. - } - - impl ops::Deref for RwLockMappedWriteGuard<'_, T> { -@@ -172,5 +200,14 @@ where - impl<'a, T: ?Sized> Drop for RwLockMappedWriteGuard<'a, T> { - fn drop(&mut self) { - self.s.release(self.permits_acquired as usize); -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ self.resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ write_locked = false, -+ write_locked.op = "override", -+ ) -+ }); - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/semaphore.rs b/KubeOS-Rust/vendor/tokio/src/sync/semaphore.rs -index 839b523c..3343c74e 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/semaphore.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/semaphore.rs -@@ -1,5 +1,7 @@ - use super::batch_semaphore as ll; // low level implementation - use super::{AcquireError, TryAcquireError}; -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+use crate::util::trace; - use std::sync::Arc; - - /// Counting semaphore performing asynchronous permit acquisition. -@@ -77,6 +79,8 @@ use std::sync::Arc; - pub struct Semaphore { - /// The low level semaphore - ll_sem: ll::Semaphore, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - } - - /// A permit from the semaphore. -@@ -85,6 +89,7 @@ pub struct Semaphore { - /// - /// [`acquire`]: crate::sync::Semaphore::acquire() - #[must_use] -+#[clippy::has_significant_drop] - #[derive(Debug)] - pub struct SemaphorePermit<'a> { - sem: &'a Semaphore, -@@ -97,6 +102,7 @@ pub struct SemaphorePermit<'a> { - /// - /// [`acquire_owned`]: crate::sync::Semaphore::acquire_owned() - #[must_use] -+#[clippy::has_significant_drop] - #[derive(Debug)] - pub struct OwnedSemaphorePermit { - sem: Arc, -@@ -119,10 +125,41 @@ fn bounds() { - } - - impl Semaphore { -+ /// The maximum number of permits which a semaphore can hold. It is `usize::MAX >> 3`. -+ /// -+ /// Exceeding this limit typically results in a panic. -+ pub const MAX_PERMITS: usize = super::batch_semaphore::Semaphore::MAX_PERMITS; -+ - /// Creates a new semaphore with the initial number of permits. -+ /// -+ /// Panics if `permits` exceeds [`Semaphore::MAX_PERMITS`]. -+ #[track_caller] - pub fn new(permits: usize) -> Self { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = { -+ let location = std::panic::Location::caller(); -+ -+ tracing::trace_span!( -+ "runtime.resource", -+ concrete_type = "Semaphore", -+ kind = "Sync", -+ loc.file = location.file(), -+ loc.line = location.line(), -+ loc.col = location.column(), -+ inherits_child_attrs = true, -+ ) -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let ll_sem = resource_span.in_scope(|| ll::Semaphore::new(permits)); -+ -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ let ll_sem = ll::Semaphore::new(permits); -+ - Self { -- ll_sem: ll::Semaphore::new(permits), -+ ll_sem, -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span, - } - } - -@@ -139,9 +176,16 @@ impl Semaphore { - #[cfg(all(feature = "parking_lot", not(all(loom, test))))] - #[cfg_attr(docsrs, doc(cfg(feature = "parking_lot")))] - pub const fn const_new(permits: usize) -> Self { -- Self { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ return Self { - ll_sem: ll::Semaphore::const_new(permits), -- } -+ resource_span: tracing::Span::none(), -+ }; -+ -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ return Self { -+ ll_sem: ll::Semaphore::const_new(permits), -+ }; - } - - /// Returns the current number of available permits. -@@ -151,7 +195,7 @@ impl Semaphore { - - /// Adds `n` new permits to the semaphore. - /// -- /// The maximum number of permits is `usize::MAX >> 3`, and this function will panic if the limit is exceeded. -+ /// The maximum number of permits is [`Semaphore::MAX_PERMITS`], and this function will panic if the limit is exceeded. - pub fn add_permits(&self, n: usize) { - self.ll_sem.release(n); - } -@@ -191,7 +235,18 @@ impl Semaphore { - /// [`AcquireError`]: crate::sync::AcquireError - /// [`SemaphorePermit`]: crate::sync::SemaphorePermit - pub async fn acquire(&self) -> Result, AcquireError> { -- self.ll_sem.acquire(1).await?; -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let inner = trace::async_op( -+ || self.ll_sem.acquire(1), -+ self.resource_span.clone(), -+ "Semaphore::acquire", -+ "poll", -+ true, -+ ); -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ let inner = self.ll_sem.acquire(1); -+ -+ inner.await?; - Ok(SemaphorePermit { - sem: self, - permits: 1, -@@ -227,7 +282,19 @@ impl Semaphore { - /// [`AcquireError`]: crate::sync::AcquireError - /// [`SemaphorePermit`]: crate::sync::SemaphorePermit - pub async fn acquire_many(&self, n: u32) -> Result, AcquireError> { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ trace::async_op( -+ || self.ll_sem.acquire(n), -+ self.resource_span.clone(), -+ "Semaphore::acquire_many", -+ "poll", -+ true, -+ ) -+ .await?; -+ -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] - self.ll_sem.acquire(n).await?; -+ - Ok(SemaphorePermit { - sem: self, - permits: n, -@@ -350,7 +417,18 @@ impl Semaphore { - /// [`AcquireError`]: crate::sync::AcquireError - /// [`OwnedSemaphorePermit`]: crate::sync::OwnedSemaphorePermit - pub async fn acquire_owned(self: Arc) -> Result { -- self.ll_sem.acquire(1).await?; -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let inner = trace::async_op( -+ || self.ll_sem.acquire(1), -+ self.resource_span.clone(), -+ "Semaphore::acquire_owned", -+ "poll", -+ true, -+ ); -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ let inner = self.ll_sem.acquire(1); -+ -+ inner.await?; - Ok(OwnedSemaphorePermit { - sem: self, - permits: 1, -@@ -403,7 +481,18 @@ impl Semaphore { - self: Arc, - n: u32, - ) -> Result { -- self.ll_sem.acquire(n).await?; -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let inner = trace::async_op( -+ || self.ll_sem.acquire(n), -+ self.resource_span.clone(), -+ "Semaphore::acquire_many_owned", -+ "poll", -+ true, -+ ); -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ let inner = self.ll_sem.acquire(n); -+ -+ inner.await?; - Ok(OwnedSemaphorePermit { - sem: self, - permits: n, -@@ -540,6 +629,25 @@ impl<'a> SemaphorePermit<'a> { - pub fn forget(mut self) { - self.permits = 0; - } -+ -+ /// Merge two [`SemaphorePermit`] instances together, consuming `other` -+ /// without releasing the permits it holds. -+ /// -+ /// Permits held by both `self` and `other` are released when `self` drops. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if permits from different [`Semaphore`] instances -+ /// are merged. -+ #[track_caller] -+ pub fn merge(&mut self, mut other: Self) { -+ assert!( -+ std::ptr::eq(self.sem, other.sem), -+ "merging permits from different semaphore instances" -+ ); -+ self.permits += other.permits; -+ other.permits = 0; -+ } - } - - impl OwnedSemaphorePermit { -@@ -549,9 +657,33 @@ impl OwnedSemaphorePermit { - pub fn forget(mut self) { - self.permits = 0; - } -+ -+ /// Merge two [`OwnedSemaphorePermit`] instances together, consuming `other` -+ /// without releasing the permits it holds. -+ /// -+ /// Permits held by both `self` and `other` are released when `self` drops. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if permits from different [`Semaphore`] instances -+ /// are merged. -+ #[track_caller] -+ pub fn merge(&mut self, mut other: Self) { -+ assert!( -+ Arc::ptr_eq(&self.sem, &other.sem), -+ "merging permits from different semaphore instances" -+ ); -+ self.permits += other.permits; -+ other.permits = 0; -+ } -+ -+ /// Returns the [`Semaphore`] from which this permit was acquired. -+ pub fn semaphore(&self) -> &Arc { -+ &self.sem -+ } - } - --impl<'a> Drop for SemaphorePermit<'_> { -+impl Drop for SemaphorePermit<'_> { - fn drop(&mut self) { - self.sem.add_permits(self.permits as usize); - } -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/task/atomic_waker.rs b/KubeOS-Rust/vendor/tokio/src/sync/task/atomic_waker.rs -index e1330fb1..13aba354 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/task/atomic_waker.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/task/atomic_waker.rs -@@ -1,7 +1,8 @@ - #![cfg_attr(any(loom, not(feature = "sync")), allow(dead_code, unreachable_pub))] - - use crate::loom::cell::UnsafeCell; --use crate::loom::sync::atomic::{self, AtomicUsize}; -+use crate::loom::hint; -+use crate::loom::sync::atomic::AtomicUsize; - - use std::fmt; - use std::panic::{resume_unwind, AssertUnwindSafe, RefUnwindSafe, UnwindSafe}; -@@ -281,9 +282,7 @@ impl AtomicWaker { - waker.wake(); - - // This is equivalent to a spin lock, so use a spin hint. -- // TODO: once we bump MSRV to 1.49+, use `hint::spin_loop` instead. -- #[allow(deprecated)] -- atomic::spin_loop_hint(); -+ hint::spin_loop(); - } - state => { - // In this case, a concurrent thread is holding the -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/tests/atomic_waker.rs b/KubeOS-Rust/vendor/tokio/src/sync/tests/atomic_waker.rs -index b167a5d8..8ebfb915 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/tests/atomic_waker.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/tests/atomic_waker.rs -@@ -4,7 +4,7 @@ use tokio_test::task; - use std::task::Waker; - - trait AssertSend: Send {} --trait AssertSync: Send {} -+trait AssertSync: Sync {} - - impl AssertSend for AtomicWaker {} - impl AssertSync for AtomicWaker {} -@@ -12,6 +12,9 @@ impl AssertSync for AtomicWaker {} - impl AssertSend for Waker {} - impl AssertSync for Waker {} - -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+ - #[test] - fn basic_usage() { - let mut waker = task::spawn(AtomicWaker::new()); -@@ -34,6 +37,7 @@ fn wake_without_register() { - } - - #[test] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - fn atomic_waker_panic_safe() { - use std::panic; - use std::ptr; -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/tests/loom_notify.rs b/KubeOS-Rust/vendor/tokio/src/sync/tests/loom_notify.rs -index d484a758..a4ded1d3 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/tests/loom_notify.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/tests/loom_notify.rs -@@ -4,6 +4,11 @@ use loom::future::block_on; - use loom::sync::Arc; - use loom::thread; - -+use tokio_test::{assert_pending, assert_ready}; -+ -+/// `util::wake_list::NUM_WAKERS` -+const WAKE_LIST_SIZE: usize = 32; -+ - #[test] - fn notify_one() { - loom::model(|| { -@@ -138,3 +143,189 @@ fn notify_drop() { - th2.join().unwrap(); - }); - } -+ -+/// Polls two `Notified` futures and checks if poll results are consistent -+/// with each other. If the first future is notified by a `notify_waiters` -+/// call, then the second one must be notified as well. -+#[test] -+fn notify_waiters_poll_consistency() { -+ fn notify_waiters_poll_consistency_variant(poll_setting: [bool; 2]) { -+ let notify = Arc::new(Notify::new()); -+ let mut notified = [ -+ tokio_test::task::spawn(notify.notified()), -+ tokio_test::task::spawn(notify.notified()), -+ ]; -+ for i in 0..2 { -+ if poll_setting[i] { -+ assert_pending!(notified[i].poll()); -+ } -+ } -+ -+ let tx = notify.clone(); -+ let th = thread::spawn(move || { -+ tx.notify_waiters(); -+ }); -+ -+ let res1 = notified[0].poll(); -+ let res2 = notified[1].poll(); -+ -+ // If res1 is ready, then res2 must also be ready. -+ assert!(res1.is_pending() || res2.is_ready()); -+ -+ th.join().unwrap(); -+ } -+ -+ // We test different scenarios in which pending futures had or had not -+ // been polled before the call to `notify_waiters`. -+ loom::model(|| notify_waiters_poll_consistency_variant([false, false])); -+ loom::model(|| notify_waiters_poll_consistency_variant([true, false])); -+ loom::model(|| notify_waiters_poll_consistency_variant([false, true])); -+ loom::model(|| notify_waiters_poll_consistency_variant([true, true])); -+} -+ -+/// Polls two `Notified` futures and checks if poll results are consistent -+/// with each other. If the first future is notified by a `notify_waiters` -+/// call, then the second one must be notified as well. -+/// -+/// Here we also add other `Notified` futures in between to force the two -+/// tested futures to end up in different chunks. -+#[test] -+fn notify_waiters_poll_consistency_many() { -+ fn notify_waiters_poll_consistency_many_variant(order: [usize; 2]) { -+ let notify = Arc::new(Notify::new()); -+ -+ let mut futs = (0..WAKE_LIST_SIZE + 1) -+ .map(|_| tokio_test::task::spawn(notify.notified())) -+ .collect::>(); -+ -+ assert_pending!(futs[order[0]].poll()); -+ for i in 2..futs.len() { -+ assert_pending!(futs[i].poll()); -+ } -+ assert_pending!(futs[order[1]].poll()); -+ -+ let tx = notify.clone(); -+ let th = thread::spawn(move || { -+ tx.notify_waiters(); -+ }); -+ -+ let res1 = futs[0].poll(); -+ let res2 = futs[1].poll(); -+ -+ // If res1 is ready, then res2 must also be ready. -+ assert!(res1.is_pending() || res2.is_ready()); -+ -+ th.join().unwrap(); -+ } -+ -+ // We test different scenarios in which futures are polled in different order. -+ loom::model(|| notify_waiters_poll_consistency_many_variant([0, 1])); -+ loom::model(|| notify_waiters_poll_consistency_many_variant([1, 0])); -+} -+ -+/// Checks if a call to `notify_waiters` is observed as atomic when combined -+/// with a concurrent call to `notify_one`. -+#[test] -+fn notify_waiters_is_atomic() { -+ fn notify_waiters_is_atomic_variant(tested_fut_index: usize) { -+ let notify = Arc::new(Notify::new()); -+ -+ let mut futs = (0..WAKE_LIST_SIZE + 1) -+ .map(|_| tokio_test::task::spawn(notify.notified())) -+ .collect::>(); -+ -+ for fut in &mut futs { -+ assert_pending!(fut.poll()); -+ } -+ -+ let tx = notify.clone(); -+ let th = thread::spawn(move || { -+ tx.notify_waiters(); -+ }); -+ -+ block_on(async { -+ // If awaiting one of the futures completes, then we should be -+ // able to assume that all pending futures are notified. Therefore -+ // a notification from a subsequent `notify_one` call should not -+ // be consumed by an old future. -+ futs.remove(tested_fut_index).await; -+ -+ let mut new_fut = tokio_test::task::spawn(notify.notified()); -+ assert_pending!(new_fut.poll()); -+ -+ notify.notify_one(); -+ -+ // `new_fut` must consume the notification from `notify_one`. -+ assert_ready!(new_fut.poll()); -+ }); -+ -+ th.join().unwrap(); -+ } -+ -+ // We test different scenarios in which the tested future is at the beginning -+ // or at the end of the waiters queue used by `Notify`. -+ loom::model(|| notify_waiters_is_atomic_variant(0)); -+ loom::model(|| notify_waiters_is_atomic_variant(32)); -+} -+ -+/// Checks if a single call to `notify_waiters` does not get through two `Notified` -+/// futures created and awaited sequentially like this: -+/// ```ignore -+/// notify.notified().await; -+/// notify.notified().await; -+/// ``` -+#[test] -+fn notify_waiters_sequential_notified_await() { -+ use crate::sync::oneshot; -+ -+ loom::model(|| { -+ let notify = Arc::new(Notify::new()); -+ -+ let (tx_fst, rx_fst) = oneshot::channel(); -+ let (tx_snd, rx_snd) = oneshot::channel(); -+ -+ let receiver = thread::spawn({ -+ let notify = notify.clone(); -+ move || { -+ block_on(async { -+ // Poll the first `Notified` to put it as the first waiter -+ // in the queue. -+ let mut first_notified = tokio_test::task::spawn(notify.notified()); -+ assert_pending!(first_notified.poll()); -+ -+ // Create additional waiters to force `notify_waiters` to -+ // release the lock at least once. -+ let _task_pile = (0..WAKE_LIST_SIZE + 1) -+ .map(|_| { -+ let mut fut = tokio_test::task::spawn(notify.notified()); -+ assert_pending!(fut.poll()); -+ fut -+ }) -+ .collect::>(); -+ -+ // We are ready for the notify_waiters call. -+ tx_fst.send(()).unwrap(); -+ -+ first_notified.await; -+ -+ // Poll the second `Notified` future to try to insert -+ // it to the waiters queue. -+ let mut second_notified = tokio_test::task::spawn(notify.notified()); -+ assert_pending!(second_notified.poll()); -+ -+ // Wait for the `notify_waiters` to end and check if we -+ // are woken up. -+ rx_snd.await.unwrap(); -+ assert_pending!(second_notified.poll()); -+ }); -+ } -+ }); -+ -+ // Wait for the signal and call `notify_waiters`. -+ block_on(rx_fst).unwrap(); -+ notify.notify_waiters(); -+ tx_snd.send(()).unwrap(); -+ -+ receiver.join().unwrap(); -+ }); -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/tests/loom_watch.rs b/KubeOS-Rust/vendor/tokio/src/sync/tests/loom_watch.rs -index c575b5b6..51589cd8 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/tests/loom_watch.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/tests/loom_watch.rs -@@ -2,6 +2,7 @@ use crate::sync::watch; - - use loom::future::block_on; - use loom::thread; -+use std::sync::Arc; - - #[test] - fn smoke() { -@@ -34,3 +35,56 @@ fn smoke() { - th.join().unwrap(); - }) - } -+ -+#[test] -+fn wait_for_test() { -+ loom::model(move || { -+ let (tx, mut rx) = watch::channel(false); -+ -+ let tx_arc = Arc::new(tx); -+ let tx1 = tx_arc.clone(); -+ let tx2 = tx_arc.clone(); -+ -+ let th1 = thread::spawn(move || { -+ for _ in 0..2 { -+ tx1.send_modify(|_x| {}); -+ } -+ }); -+ -+ let th2 = thread::spawn(move || { -+ tx2.send(true).unwrap(); -+ }); -+ -+ assert_eq!(*block_on(rx.wait_for(|x| *x)).unwrap(), true); -+ -+ th1.join().unwrap(); -+ th2.join().unwrap(); -+ }); -+} -+ -+#[test] -+fn wait_for_returns_correct_value() { -+ loom::model(move || { -+ let (tx, mut rx) = watch::channel(0); -+ -+ let jh = thread::spawn(move || { -+ tx.send(1).unwrap(); -+ tx.send(2).unwrap(); -+ tx.send(3).unwrap(); -+ }); -+ -+ // Stop at the first value we are called at. -+ let mut stopped_at = usize::MAX; -+ let returned = *block_on(rx.wait_for(|x| { -+ stopped_at = *x; -+ true -+ })) -+ .unwrap(); -+ -+ // Check that it returned the same value as the one we returned -+ // `true` for. -+ assert_eq!(stopped_at, returned); -+ -+ jh.join().unwrap(); -+ }); -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/tests/notify.rs b/KubeOS-Rust/vendor/tokio/src/sync/tests/notify.rs -index 8c9a5735..4b598959 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/tests/notify.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/tests/notify.rs -@@ -4,6 +4,9 @@ use std::mem::ManuallyDrop; - use std::sync::Arc; - use std::task::{Context, RawWaker, RawWakerVTable, Waker}; - -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+ - #[test] - fn notify_clones_waker_before_lock() { - const VTABLE: &RawWakerVTable = &RawWakerVTable::new(clone_w, wake, wake_by_ref, drop_w); -@@ -42,3 +45,76 @@ fn notify_clones_waker_before_lock() { - // The result doesn't matter, we're just testing that we don't deadlock. - let _ = future.poll(&mut cx); - } -+ -+#[cfg(panic = "unwind")] -+#[test] -+fn notify_waiters_handles_panicking_waker() { -+ use futures::task::ArcWake; -+ -+ let notify = Arc::new(Notify::new()); -+ -+ struct PanickingWaker(Arc); -+ -+ impl ArcWake for PanickingWaker { -+ fn wake_by_ref(_arc_self: &Arc) { -+ panic!("waker panicked"); -+ } -+ } -+ -+ let bad_fut = notify.notified(); -+ pin!(bad_fut); -+ -+ let waker = futures::task::waker(Arc::new(PanickingWaker(notify.clone()))); -+ let mut cx = Context::from_waker(&waker); -+ let _ = bad_fut.poll(&mut cx); -+ -+ let mut futs = Vec::new(); -+ for _ in 0..32 { -+ let mut fut = tokio_test::task::spawn(notify.notified()); -+ assert!(fut.poll().is_pending()); -+ futs.push(fut); -+ } -+ -+ assert!(std::panic::catch_unwind(|| { -+ notify.notify_waiters(); -+ }) -+ .is_err()); -+ -+ for mut fut in futs { -+ assert!(fut.poll().is_ready()); -+ } -+} -+ -+#[test] -+fn notify_simple() { -+ let notify = Notify::new(); -+ -+ let mut fut1 = tokio_test::task::spawn(notify.notified()); -+ assert!(fut1.poll().is_pending()); -+ -+ let mut fut2 = tokio_test::task::spawn(notify.notified()); -+ assert!(fut2.poll().is_pending()); -+ -+ notify.notify_waiters(); -+ -+ assert!(fut1.poll().is_ready()); -+ assert!(fut2.poll().is_ready()); -+} -+ -+#[test] -+#[cfg(not(tokio_wasm))] -+fn watch_test() { -+ let rt = crate::runtime::Builder::new_current_thread() -+ .build() -+ .unwrap(); -+ -+ rt.block_on(async { -+ let (tx, mut rx) = crate::sync::watch::channel(()); -+ -+ crate::spawn(async move { -+ let _ = tx.send(()); -+ }); -+ -+ let _ = rx.changed().await; -+ }); -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/tests/semaphore_batch.rs b/KubeOS-Rust/vendor/tokio/src/sync/tests/semaphore_batch.rs -index 9342cd1c..85089cd2 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/tests/semaphore_batch.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/tests/semaphore_batch.rs -@@ -1,6 +1,11 @@ - use crate::sync::batch_semaphore::Semaphore; - use tokio_test::*; - -+const MAX_PERMITS: usize = crate::sync::Semaphore::MAX_PERMITS; -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+ - #[test] - fn poll_acquire_one_available() { - let s = Semaphore::new(100); -@@ -165,11 +170,16 @@ fn poll_acquire_one_zero_permits() { - assert_ready_ok!(acquire.poll()); - } - -+#[test] -+fn max_permits_doesnt_panic() { -+ Semaphore::new(MAX_PERMITS); -+} -+ - #[test] - #[should_panic] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - fn validates_max_permits() { -- use std::usize; -- Semaphore::new((usize::MAX >> 2) + 1); -+ Semaphore::new(MAX_PERMITS + 1); - } - - #[test] -@@ -248,3 +258,32 @@ fn cancel_acquire_releases_permits() { - assert_eq!(6, s.available_permits()); - assert_ok!(s.try_acquire(6)); - } -+ -+#[test] -+fn release_permits_at_drop() { -+ use crate::sync::semaphore::*; -+ use futures::task::ArcWake; -+ use std::future::Future; -+ use std::sync::Arc; -+ -+ let sem = Arc::new(Semaphore::new(1)); -+ -+ struct ReleaseOnDrop(Option); -+ -+ impl ArcWake for ReleaseOnDrop { -+ fn wake_by_ref(_arc_self: &Arc) {} -+ } -+ -+ let mut fut = Box::pin(async { -+ let _permit = sem.acquire().await.unwrap(); -+ }); -+ -+ // Second iteration shouldn't deadlock. -+ for _ in 0..=1 { -+ let waker = futures::task::waker(Arc::new(ReleaseOnDrop( -+ sem.clone().try_acquire_owned().ok(), -+ ))); -+ let mut cx = std::task::Context::from_waker(&waker); -+ assert!(fut.as_mut().poll(&mut cx).is_pending()); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/sync/watch.rs b/KubeOS-Rust/vendor/tokio/src/sync/watch.rs -index 7e45c116..449711ad 100644 ---- a/KubeOS-Rust/vendor/tokio/src/sync/watch.rs -+++ b/KubeOS-Rust/vendor/tokio/src/sync/watch.rs -@@ -9,10 +9,10 @@ - //! # Usage - //! - //! [`channel`] returns a [`Sender`] / [`Receiver`] pair. These are the producer --//! and sender halves of the channel. The channel is created with an initial -+//! and consumer halves of the channel. The channel is created with an initial - //! value. The **latest** value stored in the channel is accessed with - //! [`Receiver::borrow()`]. Awaiting [`Receiver::changed()`] waits for a new --//! value to sent by the [`Sender`] half. -+//! value to be sent by the [`Sender`] half. - //! - //! # Examples - //! -@@ -20,15 +20,15 @@ - //! use tokio::sync::watch; - //! - //! # async fn dox() -> Result<(), Box> { --//! let (tx, mut rx) = watch::channel("hello"); -+//! let (tx, mut rx) = watch::channel("hello"); - //! --//! tokio::spawn(async move { --//! while rx.changed().await.is_ok() { --//! println!("received = {:?}", *rx.borrow()); --//! } --//! }); -+//! tokio::spawn(async move { -+//! while rx.changed().await.is_ok() { -+//! println!("received = {:?}", *rx.borrow()); -+//! } -+//! }); - //! --//! tx.send("world")?; -+//! tx.send("world")?; - //! # Ok(()) - //! # } - //! ``` -@@ -39,6 +39,9 @@ - //! when all [`Receiver`] handles have been dropped. This indicates that there - //! is no further interest in the values being produced and work can be stopped. - //! -+//! The value in the channel will not be dropped until the sender and all receivers -+//! have been dropped. -+//! - //! # Thread safety - //! - //! Both [`Sender`] and [`Receiver`] are thread safe. They can be moved to other -@@ -58,8 +61,10 @@ use crate::sync::notify::Notify; - use crate::loom::sync::atomic::AtomicUsize; - use crate::loom::sync::atomic::Ordering::Relaxed; - use crate::loom::sync::{Arc, RwLock, RwLockReadGuard}; -+use std::fmt; - use std::mem; - use std::ops; -+use std::panic; - - /// Receives values from the associated [`Sender`](struct@Sender). - /// -@@ -89,14 +94,82 @@ pub struct Sender { - /// Returns a reference to the inner value. - /// - /// Outstanding borrows hold a read lock on the inner value. This means that --/// long lived borrows could cause the produce half to block. It is recommended --/// to keep the borrow as short lived as possible. -+/// long-lived borrows could cause the producer half to block. It is recommended -+/// to keep the borrow as short-lived as possible. Additionally, if you are -+/// running in an environment that allows `!Send` futures, you must ensure that -+/// the returned `Ref` type is never held alive across an `.await` point, -+/// otherwise, it can lead to a deadlock. -+/// -+/// The priority policy of the lock is dependent on the underlying lock -+/// implementation, and this type does not guarantee that any particular policy -+/// will be used. In particular, a producer which is waiting to acquire the lock -+/// in `send` might or might not block concurrent calls to `borrow`, e.g.: -+/// -+///

Potential deadlock example -+/// -+/// ```text -+/// // Task 1 (on thread A) | // Task 2 (on thread B) -+/// let _ref1 = rx.borrow(); | -+/// | // will block -+/// | let _ = tx.send(()); -+/// // may deadlock | -+/// let _ref2 = rx.borrow(); | -+/// ``` -+///
- #[derive(Debug)] - pub struct Ref<'a, T> { - inner: RwLockReadGuard<'a, T>, -+ has_changed: bool, -+} -+ -+impl<'a, T> Ref<'a, T> { -+ /// Indicates if the borrowed value is considered as _changed_ since the last -+ /// time it has been marked as seen. -+ /// -+ /// Unlike [`Receiver::has_changed()`], this method does not fail if the channel is closed. -+ /// -+ /// When borrowed from the [`Sender`] this function will always return `false`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::watch; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, mut rx) = watch::channel("hello"); -+ /// -+ /// tx.send("goodbye").unwrap(); -+ /// // The sender does never consider the value as changed. -+ /// assert!(!tx.borrow().has_changed()); -+ /// -+ /// // Drop the sender immediately, just for testing purposes. -+ /// drop(tx); -+ /// -+ /// // Even if the sender has already been dropped... -+ /// assert!(rx.has_changed().is_err()); -+ /// // ...the modified value is still readable and detected as changed. -+ /// assert_eq!(*rx.borrow(), "goodbye"); -+ /// assert!(rx.borrow().has_changed()); -+ /// -+ /// // Read the changed value and mark it as seen. -+ /// { -+ /// let received = rx.borrow_and_update(); -+ /// assert_eq!(*received, "goodbye"); -+ /// assert!(received.has_changed()); -+ /// // Release the read lock when leaving this scope. -+ /// } -+ /// -+ /// // Now the value has already been marked as seen and could -+ /// // never be modified again (after the sender has been dropped). -+ /// assert!(!rx.borrow().has_changed()); -+ /// } -+ /// ``` -+ pub fn has_changed(&self) -> bool { -+ self.has_changed -+ } - } - --#[derive(Debug)] - struct Shared { - /// The most recent value. - value: RwLock, -@@ -111,12 +184,24 @@ struct Shared { - ref_count_rx: AtomicUsize, - - /// Notifies waiting receivers that the value changed. -- notify_rx: Notify, -+ notify_rx: big_notify::BigNotify, - - /// Notifies any task listening for `Receiver` dropped events. - notify_tx: Notify, - } - -+impl fmt::Debug for Shared { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ let state = self.state.load(); -+ f.debug_struct("Shared") -+ .field("value", &self.value) -+ .field("version", &state.version()) -+ .field("is_closed", &state.is_closed()) -+ .field("ref_count_rx", &self.ref_count_rx) -+ .finish() -+ } -+} -+ - pub mod error { - //! Watch error types. - -@@ -137,7 +222,7 @@ pub mod error { - impl std::error::Error for SendError {} - - /// Error produced when receiving a change notification. -- #[derive(Debug)] -+ #[derive(Debug, Clone)] - pub struct RecvError(pub(super) ()); - - // ===== impl RecvError ===== -@@ -151,6 +236,62 @@ pub mod error { - impl std::error::Error for RecvError {} - } - -+mod big_notify { -+ use super::*; -+ use crate::sync::notify::Notified; -+ -+ // To avoid contention on the lock inside the `Notify`, we store multiple -+ // copies of it. Then, we use either circular access or randomness to spread -+ // out threads over different `Notify` objects. -+ // -+ // Some simple benchmarks show that randomness performs slightly better than -+ // circular access (probably due to contention on `next`), so we prefer to -+ // use randomness when Tokio is compiled with a random number generator. -+ // -+ // When the random number generator is not available, we fall back to -+ // circular access. -+ -+ pub(super) struct BigNotify { -+ #[cfg(not(all(not(loom), feature = "sync", any(feature = "rt", feature = "macros"))))] -+ next: AtomicUsize, -+ inner: [Notify; 8], -+ } -+ -+ impl BigNotify { -+ pub(super) fn new() -> Self { -+ Self { -+ #[cfg(not(all( -+ not(loom), -+ feature = "sync", -+ any(feature = "rt", feature = "macros") -+ )))] -+ next: AtomicUsize::new(0), -+ inner: Default::default(), -+ } -+ } -+ -+ pub(super) fn notify_waiters(&self) { -+ for notify in &self.inner { -+ notify.notify_waiters(); -+ } -+ } -+ -+ /// This function implements the case where randomness is not available. -+ #[cfg(not(all(not(loom), feature = "sync", any(feature = "rt", feature = "macros"))))] -+ pub(super) fn notified(&self) -> Notified<'_> { -+ let i = self.next.fetch_add(1, Relaxed) % 8; -+ self.inner[i].notified() -+ } -+ -+ /// This function implements the case where randomness is available. -+ #[cfg(all(not(loom), feature = "sync", any(feature = "rt", feature = "macros")))] -+ pub(super) fn notified(&self) -> Notified<'_> { -+ let i = crate::runtime::context::thread_rng_n(8) as usize; -+ self.inner[i].notified() -+ } -+ } -+} -+ - use self::state::{AtomicState, Version}; - mod state { - use crate::loom::sync::atomic::AtomicUsize; -@@ -250,7 +391,7 @@ pub fn channel(init: T) -> (Sender, Receiver) { - value: RwLock::new(init), - state: AtomicState::new(), - ref_count_rx: AtomicUsize::new(1), -- notify_rx: Notify::new(), -+ notify_rx: big_notify::BigNotify::new(), - notify_tx: Notify::new(), - }); - -@@ -281,9 +422,29 @@ impl Receiver { - /// [`changed`] may return immediately even if you have already seen the - /// value with a call to `borrow`. - /// -- /// Outstanding borrows hold a read lock. This means that long lived borrows -- /// could cause the send half to block. It is recommended to keep the borrow -- /// as short lived as possible. -+ /// Outstanding borrows hold a read lock on the inner value. This means that -+ /// long-lived borrows could cause the producer half to block. It is recommended -+ /// to keep the borrow as short-lived as possible. Additionally, if you are -+ /// running in an environment that allows `!Send` futures, you must ensure that -+ /// the returned `Ref` type is never held alive across an `.await` point, -+ /// otherwise, it can lead to a deadlock. -+ /// -+ /// The priority policy of the lock is dependent on the underlying lock -+ /// implementation, and this type does not guarantee that any particular policy -+ /// will be used. In particular, a producer which is waiting to acquire the lock -+ /// in `send` might or might not block concurrent calls to `borrow`, e.g.: -+ /// -+ ///
Potential deadlock example -+ /// -+ /// ```text -+ /// // Task 1 (on thread A) | // Task 2 (on thread B) -+ /// let _ref1 = rx.borrow(); | -+ /// | // will block -+ /// | let _ = tx.send(()); -+ /// // may deadlock | -+ /// let _ref2 = rx.borrow(); | -+ /// ``` -+ ///
- /// - /// [`changed`]: Receiver::changed - /// -@@ -297,25 +458,101 @@ impl Receiver { - /// ``` - pub fn borrow(&self) -> Ref<'_, T> { - let inner = self.shared.value.read().unwrap(); -- Ref { inner } -+ -+ // After obtaining a read-lock no concurrent writes could occur -+ // and the loaded version matches that of the borrowed reference. -+ let new_version = self.shared.state.load().version(); -+ let has_changed = self.version != new_version; -+ -+ Ref { inner, has_changed } - } - -- /// Returns a reference to the most recently sent value and mark that value -+ /// Returns a reference to the most recently sent value and marks that value - /// as seen. - /// -- /// This method marks the value as seen, so [`changed`] will not return -- /// immediately if the newest value is one previously returned by -- /// `borrow_and_update`. -+ /// This method marks the current value as seen. Subsequent calls to [`changed`] -+ /// will not return immediately until the [`Sender`] has modified the shared -+ /// value again. -+ /// -+ /// Outstanding borrows hold a read lock on the inner value. This means that -+ /// long-lived borrows could cause the producer half to block. It is recommended -+ /// to keep the borrow as short-lived as possible. Additionally, if you are -+ /// running in an environment that allows `!Send` futures, you must ensure that -+ /// the returned `Ref` type is never held alive across an `.await` point, -+ /// otherwise, it can lead to a deadlock. -+ /// -+ /// The priority policy of the lock is dependent on the underlying lock -+ /// implementation, and this type does not guarantee that any particular policy -+ /// will be used. In particular, a producer which is waiting to acquire the lock -+ /// in `send` might or might not block concurrent calls to `borrow`, e.g.: - /// -- /// Outstanding borrows hold a read lock. This means that long lived borrows -- /// could cause the send half to block. It is recommended to keep the borrow -- /// as short lived as possible. -+ ///
Potential deadlock example -+ /// -+ /// ```text -+ /// // Task 1 (on thread A) | // Task 2 (on thread B) -+ /// let _ref1 = rx1.borrow_and_update(); | -+ /// | // will block -+ /// | let _ = tx.send(()); -+ /// // may deadlock | -+ /// let _ref2 = rx2.borrow_and_update(); | -+ /// ``` -+ ///
- /// - /// [`changed`]: Receiver::changed - pub fn borrow_and_update(&mut self) -> Ref<'_, T> { - let inner = self.shared.value.read().unwrap(); -- self.version = self.shared.state.load().version(); -- Ref { inner } -+ -+ // After obtaining a read-lock no concurrent writes could occur -+ // and the loaded version matches that of the borrowed reference. -+ let new_version = self.shared.state.load().version(); -+ let has_changed = self.version != new_version; -+ -+ // Mark the shared value as seen by updating the version -+ self.version = new_version; -+ -+ Ref { inner, has_changed } -+ } -+ -+ /// Checks if this channel contains a message that this receiver has not yet -+ /// seen. The new value is not marked as seen. -+ /// -+ /// Although this method is called `has_changed`, it does not check new -+ /// messages for equality, so this call will return true even if the new -+ /// message is equal to the old message. -+ /// -+ /// Returns an error if the channel has been closed. -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::watch; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let (tx, mut rx) = watch::channel("hello"); -+ /// -+ /// tx.send("goodbye").unwrap(); -+ /// -+ /// assert!(rx.has_changed().unwrap()); -+ /// assert_eq!(*rx.borrow_and_update(), "goodbye"); -+ /// -+ /// // The value has been marked as seen -+ /// assert!(!rx.has_changed().unwrap()); -+ /// -+ /// drop(tx); -+ /// // The `tx` handle has been dropped -+ /// assert!(rx.has_changed().is_err()); -+ /// } -+ /// ``` -+ pub fn has_changed(&self) -> Result { -+ // Load the version from the state -+ let state = self.shared.state.load(); -+ if state.is_closed() { -+ // The sender has dropped. -+ return Err(error::RecvError(())); -+ } -+ let new_version = state.version(); -+ -+ Ok(self.version != new_version) - } - - /// Waits for a change notification, then marks the newest value as seen. -@@ -358,21 +595,112 @@ impl Receiver { - /// } - /// ``` - pub async fn changed(&mut self) -> Result<(), error::RecvError> { -+ changed_impl(&self.shared, &mut self.version).await -+ } -+ -+ /// Waits for a value that satisifes the provided condition. -+ /// -+ /// This method will call the provided closure whenever something is sent on -+ /// the channel. Once the closure returns `true`, this method will return a -+ /// reference to the value that was passed to the closure. -+ /// -+ /// Before `wait_for` starts waiting for changes, it will call the closure -+ /// on the current value. If the closure returns `true` when given the -+ /// current value, then `wait_for` will immediately return a reference to -+ /// the current value. This is the case even if the current value is already -+ /// considered seen. -+ /// -+ /// The watch channel only keeps track of the most recent value, so if -+ /// several messages are sent faster than `wait_for` is able to call the -+ /// closure, then it may skip some updates. Whenever the closure is called, -+ /// it will be called with the most recent value. -+ /// -+ /// When this function returns, the value that was passed to the closure -+ /// when it returned `true` will be considered seen. -+ /// -+ /// If the channel is closed, then `wait_for` will return a `RecvError`. -+ /// Once this happens, no more messages can ever be sent on the channel. -+ /// When an error is returned, it is guaranteed that the closure has been -+ /// called on the last value, and that it returned `false` for that value. -+ /// (If the closure returned `true`, then the last value would have been -+ /// returned instead of the error.) -+ /// -+ /// Like the `borrow` method, the returned borrow holds a read lock on the -+ /// inner value. This means that long-lived borrows could cause the producer -+ /// half to block. It is recommended to keep the borrow as short-lived as -+ /// possible. See the documentation of `borrow` for more information on -+ /// this. -+ /// -+ /// [`Receiver::changed()`]: crate::sync::watch::Receiver::changed -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::watch; -+ /// -+ /// #[tokio::main] -+ /// -+ /// async fn main() { -+ /// let (tx, _rx) = watch::channel("hello"); -+ /// -+ /// tx.send("goodbye").unwrap(); -+ /// -+ /// // here we subscribe to a second receiver -+ /// // now in case of using `changed` we would have -+ /// // to first check the current value and then wait -+ /// // for changes or else `changed` would hang. -+ /// let mut rx2 = tx.subscribe(); -+ /// -+ /// // in place of changed we have use `wait_for` -+ /// // which would automatically check the current value -+ /// // and wait for changes until the closure returns true. -+ /// assert!(rx2.wait_for(|val| *val == "goodbye").await.is_ok()); -+ /// assert_eq!(*rx2.borrow(), "goodbye"); -+ /// } -+ /// ``` -+ pub async fn wait_for( -+ &mut self, -+ mut f: impl FnMut(&T) -> bool, -+ ) -> Result, error::RecvError> { -+ let mut closed = false; - loop { -- // In order to avoid a race condition, we first request a notification, -- // **then** check the current value's version. If a new version exists, -- // the notification request is dropped. -- let notified = self.shared.notify_rx.notified(); -+ { -+ let inner = self.shared.value.read().unwrap(); -+ -+ let new_version = self.shared.state.load().version(); -+ let has_changed = self.version != new_version; -+ self.version = new_version; - -- if let Some(ret) = maybe_changed(&self.shared, &mut self.version) { -- return ret; -+ if (!closed || has_changed) && f(&inner) { -+ return Ok(Ref { inner, has_changed }); -+ } - } - -- notified.await; -- // loop around again in case the wake-up was spurious -+ if closed { -+ return Err(error::RecvError(())); -+ } -+ -+ // Wait for the value to change. -+ closed = changed_impl(&self.shared, &mut self.version).await.is_err(); - } - } - -+ /// Returns `true` if receivers belong to the same channel. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// let (tx, rx) = tokio::sync::watch::channel(true); -+ /// let rx2 = rx.clone(); -+ /// assert!(rx.same_channel(&rx2)); -+ /// -+ /// let (tx3, rx3) = tokio::sync::watch::channel(true); -+ /// assert!(!rx3.same_channel(&rx2)); -+ /// ``` -+ pub fn same_channel(&self, other: &Self) -> bool { -+ Arc::ptr_eq(&self.shared, &other.shared) -+ } -+ - cfg_process_driver! { - pub(crate) fn try_has_changed(&mut self) -> Option> { - maybe_changed(&self.shared, &mut self.version) -@@ -402,6 +730,25 @@ fn maybe_changed( - None - } - -+async fn changed_impl( -+ shared: &Shared, -+ version: &mut Version, -+) -> Result<(), error::RecvError> { -+ loop { -+ // In order to avoid a race condition, we first request a notification, -+ // **then** check the current value's version. If a new version exists, -+ // the notification request is dropped. -+ let notified = shared.notify_rx.notified(); -+ -+ if let Some(ret) = maybe_changed(shared, version) { -+ return ret; -+ } -+ -+ notified.await; -+ // loop around again in case the wake-up was spurious -+ } -+} -+ - impl Clone for Receiver { - fn clone(&self) -> Self { - let version = self.version; -@@ -425,8 +772,22 @@ impl Drop for Receiver { - impl Sender { - /// Sends a new value via the channel, notifying all receivers. - /// -- /// This method fails if the channel has been closed, which happens when -- /// every receiver has been dropped. -+ /// This method fails if the channel is closed, which is the case when -+ /// every receiver has been dropped. It is possible to reopen the channel -+ /// using the [`subscribe`] method. However, when `send` fails, the value -+ /// isn't made available for future receivers (but returned with the -+ /// [`SendError`]). -+ /// -+ /// To always make a new value available for future receivers, even if no -+ /// receiver currently exists, one of the other send methods -+ /// ([`send_if_modified`], [`send_modify`], or [`send_replace`]) can be -+ /// used instead. -+ /// -+ /// [`subscribe`]: Sender::subscribe -+ /// [`SendError`]: error::SendError -+ /// [`send_if_modified`]: Sender::send_if_modified -+ /// [`send_modify`]: Sender::send_modify -+ /// [`send_replace`]: Sender::send_replace - pub fn send(&self, value: T) -> Result<(), error::SendError> { - // This is pretty much only useful as a hint anyway, so synchronization isn't critical. - if 0 == self.receiver_count() { -@@ -437,27 +798,129 @@ impl Sender { - Ok(()) - } - -- /// Sends a new value via the channel, notifying all receivers and returning -- /// the previous value in the channel. -+ /// Modifies the watched value **unconditionally** in-place, -+ /// notifying all receivers. - /// -- /// This can be useful for reusing the buffers inside a watched value. -- /// Additionally, this method permits sending values even when there are no -- /// receivers. -+ /// This can be useful for modifying the watched value, without -+ /// having to allocate a new instance. Additionally, this -+ /// method permits sending values even when there are no receivers. -+ /// -+ /// Prefer to use the more versatile function [`Self::send_if_modified()`] -+ /// if the value is only modified conditionally during the mutable borrow -+ /// to prevent unneeded change notifications for unmodified values. -+ /// -+ /// # Panics -+ /// -+ /// This function panics when the invocation of the `modify` closure panics. -+ /// No receivers are notified when panicking. All changes of the watched -+ /// value applied by the closure before panicking will be visible in -+ /// subsequent calls to `borrow`. - /// - /// # Examples - /// - /// ``` - /// use tokio::sync::watch; - /// -- /// let (tx, _rx) = watch::channel(1); -- /// assert_eq!(tx.send_replace(2), 1); -- /// assert_eq!(tx.send_replace(3), 2); -+ /// struct State { -+ /// counter: usize, -+ /// } -+ /// let (state_tx, state_rx) = watch::channel(State { counter: 0 }); -+ /// state_tx.send_modify(|state| state.counter += 1); -+ /// assert_eq!(state_rx.borrow().counter, 1); - /// ``` -- pub fn send_replace(&self, value: T) -> T { -- let old = { -+ pub fn send_modify(&self, modify: F) -+ where -+ F: FnOnce(&mut T), -+ { -+ self.send_if_modified(|value| { -+ modify(value); -+ true -+ }); -+ } -+ -+ /// Modifies the watched value **conditionally** in-place, -+ /// notifying all receivers only if modified. -+ /// -+ /// This can be useful for modifying the watched value, without -+ /// having to allocate a new instance. Additionally, this -+ /// method permits sending values even when there are no receivers. -+ /// -+ /// The `modify` closure must return `true` if the value has actually -+ /// been modified during the mutable borrow. It should only return `false` -+ /// if the value is guaranteed to be unmodified despite the mutable -+ /// borrow. -+ /// -+ /// Receivers are only notified if the closure returned `true`. If the -+ /// closure has modified the value but returned `false` this results -+ /// in a *silent modification*, i.e. the modified value will be visible -+ /// in subsequent calls to `borrow`, but receivers will not receive -+ /// a change notification. -+ /// -+ /// Returns the result of the closure, i.e. `true` if the value has -+ /// been modified and `false` otherwise. -+ /// -+ /// # Panics -+ /// -+ /// This function panics when the invocation of the `modify` closure panics. -+ /// No receivers are notified when panicking. All changes of the watched -+ /// value applied by the closure before panicking will be visible in -+ /// subsequent calls to `borrow`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::watch; -+ /// -+ /// struct State { -+ /// counter: usize, -+ /// } -+ /// let (state_tx, mut state_rx) = watch::channel(State { counter: 1 }); -+ /// let inc_counter_if_odd = |state: &mut State| { -+ /// if state.counter % 2 == 1 { -+ /// state.counter += 1; -+ /// return true; -+ /// } -+ /// false -+ /// }; -+ /// -+ /// assert_eq!(state_rx.borrow().counter, 1); -+ /// -+ /// assert!(!state_rx.has_changed().unwrap()); -+ /// assert!(state_tx.send_if_modified(inc_counter_if_odd)); -+ /// assert!(state_rx.has_changed().unwrap()); -+ /// assert_eq!(state_rx.borrow_and_update().counter, 2); -+ /// -+ /// assert!(!state_rx.has_changed().unwrap()); -+ /// assert!(!state_tx.send_if_modified(inc_counter_if_odd)); -+ /// assert!(!state_rx.has_changed().unwrap()); -+ /// assert_eq!(state_rx.borrow_and_update().counter, 2); -+ /// ``` -+ pub fn send_if_modified(&self, modify: F) -> bool -+ where -+ F: FnOnce(&mut T) -> bool, -+ { -+ { - // Acquire the write lock and update the value. - let mut lock = self.shared.value.write().unwrap(); -- let old = mem::replace(&mut *lock, value); -+ -+ // Update the value and catch possible panic inside func. -+ let result = panic::catch_unwind(panic::AssertUnwindSafe(|| modify(&mut lock))); -+ match result { -+ Ok(modified) => { -+ if !modified { -+ // Abort, i.e. don't notify receivers if unmodified -+ return false; -+ } -+ // Continue if modified -+ } -+ Err(panicked) => { -+ // Drop the lock to avoid poisoning it. -+ drop(lock); -+ // Forward the panic to the caller. -+ panic::resume_unwind(panicked); -+ // Unreachable -+ } -+ }; - - self.shared.state.increment_version(); - -@@ -467,21 +930,44 @@ impl Sender { - // that receivers are able to figure out the version number of the - // value they are currently looking at. - drop(lock); -+ } - -- old -- }; -- -- // Notify all watchers - self.shared.notify_rx.notify_waiters(); - -- old -+ true -+ } -+ -+ /// Sends a new value via the channel, notifying all receivers and returning -+ /// the previous value in the channel. -+ /// -+ /// This can be useful for reusing the buffers inside a watched value. -+ /// Additionally, this method permits sending values even when there are no -+ /// receivers. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::sync::watch; -+ /// -+ /// let (tx, _rx) = watch::channel(1); -+ /// assert_eq!(tx.send_replace(2), 1); -+ /// assert_eq!(tx.send_replace(3), 2); -+ /// ``` -+ pub fn send_replace(&self, mut value: T) -> T { -+ // swap old watched value with the new one -+ self.send_modify(|old| mem::swap(old, &mut value)); -+ -+ value - } - - /// Returns a reference to the most recently sent value - /// -- /// Outstanding borrows hold a read lock. This means that long lived borrows -- /// could cause the send half to block. It is recommended to keep the borrow -- /// as short lived as possible. -+ /// Outstanding borrows hold a read lock on the inner value. This means that -+ /// long-lived borrows could cause the producer half to block. It is recommended -+ /// to keep the borrow as short-lived as possible. Additionally, if you are -+ /// running in an environment that allows `!Send` futures, you must ensure that -+ /// the returned `Ref` type is never held alive across an `.await` point, -+ /// otherwise, it can lead to a deadlock. - /// - /// # Examples - /// -@@ -493,7 +979,11 @@ impl Sender { - /// ``` - pub fn borrow(&self) -> Ref<'_, T> { - let inner = self.shared.value.read().unwrap(); -- Ref { inner } -+ -+ // The sender/producer always sees the current version -+ let has_changed = false; -+ -+ Ref { inner, has_changed } - } - - /// Checks if the channel has been closed. This happens when all receivers -diff --git a/KubeOS-Rust/vendor/tokio/src/task/blocking.rs b/KubeOS-Rust/vendor/tokio/src/task/blocking.rs -index 825f25f8..46756a9b 100644 ---- a/KubeOS-Rust/vendor/tokio/src/task/blocking.rs -+++ b/KubeOS-Rust/vendor/tokio/src/task/blocking.rs -@@ -70,11 +70,12 @@ cfg_rt_multi_thread! { - /// This function panics if called from a [`current_thread`] runtime. - /// - /// [`current_thread`]: fn@crate::runtime::Builder::new_current_thread -+ #[track_caller] - pub fn block_in_place(f: F) -> R - where - F: FnOnce() -> R, - { -- crate::runtime::thread_pool::block_in_place(f) -+ crate::runtime::scheduler::multi_thread::block_in_place(f) - } - } - -@@ -102,14 +103,24 @@ cfg_rt! { - /// their own. If you want to spawn an ordinary thread, you should use - /// [`thread::spawn`] instead. - /// -- /// Closures spawned using `spawn_blocking` cannot be cancelled. When you shut -- /// down the executor, it will wait indefinitely for all blocking operations to -+ /// Closures spawned using `spawn_blocking` cannot be cancelled abruptly; there -+ /// is no standard low level API to cause a thread to stop running. However, -+ /// a useful pattern is to pass some form of "cancellation token" into -+ /// the thread. This could be an [`AtomicBool`] that the task checks periodically. -+ /// Another approach is to have the thread primarily read or write from a channel, -+ /// and to exit when the channel closes; assuming the other side of the channel is dropped -+ /// when cancellation occurs, this will cause the blocking task thread to exit -+ /// soon after as well. -+ /// -+ /// When you shut down the executor, it will wait indefinitely for all blocking operations to - /// finish. You can use [`shutdown_timeout`] to stop waiting for them after a - /// certain timeout. Be aware that this will still not cancel the tasks — they -- /// are simply allowed to keep running after the method returns. -+ /// are simply allowed to keep running after the method returns. It is possible -+ /// for a blocking task to be cancelled if it has not yet started running, but this -+ /// is not guaranteed. - /// - /// Note that if you are using the single threaded runtime, this function will -- /// still spawn additional threads for blocking operations. The basic -+ /// still spawn additional threads for blocking operations. The current-thread - /// scheduler's single thread is only used for asynchronous code. - /// - /// # Related APIs and patterns for bridging asynchronous and blocking code -@@ -140,6 +151,7 @@ cfg_rt! { - /// [`thread::spawn`]: fn@std::thread::spawn - /// [`shutdown_timeout`]: fn@crate::runtime::Runtime::shutdown_timeout - /// [bridgesync]: https://tokio.rs/tokio/topics/bridging -+ /// [`AtomicBool`]: struct@std::sync::atomic::AtomicBool - /// - /// # Examples - /// -@@ -188,7 +200,7 @@ cfg_rt! { - /// worker.await.unwrap(); - /// # } - /// ``` -- #[cfg_attr(tokio_track_caller, track_caller)] -+ #[track_caller] - pub fn spawn_blocking(f: F) -> JoinHandle - where - F: FnOnce() -> R + Send + 'static, -diff --git a/KubeOS-Rust/vendor/tokio/src/task/builder.rs b/KubeOS-Rust/vendor/tokio/src/task/builder.rs -index f991fc65..91c400c5 100644 ---- a/KubeOS-Rust/vendor/tokio/src/task/builder.rs -+++ b/KubeOS-Rust/vendor/tokio/src/task/builder.rs -@@ -1,9 +1,16 @@ - #![allow(unreachable_pub)] --use crate::{runtime::context, task::JoinHandle}; --use std::future::Future; -+use crate::{ -+ runtime::Handle, -+ task::{JoinHandle, LocalSet}, -+}; -+use std::{future::Future, io}; - - /// Factory which is used to configure the properties of a new task. - /// -+/// **Note**: This is an [unstable API][unstable]. The public API of this type -+/// may break in 1.x releases. See [the documentation on unstable -+/// features][unstable] for details. -+/// - /// Methods can be chained in order to configure it. - /// - /// Currently, there is only one configuration option: -@@ -41,11 +48,17 @@ use std::future::Future; - /// .spawn(async move { - /// // Process each socket concurrently. - /// process(socket).await --/// }); -+/// })?; - /// } - /// } - /// ``` -+/// [unstable]: crate#unstable-features -+/// [`name`]: Builder::name -+/// [`spawn_local`]: Builder::spawn_local -+/// [`spawn`]: Builder::spawn -+/// [`spawn_blocking`]: Builder::spawn_blocking - #[derive(Default, Debug)] -+#[cfg_attr(docsrs, doc(cfg(all(tokio_unstable, feature = "tracing"))))] - pub struct Builder<'a> { - name: Option<&'a str>, - } -@@ -61,42 +74,128 @@ impl<'a> Builder<'a> { - Self { name: Some(name) } - } - -- /// Spawns a task on the executor. -+ /// Spawns a task with this builder's settings on the current runtime. -+ /// -+ /// # Panics -+ /// -+ /// This method panics if called outside of a Tokio runtime. - /// - /// See [`task::spawn`](crate::task::spawn) for - /// more details. -- #[cfg_attr(tokio_track_caller, track_caller)] -- pub fn spawn(self, future: Fut) -> JoinHandle -+ #[track_caller] -+ pub fn spawn(self, future: Fut) -> io::Result> - where - Fut: Future + Send + 'static, - Fut::Output: Send + 'static, - { -- super::spawn::spawn_inner(future, self.name) -+ Ok(super::spawn::spawn_inner(future, self.name)) - } - -- /// Spawns a task on the current thread. -+ /// Spawn a task with this builder's settings on the provided [runtime -+ /// handle]. - /// -- /// See [`task::spawn_local`](crate::task::spawn_local) -- /// for more details. -- #[cfg_attr(tokio_track_caller, track_caller)] -- pub fn spawn_local(self, future: Fut) -> JoinHandle -+ /// See [`Handle::spawn`] for more details. -+ /// -+ /// [runtime handle]: crate::runtime::Handle -+ /// [`Handle::spawn`]: crate::runtime::Handle::spawn -+ #[track_caller] -+ pub fn spawn_on(self, future: Fut, handle: &Handle) -> io::Result> -+ where -+ Fut: Future + Send + 'static, -+ Fut::Output: Send + 'static, -+ { -+ Ok(handle.spawn_named(future, self.name)) -+ } -+ -+ /// Spawns `!Send` a task on the current [`LocalSet`] with this builder's -+ /// settings. -+ /// -+ /// The spawned future will be run on the same thread that called `spawn_local`. -+ /// This may only be called from the context of a [local task set][`LocalSet`]. -+ /// -+ /// # Panics -+ /// -+ /// This function panics if called outside of a [local task set][`LocalSet`]. -+ /// -+ /// See [`task::spawn_local`] for more details. -+ /// -+ /// [`task::spawn_local`]: crate::task::spawn_local -+ /// [`LocalSet`]: crate::task::LocalSet -+ #[track_caller] -+ pub fn spawn_local(self, future: Fut) -> io::Result> - where - Fut: Future + 'static, - Fut::Output: 'static, - { -- super::local::spawn_local_inner(future, self.name) -+ Ok(super::local::spawn_local_inner(future, self.name)) -+ } -+ -+ /// Spawns `!Send` a task on the provided [`LocalSet`] with this builder's -+ /// settings. -+ /// -+ /// See [`LocalSet::spawn_local`] for more details. -+ /// -+ /// [`LocalSet::spawn_local`]: crate::task::LocalSet::spawn_local -+ /// [`LocalSet`]: crate::task::LocalSet -+ #[track_caller] -+ pub fn spawn_local_on( -+ self, -+ future: Fut, -+ local_set: &LocalSet, -+ ) -> io::Result> -+ where -+ Fut: Future + 'static, -+ Fut::Output: 'static, -+ { -+ Ok(local_set.spawn_named(future, self.name)) - } - - /// Spawns blocking code on the blocking threadpool. - /// -+ /// # Panics -+ /// -+ /// This method panics if called outside of a Tokio runtime. -+ /// - /// See [`task::spawn_blocking`](crate::task::spawn_blocking) - /// for more details. -- #[cfg_attr(tokio_track_caller, track_caller)] -- pub fn spawn_blocking(self, function: Function) -> JoinHandle -+ #[track_caller] -+ pub fn spawn_blocking( -+ self, -+ function: Function, -+ ) -> io::Result> - where - Function: FnOnce() -> Output + Send + 'static, - Output: Send + 'static, - { -- context::current().spawn_blocking_inner(function, self.name) -+ let handle = Handle::current(); -+ self.spawn_blocking_on(function, &handle) -+ } -+ -+ /// Spawns blocking code on the provided [runtime handle]'s blocking threadpool. -+ /// -+ /// See [`Handle::spawn_blocking`] for more details. -+ /// -+ /// [runtime handle]: crate::runtime::Handle -+ /// [`Handle::spawn_blocking`]: crate::runtime::Handle::spawn_blocking -+ #[track_caller] -+ pub fn spawn_blocking_on( -+ self, -+ function: Function, -+ handle: &Handle, -+ ) -> io::Result> -+ where -+ Function: FnOnce() -> Output + Send + 'static, -+ Output: Send + 'static, -+ { -+ use crate::runtime::Mandatory; -+ let (join_handle, spawn_result) = handle.inner.blocking_spawner().spawn_blocking_inner( -+ function, -+ Mandatory::NonMandatory, -+ self.name, -+ handle, -+ ); -+ -+ spawn_result?; -+ Ok(join_handle) - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/task/consume_budget.rs b/KubeOS-Rust/vendor/tokio/src/task/consume_budget.rs -new file mode 100644 -index 00000000..1212cfcc ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/task/consume_budget.rs -@@ -0,0 +1,45 @@ -+use std::task::Poll; -+ -+/// Consumes a unit of budget and returns the execution back to the Tokio -+/// runtime *if* the task's coop budget was exhausted. -+/// -+/// The task will only yield if its entire coop budget has been exhausted. -+/// This function can be used in order to insert optional yield points into long -+/// computations that do not use Tokio resources like sockets or semaphores, -+/// without redundantly yielding to the runtime each time. -+/// -+/// **Note**: This is an [unstable API][unstable]. The public API of this type -+/// may break in 1.x releases. See [the documentation on unstable -+/// features][unstable] for details. -+/// -+/// # Examples -+/// -+/// Make sure that a function which returns a sum of (potentially lots of) -+/// iterated values is cooperative. -+/// -+/// ``` -+/// async fn sum_iterator(input: &mut impl std::iter::Iterator) -> i64 { -+/// let mut sum: i64 = 0; -+/// while let Some(i) = input.next() { -+/// sum += i; -+/// tokio::task::consume_budget().await -+/// } -+/// sum -+/// } -+/// ``` -+/// [unstable]: crate#unstable-features -+#[cfg_attr(docsrs, doc(cfg(all(tokio_unstable, feature = "rt"))))] -+pub async fn consume_budget() { -+ let mut status = Poll::Pending; -+ -+ crate::future::poll_fn(move |cx| { -+ if status.is_ready() { -+ return status; -+ } -+ status = crate::runtime::coop::poll_proceed(cx).map(|restore| { -+ restore.made_progress(); -+ }); -+ status -+ }) -+ .await -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/task/join_set.rs b/KubeOS-Rust/vendor/tokio/src/task/join_set.rs -new file mode 100644 -index 00000000..041b06cb ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/task/join_set.rs -@@ -0,0 +1,583 @@ -+//! A collection of tasks spawned on a Tokio runtime. -+//! -+//! This module provides the [`JoinSet`] type, a collection which stores a set -+//! of spawned tasks and allows asynchronously awaiting the output of those -+//! tasks as they complete. See the documentation for the [`JoinSet`] type for -+//! details. -+use std::fmt; -+use std::future::Future; -+use std::pin::Pin; -+use std::task::{Context, Poll}; -+ -+use crate::runtime::Handle; -+#[cfg(tokio_unstable)] -+use crate::task::Id; -+use crate::task::{AbortHandle, JoinError, JoinHandle, LocalSet}; -+use crate::util::IdleNotifiedSet; -+ -+/// A collection of tasks spawned on a Tokio runtime. -+/// -+/// A `JoinSet` can be used to await the completion of some or all of the tasks -+/// in the set. The set is not ordered, and the tasks will be returned in the -+/// order they complete. -+/// -+/// All of the tasks must have the same return type `T`. -+/// -+/// When the `JoinSet` is dropped, all tasks in the `JoinSet` are immediately aborted. -+/// -+/// # Examples -+/// -+/// Spawn multiple tasks and wait for them. -+/// -+/// ``` -+/// use tokio::task::JoinSet; -+/// -+/// #[tokio::main] -+/// async fn main() { -+/// let mut set = JoinSet::new(); -+/// -+/// for i in 0..10 { -+/// set.spawn(async move { i }); -+/// } -+/// -+/// let mut seen = [false; 10]; -+/// while let Some(res) = set.join_next().await { -+/// let idx = res.unwrap(); -+/// seen[idx] = true; -+/// } -+/// -+/// for i in 0..10 { -+/// assert!(seen[i]); -+/// } -+/// } -+/// ``` -+#[cfg_attr(docsrs, doc(cfg(feature = "rt")))] -+pub struct JoinSet { -+ inner: IdleNotifiedSet>, -+} -+ -+/// A variant of [`task::Builder`] that spawns tasks on a [`JoinSet`] rather -+/// than on the current default runtime. -+/// -+/// [`task::Builder`]: crate::task::Builder -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+#[cfg_attr(docsrs, doc(cfg(all(tokio_unstable, feature = "tracing"))))] -+#[must_use = "builders do nothing unless used to spawn a task"] -+pub struct Builder<'a, T> { -+ joinset: &'a mut JoinSet, -+ builder: super::Builder<'a>, -+} -+ -+impl JoinSet { -+ /// Create a new `JoinSet`. -+ pub fn new() -> Self { -+ Self { -+ inner: IdleNotifiedSet::new(), -+ } -+ } -+ -+ /// Returns the number of tasks currently in the `JoinSet`. -+ pub fn len(&self) -> usize { -+ self.inner.len() -+ } -+ -+ /// Returns whether the `JoinSet` is empty. -+ pub fn is_empty(&self) -> bool { -+ self.inner.is_empty() -+ } -+} -+ -+impl JoinSet { -+ /// Returns a [`Builder`] that can be used to configure a task prior to -+ /// spawning it on this `JoinSet`. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::task::JoinSet; -+ /// -+ /// #[tokio::main] -+ /// async fn main() -> std::io::Result<()> { -+ /// let mut set = JoinSet::new(); -+ /// -+ /// // Use the builder to configure a task's name before spawning it. -+ /// set.build_task() -+ /// .name("my_task") -+ /// .spawn(async { /* ... */ })?; -+ /// -+ /// Ok(()) -+ /// } -+ /// ``` -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ #[cfg_attr(docsrs, doc(cfg(all(tokio_unstable, feature = "tracing"))))] -+ pub fn build_task(&mut self) -> Builder<'_, T> { -+ Builder { -+ builder: super::Builder::new(), -+ joinset: self, -+ } -+ } -+ -+ /// Spawn the provided task on the `JoinSet`, returning an [`AbortHandle`] -+ /// that can be used to remotely cancel the task. -+ /// -+ /// The provided future will start running in the background immediately -+ /// when this method is called, even if you don't await anything on this -+ /// `JoinSet`. -+ /// -+ /// # Panics -+ /// -+ /// This method panics if called outside of a Tokio runtime. -+ /// -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ #[track_caller] -+ pub fn spawn(&mut self, task: F) -> AbortHandle -+ where -+ F: Future, -+ F: Send + 'static, -+ T: Send, -+ { -+ self.insert(crate::spawn(task)) -+ } -+ -+ /// Spawn the provided task on the provided runtime and store it in this -+ /// `JoinSet` returning an [`AbortHandle`] that can be used to remotely -+ /// cancel the task. -+ /// -+ /// The provided future will start running in the background immediately -+ /// when this method is called, even if you don't await anything on this -+ /// `JoinSet`. -+ /// -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ #[track_caller] -+ pub fn spawn_on(&mut self, task: F, handle: &Handle) -> AbortHandle -+ where -+ F: Future, -+ F: Send + 'static, -+ T: Send, -+ { -+ self.insert(handle.spawn(task)) -+ } -+ -+ /// Spawn the provided task on the current [`LocalSet`] and store it in this -+ /// `JoinSet`, returning an [`AbortHandle`] that can be used to remotely -+ /// cancel the task. -+ /// -+ /// The provided future will start running in the background immediately -+ /// when this method is called, even if you don't await anything on this -+ /// `JoinSet`. -+ /// -+ /// # Panics -+ /// -+ /// This method panics if it is called outside of a `LocalSet`. -+ /// -+ /// [`LocalSet`]: crate::task::LocalSet -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ #[track_caller] -+ pub fn spawn_local(&mut self, task: F) -> AbortHandle -+ where -+ F: Future, -+ F: 'static, -+ { -+ self.insert(crate::task::spawn_local(task)) -+ } -+ -+ /// Spawn the provided task on the provided [`LocalSet`] and store it in -+ /// this `JoinSet`, returning an [`AbortHandle`] that can be used to -+ /// remotely cancel the task. -+ /// -+ /// Unlike the [`spawn_local`] method, this method may be used to spawn local -+ /// tasks on a `LocalSet` that is _not_ currently running. The provided -+ /// future will start running whenever the `LocalSet` is next started. -+ /// -+ /// [`LocalSet`]: crate::task::LocalSet -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ /// [`spawn_local`]: Self::spawn_local -+ #[track_caller] -+ pub fn spawn_local_on(&mut self, task: F, local_set: &LocalSet) -> AbortHandle -+ where -+ F: Future, -+ F: 'static, -+ { -+ self.insert(local_set.spawn_local(task)) -+ } -+ -+ /// Spawn the blocking code on the blocking threadpool and store -+ /// it in this `JoinSet`, returning an [`AbortHandle`] that can be -+ /// used to remotely cancel the task. -+ /// -+ /// # Examples -+ /// -+ /// Spawn multiple blocking tasks and wait for them. -+ /// -+ /// ``` -+ /// use tokio::task::JoinSet; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let mut set = JoinSet::new(); -+ /// -+ /// for i in 0..10 { -+ /// set.spawn_blocking(move || { i }); -+ /// } -+ /// -+ /// let mut seen = [false; 10]; -+ /// while let Some(res) = set.join_next().await { -+ /// let idx = res.unwrap(); -+ /// seen[idx] = true; -+ /// } -+ /// -+ /// for i in 0..10 { -+ /// assert!(seen[i]); -+ /// } -+ /// } -+ /// ``` -+ /// -+ /// # Panics -+ /// -+ /// This method panics if called outside of a Tokio runtime. -+ /// -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ #[track_caller] -+ pub fn spawn_blocking(&mut self, f: F) -> AbortHandle -+ where -+ F: FnOnce() -> T, -+ F: Send + 'static, -+ T: Send, -+ { -+ self.insert(crate::runtime::spawn_blocking(f)) -+ } -+ -+ /// Spawn the blocking code on the blocking threadpool of the -+ /// provided runtime and store it in this `JoinSet`, returning an -+ /// [`AbortHandle`] that can be used to remotely cancel the task. -+ /// -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ #[track_caller] -+ pub fn spawn_blocking_on(&mut self, f: F, handle: &Handle) -> AbortHandle -+ where -+ F: FnOnce() -> T, -+ F: Send + 'static, -+ T: Send, -+ { -+ self.insert(handle.spawn_blocking(f)) -+ } -+ -+ fn insert(&mut self, jh: JoinHandle) -> AbortHandle { -+ let abort = jh.abort_handle(); -+ let mut entry = self.inner.insert_idle(jh); -+ -+ // Set the waker that is notified when the task completes. -+ entry.with_value_and_context(|jh, ctx| jh.set_join_waker(ctx.waker())); -+ abort -+ } -+ -+ /// Waits until one of the tasks in the set completes and returns its output. -+ /// -+ /// Returns `None` if the set is empty. -+ /// -+ /// # Cancel Safety -+ /// -+ /// This method is cancel safe. If `join_next` is used as the event in a `tokio::select!` -+ /// statement and some other branch completes first, it is guaranteed that no tasks were -+ /// removed from this `JoinSet`. -+ pub async fn join_next(&mut self) -> Option> { -+ crate::future::poll_fn(|cx| self.poll_join_next(cx)).await -+ } -+ -+ /// Waits until one of the tasks in the set completes and returns its -+ /// output, along with the [task ID] of the completed task. -+ /// -+ /// Returns `None` if the set is empty. -+ /// -+ /// When this method returns an error, then the id of the task that failed can be accessed -+ /// using the [`JoinError::id`] method. -+ /// -+ /// # Cancel Safety -+ /// -+ /// This method is cancel safe. If `join_next_with_id` is used as the event in a `tokio::select!` -+ /// statement and some other branch completes first, it is guaranteed that no tasks were -+ /// removed from this `JoinSet`. -+ /// -+ /// [task ID]: crate::task::Id -+ /// [`JoinError::id`]: fn@crate::task::JoinError::id -+ #[cfg(tokio_unstable)] -+ #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))] -+ pub async fn join_next_with_id(&mut self) -> Option> { -+ crate::future::poll_fn(|cx| self.poll_join_next_with_id(cx)).await -+ } -+ -+ /// Aborts all tasks and waits for them to finish shutting down. -+ /// -+ /// Calling this method is equivalent to calling [`abort_all`] and then calling [`join_next`] in -+ /// a loop until it returns `None`. -+ /// -+ /// This method ignores any panics in the tasks shutting down. When this call returns, the -+ /// `JoinSet` will be empty. -+ /// -+ /// [`abort_all`]: fn@Self::abort_all -+ /// [`join_next`]: fn@Self::join_next -+ pub async fn shutdown(&mut self) { -+ self.abort_all(); -+ while self.join_next().await.is_some() {} -+ } -+ -+ /// Aborts all tasks on this `JoinSet`. -+ /// -+ /// This does not remove the tasks from the `JoinSet`. To wait for the tasks to complete -+ /// cancellation, you should call `join_next` in a loop until the `JoinSet` is empty. -+ pub fn abort_all(&mut self) { -+ self.inner.for_each(|jh| jh.abort()); -+ } -+ -+ /// Removes all tasks from this `JoinSet` without aborting them. -+ /// -+ /// The tasks removed by this call will continue to run in the background even if the `JoinSet` -+ /// is dropped. -+ pub fn detach_all(&mut self) { -+ self.inner.drain(drop); -+ } -+ -+ /// Polls for one of the tasks in the set to complete. -+ /// -+ /// If this returns `Poll::Ready(Some(_))`, then the task that completed is removed from the set. -+ /// -+ /// When the method returns `Poll::Pending`, the `Waker` in the provided `Context` is scheduled -+ /// to receive a wakeup when a task in the `JoinSet` completes. Note that on multiple calls to -+ /// `poll_join_next`, only the `Waker` from the `Context` passed to the most recent call is -+ /// scheduled to receive a wakeup. -+ /// -+ /// # Returns -+ /// -+ /// This function returns: -+ /// -+ /// * `Poll::Pending` if the `JoinSet` is not empty but there is no task whose output is -+ /// available right now. -+ /// * `Poll::Ready(Some(Ok(value)))` if one of the tasks in this `JoinSet` has completed. -+ /// The `value` is the return value of one of the tasks that completed. -+ /// * `Poll::Ready(Some(Err(err)))` if one of the tasks in this `JoinSet` has panicked or been -+ /// aborted. The `err` is the `JoinError` from the panicked/aborted task. -+ /// * `Poll::Ready(None)` if the `JoinSet` is empty. -+ /// -+ /// Note that this method may return `Poll::Pending` even if one of the tasks has completed. -+ /// This can happen if the [coop budget] is reached. -+ /// -+ /// [coop budget]: crate::task#cooperative-scheduling -+ fn poll_join_next(&mut self, cx: &mut Context<'_>) -> Poll>> { -+ // The call to `pop_notified` moves the entry to the `idle` list. It is moved back to -+ // the `notified` list if the waker is notified in the `poll` call below. -+ let mut entry = match self.inner.pop_notified(cx.waker()) { -+ Some(entry) => entry, -+ None => { -+ if self.is_empty() { -+ return Poll::Ready(None); -+ } else { -+ // The waker was set by `pop_notified`. -+ return Poll::Pending; -+ } -+ } -+ }; -+ -+ let res = entry.with_value_and_context(|jh, ctx| Pin::new(jh).poll(ctx)); -+ -+ if let Poll::Ready(res) = res { -+ let _entry = entry.remove(); -+ Poll::Ready(Some(res)) -+ } else { -+ // A JoinHandle generally won't emit a wakeup without being ready unless -+ // the coop limit has been reached. We yield to the executor in this -+ // case. -+ cx.waker().wake_by_ref(); -+ Poll::Pending -+ } -+ } -+ -+ /// Polls for one of the tasks in the set to complete. -+ /// -+ /// If this returns `Poll::Ready(Some(_))`, then the task that completed is removed from the set. -+ /// -+ /// When the method returns `Poll::Pending`, the `Waker` in the provided `Context` is scheduled -+ /// to receive a wakeup when a task in the `JoinSet` completes. Note that on multiple calls to -+ /// `poll_join_next`, only the `Waker` from the `Context` passed to the most recent call is -+ /// scheduled to receive a wakeup. -+ /// -+ /// # Returns -+ /// -+ /// This function returns: -+ /// -+ /// * `Poll::Pending` if the `JoinSet` is not empty but there is no task whose output is -+ /// available right now. -+ /// * `Poll::Ready(Some(Ok((id, value))))` if one of the tasks in this `JoinSet` has completed. -+ /// The `value` is the return value of one of the tasks that completed, and -+ /// `id` is the [task ID] of that task. -+ /// * `Poll::Ready(Some(Err(err)))` if one of the tasks in this `JoinSet` has panicked or been -+ /// aborted. The `err` is the `JoinError` from the panicked/aborted task. -+ /// * `Poll::Ready(None)` if the `JoinSet` is empty. -+ /// -+ /// Note that this method may return `Poll::Pending` even if one of the tasks has completed. -+ /// This can happen if the [coop budget] is reached. -+ /// -+ /// [coop budget]: crate::task#cooperative-scheduling -+ /// [task ID]: crate::task::Id -+ #[cfg(tokio_unstable)] -+ fn poll_join_next_with_id( -+ &mut self, -+ cx: &mut Context<'_>, -+ ) -> Poll>> { -+ // The call to `pop_notified` moves the entry to the `idle` list. It is moved back to -+ // the `notified` list if the waker is notified in the `poll` call below. -+ let mut entry = match self.inner.pop_notified(cx.waker()) { -+ Some(entry) => entry, -+ None => { -+ if self.is_empty() { -+ return Poll::Ready(None); -+ } else { -+ // The waker was set by `pop_notified`. -+ return Poll::Pending; -+ } -+ } -+ }; -+ -+ let res = entry.with_value_and_context(|jh, ctx| Pin::new(jh).poll(ctx)); -+ -+ if let Poll::Ready(res) = res { -+ let entry = entry.remove(); -+ // If the task succeeded, add the task ID to the output. Otherwise, the -+ // `JoinError` will already have the task's ID. -+ Poll::Ready(Some(res.map(|output| (entry.id(), output)))) -+ } else { -+ // A JoinHandle generally won't emit a wakeup without being ready unless -+ // the coop limit has been reached. We yield to the executor in this -+ // case. -+ cx.waker().wake_by_ref(); -+ Poll::Pending -+ } -+ } -+} -+ -+impl Drop for JoinSet { -+ fn drop(&mut self) { -+ self.inner.drain(|join_handle| join_handle.abort()); -+ } -+} -+ -+impl fmt::Debug for JoinSet { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ f.debug_struct("JoinSet").field("len", &self.len()).finish() -+ } -+} -+ -+impl Default for JoinSet { -+ fn default() -> Self { -+ Self::new() -+ } -+} -+ -+// === impl Builder === -+ -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+#[cfg_attr(docsrs, doc(cfg(all(tokio_unstable, feature = "tracing"))))] -+impl<'a, T: 'static> Builder<'a, T> { -+ /// Assigns a name to the task which will be spawned. -+ pub fn name(self, name: &'a str) -> Self { -+ let builder = self.builder.name(name); -+ Self { builder, ..self } -+ } -+ -+ /// Spawn the provided task with this builder's settings and store it in the -+ /// [`JoinSet`], returning an [`AbortHandle`] that can be used to remotely -+ /// cancel the task. -+ /// -+ /// # Returns -+ /// -+ /// An [`AbortHandle`] that can be used to remotely cancel the task. -+ /// -+ /// # Panics -+ /// -+ /// This method panics if called outside of a Tokio runtime. -+ /// -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ #[track_caller] -+ pub fn spawn(self, future: F) -> std::io::Result -+ where -+ F: Future, -+ F: Send + 'static, -+ T: Send, -+ { -+ Ok(self.joinset.insert(self.builder.spawn(future)?)) -+ } -+ -+ /// Spawn the provided task on the provided [runtime handle] with this -+ /// builder's settings, and store it in the [`JoinSet`]. -+ /// -+ /// # Returns -+ /// -+ /// An [`AbortHandle`] that can be used to remotely cancel the task. -+ /// -+ /// -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ /// [runtime handle]: crate::runtime::Handle -+ #[track_caller] -+ pub fn spawn_on(self, future: F, handle: &Handle) -> std::io::Result -+ where -+ F: Future, -+ F: Send + 'static, -+ T: Send, -+ { -+ Ok(self.joinset.insert(self.builder.spawn_on(future, handle)?)) -+ } -+ -+ /// Spawn the provided task on the current [`LocalSet`] with this builder's -+ /// settings, and store it in the [`JoinSet`]. -+ /// -+ /// # Returns -+ /// -+ /// An [`AbortHandle`] that can be used to remotely cancel the task. -+ /// -+ /// # Panics -+ /// -+ /// This method panics if it is called outside of a `LocalSet`. -+ /// -+ /// [`LocalSet`]: crate::task::LocalSet -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ #[track_caller] -+ pub fn spawn_local(self, future: F) -> std::io::Result -+ where -+ F: Future, -+ F: 'static, -+ { -+ Ok(self.joinset.insert(self.builder.spawn_local(future)?)) -+ } -+ -+ /// Spawn the provided task on the provided [`LocalSet`] with this builder's -+ /// settings, and store it in the [`JoinSet`]. -+ /// -+ /// # Returns -+ /// -+ /// An [`AbortHandle`] that can be used to remotely cancel the task. -+ /// -+ /// [`LocalSet`]: crate::task::LocalSet -+ /// [`AbortHandle`]: crate::task::AbortHandle -+ #[track_caller] -+ pub fn spawn_local_on(self, future: F, local_set: &LocalSet) -> std::io::Result -+ where -+ F: Future, -+ F: 'static, -+ { -+ Ok(self -+ .joinset -+ .insert(self.builder.spawn_local_on(future, local_set)?)) -+ } -+} -+ -+// Manual `Debug` impl so that `Builder` is `Debug` regardless of whether `T` is -+// `Debug`. -+#[cfg(all(tokio_unstable, feature = "tracing"))] -+#[cfg_attr(docsrs, doc(cfg(all(tokio_unstable, feature = "tracing"))))] -+impl<'a, T> fmt::Debug for Builder<'a, T> { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ f.debug_struct("join_set::Builder") -+ .field("joinset", &self.joinset) -+ .field("builder", &self.builder) -+ .finish() -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/task/local.rs b/KubeOS-Rust/vendor/tokio/src/task/local.rs -index 4a5d313c..b709c215 100644 ---- a/KubeOS-Rust/vendor/tokio/src/task/local.rs -+++ b/KubeOS-Rust/vendor/tokio/src/task/local.rs -@@ -1,8 +1,10 @@ - //! Runs `!Send` futures on the current thread. -+use crate::loom::cell::UnsafeCell; - use crate::loom::sync::{Arc, Mutex}; - use crate::runtime::task::{self, JoinHandle, LocalOwnedTasks, Task}; -+use crate::runtime::{context, ThreadId}; - use crate::sync::AtomicWaker; --use crate::util::VecDequeCell; -+use crate::util::RcCell; - - use std::cell::Cell; - use std::collections::VecDeque; -@@ -10,6 +12,7 @@ use std::fmt; - use std::future::Future; - use std::marker::PhantomData; - use std::pin::Pin; -+use std::rc::Rc; - use std::task::Poll; - - use pin_project_lite::pin_project; -@@ -31,14 +34,14 @@ cfg_rt! { - /// async fn main() { - /// // `Rc` does not implement `Send`, and thus may not be sent between - /// // threads safely. -- /// let unsend_data = Rc::new("my unsend data..."); -+ /// let nonsend_data = Rc::new("my nonsend data..."); - /// -- /// let unsend_data = unsend_data.clone(); -- /// // Because the `async` block here moves `unsend_data`, the future is `!Send`. -+ /// let nonsend_data = nonsend_data.clone(); -+ /// // Because the `async` block here moves `nonsend_data`, the future is `!Send`. - /// // Since `tokio::spawn` requires the spawned future to implement `Send`, this - /// // will not compile. - /// tokio::spawn(async move { -- /// println!("{}", unsend_data); -+ /// println!("{}", nonsend_data); - /// // ... - /// }).await.unwrap(); - /// } -@@ -57,18 +60,18 @@ cfg_rt! { - /// - /// #[tokio::main] - /// async fn main() { -- /// let unsend_data = Rc::new("my unsend data..."); -+ /// let nonsend_data = Rc::new("my nonsend data..."); - /// - /// // Construct a local task set that can run `!Send` futures. - /// let local = task::LocalSet::new(); - /// - /// // Run the local task set. - /// local.run_until(async move { -- /// let unsend_data = unsend_data.clone(); -+ /// let nonsend_data = nonsend_data.clone(); - /// // `spawn_local` ensures that the future is spawned on the local - /// // task set. - /// task::spawn_local(async move { -- /// println!("{}", unsend_data); -+ /// println!("{}", nonsend_data); - /// // ... - /// }).await.unwrap(); - /// }).await; -@@ -91,18 +94,18 @@ cfg_rt! { - /// - /// #[tokio::main] - /// async fn main() { -- /// let unsend_data = Rc::new("world"); -+ /// let nonsend_data = Rc::new("world"); - /// let local = task::LocalSet::new(); - /// -- /// let unsend_data2 = unsend_data.clone(); -+ /// let nonsend_data2 = nonsend_data.clone(); - /// local.spawn_local(async move { - /// // ... -- /// println!("hello {}", unsend_data2) -+ /// println!("hello {}", nonsend_data2) - /// }); - /// - /// local.spawn_local(async move { - /// time::sleep(time::Duration::from_millis(100)).await; -- /// println!("goodbye {}", unsend_data) -+ /// println!("goodbye {}", nonsend_data) - /// }); - /// - /// // ... -@@ -159,7 +162,7 @@ cfg_rt! { - /// tokio::task::spawn_local(run_task(new_task)); - /// } - /// // If the while loop returns, then all the LocalSpawner -- /// // objects have have been dropped. -+ /// // objects have been dropped. - /// }); - /// - /// // This will return once all senders are dropped and all -@@ -215,7 +218,7 @@ cfg_rt! { - tick: Cell, - - /// State available from thread-local. -- context: Context, -+ context: Rc, - - /// This type should not be Send. - _not_send: PhantomData<*const ()>, -@@ -224,23 +227,44 @@ cfg_rt! { - - /// State available from the thread-local. - struct Context { -- /// Collection of all active tasks spawned onto this executor. -- owned: LocalOwnedTasks>, -- -- /// Local run queue sender and receiver. -- queue: VecDequeCell>>, -- - /// State shared between threads. - shared: Arc, -+ -+ /// True if a task panicked without being handled and the local set is -+ /// configured to shutdown on unhandled panic. -+ unhandled_panic: Cell, - } - - /// LocalSet state shared between threads. - struct Shared { -+ /// # Safety -+ /// -+ /// This field must *only* be accessed from the thread that owns the -+ /// `LocalSet` (i.e., `Thread::current().id() == owner`). -+ local_state: LocalState, -+ - /// Remote run queue sender. - queue: Mutex>>>>, - - /// Wake the `LocalSet` task. - waker: AtomicWaker, -+ -+ /// How to respond to unhandled task panics. -+ #[cfg(tokio_unstable)] -+ pub(crate) unhandled_panic: crate::runtime::UnhandledPanic, -+} -+ -+/// Tracks the `LocalSet` state that must only be accessed from the thread that -+/// created the `LocalSet`. -+struct LocalState { -+ /// The `ThreadId` of the thread that owns the `LocalSet`. -+ owner: ThreadId, -+ -+ /// Local run queue sender and receiver. -+ local_queue: UnsafeCell>>>, -+ -+ /// Collection of all active tasks spawned onto this executor. -+ owned: LocalOwnedTasks>, - } - - pin_project! { -@@ -252,17 +276,30 @@ pin_project! { - } - } - --scoped_thread_local!(static CURRENT: Context); -+tokio_thread_local!(static CURRENT: LocalData = const { LocalData { -+ ctx: RcCell::new(), -+} }); -+ -+struct LocalData { -+ ctx: RcCell, -+} - - cfg_rt! { -- /// Spawns a `!Send` future on the local task set. -+ /// Spawns a `!Send` future on the current [`LocalSet`]. - /// -- /// The spawned future will be run on the same thread that called `spawn_local.` -- /// This may only be called from the context of a local task set. -+ /// The spawned future will run on the same thread that called `spawn_local`. -+ /// -+ /// The provided future will start running in the background immediately -+ /// when `spawn_local` is called, even if you don't await the returned -+ /// `JoinHandle`. - /// - /// # Panics - /// -- /// - This function panics if called outside of a local task set. -+ /// This function panics if called outside of a [`LocalSet`]. -+ /// -+ /// Note that if [`tokio::spawn`] is used from within a `LocalSet`, the -+ /// resulting new task will _not_ be inside the `LocalSet`, so you must use -+ /// use `spawn_local` if you want to stay within the `LocalSet`. - /// - /// # Examples - /// -@@ -272,21 +309,24 @@ cfg_rt! { - /// - /// #[tokio::main] - /// async fn main() { -- /// let unsend_data = Rc::new("my unsend data..."); -+ /// let nonsend_data = Rc::new("my nonsend data..."); - /// - /// let local = task::LocalSet::new(); - /// - /// // Run the local task set. - /// local.run_until(async move { -- /// let unsend_data = unsend_data.clone(); -+ /// let nonsend_data = nonsend_data.clone(); - /// task::spawn_local(async move { -- /// println!("{}", unsend_data); -+ /// println!("{}", nonsend_data); - /// // ... - /// }).await.unwrap(); - /// }).await; - /// } - /// ``` -- #[cfg_attr(tokio_track_caller, track_caller)] -+ /// -+ /// [`LocalSet`]: struct@crate::task::LocalSet -+ /// [`tokio::spawn`]: fn@crate::task::spawn -+ #[track_caller] - pub fn spawn_local(future: F) -> JoinHandle - where - F: Future + 'static, -@@ -295,23 +335,16 @@ cfg_rt! { - spawn_local_inner(future, None) - } - -+ -+ #[track_caller] - pub(super) fn spawn_local_inner(future: F, name: Option<&str>) -> JoinHandle - where F: Future + 'static, - F::Output: 'static - { -- let future = crate::util::trace::task(future, "local", name); -- CURRENT.with(|maybe_cx| { -- let cx = maybe_cx -- .expect("`spawn_local` called from outside of a `task::LocalSet`"); -- -- let (handle, notified) = cx.owned.bind(future, cx.shared.clone()); -- -- if let Some(notified) = notified { -- cx.shared.schedule(notified); -- } -- -- handle -- }) -+ match CURRENT.with(|LocalData { ctx, .. }| ctx.get()) { -+ None => panic!("`spawn_local` called from outside of a `task::LocalSet`"), -+ Some(cx) => cx.spawn(future, name) -+ } - } - } - -@@ -324,29 +357,72 @@ const MAX_TASKS_PER_TICK: usize = 61; - /// How often it check the remote queue first. - const REMOTE_FIRST_INTERVAL: u8 = 31; - -+/// Context guard for LocalSet -+pub struct LocalEnterGuard(Option>); -+ -+impl Drop for LocalEnterGuard { -+ fn drop(&mut self) { -+ CURRENT.with(|LocalData { ctx, .. }| { -+ ctx.set(self.0.take()); -+ }) -+ } -+} -+ -+impl fmt::Debug for LocalEnterGuard { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ f.debug_struct("LocalEnterGuard").finish() -+ } -+} -+ - impl LocalSet { - /// Returns a new local task set. - pub fn new() -> LocalSet { -+ let owner = context::thread_id().expect("cannot create LocalSet during thread shutdown"); -+ - LocalSet { - tick: Cell::new(0), -- context: Context { -- owned: LocalOwnedTasks::new(), -- queue: VecDequeCell::with_capacity(INITIAL_CAPACITY), -+ context: Rc::new(Context { - shared: Arc::new(Shared { -+ local_state: LocalState { -+ owner, -+ owned: LocalOwnedTasks::new(), -+ local_queue: UnsafeCell::new(VecDeque::with_capacity(INITIAL_CAPACITY)), -+ }, - queue: Mutex::new(Some(VecDeque::with_capacity(INITIAL_CAPACITY))), - waker: AtomicWaker::new(), -+ #[cfg(tokio_unstable)] -+ unhandled_panic: crate::runtime::UnhandledPanic::Ignore, - }), -- }, -+ unhandled_panic: Cell::new(false), -+ }), - _not_send: PhantomData, - } - } - -+ /// Enters the context of this `LocalSet`. -+ /// -+ /// The [`spawn_local`] method will spawn tasks on the `LocalSet` whose -+ /// context you are inside. -+ /// -+ /// [`spawn_local`]: fn@crate::task::spawn_local -+ pub fn enter(&self) -> LocalEnterGuard { -+ CURRENT.with(|LocalData { ctx, .. }| { -+ let old = ctx.replace(Some(self.context.clone())); -+ LocalEnterGuard(old) -+ }) -+ } -+ - /// Spawns a `!Send` task onto the local task set. - /// - /// This task is guaranteed to be run on the current thread. - /// - /// Unlike the free function [`spawn_local`], this method may be used to -- /// spawn local tasks when the task set is _not_ running. For example: -+ /// spawn local tasks when the `LocalSet` is _not_ running. The provided -+ /// future will start running once the `LocalSet` is next started, even if -+ /// you don't await the returned `JoinHandle`. -+ /// -+ /// # Examples -+ /// - /// ```rust - /// use tokio::task; - /// -@@ -377,22 +453,13 @@ impl LocalSet { - /// } - /// ``` - /// [`spawn_local`]: fn@spawn_local -- #[cfg_attr(tokio_track_caller, track_caller)] -+ #[track_caller] - pub fn spawn_local(&self, future: F) -> JoinHandle - where - F: Future + 'static, - F::Output: 'static, - { -- let future = crate::util::trace::task(future, "local", None); -- -- let (handle, notified) = self.context.owned.bind(future, self.context.shared.clone()); -- -- if let Some(notified) = notified { -- self.context.shared.schedule(notified); -- } -- -- self.context.shared.waker.wake(); -- handle -+ self.spawn_named(future, None) - } - - /// Runs a future to completion on the provided runtime, driving any local -@@ -457,6 +524,7 @@ impl LocalSet { - /// [`Runtime::block_on`]: method@crate::runtime::Runtime::block_on - /// [in-place blocking]: fn@crate::task::block_in_place - /// [`spawn_blocking`]: fn@crate::task::spawn_blocking -+ #[track_caller] - #[cfg(feature = "rt")] - #[cfg_attr(docsrs, doc(cfg(feature = "rt")))] - pub fn block_on(&self, rt: &crate::runtime::Runtime, future: F) -> F::Output -@@ -505,10 +573,36 @@ impl LocalSet { - run_until.await - } - -+ pub(in crate::task) fn spawn_named( -+ &self, -+ future: F, -+ name: Option<&str>, -+ ) -> JoinHandle -+ where -+ F: Future + 'static, -+ F::Output: 'static, -+ { -+ let handle = self.context.spawn(future, name); -+ -+ // Because a task was spawned from *outside* the `LocalSet`, wake the -+ // `LocalSet` future to execute the new task, if it hasn't been woken. -+ // -+ // Spawning via the free fn `spawn` does not require this, as it can -+ // only be called from *within* a future executing on the `LocalSet` — -+ // in that case, the `LocalSet` must already be awake. -+ self.context.shared.waker.wake(); -+ handle -+ } -+ - /// Ticks the scheduler, returning whether the local future needs to be - /// notified again. - fn tick(&self) -> bool { - for _ in 0..MAX_TASKS_PER_TICK { -+ // Make sure we didn't hit an unhandled panic -+ if self.context.unhandled_panic.get() { -+ panic!("a spawned task panicked and the LocalSet is configured to shutdown on unhandled panic"); -+ } -+ - match self.next_task() { - // Run the task - // -@@ -518,7 +612,7 @@ impl LocalSet { - // task initially. Because `LocalSet` itself is `!Send`, and - // `spawn_local` spawns into the `LocalSet` on the current - // thread, the invariant is maintained. -- Some(task) => crate::coop::budget(|| task.run()), -+ Some(task) => crate::runtime::coop::budget(|| task.run()), - // We have fully drained the queue of notified tasks, so the - // local future doesn't need to be notified again — it can wait - // until something else wakes a task in the local set. -@@ -540,9 +634,9 @@ impl LocalSet { - .lock() - .as_mut() - .and_then(|queue| queue.pop_front()) -- .or_else(|| self.context.queue.pop_front()) -+ .or_else(|| self.pop_local()) - } else { -- self.context.queue.pop_front().or_else(|| { -+ self.pop_local().or_else(|| { - self.context - .shared - .queue -@@ -552,11 +646,145 @@ impl LocalSet { - }) - }; - -- task.map(|task| self.context.owned.assert_owner(task)) -+ task.map(|task| unsafe { -+ // Safety: because the `LocalSet` itself is `!Send`, we know we are -+ // on the same thread if we have access to the `LocalSet`, and can -+ // therefore access the local run queue. -+ self.context.shared.local_state.assert_owner(task) -+ }) -+ } -+ -+ fn pop_local(&self) -> Option>> { -+ unsafe { -+ // Safety: because the `LocalSet` itself is `!Send`, we know we are -+ // on the same thread if we have access to the `LocalSet`, and can -+ // therefore access the local run queue. -+ self.context.shared.local_state.task_pop_front() -+ } - } - - fn with(&self, f: impl FnOnce() -> T) -> T { -- CURRENT.set(&self.context, f) -+ CURRENT.with(|LocalData { ctx, .. }| { -+ struct Reset<'a> { -+ ctx_ref: &'a RcCell, -+ val: Option>, -+ } -+ impl<'a> Drop for Reset<'a> { -+ fn drop(&mut self) { -+ self.ctx_ref.set(self.val.take()); -+ } -+ } -+ let old = ctx.replace(Some(self.context.clone())); -+ -+ let _reset = Reset { -+ ctx_ref: ctx, -+ val: old, -+ }; -+ -+ f() -+ }) -+ } -+ -+ /// This method is like `with`, but it just calls `f` without setting the thread-local if that -+ /// fails. -+ fn with_if_possible(&self, f: impl FnOnce() -> T) -> T { -+ let mut f = Some(f); -+ -+ let res = CURRENT.try_with(|LocalData { ctx, .. }| { -+ struct Reset<'a> { -+ ctx_ref: &'a RcCell, -+ val: Option>, -+ } -+ impl<'a> Drop for Reset<'a> { -+ fn drop(&mut self) { -+ self.ctx_ref.replace(self.val.take()); -+ } -+ } -+ let old = ctx.replace(Some(self.context.clone())); -+ -+ let _reset = Reset { -+ ctx_ref: ctx, -+ val: old, -+ }; -+ -+ (f.take().unwrap())() -+ }); -+ -+ match res { -+ Ok(res) => res, -+ Err(_access_error) => (f.take().unwrap())(), -+ } -+ } -+} -+ -+cfg_unstable! { -+ impl LocalSet { -+ /// Configure how the `LocalSet` responds to an unhandled panic on a -+ /// spawned task. -+ /// -+ /// By default, an unhandled panic (i.e. a panic not caught by -+ /// [`std::panic::catch_unwind`]) has no impact on the `LocalSet`'s -+ /// execution. The panic is error value is forwarded to the task's -+ /// [`JoinHandle`] and all other spawned tasks continue running. -+ /// -+ /// The `unhandled_panic` option enables configuring this behavior. -+ /// -+ /// * `UnhandledPanic::Ignore` is the default behavior. Panics on -+ /// spawned tasks have no impact on the `LocalSet`'s execution. -+ /// * `UnhandledPanic::ShutdownRuntime` will force the `LocalSet` to -+ /// shutdown immediately when a spawned task panics even if that -+ /// task's `JoinHandle` has not been dropped. All other spawned tasks -+ /// will immediately terminate and further calls to -+ /// [`LocalSet::block_on`] and [`LocalSet::run_until`] will panic. -+ /// -+ /// # Panics -+ /// -+ /// This method panics if called after the `LocalSet` has started -+ /// running. -+ /// -+ /// # Unstable -+ /// -+ /// This option is currently unstable and its implementation is -+ /// incomplete. The API may change or be removed in the future. See -+ /// tokio-rs/tokio#4516 for more details. -+ /// -+ /// # Examples -+ /// -+ /// The following demonstrates a `LocalSet` configured to shutdown on -+ /// panic. The first spawned task panics and results in the `LocalSet` -+ /// shutting down. The second spawned task never has a chance to -+ /// execute. The call to `run_until` will panic due to the runtime being -+ /// forcibly shutdown. -+ /// -+ /// ```should_panic -+ /// use tokio::runtime::UnhandledPanic; -+ /// -+ /// # #[tokio::main] -+ /// # async fn main() { -+ /// tokio::task::LocalSet::new() -+ /// .unhandled_panic(UnhandledPanic::ShutdownRuntime) -+ /// .run_until(async { -+ /// tokio::task::spawn_local(async { panic!("boom"); }); -+ /// tokio::task::spawn_local(async { -+ /// // This task never completes -+ /// }); -+ /// -+ /// // Do some work, but `run_until` will panic before it completes -+ /// # loop { tokio::task::yield_now().await; } -+ /// }) -+ /// .await; -+ /// # } -+ /// ``` -+ /// -+ /// [`JoinHandle`]: struct@crate::task::JoinHandle -+ pub fn unhandled_panic(&mut self, behavior: crate::runtime::UnhandledPanic) -> &mut Self { -+ // TODO: This should be set as a builder -+ Rc::get_mut(&mut self.context) -+ .and_then(|ctx| Arc::get_mut(&mut ctx.shared)) -+ .expect("Unhandled Panic behavior modified after starting LocalSet") -+ .unhandled_panic = behavior; -+ self -+ } - } - } - -@@ -578,7 +806,10 @@ impl Future for LocalSet { - // there are still tasks remaining in the run queue. - cx.waker().wake_by_ref(); - Poll::Pending -- } else if self.context.owned.is_empty() { -+ -+ // Safety: called from the thread that owns `LocalSet`. Because -+ // `LocalSet` is `!Send`, this is safe. -+ } else if unsafe { self.context.shared.local_state.owned_is_empty() } { - // If the scheduler has no remaining futures, we're done! - Poll::Ready(()) - } else { -@@ -598,14 +829,34 @@ impl Default for LocalSet { - - impl Drop for LocalSet { - fn drop(&mut self) { -- self.with(|| { -+ self.with_if_possible(|| { - // Shut down all tasks in the LocalOwnedTasks and close it to - // prevent new tasks from ever being added. -- self.context.owned.close_and_shutdown_all(); -+ unsafe { -+ // Safety: called from the thread that owns `LocalSet` -+ self.context.shared.local_state.close_and_shutdown_all(); -+ } - - // We already called shutdown on all tasks above, so there is no - // need to call shutdown. -- for task in self.context.queue.take() { -+ -+ // Safety: note that this *intentionally* bypasses the unsafe -+ // `Shared::local_queue()` method. This is in order to avoid the -+ // debug assertion that we are on the thread that owns the -+ // `LocalSet`, because on some systems (e.g. at least some macOS -+ // versions), attempting to get the current thread ID can panic due -+ // to the thread's local data that stores the thread ID being -+ // dropped *before* the `LocalSet`. -+ // -+ // Despite avoiding the assertion here, it is safe for us to access -+ // the local queue in `Drop`, because the `LocalSet` itself is -+ // `!Send`, so we can reasonably guarantee that it will not be -+ // `Drop`ped from another thread. -+ let local_queue = unsafe { -+ // Safety: called from the thread that owns `LocalSet` -+ self.context.shared.local_state.take_local_queue() -+ }; -+ for task in local_queue { - drop(task); - } - -@@ -616,11 +867,41 @@ impl Drop for LocalSet { - drop(task); - } - -- assert!(self.context.owned.is_empty()); -+ // Safety: called from the thread that owns `LocalSet` -+ assert!(unsafe { self.context.shared.local_state.owned_is_empty() }); - }); - } - } - -+// === impl Context === -+ -+impl Context { -+ #[track_caller] -+ fn spawn(&self, future: F, name: Option<&str>) -> JoinHandle -+ where -+ F: Future + 'static, -+ F::Output: 'static, -+ { -+ let id = crate::runtime::task::Id::next(); -+ let future = crate::util::trace::task(future, "local", name, id.as_u64()); -+ -+ // Safety: called from the thread that owns the `LocalSet` -+ let (handle, notified) = { -+ self.shared.local_state.assert_called_from_owner_thread(); -+ self.shared -+ .local_state -+ .owned -+ .bind(future, self.shared.clone(), id) -+ }; -+ -+ if let Some(notified) = notified { -+ self.shared.schedule(notified); -+ } -+ -+ handle -+ } -+} -+ - // === impl LocalFuture === - - impl Future for RunUntil<'_, T> { -@@ -636,10 +917,10 @@ impl Future for RunUntil<'_, T> { - .waker - .register_by_ref(cx.waker()); - -- let _no_blocking = crate::runtime::enter::disallow_blocking(); -+ let _no_blocking = crate::runtime::context::disallow_block_in_place(); - let f = me.future; - -- if let Poll::Ready(output) = crate::coop::budget(|| f.poll(cx)) { -+ if let Poll::Ready(output) = f.poll(cx) { - return Poll::Ready(output); - } - -@@ -657,21 +938,41 @@ impl Future for RunUntil<'_, T> { - impl Shared { - /// Schedule the provided task on the scheduler. - fn schedule(&self, task: task::Notified>) { -- CURRENT.with(|maybe_cx| match maybe_cx { -- Some(cx) if cx.shared.ptr_eq(self) => { -- cx.queue.push_back(task); -- } -- _ => { -- // First check whether the queue is still there (if not, the -- // LocalSet is dropped). Then push to it if so, and if not, -- // do nothing. -- let mut lock = self.queue.lock(); -- -- if let Some(queue) = lock.as_mut() { -- queue.push_back(task); -- drop(lock); -+ CURRENT.with(|localdata| { -+ match localdata.ctx.get() { -+ Some(cx) if cx.shared.ptr_eq(self) => unsafe { -+ // Safety: if the current `LocalSet` context points to this -+ // `LocalSet`, then we are on the thread that owns it. -+ cx.shared.local_state.task_push_back(task); -+ }, -+ -+ // We are on the thread that owns the `LocalSet`, so we can -+ // wake to the local queue. -+ _ if context::thread_id().ok() == Some(self.local_state.owner) => { -+ unsafe { -+ // Safety: we just checked that the thread ID matches -+ // the localset's owner, so this is safe. -+ self.local_state.task_push_back(task); -+ } -+ // We still have to wake the `LocalSet`, because it isn't -+ // currently being polled. - self.waker.wake(); - } -+ -+ // We are *not* on the thread that owns the `LocalSet`, so we -+ // have to wake to the remote queue. -+ _ => { -+ // First, check whether the queue is still there (if not, the -+ // LocalSet is dropped). Then push to it if so, and if not, -+ // do nothing. -+ let mut lock = self.queue.lock(); -+ -+ if let Some(queue) = lock.as_mut() { -+ queue.push_back(task); -+ drop(lock); -+ self.waker.wake(); -+ } -+ } - } - }); - } -@@ -681,16 +982,194 @@ impl Shared { - } - } - -+// This is safe because (and only because) we *pinky pwomise* to never touch the -+// local run queue except from the thread that owns the `LocalSet`. -+unsafe impl Sync for Shared {} -+ - impl task::Schedule for Arc { - fn release(&self, task: &Task) -> Option> { -- CURRENT.with(|maybe_cx| { -- let cx = maybe_cx.expect("scheduler context missing"); -- assert!(cx.shared.ptr_eq(self)); -- cx.owned.remove(task) -- }) -+ // Safety, this is always called from the thread that owns `LocalSet` -+ unsafe { self.local_state.task_remove(task) } - } - - fn schedule(&self, task: task::Notified) { - Shared::schedule(self, task); - } -+ -+ cfg_unstable! { -+ fn unhandled_panic(&self) { -+ use crate::runtime::UnhandledPanic; -+ -+ match self.unhandled_panic { -+ UnhandledPanic::Ignore => { -+ // Do nothing -+ } -+ UnhandledPanic::ShutdownRuntime => { -+ // This hook is only called from within the runtime, so -+ // `CURRENT` should match with `&self`, i.e. there is no -+ // opportunity for a nested scheduler to be called. -+ CURRENT.with(|LocalData { ctx, .. }| match ctx.get() { -+ Some(cx) if Arc::ptr_eq(self, &cx.shared) => { -+ cx.unhandled_panic.set(true); -+ // Safety: this is always called from the thread that owns `LocalSet` -+ unsafe { cx.shared.local_state.close_and_shutdown_all(); } -+ } -+ _ => unreachable!("runtime core not set in CURRENT thread-local"), -+ }) -+ } -+ } -+ } -+ } -+} -+ -+impl LocalState { -+ unsafe fn task_pop_front(&self) -> Option>> { -+ // The caller ensures it is called from the same thread that owns -+ // the LocalSet. -+ self.assert_called_from_owner_thread(); -+ -+ self.local_queue.with_mut(|ptr| (*ptr).pop_front()) -+ } -+ -+ unsafe fn task_push_back(&self, task: task::Notified>) { -+ // The caller ensures it is called from the same thread that owns -+ // the LocalSet. -+ self.assert_called_from_owner_thread(); -+ -+ self.local_queue.with_mut(|ptr| (*ptr).push_back(task)) -+ } -+ -+ unsafe fn take_local_queue(&self) -> VecDeque>> { -+ // The caller ensures it is called from the same thread that owns -+ // the LocalSet. -+ self.assert_called_from_owner_thread(); -+ -+ self.local_queue.with_mut(|ptr| std::mem::take(&mut (*ptr))) -+ } -+ -+ unsafe fn task_remove(&self, task: &Task>) -> Option>> { -+ // The caller ensures it is called from the same thread that owns -+ // the LocalSet. -+ self.assert_called_from_owner_thread(); -+ -+ self.owned.remove(task) -+ } -+ -+ /// Returns true if the `LocalSet` does not have any spawned tasks -+ unsafe fn owned_is_empty(&self) -> bool { -+ // The caller ensures it is called from the same thread that owns -+ // the LocalSet. -+ self.assert_called_from_owner_thread(); -+ -+ self.owned.is_empty() -+ } -+ -+ unsafe fn assert_owner( -+ &self, -+ task: task::Notified>, -+ ) -> task::LocalNotified> { -+ // The caller ensures it is called from the same thread that owns -+ // the LocalSet. -+ self.assert_called_from_owner_thread(); -+ -+ self.owned.assert_owner(task) -+ } -+ -+ unsafe fn close_and_shutdown_all(&self) { -+ // The caller ensures it is called from the same thread that owns -+ // the LocalSet. -+ self.assert_called_from_owner_thread(); -+ -+ self.owned.close_and_shutdown_all() -+ } -+ -+ #[track_caller] -+ fn assert_called_from_owner_thread(&self) { -+ // FreeBSD has some weirdness around thread-local destruction. -+ // TODO: remove this hack when thread id is cleaned up -+ #[cfg(not(any(target_os = "openbsd", target_os = "freebsd")))] -+ debug_assert!( -+ // if we couldn't get the thread ID because we're dropping the local -+ // data, skip the assertion --- the `Drop` impl is not going to be -+ // called from another thread, because `LocalSet` is `!Send` -+ context::thread_id() -+ .map(|id| id == self.owner) -+ .unwrap_or(true), -+ "`LocalSet`'s local run queue must not be accessed by another thread!" -+ ); -+ } -+} -+ -+// This is `Send` because it is stored in `Shared`. It is up to the caller to -+// ensure they are on the same thread that owns the `LocalSet`. -+unsafe impl Send for LocalState {} -+ -+#[cfg(all(test, not(loom)))] -+mod tests { -+ use super::*; -+ -+ // Does a `LocalSet` running on a current-thread runtime...basically work? -+ // -+ // This duplicates a test in `tests/task_local_set.rs`, but because this is -+ // a lib test, it wil run under Miri, so this is necessary to catch stacked -+ // borrows violations in the `LocalSet` implementation. -+ #[test] -+ fn local_current_thread_scheduler() { -+ let f = async { -+ LocalSet::new() -+ .run_until(async { -+ spawn_local(async {}).await.unwrap(); -+ }) -+ .await; -+ }; -+ crate::runtime::Builder::new_current_thread() -+ .build() -+ .expect("rt") -+ .block_on(f) -+ } -+ -+ // Tests that when a task on a `LocalSet` is woken by an io driver on the -+ // same thread, the task is woken to the localset's local queue rather than -+ // its remote queue. -+ // -+ // This test has to be defined in the `local.rs` file as a lib test, rather -+ // than in `tests/`, because it makes assertions about the local set's -+ // internal state. -+ #[test] -+ fn wakes_to_local_queue() { -+ use super::*; -+ use crate::sync::Notify; -+ let rt = crate::runtime::Builder::new_current_thread() -+ .build() -+ .expect("rt"); -+ rt.block_on(async { -+ let local = LocalSet::new(); -+ let notify = Arc::new(Notify::new()); -+ let task = local.spawn_local({ -+ let notify = notify.clone(); -+ async move { -+ notify.notified().await; -+ } -+ }); -+ let mut run_until = Box::pin(local.run_until(async move { -+ task.await.unwrap(); -+ })); -+ -+ // poll the run until future once -+ crate::future::poll_fn(|cx| { -+ let _ = run_until.as_mut().poll(cx); -+ Poll::Ready(()) -+ }) -+ .await; -+ -+ notify.notify_one(); -+ let task = unsafe { local.context.shared.local_state.task_pop_front() }; -+ // TODO(eliza): it would be nice to be able to assert that this is -+ // the local task. -+ assert!( -+ task.is_some(), -+ "task should have been notified to the LocalSet's local queue" -+ ); -+ }) -+ } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/task/mod.rs b/KubeOS-Rust/vendor/tokio/src/task/mod.rs -index ea987873..9b753701 100644 ---- a/KubeOS-Rust/vendor/tokio/src/task/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/task/mod.rs -@@ -243,7 +243,7 @@ - //! - //! #### unconstrained - //! --//! If necessary, [`task::unconstrained`] lets you opt out a future of Tokio's cooperative -+//! If necessary, [`task::unconstrained`] lets you opt a future out of of Tokio's cooperative - //! scheduling. When a future is wrapped with `unconstrained`, it will never be forced to yield to - //! Tokio. For example: - //! -@@ -278,8 +278,10 @@ - cfg_rt! { - pub use crate::runtime::task::{JoinError, JoinHandle}; - -- mod blocking; -- pub use blocking::spawn_blocking; -+ cfg_not_wasi! { -+ mod blocking; -+ pub use blocking::spawn_blocking; -+ } - - mod spawn; - pub use spawn::spawn; -@@ -291,8 +293,13 @@ cfg_rt! { - mod yield_now; - pub use yield_now::yield_now; - -+ cfg_unstable! { -+ mod consume_budget; -+ pub use consume_budget::consume_budget; -+ } -+ - mod local; -- pub use local::{spawn_local, LocalSet}; -+ pub use local::{spawn_local, LocalSet, LocalEnterGuard}; - - mod task_local; - pub use task_local::LocalKey; -@@ -300,6 +307,20 @@ cfg_rt! { - mod unconstrained; - pub use unconstrained::{unconstrained, Unconstrained}; - -+ #[doc(inline)] -+ pub use join_set::JoinSet; -+ pub use crate::runtime::task::AbortHandle; -+ -+ // Uses #[cfg(...)] instead of macro since the macro adds docsrs annotations. -+ #[cfg(not(tokio_unstable))] -+ mod join_set; -+ #[cfg(tokio_unstable)] -+ pub mod join_set; -+ -+ cfg_unstable! { -+ pub use crate::runtime::task::{Id, id, try_id}; -+ } -+ - cfg_trace! { - mod builder; - pub use builder::Builder; -diff --git a/KubeOS-Rust/vendor/tokio/src/task/spawn.rs b/KubeOS-Rust/vendor/tokio/src/task/spawn.rs -index 065d38f5..66b0d673 100644 ---- a/KubeOS-Rust/vendor/tokio/src/task/spawn.rs -+++ b/KubeOS-Rust/vendor/tokio/src/task/spawn.rs -@@ -1,4 +1,5 @@ --use crate::{task::JoinHandle, util::error::CONTEXT_MISSING_ERROR}; -+use crate::runtime::Handle; -+use crate::task::JoinHandle; - - use std::future::Future; - -@@ -6,6 +7,10 @@ cfg_rt! { - /// Spawns a new asynchronous task, returning a - /// [`JoinHandle`](super::JoinHandle) for it. - /// -+ /// The provided future will start running in the background immediately -+ /// when `spawn` is called, even if you don't await the returned -+ /// `JoinHandle`. -+ /// - /// Spawning a task enables the task to execute concurrently to other tasks. The - /// spawned task may execute on the current thread, or it may be sent to a - /// different thread to be executed. The specifics depend on the current -@@ -49,6 +54,37 @@ cfg_rt! { - /// } - /// ``` - /// -+ /// To run multiple tasks in parallel and receive their results, join -+ /// handles can be stored in a vector. -+ /// ``` -+ /// # #[tokio::main(flavor = "current_thread")] async fn main() { -+ /// async fn my_background_op(id: i32) -> String { -+ /// let s = format!("Starting background task {}.", id); -+ /// println!("{}", s); -+ /// s -+ /// } -+ /// -+ /// let ops = vec![1, 2, 3]; -+ /// let mut tasks = Vec::with_capacity(ops.len()); -+ /// for op in ops { -+ /// // This call will make them start running in the background -+ /// // immediately. -+ /// tasks.push(tokio::spawn(my_background_op(op))); -+ /// } -+ /// -+ /// let mut outputs = Vec::with_capacity(tasks.len()); -+ /// for task in tasks { -+ /// outputs.push(task.await.unwrap()); -+ /// } -+ /// println!("{:?}", outputs); -+ /// # } -+ /// ``` -+ /// This example pushes the tasks to `outputs` in the order they were -+ /// started in. If you do not care about the ordering of the outputs, then -+ /// you can also use a [`JoinSet`]. -+ /// -+ /// [`JoinSet`]: struct@crate::task::JoinSet -+ /// - /// # Panics - /// - /// Panics if called from **outside** of the Tokio runtime. -@@ -121,7 +157,7 @@ cfg_rt! { - /// ```text - /// error[E0391]: cycle detected when processing `main` - /// ``` -- #[cfg_attr(tokio_track_caller, track_caller)] -+ #[track_caller] - pub fn spawn(future: T) -> JoinHandle - where - T: Future + Send + 'static, -@@ -136,14 +172,16 @@ cfg_rt! { - } - } - -- #[cfg_attr(tokio_track_caller, track_caller)] -+ #[track_caller] - pub(super) fn spawn_inner(future: T, name: Option<&str>) -> JoinHandle - where - T: Future + Send + 'static, - T::Output: Send + 'static, - { -- let spawn_handle = crate::runtime::context::spawn_handle().expect(CONTEXT_MISSING_ERROR); -- let task = crate::util::trace::task(future, "task", name); -- spawn_handle.spawn(task) -+ use crate::runtime::task; -+ let id = task::Id::next(); -+ let task = crate::util::trace::task(future, "task", name, id.as_u64()); -+ let handle = Handle::current(); -+ handle.inner.spawn(task, id) - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/task/task_local.rs b/KubeOS-Rust/vendor/tokio/src/task/task_local.rs -index b6e7df43..d3b108fe 100644 ---- a/KubeOS-Rust/vendor/tokio/src/task/task_local.rs -+++ b/KubeOS-Rust/vendor/tokio/src/task/task_local.rs -@@ -1,11 +1,10 @@ --use pin_project_lite::pin_project; - use std::cell::RefCell; - use std::error::Error; - use std::future::Future; - use std::marker::PhantomPinned; - use std::pin::Pin; - use std::task::{Context, Poll}; --use std::{fmt, thread}; -+use std::{fmt, mem, thread}; - - /// Declares a new task-local key of type [`tokio::task::LocalKey`]. - /// -@@ -48,9 +47,27 @@ macro_rules! task_local { - } - - #[doc(hidden)] -+#[cfg(not(tokio_no_const_thread_local))] - #[macro_export] - macro_rules! __task_local_inner { - ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty) => { -+ $(#[$attr])* -+ $vis static $name: $crate::task::LocalKey<$t> = { -+ std::thread_local! { -+ static __KEY: std::cell::RefCell> = const { std::cell::RefCell::new(None) }; -+ } -+ -+ $crate::task::LocalKey { inner: __KEY } -+ }; -+ }; -+} -+ -+#[doc(hidden)] -+#[cfg(tokio_no_const_thread_local)] -+#[macro_export] -+macro_rules! __task_local_inner { -+ ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty) => { -+ $(#[$attr])* - $vis static $name: $crate::task::LocalKey<$t> = { - std::thread_local! { - static __KEY: std::cell::RefCell> = std::cell::RefCell::new(None); -@@ -63,7 +80,7 @@ macro_rules! __task_local_inner { - - /// A key for task-local data. - /// --/// This type is generated by the `task_local!` macro. -+/// This type is generated by the [`task_local!`] macro. - /// - /// Unlike [`std::thread::LocalKey`], `tokio::task::LocalKey` will - /// _not_ lazily initialize the value on first access. Instead, the -@@ -91,7 +108,9 @@ macro_rules! __task_local_inner { - /// }).await; - /// # } - /// ``` -+/// - /// [`std::thread::LocalKey`]: struct@std::thread::LocalKey -+/// [`task_local!`]: ../macro.task_local.html - #[cfg_attr(docsrs, doc(cfg(feature = "rt")))] - pub struct LocalKey { - #[doc(hidden)] -@@ -103,6 +122,11 @@ impl LocalKey { - /// - /// On completion of `scope`, the task-local will be dropped. - /// -+ /// ### Panics -+ /// -+ /// If you poll the returned future inside a call to [`with`] or -+ /// [`try_with`] on the same `LocalKey`, then the call to `poll` will panic. -+ /// - /// ### Examples - /// - /// ``` -@@ -116,6 +140,9 @@ impl LocalKey { - /// }).await; - /// # } - /// ``` -+ /// -+ /// [`with`]: fn@Self::with -+ /// [`try_with`]: fn@Self::try_with - pub fn scope(&'static self, value: T, f: F) -> TaskLocalFuture - where - F: Future, -@@ -123,14 +150,19 @@ impl LocalKey { - TaskLocalFuture { - local: self, - slot: Some(value), -- future: f, -+ future: Some(f), - _pinned: PhantomPinned, - } - } - - /// Sets a value `T` as the task-local value for the closure `F`. - /// -- /// On completion of `scope`, the task-local will be dropped. -+ /// On completion of `sync_scope`, the task-local will be dropped. -+ /// -+ /// ### Panics -+ /// -+ /// This method panics if called inside a call to [`with`] or [`try_with`] -+ /// on the same `LocalKey`. - /// - /// ### Examples - /// -@@ -145,34 +177,80 @@ impl LocalKey { - /// }); - /// # } - /// ``` -+ /// -+ /// [`with`]: fn@Self::with -+ /// [`try_with`]: fn@Self::try_with -+ #[track_caller] - pub fn sync_scope(&'static self, value: T, f: F) -> R - where - F: FnOnce() -> R, - { -- let scope = TaskLocalFuture { -- local: self, -- slot: Some(value), -- future: (), -- _pinned: PhantomPinned, -- }; -- crate::pin!(scope); -- scope.with_task(|_| f()) -+ let mut value = Some(value); -+ match self.scope_inner(&mut value, f) { -+ Ok(res) => res, -+ Err(err) => err.panic(), -+ } -+ } -+ -+ fn scope_inner(&'static self, slot: &mut Option, f: F) -> Result -+ where -+ F: FnOnce() -> R, -+ { -+ struct Guard<'a, T: 'static> { -+ local: &'static LocalKey, -+ slot: &'a mut Option, -+ } -+ -+ impl<'a, T: 'static> Drop for Guard<'a, T> { -+ fn drop(&mut self) { -+ // This should not panic. -+ // -+ // We know that the RefCell was not borrowed before the call to -+ // `scope_inner`, so the only way for this to panic is if the -+ // closure has created but not destroyed a RefCell guard. -+ // However, we never give user-code access to the guards, so -+ // there's no way for user-code to forget to destroy a guard. -+ // -+ // The call to `with` also should not panic, since the -+ // thread-local wasn't destroyed when we first called -+ // `scope_inner`, and it shouldn't have gotten destroyed since -+ // then. -+ self.local.inner.with(|inner| { -+ let mut ref_mut = inner.borrow_mut(); -+ mem::swap(self.slot, &mut *ref_mut); -+ }); -+ } -+ } -+ -+ self.inner.try_with(|inner| { -+ inner -+ .try_borrow_mut() -+ .map(|mut ref_mut| mem::swap(slot, &mut *ref_mut)) -+ })??; -+ -+ let guard = Guard { local: self, slot }; -+ -+ let res = f(); -+ -+ drop(guard); -+ -+ Ok(res) - } - - /// Accesses the current task-local and runs the provided closure. - /// - /// # Panics - /// -- /// This function will panic if not called within the context -- /// of a future containing a task-local with the corresponding key. -+ /// This function will panic if the task local doesn't have a value set. -+ #[track_caller] - pub fn with(&'static self, f: F) -> R - where - F: FnOnce(&T) -> R, - { -- self.try_with(f).expect( -- "cannot access a Task Local Storage value \ -- without setting it via `LocalKey::set`", -- ) -+ match self.try_with(f) { -+ Ok(res) => res, -+ Err(_) => panic!("cannot access a task-local storage value without setting it first"), -+ } - } - - /// Accesses the current task-local and runs the provided closure. -@@ -184,19 +262,32 @@ impl LocalKey { - where - F: FnOnce(&T) -> R, - { -- self.inner.with(|v| { -- if let Some(val) = v.borrow().as_ref() { -- Ok(f(val)) -- } else { -- Err(AccessError { _private: () }) -- } -- }) -+ // If called after the thread-local storing the task-local is destroyed, -+ // then we are outside of a closure where the task-local is set. -+ // -+ // Therefore, it is correct to return an AccessError if `try_with` -+ // returns an error. -+ let try_with_res = self.inner.try_with(|v| { -+ // This call to `borrow` cannot panic because no user-defined code -+ // runs while a `borrow_mut` call is active. -+ v.borrow().as_ref().map(f) -+ }); -+ -+ match try_with_res { -+ Ok(Some(res)) => Ok(res), -+ Ok(None) | Err(_) => Err(AccessError { _private: () }), -+ } - } - } - - impl LocalKey { - /// Returns a copy of the task-local value - /// if the task-local value implements `Copy`. -+ /// -+ /// # Panics -+ /// -+ /// This function will panic if the task local doesn't have a value set. -+ #[track_caller] - pub fn get(&'static self) -> T { - self.with(|v| *v) - } -@@ -208,76 +299,104 @@ impl fmt::Debug for LocalKey { - } - } - --pin_project! { -- /// A future that sets a value `T` of a task local for the future `F` during -- /// its execution. -- /// -- /// The value of the task-local must be `'static` and will be dropped on the -- /// completion of the future. -- /// -- /// Created by the function [`LocalKey::scope`](self::LocalKey::scope). -- /// -- /// ### Examples -- /// -- /// ``` -- /// # async fn dox() { -- /// tokio::task_local! { -- /// static NUMBER: u32; -- /// } -- /// -- /// NUMBER.scope(1, async move { -- /// println!("task local value: {}", NUMBER.get()); -- /// }).await; -- /// # } -- /// ``` -- pub struct TaskLocalFuture -- where -- T: 'static -- { -- local: &'static LocalKey, -- slot: Option, -- #[pin] -- future: F, -- #[pin] -- _pinned: PhantomPinned, -- } -+/// A future that sets a value `T` of a task local for the future `F` during -+/// its execution. -+/// -+/// The value of the task-local must be `'static` and will be dropped on the -+/// completion of the future. -+/// -+/// Created by the function [`LocalKey::scope`](self::LocalKey::scope). -+/// -+/// ### Examples -+/// -+/// ``` -+/// # async fn dox() { -+/// tokio::task_local! { -+/// static NUMBER: u32; -+/// } -+/// -+/// NUMBER.scope(1, async move { -+/// println!("task local value: {}", NUMBER.get()); -+/// }).await; -+/// # } -+/// ``` -+// Doesn't use pin_project due to custom Drop. -+pub struct TaskLocalFuture -+where -+ T: 'static, -+{ -+ local: &'static LocalKey, -+ slot: Option, -+ future: Option, -+ _pinned: PhantomPinned, - } - --impl TaskLocalFuture { -- fn with_task) -> R, R>(self: Pin<&mut Self>, f: F2) -> R { -- struct Guard<'a, T: 'static> { -- local: &'static LocalKey, -- slot: &'a mut Option, -- prev: Option, -- } -- -- impl Drop for Guard<'_, T> { -- fn drop(&mut self) { -- let value = self.local.inner.with(|c| c.replace(self.prev.take())); -- *self.slot = value; -- } -- } -+impl Future for TaskLocalFuture { -+ type Output = F::Output; - -- let mut project = self.project(); -- let val = project.slot.take(); -+ #[track_caller] -+ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -+ // safety: The TaskLocalFuture struct is `!Unpin` so there is no way to -+ // move `self.future` from now on. -+ let this = unsafe { Pin::into_inner_unchecked(self) }; -+ let mut future_opt = unsafe { Pin::new_unchecked(&mut this.future) }; - -- let prev = project.local.inner.with(|c| c.replace(val)); -+ let res = -+ this.local -+ .scope_inner(&mut this.slot, || match future_opt.as_mut().as_pin_mut() { -+ Some(fut) => { -+ let res = fut.poll(cx); -+ if res.is_ready() { -+ future_opt.set(None); -+ } -+ Some(res) -+ } -+ None => None, -+ }); - -- let _guard = Guard { -- prev, -- slot: &mut project.slot, -- local: *project.local, -- }; -+ match res { -+ Ok(Some(res)) => res, -+ Ok(None) => panic!("`TaskLocalFuture` polled after completion"), -+ Err(err) => err.panic(), -+ } -+ } -+} - -- f(project.future) -+impl Drop for TaskLocalFuture { -+ fn drop(&mut self) { -+ if mem::needs_drop::() && self.future.is_some() { -+ // Drop the future while the task-local is set, if possible. Otherwise -+ // the future is dropped normally when the `Option` field drops. -+ let future = &mut self.future; -+ let _ = self.local.scope_inner(&mut self.slot, || { -+ *future = None; -+ }); -+ } - } - } - --impl Future for TaskLocalFuture { -- type Output = F::Output; -+impl fmt::Debug for TaskLocalFuture -+where -+ T: fmt::Debug, -+{ -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ /// Format the Option without Some. -+ struct TransparentOption<'a, T> { -+ value: &'a Option, -+ } -+ impl<'a, T: fmt::Debug> fmt::Debug for TransparentOption<'a, T> { -+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -+ match self.value.as_ref() { -+ Some(value) => value.fmt(f), -+ // Hitting the None branch should not be possible. -+ None => f.pad(""), -+ } -+ } -+ } - -- fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -- self.with_task(|f| f.poll(cx)) -+ f.debug_struct("TaskLocalFuture") -+ .field("value", &TransparentOption { value: &self.slot }) -+ .finish() - } - } - -@@ -300,3 +419,30 @@ impl fmt::Display for AccessError { - } - - impl Error for AccessError {} -+ -+enum ScopeInnerErr { -+ BorrowError, -+ AccessError, -+} -+ -+impl ScopeInnerErr { -+ #[track_caller] -+ fn panic(&self) -> ! { -+ match self { -+ Self::BorrowError => panic!("cannot enter a task-local scope while the task-local storage is borrowed"), -+ Self::AccessError => panic!("cannot enter a task-local scope during or after destruction of the underlying thread-local"), -+ } -+ } -+} -+ -+impl From for ScopeInnerErr { -+ fn from(_: std::cell::BorrowMutError) -> Self { -+ Self::BorrowError -+ } -+} -+ -+impl From for ScopeInnerErr { -+ fn from(_: std::thread::AccessError) -> Self { -+ Self::AccessError -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/task/unconstrained.rs b/KubeOS-Rust/vendor/tokio/src/task/unconstrained.rs -index 31c732bf..40384c87 100644 ---- a/KubeOS-Rust/vendor/tokio/src/task/unconstrained.rs -+++ b/KubeOS-Rust/vendor/tokio/src/task/unconstrained.rs -@@ -22,7 +22,7 @@ where - cfg_coop! { - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let inner = self.project().inner; -- crate::coop::with_unconstrained(|| inner.poll(cx)) -+ crate::runtime::coop::with_unconstrained(|| inner.poll(cx)) - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/task/yield_now.rs b/KubeOS-Rust/vendor/tokio/src/task/yield_now.rs -index 5eeb46a8..7b61dd86 100644 ---- a/KubeOS-Rust/vendor/tokio/src/task/yield_now.rs -+++ b/KubeOS-Rust/vendor/tokio/src/task/yield_now.rs -@@ -1,3 +1,5 @@ -+use crate::runtime::context; -+ - use std::future::Future; - use std::pin::Pin; - use std::task::{Context, Poll}; -@@ -33,7 +35,6 @@ use std::task::{Context, Poll}; - /// which order the runtime polls your tasks in. - /// - /// [`tokio::select!`]: macro@crate::select --#[must_use = "yield_now does nothing unless polled/`await`-ed"] - #[cfg_attr(docsrs, doc(cfg(feature = "rt")))] - pub async fn yield_now() { - /// Yield implementation -@@ -50,7 +51,17 @@ pub async fn yield_now() { - } - - self.yielded = true; -- cx.waker().wake_by_ref(); -+ -+ let defer = context::with_defer(|rt| { -+ rt.defer(cx.waker().clone()); -+ }); -+ -+ if defer.is_none() { -+ // Not currently in a runtime, just notify ourselves -+ // immediately. -+ cx.waker().wake_by_ref(); -+ } -+ - Poll::Pending - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/time/clock.rs b/KubeOS-Rust/vendor/tokio/src/time/clock.rs -index 41be9bac..091cf4b1 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/clock.rs -+++ b/KubeOS-Rust/vendor/tokio/src/time/clock.rs -@@ -29,26 +29,53 @@ cfg_not_test_util! { - - cfg_test_util! { - use crate::time::{Duration, Instant}; -- use crate::loom::sync::{Arc, Mutex}; -+ use crate::loom::sync::Mutex; -+ use crate::loom::sync::atomic::Ordering; -+ use std::sync::atomic::AtomicBool as StdAtomicBool; - - cfg_rt! { -- fn clock() -> Option { -- crate::runtime::context::clock() -+ #[track_caller] -+ fn with_clock(f: impl FnOnce(Option<&Clock>) -> Result) -> R { -+ use crate::runtime::Handle; -+ -+ let res = match Handle::try_current() { -+ Ok(handle) => f(Some(handle.inner.driver().clock())), -+ Err(ref e) if e.is_missing_context() => f(None), -+ Err(_) => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR), -+ }; -+ -+ match res { -+ Ok(ret) => ret, -+ Err(msg) => panic!("{}", msg), -+ } - } - } - - cfg_not_rt! { -- fn clock() -> Option { -- None -+ #[track_caller] -+ fn with_clock(f: impl FnOnce(Option<&Clock>) -> Result) -> R { -+ match f(None) { -+ Ok(ret) => ret, -+ Err(msg) => panic!("{}", msg), -+ } - } - } - - /// A handle to a source of time. -- #[derive(Debug, Clone)] -+ #[derive(Debug)] - pub(crate) struct Clock { -- inner: Arc>, -+ inner: Mutex, - } - -+ // Used to track if the clock was ever paused. This is an optimization to -+ // avoid touching the mutex if `test-util` was accidentally enabled in -+ // release mode. -+ // -+ // A static is used so we can avoid accessing the thread-local as well. The -+ // `std` AtomicBool is used directly because loom does not support static -+ // atomics. -+ static DID_PAUSE_CLOCK: StdAtomicBool = StdAtomicBool::new(false); -+ - #[derive(Debug)] - struct Inner { - /// True if the ability to pause time is enabled. -@@ -59,6 +86,9 @@ cfg_test_util! { - - /// Instant at which the clock was last unfrozen. - unfrozen: Option, -+ -+ /// Number of `inhibit_auto_advance` calls still in effect. -+ auto_advance_inhibit_count: usize, - } - - /// Pauses time. -@@ -96,9 +126,14 @@ cfg_test_util! { - /// - /// [`Sleep`]: crate::time::Sleep - /// [`advance`]: crate::time::advance -+ #[track_caller] - pub fn pause() { -- let clock = clock().expect("time cannot be frozen from outside the Tokio runtime"); -- clock.pause(); -+ with_clock(|maybe_clock| { -+ match maybe_clock { -+ Some(clock) => clock.pause(), -+ None => Err("time cannot be frozen from outside the Tokio runtime"), -+ } -+ }) - } - - /// Resumes time. -@@ -110,15 +145,23 @@ cfg_test_util! { - /// - /// Panics if time is not frozen or if called from outside of the Tokio - /// runtime. -+ #[track_caller] - pub fn resume() { -- let clock = clock().expect("time cannot be frozen from outside the Tokio runtime"); -- let mut inner = clock.inner.lock(); -+ with_clock(|maybe_clock| { -+ let clock = match maybe_clock { -+ Some(clock) => clock, -+ None => return Err("time cannot be frozen from outside the Tokio runtime"), -+ }; - -- if inner.unfrozen.is_some() { -- panic!("time is not frozen"); -- } -+ let mut inner = clock.inner.lock(); -+ -+ if inner.unfrozen.is_some() { -+ return Err("time is not frozen"); -+ } - -- inner.unfrozen = Some(std::time::Instant::now()); -+ inner.unfrozen = Some(std::time::Instant::now()); -+ Ok(()) -+ }) - } - - /// Advances time. -@@ -153,19 +196,31 @@ cfg_test_util! { - /// - /// [`sleep`]: fn@crate::time::sleep - pub async fn advance(duration: Duration) { -- let clock = clock().expect("time cannot be frozen from outside the Tokio runtime"); -- clock.advance(duration); -+ with_clock(|maybe_clock| { -+ let clock = match maybe_clock { -+ Some(clock) => clock, -+ None => return Err("time cannot be frozen from outside the Tokio runtime"), -+ }; -+ -+ clock.advance(duration) -+ }); - - crate::task::yield_now().await; - } - - /// Returns the current instant, factoring in frozen time. - pub(crate) fn now() -> Instant { -- if let Some(clock) = clock() { -- clock.now() -- } else { -- Instant::from_std(std::time::Instant::now()) -+ if !DID_PAUSE_CLOCK.load(Ordering::Acquire) { -+ return Instant::from_std(std::time::Instant::now()); - } -+ -+ with_clock(|maybe_clock| { -+ Ok(if let Some(clock) = maybe_clock { -+ clock.now() -+ } else { -+ Instant::from_std(std::time::Instant::now()) -+ }) -+ }) - } - - impl Clock { -@@ -175,47 +230,70 @@ cfg_test_util! { - let now = std::time::Instant::now(); - - let clock = Clock { -- inner: Arc::new(Mutex::new(Inner { -+ inner: Mutex::new(Inner { - enable_pausing, - base: now, - unfrozen: Some(now), -- })), -+ auto_advance_inhibit_count: 0, -+ }), - }; - - if start_paused { -- clock.pause(); -+ if let Err(msg) = clock.pause() { -+ panic!("{}", msg); -+ } - } - - clock - } - -- pub(crate) fn pause(&self) { -+ pub(crate) fn pause(&self) -> Result<(), &'static str> { - let mut inner = self.inner.lock(); - - if !inner.enable_pausing { - drop(inner); // avoid poisoning the lock -- panic!("`time::pause()` requires the `current_thread` Tokio runtime. \ -+ return Err("`time::pause()` requires the `current_thread` Tokio runtime. \ - This is the default Runtime used by `#[tokio::test]."); - } - -- let elapsed = inner.unfrozen.as_ref().expect("time is already frozen").elapsed(); -+ // Track that we paused the clock -+ DID_PAUSE_CLOCK.store(true, Ordering::Release); -+ -+ let elapsed = match inner.unfrozen.as_ref() { -+ Some(v) => v.elapsed(), -+ None => return Err("time is already frozen") -+ }; - inner.base += elapsed; - inner.unfrozen = None; -+ -+ Ok(()) -+ } -+ -+ /// Temporarily stop auto-advancing the clock (see `tokio::time::pause`). -+ pub(crate) fn inhibit_auto_advance(&self) { -+ let mut inner = self.inner.lock(); -+ inner.auto_advance_inhibit_count += 1; -+ } -+ -+ pub(crate) fn allow_auto_advance(&self) { -+ let mut inner = self.inner.lock(); -+ inner.auto_advance_inhibit_count -= 1; - } - -- pub(crate) fn is_paused(&self) -> bool { -+ pub(crate) fn can_auto_advance(&self) -> bool { - let inner = self.inner.lock(); -- inner.unfrozen.is_none() -+ inner.unfrozen.is_none() && inner.auto_advance_inhibit_count == 0 - } - -- pub(crate) fn advance(&self, duration: Duration) { -+ pub(crate) fn advance(&self, duration: Duration) -> Result<(), &'static str> { - let mut inner = self.inner.lock(); - - if inner.unfrozen.is_some() { -- panic!("time is not frozen"); -+ return Err("time is not frozen"); - } - - inner.base += duration; -+ Ok(()) - } - - pub(crate) fn now(&self) -> Instant { -diff --git a/KubeOS-Rust/vendor/tokio/src/time/driver/handle.rs b/KubeOS-Rust/vendor/tokio/src/time/driver/handle.rs -deleted file mode 100644 -index 7aaf65a7..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/time/driver/handle.rs -+++ /dev/null -@@ -1,88 +0,0 @@ --use crate::loom::sync::Arc; --use crate::time::driver::ClockTime; --use std::fmt; -- --/// Handle to time driver instance. --#[derive(Clone)] --pub(crate) struct Handle { -- time_source: ClockTime, -- inner: Arc, --} -- --impl Handle { -- /// Creates a new timer `Handle` from a shared `Inner` timer state. -- pub(super) fn new(inner: Arc) -> Self { -- let time_source = inner.state.lock().time_source.clone(); -- Handle { time_source, inner } -- } -- -- /// Returns the time source associated with this handle. -- pub(super) fn time_source(&self) -> &ClockTime { -- &self.time_source -- } -- -- /// Access the driver's inner structure. -- pub(super) fn get(&self) -> &super::Inner { -- &*self.inner -- } -- -- /// Checks whether the driver has been shutdown. -- pub(super) fn is_shutdown(&self) -> bool { -- self.inner.is_shutdown() -- } --} -- --cfg_rt! { -- impl Handle { -- /// Tries to get a handle to the current timer. -- /// -- /// # Panics -- /// -- /// This function panics if there is no current timer set. -- /// -- /// It can be triggered when `Builder::enable_time()` or -- /// `Builder::enable_all()` are not included in the builder. -- /// -- /// It can also panic whenever a timer is created outside of a -- /// Tokio runtime. That is why `rt.block_on(delay_for(...))` will panic, -- /// since the function is executed outside of the runtime. -- /// Whereas `rt.block_on(async {delay_for(...).await})` doesn't panic. -- /// And this is because wrapping the function on an async makes it lazy, -- /// and so gets executed inside the runtime successfully without -- /// panicking. -- pub(crate) fn current() -> Self { -- crate::runtime::context::time_handle() -- .expect("A Tokio 1.x context was found, but timers are disabled. Call `enable_time` on the runtime builder to enable timers.") -- } -- } --} -- --cfg_not_rt! { -- impl Handle { -- /// Tries to get a handle to the current timer. -- /// -- /// # Panics -- /// -- /// This function panics if there is no current timer set. -- /// -- /// It can be triggered when `Builder::enable_time()` or -- /// `Builder::enable_all()` are not included in the builder. -- /// -- /// It can also panic whenever a timer is created outside of a Tokio -- /// runtime. That is why `rt.block_on(delay_for(...))` will panic, -- /// since the function is executed outside of the runtime. -- /// Whereas `rt.block_on(async {delay_for(...).await})` doesn't -- /// panic. And this is because wrapping the function on an async makes it -- /// lazy, and so outside executed inside the runtime successfully without -- /// panicking. -- pub(crate) fn current() -> Self { -- panic!("{}", crate::util::error::CONTEXT_MISSING_ERROR) -- } -- } --} -- --impl fmt::Debug for Handle { -- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -- write!(f, "Handle") -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/time/driver/wheel/stack.rs b/KubeOS-Rust/vendor/tokio/src/time/driver/wheel/stack.rs -deleted file mode 100644 -index 80651c30..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/time/driver/wheel/stack.rs -+++ /dev/null -@@ -1,112 +0,0 @@ --use super::{Item, OwnedItem}; --use crate::time::driver::Entry; -- --use std::ptr; -- --/// A doubly linked stack. --#[derive(Debug)] --pub(crate) struct Stack { -- head: Option, --} -- --impl Default for Stack { -- fn default() -> Stack { -- Stack { head: None } -- } --} -- --impl Stack { -- pub(crate) fn is_empty(&self) -> bool { -- self.head.is_none() -- } -- -- pub(crate) fn push(&mut self, entry: OwnedItem) { -- // Get a pointer to the entry to for the prev link -- let ptr: *const Entry = &*entry as *const _; -- -- // Remove the old head entry -- let old = self.head.take(); -- -- unsafe { -- // Ensure the entry is not already in a stack. -- debug_assert!((*entry.next_stack.get()).is_none()); -- debug_assert!((*entry.prev_stack.get()).is_null()); -- -- if let Some(ref entry) = old.as_ref() { -- debug_assert!({ -- // The head is not already set to the entry -- ptr != &***entry as *const _ -- }); -- -- // Set the previous link on the old head -- *entry.prev_stack.get() = ptr; -- } -- -- // Set this entry's next pointer -- *entry.next_stack.get() = old; -- } -- -- // Update the head pointer -- self.head = Some(entry); -- } -- -- /// Pops an item from the stack. -- pub(crate) fn pop(&mut self) -> Option { -- let entry = self.head.take(); -- -- unsafe { -- if let Some(entry) = entry.as_ref() { -- self.head = (*entry.next_stack.get()).take(); -- -- if let Some(entry) = self.head.as_ref() { -- *entry.prev_stack.get() = ptr::null(); -- } -- -- *entry.prev_stack.get() = ptr::null(); -- } -- } -- -- entry -- } -- -- pub(crate) fn remove(&mut self, entry: &Item) { -- unsafe { -- // Ensure that the entry is in fact contained by the stack -- debug_assert!({ -- // This walks the full linked list even if an entry is found. -- let mut next = self.head.as_ref(); -- let mut contains = false; -- -- while let Some(n) = next { -- if entry as *const _ == &**n as *const _ { -- debug_assert!(!contains); -- contains = true; -- } -- -- next = (*n.next_stack.get()).as_ref(); -- } -- -- contains -- }); -- -- // Unlink `entry` from the next node -- let next = (*entry.next_stack.get()).take(); -- -- if let Some(next) = next.as_ref() { -- (*next.prev_stack.get()) = *entry.prev_stack.get(); -- } -- -- // Unlink `entry` from the prev node -- -- if let Some(prev) = (*entry.prev_stack.get()).as_ref() { -- *prev.next_stack.get() = next; -- } else { -- // It is the head -- self.head = next; -- } -- -- // Unset the prev pointer -- *entry.prev_stack.get() = ptr::null(); -- } -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/time/error.rs b/KubeOS-Rust/vendor/tokio/src/time/error.rs -index 63f0a3b0..71344d43 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/error.rs -+++ b/KubeOS-Rust/vendor/tokio/src/time/error.rs -@@ -41,7 +41,10 @@ impl From for Error { - } - - /// Errors returned by `Timeout`. --#[derive(Debug, PartialEq)] -+/// -+/// This error is returned when a timeout expires before the function was able -+/// to finish. -+#[derive(Debug, PartialEq, Eq)] - pub struct Elapsed(()); - - #[derive(Debug)] -diff --git a/KubeOS-Rust/vendor/tokio/src/time/instant.rs b/KubeOS-Rust/vendor/tokio/src/time/instant.rs -index f7cf12d4..14cf6e56 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/instant.rs -+++ b/KubeOS-Rust/vendor/tokio/src/time/instant.rs -@@ -67,13 +67,10 @@ impl Instant { - self.std - } - -- /// Returns the amount of time elapsed from another instant to this one. -- /// -- /// # Panics -- /// -- /// This function will panic if `earlier` is later than `self`. -+ /// Returns the amount of time elapsed from another instant to this one, or -+ /// zero duration if that instant is later than this one. - pub fn duration_since(&self, earlier: Instant) -> Duration { -- self.std.duration_since(earlier.std) -+ self.std.saturating_duration_since(earlier.std) - } - - /// Returns the amount of time elapsed from another instant to this one, or -@@ -118,13 +115,8 @@ impl Instant { - self.std.saturating_duration_since(earlier.std) - } - -- /// Returns the amount of time elapsed since this instant was created. -- /// -- /// # Panics -- /// -- /// This function may panic if the current time is earlier than this -- /// instant, which is something that can happen if an `Instant` is -- /// produced synthetically. -+ /// Returns the amount of time elapsed since this instant was created, -+ /// or zero duration if that this instant is in the future. - /// - /// # Examples - /// -@@ -140,7 +132,7 @@ impl Instant { - /// } - /// ``` - pub fn elapsed(&self) -> Duration { -- Instant::now() - *self -+ Instant::now().saturating_duration_since(*self) - } - - /// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be -@@ -188,7 +180,7 @@ impl ops::Sub for Instant { - type Output = Duration; - - fn sub(self, rhs: Instant) -> Duration { -- self.std - rhs.std -+ self.std.saturating_duration_since(rhs.std) - } - } - -@@ -196,7 +188,7 @@ impl ops::Sub for Instant { - type Output = Instant; - - fn sub(self, rhs: Duration) -> Instant { -- Instant::from_std(self.std - rhs) -+ Instant::from_std(std::time::Instant::sub(self.std, rhs)) - } - } - -diff --git a/KubeOS-Rust/vendor/tokio/src/time/interval.rs b/KubeOS-Rust/vendor/tokio/src/time/interval.rs -index 7e07e512..cc17c5a2 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/interval.rs -+++ b/KubeOS-Rust/vendor/tokio/src/time/interval.rs -@@ -1,9 +1,11 @@ - use crate::future::poll_fn; - use crate::time::{sleep_until, Duration, Instant, Sleep}; -+use crate::util::trace; - -+use std::future::Future; -+use std::panic::Location; - use std::pin::Pin; - use std::task::{Context, Poll}; --use std::{convert::TryInto, future::Future}; - - /// Creates new [`Interval`] that yields with interval of `period`. The first - /// tick completes immediately. The default [`MissedTickBehavior`] is -@@ -68,10 +70,10 @@ use std::{convert::TryInto, future::Future}; - /// - /// [`sleep`]: crate::time::sleep() - /// [`.tick().await`]: Interval::tick -+#[track_caller] - pub fn interval(period: Duration) -> Interval { - assert!(period > Duration::new(0, 0), "`period` must be non-zero."); -- -- interval_at(Instant::now(), period) -+ internal_interval_at(Instant::now(), period, trace::caller_location()) - } - - /// Creates new [`Interval`] that yields with interval of `period` with the -@@ -103,13 +105,44 @@ pub fn interval(period: Duration) -> Interval { - /// // approximately 70ms have elapsed. - /// } - /// ``` -+#[track_caller] - pub fn interval_at(start: Instant, period: Duration) -> Interval { - assert!(period > Duration::new(0, 0), "`period` must be non-zero."); -+ internal_interval_at(start, period, trace::caller_location()) -+} -+ -+#[cfg_attr(not(all(tokio_unstable, feature = "tracing")), allow(unused_variables))] -+fn internal_interval_at( -+ start: Instant, -+ period: Duration, -+ location: Option<&'static Location<'static>>, -+) -> Interval { -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = { -+ let location = location.expect("should have location if tracing"); -+ -+ tracing::trace_span!( -+ "runtime.resource", -+ concrete_type = "Interval", -+ kind = "timer", -+ loc.file = location.file(), -+ loc.line = location.line(), -+ loc.col = location.column(), -+ ) -+ }; -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let delay = resource_span.in_scope(|| Box::pin(sleep_until(start))); -+ -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ let delay = Box::pin(sleep_until(start)); - - Interval { -- delay: Box::pin(sleep_until(start)), -+ delay, - period, - missed_tick_behavior: Default::default(), -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span, - } - } - -@@ -124,7 +157,7 @@ pub fn interval_at(start: Instant, period: Duration) -> Interval { - /// - /// #[tokio::main] - /// async fn main() { --/// // ticks every 2 seconds -+/// // ticks every 2 milliseconds - /// let mut interval = time::interval(Duration::from_millis(2)); - /// for _ in 0..5 { - /// interval.tick().await; -@@ -174,6 +207,9 @@ pub enum MissedTickBehavior { - /// # async fn main() { - /// let mut interval = interval(Duration::from_millis(50)); - /// -+ /// // First tick resolves immediately after creation -+ /// interval.tick().await; -+ /// - /// task_that_takes_200_millis().await; - /// // The `Interval` has missed a tick - /// -@@ -242,7 +278,7 @@ pub enum MissedTickBehavior { - /// // 50ms after the call to `tick` up above. That is, in `tick`, when we - /// // recognize that we missed a tick, we schedule the next tick to happen - /// // 50ms (or whatever the `period` is) from right then, not from when -- /// // were were *supposed* to tick -+ /// // were *supposed* to tick - /// interval.tick().await; - /// # } - /// ``` -@@ -362,6 +398,9 @@ pub struct Interval { - - /// The strategy `Interval` should use when a tick is missed. - missed_tick_behavior: MissedTickBehavior, -+ -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ resource_span: tracing::Span, - } - - impl Interval { -@@ -384,6 +423,7 @@ impl Interval { - /// let mut interval = time::interval(Duration::from_millis(10)); - /// - /// interval.tick().await; -+ /// // approximately 0ms have elapsed. The first tick completes immediately. - /// interval.tick().await; - /// interval.tick().await; - /// -@@ -391,7 +431,20 @@ impl Interval { - /// } - /// ``` - pub async fn tick(&mut self) -> Instant { -- poll_fn(|cx| self.poll_tick(cx)).await -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let resource_span = self.resource_span.clone(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let instant = trace::async_op( -+ || poll_fn(|cx| self.poll_tick(cx)), -+ resource_span, -+ "Interval::tick", -+ "poll_tick", -+ false, -+ ); -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] -+ let instant = poll_fn(|cx| self.poll_tick(cx)); -+ -+ instant.await - } - - /// Polls for the next instant in the interval to be reached. -@@ -429,12 +482,45 @@ impl Interval { - timeout + self.period - }; - -- self.delay.as_mut().reset(next); -+ // When we arrive here, the internal delay returned `Poll::Ready`. -+ // Reset the delay but do not register it. It should be registered with -+ // the next call to [`poll_tick`]. -+ self.delay.as_mut().reset_without_reregister(next); - - // Return the time when we were scheduled to tick - Poll::Ready(timeout) - } - -+ /// Resets the interval to complete one period after the current time. -+ /// -+ /// This method ignores [`MissedTickBehavior`] strategy. -+ /// -+ /// # Examples -+ /// -+ /// ``` -+ /// use tokio::time; -+ /// -+ /// use std::time::Duration; -+ /// -+ /// #[tokio::main] -+ /// async fn main() { -+ /// let mut interval = time::interval(Duration::from_millis(100)); -+ /// -+ /// interval.tick().await; -+ /// -+ /// time::sleep(Duration::from_millis(50)).await; -+ /// interval.reset(); -+ /// -+ /// interval.tick().await; -+ /// interval.tick().await; -+ /// -+ /// // approximately 250ms have elapsed. -+ /// } -+ /// ``` -+ pub fn reset(&mut self) { -+ self.delay.as_mut().reset(Instant::now() + self.period); -+ } -+ - /// Returns the [`MissedTickBehavior`] strategy currently being used. - pub fn missed_tick_behavior(&self) -> MissedTickBehavior { - self.missed_tick_behavior -diff --git a/KubeOS-Rust/vendor/tokio/src/time/mod.rs b/KubeOS-Rust/vendor/tokio/src/time/mod.rs -index 281990ef..a1f27b83 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/time/mod.rs -@@ -82,17 +82,13 @@ - //! ``` - //! - //! [`interval`]: crate::time::interval() -+//! [`sleep`]: sleep() - - mod clock; - pub(crate) use self::clock::Clock; - #[cfg(feature = "test-util")] - pub use clock::{advance, pause, resume}; - --pub(crate) mod driver; -- --#[doc(inline)] --pub use driver::sleep::{sleep, sleep_until, Sleep}; -- - pub mod error; - - mod instant; -@@ -101,14 +97,13 @@ pub use self::instant::Instant; - mod interval; - pub use interval::{interval, interval_at, Interval, MissedTickBehavior}; - -+mod sleep; -+pub use sleep::{sleep, sleep_until, Sleep}; -+ - mod timeout; - #[doc(inline)] - pub use timeout::{timeout, timeout_at, Timeout}; - --#[cfg(test)] --#[cfg(not(loom))] --mod tests; -- - // Re-export for convenience - #[doc(no_inline)] - pub use std::time::Duration; -diff --git a/KubeOS-Rust/vendor/tokio/src/time/driver/sleep.rs b/KubeOS-Rust/vendor/tokio/src/time/sleep.rs -similarity index 65% -rename from KubeOS-Rust/vendor/tokio/src/time/driver/sleep.rs -rename to KubeOS-Rust/vendor/tokio/src/time/sleep.rs -index 43ff694f..ccf53ef8 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/driver/sleep.rs -+++ b/KubeOS-Rust/vendor/tokio/src/time/sleep.rs -@@ -1,4 +1,4 @@ --use crate::time::driver::{Handle, TimerEntry}; -+use crate::runtime::time::TimerEntry; - use crate::time::{error::Error, Duration, Instant}; - use crate::util::trace; - -@@ -8,10 +8,6 @@ use std::panic::Location; - use std::pin::Pin; - use std::task::{self, Poll}; - --cfg_trace! { -- use crate::time::driver::ClockTime; --} -- - /// Waits until `deadline` is reached. - /// - /// No work is performed while awaiting on the sleep future to complete. `Sleep` -@@ -41,11 +37,28 @@ cfg_trace! { - /// - /// See the documentation for the [`Sleep`] type for more examples. - /// -+/// # Panics -+/// -+/// This function panics if there is no current timer set. -+/// -+/// It can be triggered when [`Builder::enable_time`] or -+/// [`Builder::enable_all`] are not included in the builder. -+/// -+/// It can also panic whenever a timer is created outside of a -+/// Tokio runtime. That is why `rt.block_on(sleep(...))` will panic, -+/// since the function is executed outside of the runtime. -+/// Whereas `rt.block_on(async {sleep(...).await})` doesn't panic. -+/// And this is because wrapping the function on an async makes it lazy, -+/// and so gets executed inside the runtime successfully without -+/// panicking. -+/// - /// [`Sleep`]: struct@crate::time::Sleep - /// [`interval`]: crate::time::interval() -+/// [`Builder::enable_time`]: crate::runtime::Builder::enable_time -+/// [`Builder::enable_all`]: crate::runtime::Builder::enable_all - // Alias for old name in 0.x - #[cfg_attr(docsrs, doc(alias = "delay_until"))] --#[cfg_attr(tokio_track_caller, track_caller)] -+#[track_caller] - pub fn sleep_until(deadline: Instant) -> Sleep { - return Sleep::new_timeout(deadline, trace::caller_location()); - } -@@ -57,7 +70,9 @@ pub fn sleep_until(deadline: Instant) -> Sleep { - /// - /// No work is performed while awaiting on the sleep future to complete. `Sleep` - /// operates at millisecond granularity and should not be used for tasks that --/// require high-resolution timers. -+/// require high-resolution timers. The implementation is platform specific, -+/// and some platforms (specifically Windows) will provide timers with a -+/// larger resolution than 1 ms. - /// - /// To run something regularly on a schedule, see [`interval`]. - /// -@@ -84,12 +99,29 @@ pub fn sleep_until(deadline: Instant) -> Sleep { - /// - /// See the documentation for the [`Sleep`] type for more examples. - /// -+/// # Panics -+/// -+/// This function panics if there is no current timer set. -+/// -+/// It can be triggered when [`Builder::enable_time`] or -+/// [`Builder::enable_all`] are not included in the builder. -+/// -+/// It can also panic whenever a timer is created outside of a -+/// Tokio runtime. That is why `rt.block_on(sleep(...))` will panic, -+/// since the function is executed outside of the runtime. -+/// Whereas `rt.block_on(async {sleep(...).await})` doesn't panic. -+/// And this is because wrapping the function on an async makes it lazy, -+/// and so gets executed inside the runtime successfully without -+/// panicking. -+/// - /// [`Sleep`]: struct@crate::time::Sleep - /// [`interval`]: crate::time::interval() -+/// [`Builder::enable_time`]: crate::runtime::Builder::enable_time -+/// [`Builder::enable_all`]: crate::runtime::Builder::enable_all - // Alias for old name in 0.x - #[cfg_attr(docsrs, doc(alias = "delay_for"))] - #[cfg_attr(docsrs, doc(alias = "wait"))] --#[cfg_attr(tokio_track_caller, track_caller)] -+#[track_caller] - pub fn sleep(duration: Duration) -> Sleep { - let location = trace::caller_location(); - -@@ -203,39 +235,37 @@ pin_project! { - cfg_trace! { - #[derive(Debug)] - struct Inner { -- deadline: Instant, -- resource_span: tracing::Span, -- async_op_span: tracing::Span, -- time_source: ClockTime, -+ ctx: trace::AsyncOpTracingCtx, - } - } - - cfg_not_trace! { - #[derive(Debug)] - struct Inner { -- deadline: Instant, - } - } - - impl Sleep { - #[cfg_attr(not(all(tokio_unstable, feature = "tracing")), allow(unused_variables))] -+ #[track_caller] - pub(crate) fn new_timeout( - deadline: Instant, - location: Option<&'static Location<'static>>, - ) -> Sleep { -- let handle = Handle::current(); -+ use crate::runtime::scheduler; -+ -+ let handle = scheduler::Handle::current(); - let entry = TimerEntry::new(&handle, deadline); - - #[cfg(all(tokio_unstable, feature = "tracing"))] - let inner = { -- let time_source = handle.time_source().clone(); -+ let clock = handle.driver().clock(); -+ let handle = &handle.driver().time(); -+ let time_source = handle.time_source(); - let deadline_tick = time_source.deadline_to_tick(deadline); -- let duration = deadline_tick.checked_sub(time_source.now()).unwrap_or(0); -+ let duration = deadline_tick.saturating_sub(time_source.now(clock)); - -- #[cfg(tokio_track_caller)] -- let location = location.expect("should have location if tracking caller"); -- -- #[cfg(tokio_track_caller)] -+ let location = location.expect("should have location if tracing"); - let resource_span = tracing::trace_span!( - "runtime.resource", - concrete_type = "Sleep", -@@ -245,31 +275,31 @@ impl Sleep { - loc.col = location.column(), - ); - -- #[cfg(not(tokio_track_caller))] -- let resource_span = -- tracing::trace_span!("runtime.resource", concrete_type = "Sleep", kind = "timer"); -+ let async_op_span = resource_span.in_scope(|| { -+ tracing::trace!( -+ target: "runtime::resource::state_update", -+ duration = duration, -+ duration.unit = "ms", -+ duration.op = "override", -+ ); - -- let async_op_span = -- tracing::trace_span!("runtime.resource.async_op", source = "Sleep::new_timeout"); -+ tracing::trace_span!("runtime.resource.async_op", source = "Sleep::new_timeout") -+ }); - -- tracing::trace!( -- target: "runtime::resource::state_update", -- parent: resource_span.id(), -- duration = duration, -- duration.unit = "ms", -- duration.op = "override", -- ); -+ let async_op_poll_span = -+ async_op_span.in_scope(|| tracing::trace_span!("runtime.resource.async_op.poll")); - -- Inner { -- deadline, -- resource_span, -+ let ctx = trace::AsyncOpTracingCtx { - async_op_span, -- time_source, -- } -+ async_op_poll_span, -+ resource_span, -+ }; -+ -+ Inner { ctx } - }; - - #[cfg(not(all(tokio_unstable, feature = "tracing")))] -- let inner = Inner { deadline }; -+ let inner = Inner {}; - - Sleep { inner, entry } - } -@@ -280,7 +310,7 @@ impl Sleep { - - /// Returns the instant at which the future will complete. - pub fn deadline(&self) -> Instant { -- self.inner.deadline -+ self.entry.deadline() - } - - /// Returns `true` if `Sleep` has elapsed. -@@ -323,61 +353,73 @@ impl Sleep { - self.reset_inner(deadline) - } - -+ /// Resets the `Sleep` instance to a new deadline without reregistering it -+ /// to be woken up. -+ /// -+ /// Calling this function allows changing the instant at which the `Sleep` -+ /// future completes without having to create new associated state and -+ /// without having it registered. This is required in e.g. the -+ /// [crate::time::Interval] where we want to reset the internal [Sleep] -+ /// without having it wake up the last task that polled it. -+ pub(crate) fn reset_without_reregister(self: Pin<&mut Self>, deadline: Instant) { -+ let mut me = self.project(); -+ me.entry.as_mut().reset(deadline, false); -+ } -+ - fn reset_inner(self: Pin<&mut Self>, deadline: Instant) { -- let me = self.project(); -- me.entry.reset(deadline); -- (*me.inner).deadline = deadline; -+ let mut me = self.project(); -+ me.entry.as_mut().reset(deadline, true); - - #[cfg(all(tokio_unstable, feature = "tracing"))] - { -- me.inner.async_op_span = -+ let _resource_enter = me.inner.ctx.resource_span.enter(); -+ me.inner.ctx.async_op_span = - tracing::trace_span!("runtime.resource.async_op", source = "Sleep::reset"); -+ let _async_op_enter = me.inner.ctx.async_op_span.enter(); -+ -+ me.inner.ctx.async_op_poll_span = -+ tracing::trace_span!("runtime.resource.async_op.poll"); -+ -+ let duration = { -+ let clock = me.entry.clock(); -+ let time_source = me.entry.driver().time_source(); -+ let now = time_source.now(clock); -+ let deadline_tick = time_source.deadline_to_tick(deadline); -+ deadline_tick.saturating_sub(now) -+ }; - - tracing::trace!( - target: "runtime::resource::state_update", -- parent: me.inner.resource_span.id(), -- duration = { -- let now = me.inner.time_source.now(); -- let deadline_tick = me.inner.time_source.deadline_to_tick(deadline); -- deadline_tick.checked_sub(now).unwrap_or(0) -- }, -+ duration = duration, - duration.unit = "ms", - duration.op = "override", - ); - } - } - -- cfg_not_trace! { -- fn poll_elapsed(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll> { -- let me = self.project(); -+ fn poll_elapsed(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll> { -+ let me = self.project(); - -- // Keep track of task budget -- let coop = ready!(crate::coop::poll_proceed(cx)); -+ // Keep track of task budget -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let coop = ready!(trace_poll_op!( -+ "poll_elapsed", -+ crate::runtime::coop::poll_proceed(cx), -+ )); - -- me.entry.poll_elapsed(cx).map(move |r| { -- coop.made_progress(); -- r -- }) -- } -- } -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ let coop = ready!(crate::runtime::coop::poll_proceed(cx)); - -- cfg_trace! { -- fn poll_elapsed(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll> { -- let me = self.project(); -- // Keep track of task budget -- let coop = ready!(trace_poll_op!( -- "poll_elapsed", -- crate::coop::poll_proceed(cx), -- me.inner.resource_span.id(), -- )); -- -- let result = me.entry.poll_elapsed(cx).map(move |r| { -- coop.made_progress(); -- r -- }); -+ let result = me.entry.poll_elapsed(cx).map(move |r| { -+ coop.made_progress(); -+ r -+ }); - -- trace_poll_op!("poll_elapsed", result, me.inner.resource_span.id()) -- } -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ return trace_poll_op!("poll_elapsed", result); -+ -+ #[cfg(any(not(tokio_unstable), not(feature = "tracing")))] -+ return result; - } - } - -@@ -395,8 +437,11 @@ impl Future for Sleep { - // really do much better if we passed the error onwards. - fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll { - #[cfg(all(tokio_unstable, feature = "tracing"))] -- let _span = self.inner.async_op_span.clone().entered(); -- -+ let _res_span = self.inner.ctx.resource_span.clone().entered(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let _ao_span = self.inner.ctx.async_op_span.clone().entered(); -+ #[cfg(all(tokio_unstable, feature = "tracing"))] -+ let _ao_poll_span = self.inner.ctx.async_op_poll_span.clone().entered(); - match ready!(self.as_mut().poll_elapsed(cx)) { - Ok(()) => Poll::Ready(()), - Err(e) => panic!("timer error: {}", e), -diff --git a/KubeOS-Rust/vendor/tokio/src/time/tests/mod.rs b/KubeOS-Rust/vendor/tokio/src/time/tests/mod.rs -deleted file mode 100644 -index 35e1060a..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/time/tests/mod.rs -+++ /dev/null -@@ -1,22 +0,0 @@ --mod test_sleep; -- --use crate::time::{self, Instant}; --use std::time::Duration; -- --fn assert_send() {} --fn assert_sync() {} -- --#[test] --fn registration_is_send_and_sync() { -- use crate::time::Sleep; -- -- assert_send::(); -- assert_sync::(); --} -- --#[test] --#[should_panic] --fn sleep_is_eager() { -- let when = Instant::now() + Duration::from_millis(100); -- let _ = time::sleep_until(when); --} -diff --git a/KubeOS-Rust/vendor/tokio/src/time/tests/test_sleep.rs b/KubeOS-Rust/vendor/tokio/src/time/tests/test_sleep.rs -deleted file mode 100644 -index 77ca07e3..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/time/tests/test_sleep.rs -+++ /dev/null -@@ -1,443 +0,0 @@ --//use crate::time::driver::{Driver, Entry, Handle}; -- --/* --macro_rules! poll { -- ($e:expr) => { -- $e.enter(|cx, e| e.poll_elapsed(cx)) -- }; --} -- --#[test] --fn frozen_utility_returns_correct_advanced_duration() { -- let clock = Clock::new(); -- clock.pause(); -- let start = clock.now(); -- -- clock.advance(ms(10)); -- assert_eq!(clock.now() - start, ms(10)); --} -- --#[test] --fn immediate_sleep() { -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- let when = clock.now(); -- let mut e = task::spawn(sleep_until(&handle, when)); -- -- assert_ready_ok!(poll!(e)); -- -- assert_ok!(driver.park_timeout(Duration::from_millis(1000))); -- -- // The time has not advanced. The `turn` completed immediately. -- assert_eq!(clock.now() - start, ms(1000)); --} -- --#[test] --fn delayed_sleep_level_0() { -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- for &i in &[1, 10, 60] { -- // Create a `Sleep` that elapses in the future -- let mut e = task::spawn(sleep_until(&handle, start + ms(i))); -- -- // The sleep instance has not elapsed. -- assert_pending!(poll!(e)); -- -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(i)); -- -- assert_ready_ok!(poll!(e)); -- } --} -- --#[test] --fn sub_ms_delayed_sleep() { -- let (mut driver, clock, handle) = setup(); -- -- for _ in 0..5 { -- let deadline = clock.now() + ms(1) + Duration::new(0, 1); -- -- let mut e = task::spawn(sleep_until(&handle, deadline)); -- -- assert_pending!(poll!(e)); -- -- assert_ok!(driver.park()); -- assert_ready_ok!(poll!(e)); -- -- assert!(clock.now() >= deadline); -- -- clock.advance(Duration::new(0, 1)); -- } --} -- --#[test] --fn delayed_sleep_wrapping_level_0() { -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- assert_ok!(driver.park_timeout(ms(5))); -- assert_eq!(clock.now() - start, ms(5)); -- -- let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(60))); -- -- assert_pending!(poll!(e)); -- -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(64)); -- assert_pending!(poll!(e)); -- -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(65)); -- -- assert_ready_ok!(poll!(e)); --} -- --#[test] --fn timer_wrapping_with_higher_levels() { -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- // Set sleep to hit level 1 -- let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(64))); -- assert_pending!(poll!(e1)); -- -- // Turn a bit -- assert_ok!(driver.park_timeout(ms(5))); -- -- // Set timeout such that it will hit level 0, but wrap -- let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(60))); -- assert_pending!(poll!(e2)); -- -- // This should result in s1 firing -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(64)); -- -- assert_ready_ok!(poll!(e1)); -- assert_pending!(poll!(e2)); -- -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(65)); -- -- assert_ready_ok!(poll!(e1)); --} -- --#[test] --fn sleep_with_deadline_in_past() { -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- // Create `Sleep` that elapsed immediately. -- let mut e = task::spawn(sleep_until(&handle, clock.now() - ms(100))); -- -- // Even though the `Sleep` expires in the past, it is not ready yet -- // because the timer must observe it. -- assert_ready_ok!(poll!(e)); -- -- // Turn the timer, it runs for the elapsed time -- assert_ok!(driver.park_timeout(ms(1000))); -- -- // The time has not advanced. The `turn` completed immediately. -- assert_eq!(clock.now() - start, ms(1000)); --} -- --#[test] --fn delayed_sleep_level_1() { -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- // Create a `Sleep` that elapses in the future -- let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(234))); -- -- // The sleep has not elapsed. -- assert_pending!(poll!(e)); -- -- // Turn the timer, this will wake up to cascade the timer down. -- assert_ok!(driver.park_timeout(ms(1000))); -- assert_eq!(clock.now() - start, ms(192)); -- -- // The sleep has not elapsed. -- assert_pending!(poll!(e)); -- -- // Turn the timer again -- assert_ok!(driver.park_timeout(ms(1000))); -- assert_eq!(clock.now() - start, ms(234)); -- -- // The sleep has elapsed. -- assert_ready_ok!(poll!(e)); -- -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- // Create a `Sleep` that elapses in the future -- let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(234))); -- -- // The sleep has not elapsed. -- assert_pending!(poll!(e)); -- -- // Turn the timer with a smaller timeout than the cascade. -- assert_ok!(driver.park_timeout(ms(100))); -- assert_eq!(clock.now() - start, ms(100)); -- -- assert_pending!(poll!(e)); -- -- // Turn the timer, this will wake up to cascade the timer down. -- assert_ok!(driver.park_timeout(ms(1000))); -- assert_eq!(clock.now() - start, ms(192)); -- -- // The sleep has not elapsed. -- assert_pending!(poll!(e)); -- -- // Turn the timer again -- assert_ok!(driver.park_timeout(ms(1000))); -- assert_eq!(clock.now() - start, ms(234)); -- -- // The sleep has elapsed. -- assert_ready_ok!(poll!(e)); --} -- --#[test] --fn concurrently_set_two_timers_second_one_shorter() { -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(500))); -- let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(200))); -- -- // The sleep has not elapsed -- assert_pending!(poll!(e1)); -- assert_pending!(poll!(e2)); -- -- // Sleep until a cascade -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(192)); -- -- // Sleep until the second timer. -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(200)); -- -- // The shorter sleep fires -- assert_ready_ok!(poll!(e2)); -- assert_pending!(poll!(e1)); -- -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(448)); -- -- assert_pending!(poll!(e1)); -- -- // Turn again, this time the time will advance to the second sleep -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(500)); -- -- assert_ready_ok!(poll!(e1)); --} -- --#[test] --fn short_sleep() { -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- // Create a `Sleep` that elapses in the future -- let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(1))); -- -- // The sleep has not elapsed. -- assert_pending!(poll!(e)); -- -- // Turn the timer, but not enough time will go by. -- assert_ok!(driver.park()); -- -- // The sleep has elapsed. -- assert_ready_ok!(poll!(e)); -- -- // The time has advanced to the point of the sleep elapsing. -- assert_eq!(clock.now() - start, ms(1)); --} -- --#[test] --fn sorta_long_sleep_until() { -- const MIN_5: u64 = 5 * 60 * 1000; -- -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- // Create a `Sleep` that elapses in the future -- let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(MIN_5))); -- -- // The sleep has not elapsed. -- assert_pending!(poll!(e)); -- -- let cascades = &[262_144, 262_144 + 9 * 4096, 262_144 + 9 * 4096 + 15 * 64]; -- -- for &elapsed in cascades { -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(elapsed)); -- -- assert_pending!(poll!(e)); -- } -- -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(MIN_5)); -- -- // The sleep has elapsed. -- assert_ready_ok!(poll!(e)); --} -- --#[test] --fn very_long_sleep() { -- const MO_5: u64 = 5 * 30 * 24 * 60 * 60 * 1000; -- -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- // Create a `Sleep` that elapses in the future -- let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(MO_5))); -- -- // The sleep has not elapsed. -- assert_pending!(poll!(e)); -- -- let cascades = &[ -- 12_884_901_888, -- 12_952_010_752, -- 12_959_875_072, -- 12_959_997_952, -- ]; -- -- for &elapsed in cascades { -- assert_ok!(driver.park()); -- assert_eq!(clock.now() - start, ms(elapsed)); -- -- assert_pending!(poll!(e)); -- } -- -- // Turn the timer, but not enough time will go by. -- assert_ok!(driver.park()); -- -- // The time has advanced to the point of the sleep elapsing. -- assert_eq!(clock.now() - start, ms(MO_5)); -- -- // The sleep has elapsed. -- assert_ready_ok!(poll!(e)); --} -- --#[test] --fn unpark_is_delayed() { -- // A special park that will take much longer than the requested duration -- struct MockPark(Clock); -- -- struct MockUnpark; -- -- impl Park for MockPark { -- type Unpark = MockUnpark; -- type Error = (); -- -- fn unpark(&self) -> Self::Unpark { -- MockUnpark -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -- panic!("parking forever"); -- } -- -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- assert_eq!(duration, ms(0)); -- self.0.advance(ms(436)); -- Ok(()) -- } -- -- fn shutdown(&mut self) {} -- } -- -- impl Unpark for MockUnpark { -- fn unpark(&self) {} -- } -- -- let clock = Clock::new(); -- clock.pause(); -- let start = clock.now(); -- let mut driver = Driver::new(MockPark(clock.clone()), clock.clone()); -- let handle = driver.handle(); -- -- let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(100))); -- let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(101))); -- let mut e3 = task::spawn(sleep_until(&handle, clock.now() + ms(200))); -- -- assert_pending!(poll!(e1)); -- assert_pending!(poll!(e2)); -- assert_pending!(poll!(e3)); -- -- assert_ok!(driver.park()); -- -- assert_eq!(clock.now() - start, ms(500)); -- -- assert_ready_ok!(poll!(e1)); -- assert_ready_ok!(poll!(e2)); -- assert_ready_ok!(poll!(e3)); --} -- --#[test] --fn set_timeout_at_deadline_greater_than_max_timer() { -- const YR_1: u64 = 365 * 24 * 60 * 60 * 1000; -- const YR_5: u64 = 5 * YR_1; -- -- let (mut driver, clock, handle) = setup(); -- let start = clock.now(); -- -- for _ in 0..5 { -- assert_ok!(driver.park_timeout(ms(YR_1))); -- } -- -- let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(1))); -- assert_pending!(poll!(e)); -- -- assert_ok!(driver.park_timeout(ms(1000))); -- assert_eq!(clock.now() - start, ms(YR_5) + ms(1)); -- -- assert_ready_ok!(poll!(e)); --} -- --fn setup() -> (Driver, Clock, Handle) { -- let clock = Clock::new(); -- clock.pause(); -- let driver = Driver::new(MockPark(clock.clone()), clock.clone()); -- let handle = driver.handle(); -- -- (driver, clock, handle) --} -- --fn sleep_until(handle: &Handle, when: Instant) -> Arc { -- Entry::new(&handle, when, ms(0)) --} -- --struct MockPark(Clock); -- --struct MockUnpark; -- --impl Park for MockPark { -- type Unpark = MockUnpark; -- type Error = (); -- -- fn unpark(&self) -> Self::Unpark { -- MockUnpark -- } -- -- fn park(&mut self) -> Result<(), Self::Error> { -- panic!("parking forever"); -- } -- -- fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> { -- self.0.advance(duration); -- Ok(()) -- } -- -- fn shutdown(&mut self) {} --} -- --impl Unpark for MockUnpark { -- fn unpark(&self) {} --} -- --fn ms(n: u64) -> Duration { -- Duration::from_millis(n) --} --*/ -diff --git a/KubeOS-Rust/vendor/tokio/src/time/timeout.rs b/KubeOS-Rust/vendor/tokio/src/time/timeout.rs -index 6725caa0..52ab9891 100644 ---- a/KubeOS-Rust/vendor/tokio/src/time/timeout.rs -+++ b/KubeOS-Rust/vendor/tokio/src/time/timeout.rs -@@ -5,6 +5,7 @@ - //! [`Timeout`]: struct@Timeout - - use crate::{ -+ runtime::coop, - time::{error::Elapsed, sleep_until, Duration, Instant, Sleep}, - util::trace, - }; -@@ -20,7 +21,22 @@ use std::task::{self, Poll}; - /// value is returned. Otherwise, an error is returned and the future is - /// canceled. - /// --/// # Cancelation -+/// Note that the timeout is checked before polling the future, so if the future -+/// does not yield during execution then it is possible for the future to complete -+/// and exceed the timeout _without_ returning an error. -+/// -+/// This function returns a future whose return type is [`Result`]``, where `T` is the -+/// return type of the provided future. -+/// -+/// If the provided future completes immediately, then the future returned from -+/// this function is guaranteed to complete immediately with an [`Ok`] variant -+/// no matter the provided duration. -+/// -+/// [`Ok`]: std::result::Result::Ok -+/// [`Result`]: std::result::Result -+/// [`Elapsed`]: crate::time::error::Elapsed -+/// -+/// # Cancellation - /// - /// Cancelling a timeout is done by dropping the future. No additional cleanup - /// or other work is required. -@@ -48,10 +64,28 @@ use std::task::{self, Poll}; - /// } - /// # } - /// ``` --#[cfg_attr(tokio_track_caller, track_caller)] --pub fn timeout(duration: Duration, future: T) -> Timeout -+/// -+/// # Panics -+/// -+/// This function panics if there is no current timer set. -+/// -+/// It can be triggered when [`Builder::enable_time`] or -+/// [`Builder::enable_all`] are not included in the builder. -+/// -+/// It can also panic whenever a timer is created outside of a -+/// Tokio runtime. That is why `rt.block_on(sleep(...))` will panic, -+/// since the function is executed outside of the runtime. -+/// Whereas `rt.block_on(async {sleep(...).await})` doesn't panic. -+/// And this is because wrapping the function on an async makes it lazy, -+/// and so gets executed inside the runtime successfully without -+/// panicking. -+/// -+/// [`Builder::enable_time`]: crate::runtime::Builder::enable_time -+/// [`Builder::enable_all`]: crate::runtime::Builder::enable_all -+#[track_caller] -+pub fn timeout(duration: Duration, future: F) -> Timeout - where -- T: Future, -+ F: Future, - { - let location = trace::caller_location(); - -@@ -68,7 +102,18 @@ where - /// If the future completes before the instant is reached, then the completed - /// value is returned. Otherwise, an error is returned. - /// --/// # Cancelation -+/// This function returns a future whose return type is [`Result`]``, where `T` is the -+/// return type of the provided future. -+/// -+/// If the provided future completes immediately, then the future returned from -+/// this function is guaranteed to complete immediately with an [`Ok`] variant -+/// no matter the provided deadline. -+/// -+/// [`Ok`]: std::result::Result::Ok -+/// [`Result`]: std::result::Result -+/// [`Elapsed`]: crate::time::error::Elapsed -+/// -+/// # Cancellation - /// - /// Cancelling a timeout is done by dropping the future. No additional cleanup - /// or other work is required. -@@ -97,9 +142,9 @@ where - /// } - /// # } - /// ``` --pub fn timeout_at(deadline: Instant, future: T) -> Timeout -+pub fn timeout_at(deadline: Instant, future: F) -> Timeout - where -- T: Future, -+ F: Future, - { - let delay = sleep_until(deadline); - -@@ -151,15 +196,33 @@ where - fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll { - let me = self.project(); - -+ let had_budget_before = coop::has_budget_remaining(); -+ - // First, try polling the future - if let Poll::Ready(v) = me.value.poll(cx) { - return Poll::Ready(Ok(v)); - } - -- // Now check the timer -- match me.delay.poll(cx) { -- Poll::Ready(()) => Poll::Ready(Err(Elapsed::new())), -- Poll::Pending => Poll::Pending, -+ let has_budget_now = coop::has_budget_remaining(); -+ -+ let delay = me.delay; -+ -+ let poll_delay = || -> Poll { -+ match delay.poll(cx) { -+ Poll::Ready(()) => Poll::Ready(Err(Elapsed::new())), -+ Poll::Pending => Poll::Pending, -+ } -+ }; -+ -+ if let (true, false) = (had_budget_before, has_budget_now) { -+ // if it is the underlying future that exhausted the budget, we poll -+ // the `delay` with an unconstrained one. This prevents pathological -+ // cases where the underlying future always exhausts the budget and -+ // we never get a chance to evaluate whether the timeout was hit or -+ // not. -+ coop::with_unconstrained(poll_delay) -+ } else { -+ poll_delay() - } - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/atomic_cell.rs b/KubeOS-Rust/vendor/tokio/src/util/atomic_cell.rs -similarity index 77% -rename from KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/atomic_cell.rs -rename to KubeOS-Rust/vendor/tokio/src/util/atomic_cell.rs -index 98847e6f..07e37303 100644 ---- a/KubeOS-Rust/vendor/tokio/src/runtime/thread_pool/atomic_cell.rs -+++ b/KubeOS-Rust/vendor/tokio/src/util/atomic_cell.rs -@@ -3,7 +3,7 @@ use crate::loom::sync::atomic::AtomicPtr; - use std::ptr; - use std::sync::atomic::Ordering::AcqRel; - --pub(super) struct AtomicCell { -+pub(crate) struct AtomicCell { - data: AtomicPtr, - } - -@@ -11,22 +11,22 @@ unsafe impl Send for AtomicCell {} - unsafe impl Sync for AtomicCell {} - - impl AtomicCell { -- pub(super) fn new(data: Option>) -> AtomicCell { -+ pub(crate) fn new(data: Option>) -> AtomicCell { - AtomicCell { - data: AtomicPtr::new(to_raw(data)), - } - } - -- pub(super) fn swap(&self, val: Option>) -> Option> { -+ pub(crate) fn swap(&self, val: Option>) -> Option> { - let old = self.data.swap(to_raw(val), AcqRel); - from_raw(old) - } - -- pub(super) fn set(&self, val: Box) { -+ pub(crate) fn set(&self, val: Box) { - let _ = self.swap(Some(val)); - } - -- pub(super) fn take(&self) -> Option> { -+ pub(crate) fn take(&self) -> Option> { - self.swap(None) - } - } -diff --git a/KubeOS-Rust/vendor/tokio/src/util/error.rs b/KubeOS-Rust/vendor/tokio/src/util/error.rs -index 8f252c0c..ebb27f63 100644 ---- a/KubeOS-Rust/vendor/tokio/src/util/error.rs -+++ b/KubeOS-Rust/vendor/tokio/src/util/error.rs -@@ -1,15 +1,14 @@ -+// Some combinations of features may not use these constants. -+#![cfg_attr(not(feature = "full"), allow(dead_code))] -+ - /// Error string explaining that the Tokio context hasn't been instantiated. - pub(crate) const CONTEXT_MISSING_ERROR: &str = - "there is no reactor running, must be called from the context of a Tokio 1.x runtime"; - --// some combinations of features might not use this --#[allow(dead_code)] - /// Error string explaining that the Tokio context is shutting down and cannot drive timers. - pub(crate) const RUNTIME_SHUTTING_DOWN_ERROR: &str = - "A Tokio 1.x context was found, but it is being shutdown."; - --// some combinations of features might not use this --#[allow(dead_code)] - /// Error string explaining that the Tokio context is not available because the - /// thread-local storing it has been destroyed. This usually only happens during - /// destructors of other thread-locals. -diff --git a/KubeOS-Rust/vendor/tokio/src/util/idle_notified_set.rs b/KubeOS-Rust/vendor/tokio/src/util/idle_notified_set.rs -new file mode 100644 -index 00000000..ce8ff9e9 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/util/idle_notified_set.rs -@@ -0,0 +1,462 @@ -+//! This module defines an `IdleNotifiedSet`, which is a collection of elements. -+//! Each element is intended to correspond to a task, and the collection will -+//! keep track of which tasks have had their waker notified, and which have not. -+//! -+//! Each entry in the set holds some user-specified value. The value's type is -+//! specified using the `T` parameter. It will usually be a `JoinHandle` or -+//! similar. -+ -+use std::marker::PhantomPinned; -+use std::mem::ManuallyDrop; -+use std::ptr::NonNull; -+use std::task::{Context, Waker}; -+ -+use crate::loom::cell::UnsafeCell; -+use crate::loom::sync::{Arc, Mutex}; -+use crate::util::linked_list::{self, Link}; -+use crate::util::{waker_ref, Wake}; -+ -+type LinkedList = -+ linked_list::LinkedList, as linked_list::Link>::Target>; -+ -+/// This is the main handle to the collection. -+pub(crate) struct IdleNotifiedSet { -+ lists: Arc>, -+ length: usize, -+} -+ -+/// A handle to an entry that is guaranteed to be stored in the idle or notified -+/// list of its `IdleNotifiedSet`. This value borrows the `IdleNotifiedSet` -+/// mutably to prevent the entry from being moved to the `Neither` list, which -+/// only the `IdleNotifiedSet` may do. -+/// -+/// The main consequence of being stored in one of the lists is that the `value` -+/// field has not yet been consumed. -+/// -+/// Note: This entry can be moved from the idle to the notified list while this -+/// object exists by waking its waker. -+pub(crate) struct EntryInOneOfTheLists<'a, T> { -+ entry: Arc>, -+ set: &'a mut IdleNotifiedSet, -+} -+ -+type Lists = Mutex>; -+ -+/// The linked lists hold strong references to the ListEntry items, and the -+/// ListEntry items also hold a strong reference back to the Lists object, but -+/// the destructor of the `IdleNotifiedSet` will clear the two lists, so once -+/// that object is destroyed, no ref-cycles will remain. -+struct ListsInner { -+ notified: LinkedList, -+ idle: LinkedList, -+ /// Whenever an element in the `notified` list is woken, this waker will be -+ /// notified and consumed, if it exists. -+ waker: Option, -+} -+ -+/// Which of the two lists in the shared Lists object is this entry stored in? -+/// -+/// If the value is `Idle`, then an entry's waker may move it to the notified -+/// list. Otherwise, only the `IdleNotifiedSet` may move it. -+/// -+/// If the value is `Neither`, then it is still possible that the entry is in -+/// some third external list (this happens in `drain`). -+#[derive(Copy, Clone, Eq, PartialEq)] -+enum List { -+ Notified, -+ Idle, -+ Neither, -+} -+ -+/// An entry in the list. -+/// -+/// # Safety -+/// -+/// The `my_list` field must only be accessed while holding the mutex in -+/// `parent`. It is an invariant that the value of `my_list` corresponds to -+/// which linked list in the `parent` holds this entry. Once this field takes -+/// the value `Neither`, then it may never be modified again. -+/// -+/// If the value of `my_list` is `Notified` or `Idle`, then the `pointers` field -+/// must only be accessed while holding the mutex. If the value of `my_list` is -+/// `Neither`, then the `pointers` field may be accessed by the -+/// `IdleNotifiedSet` (this happens inside `drain`). -+/// -+/// The `value` field is owned by the `IdleNotifiedSet` and may only be accessed -+/// by the `IdleNotifiedSet`. The operation that sets the value of `my_list` to -+/// `Neither` assumes ownership of the `value`, and it must either drop it or -+/// move it out from this entry to prevent it from getting leaked. (Since the -+/// two linked lists are emptied in the destructor of `IdleNotifiedSet`, the -+/// value should not be leaked.) -+struct ListEntry { -+ /// The linked list pointers of the list this entry is in. -+ pointers: linked_list::Pointers>, -+ /// Pointer to the shared `Lists` struct. -+ parent: Arc>, -+ /// The value stored in this entry. -+ value: UnsafeCell>, -+ /// Used to remember which list this entry is in. -+ my_list: UnsafeCell, -+ /// Required by the `linked_list::Pointers` field. -+ _pin: PhantomPinned, -+} -+ -+generate_addr_of_methods! { -+ impl ListEntry { -+ unsafe fn addr_of_pointers(self: NonNull) -> NonNull>> { -+ &self.pointers -+ } -+ } -+} -+ -+// With mutable access to the `IdleNotifiedSet`, you can get mutable access to -+// the values. -+unsafe impl Send for IdleNotifiedSet {} -+// With the current API we strictly speaking don't even need `T: Sync`, but we -+// require it anyway to support adding &self APIs that access the values in the -+// future. -+unsafe impl Sync for IdleNotifiedSet {} -+ -+// These impls control when it is safe to create a Waker. Since the waker does -+// not allow access to the value in any way (including its destructor), it is -+// not necessary for `T` to be Send or Sync. -+unsafe impl Send for ListEntry {} -+unsafe impl Sync for ListEntry {} -+ -+impl IdleNotifiedSet { -+ /// Create a new IdleNotifiedSet. -+ pub(crate) fn new() -> Self { -+ let lists = Mutex::new(ListsInner { -+ notified: LinkedList::new(), -+ idle: LinkedList::new(), -+ waker: None, -+ }); -+ -+ IdleNotifiedSet { -+ lists: Arc::new(lists), -+ length: 0, -+ } -+ } -+ -+ pub(crate) fn len(&self) -> usize { -+ self.length -+ } -+ -+ pub(crate) fn is_empty(&self) -> bool { -+ self.length == 0 -+ } -+ -+ /// Insert the given value into the `idle` list. -+ pub(crate) fn insert_idle(&mut self, value: T) -> EntryInOneOfTheLists<'_, T> { -+ self.length += 1; -+ -+ let entry = Arc::new(ListEntry { -+ parent: self.lists.clone(), -+ value: UnsafeCell::new(ManuallyDrop::new(value)), -+ my_list: UnsafeCell::new(List::Idle), -+ pointers: linked_list::Pointers::new(), -+ _pin: PhantomPinned, -+ }); -+ -+ { -+ let mut lock = self.lists.lock(); -+ lock.idle.push_front(entry.clone()); -+ } -+ -+ // Safety: We just put the entry in the idle list, so it is in one of the lists. -+ EntryInOneOfTheLists { entry, set: self } -+ } -+ -+ /// Pop an entry from the notified list to poll it. The entry is moved to -+ /// the idle list atomically. -+ pub(crate) fn pop_notified(&mut self, waker: &Waker) -> Option> { -+ // We don't decrement the length because this call moves the entry to -+ // the idle list rather than removing it. -+ if self.length == 0 { -+ // Fast path. -+ return None; -+ } -+ -+ let mut lock = self.lists.lock(); -+ -+ let should_update_waker = match lock.waker.as_mut() { -+ Some(cur_waker) => !waker.will_wake(cur_waker), -+ None => true, -+ }; -+ if should_update_waker { -+ lock.waker = Some(waker.clone()); -+ } -+ -+ // Pop the entry, returning None if empty. -+ let entry = lock.notified.pop_back()?; -+ -+ lock.idle.push_front(entry.clone()); -+ -+ // Safety: We are holding the lock. -+ entry.my_list.with_mut(|ptr| unsafe { -+ *ptr = List::Idle; -+ }); -+ -+ drop(lock); -+ -+ // Safety: We just put the entry in the idle list, so it is in one of the lists. -+ Some(EntryInOneOfTheLists { entry, set: self }) -+ } -+ -+ /// Call a function on every element in this list. -+ pub(crate) fn for_each(&mut self, mut func: F) { -+ fn get_ptrs(list: &mut LinkedList, ptrs: &mut Vec<*mut T>) { -+ let mut node = list.last(); -+ -+ while let Some(entry) = node { -+ ptrs.push(entry.value.with_mut(|ptr| { -+ let ptr: *mut ManuallyDrop = ptr; -+ let ptr: *mut T = ptr.cast(); -+ ptr -+ })); -+ -+ let prev = entry.pointers.get_prev(); -+ node = prev.map(|prev| unsafe { &*prev.as_ptr() }); -+ } -+ } -+ -+ // Atomically get a raw pointer to the value of every entry. -+ // -+ // Since this only locks the mutex once, it is not possible for a value -+ // to get moved from the idle list to the notified list during the -+ // operation, which would otherwise result in some value being listed -+ // twice. -+ let mut ptrs = Vec::with_capacity(self.len()); -+ { -+ let mut lock = self.lists.lock(); -+ -+ get_ptrs(&mut lock.idle, &mut ptrs); -+ get_ptrs(&mut lock.notified, &mut ptrs); -+ } -+ debug_assert_eq!(ptrs.len(), ptrs.capacity()); -+ -+ for ptr in ptrs { -+ // Safety: When we grabbed the pointers, the entries were in one of -+ // the two lists. This means that their value was valid at the time, -+ // and it must still be valid because we are the IdleNotifiedSet, -+ // and only we can remove an entry from the two lists. (It's -+ // possible that an entry is moved from one list to the other during -+ // this loop, but that is ok.) -+ func(unsafe { &mut *ptr }); -+ } -+ } -+ -+ /// Remove all entries in both lists, applying some function to each element. -+ /// -+ /// The closure is called on all elements even if it panics. Having it panic -+ /// twice is a double-panic, and will abort the application. -+ pub(crate) fn drain(&mut self, func: F) { -+ if self.length == 0 { -+ // Fast path. -+ return; -+ } -+ self.length = 0; -+ -+ // The LinkedList is not cleared on panic, so we use a bomb to clear it. -+ // -+ // This value has the invariant that any entry in its `all_entries` list -+ // has `my_list` set to `Neither` and that the value has not yet been -+ // dropped. -+ struct AllEntries { -+ all_entries: LinkedList, -+ func: F, -+ } -+ -+ impl AllEntries { -+ fn pop_next(&mut self) -> bool { -+ if let Some(entry) = self.all_entries.pop_back() { -+ // Safety: We just took this value from the list, so we can -+ // destroy the value in the entry. -+ entry -+ .value -+ .with_mut(|ptr| unsafe { (self.func)(ManuallyDrop::take(&mut *ptr)) }); -+ true -+ } else { -+ false -+ } -+ } -+ } -+ -+ impl Drop for AllEntries { -+ fn drop(&mut self) { -+ while self.pop_next() {} -+ } -+ } -+ -+ let mut all_entries = AllEntries { -+ all_entries: LinkedList::new(), -+ func, -+ }; -+ -+ // Atomically move all entries to the new linked list in the AllEntries -+ // object. -+ { -+ let mut lock = self.lists.lock(); -+ unsafe { -+ // Safety: We are holding the lock and `all_entries` is a new -+ // LinkedList. -+ move_to_new_list(&mut lock.idle, &mut all_entries.all_entries); -+ move_to_new_list(&mut lock.notified, &mut all_entries.all_entries); -+ } -+ } -+ -+ // Keep destroying entries in the list until it is empty. -+ // -+ // If the closure panics, then the destructor of the `AllEntries` bomb -+ // ensures that we keep running the destructor on the remaining values. -+ // A second panic will abort the program. -+ while all_entries.pop_next() {} -+ } -+} -+ -+/// # Safety -+/// -+/// The mutex for the entries must be held, and the target list must be such -+/// that setting `my_list` to `Neither` is ok. -+unsafe fn move_to_new_list(from: &mut LinkedList, to: &mut LinkedList) { -+ while let Some(entry) = from.pop_back() { -+ entry.my_list.with_mut(|ptr| { -+ *ptr = List::Neither; -+ }); -+ to.push_front(entry); -+ } -+} -+ -+impl<'a, T> EntryInOneOfTheLists<'a, T> { -+ /// Remove this entry from the list it is in, returning the value associated -+ /// with the entry. -+ /// -+ /// This consumes the value, since it is no longer guaranteed to be in a -+ /// list. -+ pub(crate) fn remove(self) -> T { -+ self.set.length -= 1; -+ -+ { -+ let mut lock = self.set.lists.lock(); -+ -+ // Safety: We are holding the lock so there is no race, and we will -+ // remove the entry afterwards to uphold invariants. -+ let old_my_list = self.entry.my_list.with_mut(|ptr| unsafe { -+ let old_my_list = *ptr; -+ *ptr = List::Neither; -+ old_my_list -+ }); -+ -+ let list = match old_my_list { -+ List::Idle => &mut lock.idle, -+ List::Notified => &mut lock.notified, -+ // An entry in one of the lists is in one of the lists. -+ List::Neither => unreachable!(), -+ }; -+ -+ unsafe { -+ // Safety: We just checked that the entry is in this particular -+ // list. -+ list.remove(ListEntry::as_raw(&self.entry)).unwrap(); -+ } -+ } -+ -+ // By setting `my_list` to `Neither`, we have taken ownership of the -+ // value. We return it to the caller. -+ // -+ // Safety: We have a mutable reference to the `IdleNotifiedSet` that -+ // owns this entry, so we can use its permission to access the value. -+ self.entry -+ .value -+ .with_mut(|ptr| unsafe { ManuallyDrop::take(&mut *ptr) }) -+ } -+ -+ /// Access the value in this entry together with a context for its waker. -+ pub(crate) fn with_value_and_context(&mut self, func: F) -> U -+ where -+ F: FnOnce(&mut T, &mut Context<'_>) -> U, -+ T: 'static, -+ { -+ let waker = waker_ref(&self.entry); -+ -+ let mut context = Context::from_waker(&waker); -+ -+ // Safety: We have a mutable reference to the `IdleNotifiedSet` that -+ // owns this entry, so we can use its permission to access the value. -+ self.entry -+ .value -+ .with_mut(|ptr| unsafe { func(&mut *ptr, &mut context) }) -+ } -+} -+ -+impl Drop for IdleNotifiedSet { -+ fn drop(&mut self) { -+ // Clear both lists. -+ self.drain(drop); -+ -+ #[cfg(debug_assertions)] -+ if !std::thread::panicking() { -+ let lock = self.lists.lock(); -+ assert!(lock.idle.is_empty()); -+ assert!(lock.notified.is_empty()); -+ } -+ } -+} -+ -+impl Wake for ListEntry { -+ fn wake_by_ref(me: &Arc) { -+ let mut lock = me.parent.lock(); -+ -+ // Safety: We are holding the lock and we will update the lists to -+ // maintain invariants. -+ let old_my_list = me.my_list.with_mut(|ptr| unsafe { -+ let old_my_list = *ptr; -+ if old_my_list == List::Idle { -+ *ptr = List::Notified; -+ } -+ old_my_list -+ }); -+ -+ if old_my_list == List::Idle { -+ // We move ourself to the notified list. -+ let me = unsafe { -+ // Safety: We just checked that we are in this particular list. -+ lock.idle.remove(NonNull::from(&**me)).unwrap() -+ }; -+ lock.notified.push_front(me); -+ -+ if let Some(waker) = lock.waker.take() { -+ drop(lock); -+ waker.wake(); -+ } -+ } -+ } -+ -+ fn wake(me: Arc) { -+ Self::wake_by_ref(&me) -+ } -+} -+ -+/// # Safety -+/// -+/// `ListEntry` is forced to be !Unpin. -+unsafe impl linked_list::Link for ListEntry { -+ type Handle = Arc>; -+ type Target = ListEntry; -+ -+ fn as_raw(handle: &Self::Handle) -> NonNull> { -+ let ptr: *const ListEntry = Arc::as_ptr(handle); -+ // Safety: We can't get a null pointer from `Arc::as_ptr`. -+ unsafe { NonNull::new_unchecked(ptr as *mut ListEntry) } -+ } -+ -+ unsafe fn from_raw(ptr: NonNull>) -> Arc> { -+ Arc::from_raw(ptr.as_ptr()) -+ } -+ -+ unsafe fn pointers( -+ target: NonNull>, -+ ) -> NonNull>> { -+ ListEntry::addr_of_pointers(target) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/util/linked_list.rs b/KubeOS-Rust/vendor/tokio/src/util/linked_list.rs -index 894d2164..6bf26818 100644 ---- a/KubeOS-Rust/vendor/tokio/src/util/linked_list.rs -+++ b/KubeOS-Rust/vendor/tokio/src/util/linked_list.rs -@@ -57,6 +57,13 @@ pub(crate) unsafe trait Link { - unsafe fn from_raw(ptr: NonNull) -> Self::Handle; - - /// Return the pointers for a node -+ /// -+ /// # Safety -+ /// -+ /// The resulting pointer should have the same tag in the stacked-borrows -+ /// stack as the argument. In particular, the method may not create an -+ /// intermediate reference in the process of creating the resulting raw -+ /// pointer. - unsafe fn pointers(target: NonNull) -> NonNull>; - } - -@@ -119,7 +126,7 @@ impl LinkedList { - pub(crate) fn push_front(&mut self, val: L::Handle) { - // The value should not be dropped, it is being inserted into the list - let val = ManuallyDrop::new(val); -- let ptr = L::as_raw(&*val); -+ let ptr = L::as_raw(&val); - assert_ne!(self.head, Some(ptr)); - unsafe { - L::pointers(ptr).as_mut().set_next(self.head); -@@ -171,8 +178,12 @@ impl LinkedList { - /// - /// # Safety - /// -- /// The caller **must** ensure that `node` is currently contained by -- /// `self` or not contained by any other list. -+ /// The caller **must** ensure that exactly one of the following is true: -+ /// - `node` is currently contained by `self`, -+ /// - `node` is not contained by any list, -+ /// - `node` is currently contained by some other `GuardedLinkedList` **and** -+ /// the caller has an exclusive access to that list. This condition is -+ /// used by the linked list in `sync::Notify`. - pub(crate) unsafe fn remove(&mut self, node: NonNull) -> Option { - if let Some(prev) = L::pointers(node).as_ref().get_prev() { - debug_assert_eq!(L::pointers(prev).as_ref().get_next(), Some(node)); -@@ -219,6 +230,7 @@ impl fmt::Debug for LinkedList { - - #[cfg(any( - feature = "fs", -+ feature = "rt", - all(unix, feature = "process"), - feature = "signal", - feature = "sync", -@@ -282,6 +294,96 @@ cfg_io_readiness! { - } - } - -+// ===== impl GuardedLinkedList ===== -+ -+feature! { -+ #![any( -+ feature = "process", -+ feature = "sync", -+ feature = "rt", -+ feature = "signal", -+ )] -+ -+ /// An intrusive linked list, but instead of keeping pointers to the head -+ /// and tail nodes, it uses a special guard node linked with those nodes. -+ /// It means that the list is circular and every pointer of a node from -+ /// the list is not `None`, including pointers from the guard node. -+ /// -+ /// If a list is empty, then both pointers of the guard node are pointing -+ /// at the guard node itself. -+ pub(crate) struct GuardedLinkedList { -+ /// Pointer to the guard node. -+ guard: NonNull, -+ -+ /// Node type marker. -+ _marker: PhantomData<*const L>, -+ } -+ -+ impl>> LinkedList { -+ /// Turns a linked list into the guarded version by linking the guard node -+ /// with the head and tail nodes. Like with other nodes, you should guarantee -+ /// that the guard node is pinned in memory. -+ pub(crate) fn into_guarded(self, guard_handle: L::Handle) -> GuardedLinkedList { -+ // `guard_handle` is a NonNull pointer, we don't have to care about dropping it. -+ let guard = L::as_raw(&guard_handle); -+ -+ unsafe { -+ if let Some(head) = self.head { -+ debug_assert!(L::pointers(head).as_ref().get_prev().is_none()); -+ L::pointers(head).as_mut().set_prev(Some(guard)); -+ L::pointers(guard).as_mut().set_next(Some(head)); -+ -+ // The list is not empty, so the tail cannot be `None`. -+ let tail = self.tail.unwrap(); -+ debug_assert!(L::pointers(tail).as_ref().get_next().is_none()); -+ L::pointers(tail).as_mut().set_next(Some(guard)); -+ L::pointers(guard).as_mut().set_prev(Some(tail)); -+ } else { -+ // The list is empty. -+ L::pointers(guard).as_mut().set_prev(Some(guard)); -+ L::pointers(guard).as_mut().set_next(Some(guard)); -+ } -+ } -+ -+ GuardedLinkedList { guard, _marker: PhantomData } -+ } -+ } -+ -+ impl GuardedLinkedList { -+ fn tail(&self) -> Option> { -+ let tail_ptr = unsafe { -+ L::pointers(self.guard).as_ref().get_prev().unwrap() -+ }; -+ -+ // Compare the tail pointer with the address of the guard node itself. -+ // If the guard points at itself, then there are no other nodes and -+ // the list is considered empty. -+ if tail_ptr != self.guard { -+ Some(tail_ptr) -+ } else { -+ None -+ } -+ } -+ -+ /// Removes the last element from a list and returns it, or None if it is -+ /// empty. -+ pub(crate) fn pop_back(&mut self) -> Option { -+ unsafe { -+ let last = self.tail()?; -+ let before_last = L::pointers(last).as_ref().get_prev().unwrap(); -+ -+ L::pointers(self.guard).as_mut().set_prev(Some(before_last)); -+ L::pointers(before_last).as_mut().set_next(Some(self.guard)); -+ -+ L::pointers(last).as_mut().set_prev(None); -+ L::pointers(last).as_mut().set_next(None); -+ -+ Some(L::from_raw(last)) -+ } -+ } -+ } -+} -+ - // ===== impl Pointers ===== - - impl Pointers { -@@ -296,7 +398,7 @@ impl Pointers { - } - } - -- fn get_prev(&self) -> Option> { -+ pub(crate) fn get_prev(&self) -> Option> { - // SAFETY: prev is the first field in PointersInner, which is #[repr(C)]. - unsafe { - let inner = self.inner.get(); -@@ -304,7 +406,7 @@ impl Pointers { - ptr::read(prev) - } - } -- fn get_next(&self) -> Option> { -+ pub(crate) fn get_next(&self) -> Option> { - // SAFETY: next is the second field in PointersInner, which is #[repr(C)]. - unsafe { - let inner = self.inner.get(); -@@ -344,14 +446,15 @@ impl fmt::Debug for Pointers { - } - } - --#[cfg(test)] -+#[cfg(any(test, fuzzing))] - #[cfg(not(loom))] --mod tests { -+pub(crate) mod tests { - use super::*; - - use std::pin::Pin; - - #[derive(Debug)] -+ #[repr(C)] - struct Entry { - pointers: Pointers, - val: i32, -@@ -369,8 +472,8 @@ mod tests { - Pin::new_unchecked(&*ptr.as_ptr()) - } - -- unsafe fn pointers(mut target: NonNull) -> NonNull> { -- NonNull::from(&mut target.as_mut().pointers) -+ unsafe fn pointers(target: NonNull) -> NonNull> { -+ target.cast() - } - } - -@@ -404,6 +507,7 @@ mod tests { - } - } - -+ #[cfg(test)] - macro_rules! assert_clean { - ($e:ident) => {{ - assert!($e.pointers.get_next().is_none()); -@@ -411,6 +515,7 @@ mod tests { - }}; - } - -+ #[cfg(test)] - macro_rules! assert_ptr_eq { - ($a:expr, $b:expr) => {{ - // Deal with mapping a Pin<&mut T> -> Option> -@@ -614,29 +719,22 @@ mod tests { - } - } - -- proptest::proptest! { -- #[test] -- fn fuzz_linked_list(ops: Vec) { -- run_fuzz(ops); -- } -- } -- -- fn run_fuzz(ops: Vec) { -- use std::collections::VecDeque; -- -- #[derive(Debug)] -+ /// This is a fuzz test. You run it by entering `cargo fuzz run fuzz_linked_list` in CLI in `/tokio/` module. -+ #[cfg(fuzzing)] -+ pub fn fuzz_linked_list(ops: &[u8]) { - enum Op { - Push, - Pop, - Remove(usize), - } -+ use std::collections::VecDeque; - - let ops = ops - .iter() -- .map(|i| match i % 3 { -+ .map(|i| match i % 3u8 { - 0 => Op::Push, - 1 => Op::Pop, -- 2 => Op::Remove(i / 3), -+ 2 => Op::Remove((i / 3u8) as usize), - _ => unreachable!(), - }) - .collect::>(); -diff --git a/KubeOS-Rust/vendor/tokio/src/util/memchr.rs b/KubeOS-Rust/vendor/tokio/src/util/memchr.rs -new file mode 100644 -index 00000000..44fd2da3 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/util/memchr.rs -@@ -0,0 +1,74 @@ -+//! Search for a byte in a byte array using libc. -+//! -+//! When nothing pulls in libc, then just use a trivial implementation. Note -+//! that we only depend on libc on unix. -+ -+#[cfg(not(all(unix, feature = "libc")))] -+pub(crate) fn memchr(needle: u8, haystack: &[u8]) -> Option { -+ haystack.iter().position(|val| needle == *val) -+} -+ -+#[cfg(all(unix, feature = "libc"))] -+pub(crate) fn memchr(needle: u8, haystack: &[u8]) -> Option { -+ let start = haystack.as_ptr(); -+ -+ // SAFETY: `start` is valid for `haystack.len()` bytes. -+ let ptr = unsafe { libc::memchr(start.cast(), needle as _, haystack.len()) }; -+ -+ if ptr.is_null() { -+ None -+ } else { -+ Some(ptr as usize - start as usize) -+ } -+} -+ -+#[cfg(test)] -+mod tests { -+ use super::memchr; -+ -+ #[test] -+ fn memchr_test() { -+ let haystack = b"123abc456\0\xffabc\n"; -+ -+ assert_eq!(memchr(b'1', haystack), Some(0)); -+ assert_eq!(memchr(b'2', haystack), Some(1)); -+ assert_eq!(memchr(b'3', haystack), Some(2)); -+ assert_eq!(memchr(b'4', haystack), Some(6)); -+ assert_eq!(memchr(b'5', haystack), Some(7)); -+ assert_eq!(memchr(b'6', haystack), Some(8)); -+ assert_eq!(memchr(b'7', haystack), None); -+ assert_eq!(memchr(b'a', haystack), Some(3)); -+ assert_eq!(memchr(b'b', haystack), Some(4)); -+ assert_eq!(memchr(b'c', haystack), Some(5)); -+ assert_eq!(memchr(b'd', haystack), None); -+ assert_eq!(memchr(b'A', haystack), None); -+ assert_eq!(memchr(0, haystack), Some(9)); -+ assert_eq!(memchr(0xff, haystack), Some(10)); -+ assert_eq!(memchr(0xfe, haystack), None); -+ assert_eq!(memchr(1, haystack), None); -+ assert_eq!(memchr(b'\n', haystack), Some(14)); -+ assert_eq!(memchr(b'\r', haystack), None); -+ } -+ -+ #[test] -+ fn memchr_all() { -+ let mut arr = Vec::new(); -+ for b in 0..=255 { -+ arr.push(b); -+ } -+ for b in 0..=255 { -+ assert_eq!(memchr(b, &arr), Some(b as usize)); -+ } -+ arr.reverse(); -+ for b in 0..=255 { -+ assert_eq!(memchr(b, &arr), Some(255 - b as usize)); -+ } -+ } -+ -+ #[test] -+ fn memchr_empty() { -+ for b in 0..=255 { -+ assert_eq!(memchr(b, b""), None); -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/util/mod.rs b/KubeOS-Rust/vendor/tokio/src/util/mod.rs -index df30f2b8..b1afc571 100644 ---- a/KubeOS-Rust/vendor/tokio/src/util/mod.rs -+++ b/KubeOS-Rust/vendor/tokio/src/util/mod.rs -@@ -3,6 +3,17 @@ cfg_io_driver! { - pub(crate) mod slab; - } - -+#[cfg(feature = "rt")] -+pub(crate) mod atomic_cell; -+ -+#[cfg(any( -+ feature = "rt", -+ feature = "signal", -+ feature = "process", -+ tokio_no_const_mutex_new, -+))] -+pub(crate) mod once_cell; -+ - #[cfg(any( - // io driver uses `WakeList` directly - feature = "net", -@@ -37,10 +48,15 @@ pub(crate) use wake_list::WakeList; - ))] - pub(crate) mod linked_list; - --#[cfg(any(feature = "rt-multi-thread", feature = "macros"))] --mod rand; -+#[cfg(any(feature = "rt", feature = "macros"))] -+pub(crate) mod rand; - - cfg_rt! { -+ mod idle_notified_set; -+ pub(crate) use idle_notified_set::IdleNotifiedSet; -+ -+ pub(crate) use self::rand::RngSeedGenerator; -+ - mod wake; - pub(crate) use wake::WakerRef; - pub(crate) use wake::{waker_ref, Wake}; -@@ -48,28 +64,18 @@ cfg_rt! { - mod sync_wrapper; - pub(crate) use sync_wrapper::SyncWrapper; - -- mod vec_deque_cell; -- pub(crate) use vec_deque_cell::VecDequeCell; -+ mod rc_cell; -+ pub(crate) use rc_cell::RcCell; - } - - cfg_rt_multi_thread! { -- pub(crate) use self::rand::FastRand; -- - mod try_lock; - pub(crate) use try_lock::TryLock; - } - - pub(crate) mod trace; - --#[cfg(any(feature = "macros"))] --#[cfg_attr(not(feature = "macros"), allow(unreachable_pub))] --pub use self::rand::thread_rng_n; -- --#[cfg(any( -- feature = "rt", -- feature = "time", -- feature = "net", -- feature = "process", -- all(unix, feature = "signal") --))] - pub(crate) mod error; -+ -+#[cfg(feature = "io-util")] -+pub(crate) mod memchr; -diff --git a/KubeOS-Rust/vendor/tokio/src/util/once_cell.rs b/KubeOS-Rust/vendor/tokio/src/util/once_cell.rs -new file mode 100644 -index 00000000..71fc0075 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/util/once_cell.rs -@@ -0,0 +1,70 @@ -+#![allow(dead_code)] -+use std::cell::UnsafeCell; -+use std::mem::MaybeUninit; -+use std::sync::Once; -+ -+pub(crate) struct OnceCell { -+ once: Once, -+ value: UnsafeCell>, -+} -+ -+unsafe impl Send for OnceCell {} -+unsafe impl Sync for OnceCell {} -+ -+impl OnceCell { -+ pub(crate) const fn new() -> Self { -+ Self { -+ once: Once::new(), -+ value: UnsafeCell::new(MaybeUninit::uninit()), -+ } -+ } -+ -+ /// Get the value inside this cell, initializing it using the provided -+ /// function if necessary. -+ /// -+ /// If the `init` closure panics, then the `OnceCell` is poisoned and all -+ /// future calls to `get` will panic. -+ #[inline] -+ pub(crate) fn get(&self, init: impl FnOnce() -> T) -> &T { -+ if !self.once.is_completed() { -+ self.do_init(init); -+ } -+ -+ // Safety: The `std::sync::Once` guarantees that we can only reach this -+ // line if a `call_once` closure has been run exactly once and without -+ // panicking. Thus, the value is not uninitialized. -+ // -+ // There is also no race because the only `&self` method that modifies -+ // `value` is `do_init`, but if the `call_once` closure is still -+ // running, then no thread has gotten past the `call_once`. -+ unsafe { &*(self.value.get() as *const T) } -+ } -+ -+ #[cold] -+ fn do_init(&self, init: impl FnOnce() -> T) { -+ let value_ptr = self.value.get() as *mut T; -+ -+ self.once.call_once(|| { -+ let set_to = init(); -+ -+ // Safety: The `std::sync::Once` guarantees that this initialization -+ // will run at most once, and that no thread can get past the -+ // `call_once` until it has run exactly once. Thus, we have -+ // exclusive access to `value`. -+ unsafe { -+ std::ptr::write(value_ptr, set_to); -+ } -+ }); -+ } -+} -+ -+impl Drop for OnceCell { -+ fn drop(&mut self) { -+ if self.once.is_completed() { -+ let value_ptr = self.value.get() as *mut T; -+ unsafe { -+ std::ptr::drop_in_place(value_ptr); -+ } -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/util/pad.rs b/KubeOS-Rust/vendor/tokio/src/util/pad.rs -deleted file mode 100644 -index bf0913ca..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/util/pad.rs -+++ /dev/null -@@ -1,52 +0,0 @@ --use core::fmt; --use core::ops::{Deref, DerefMut}; -- --#[derive(Clone, Copy, Default, Hash, PartialEq, Eq)] --// Starting from Intel's Sandy Bridge, spatial prefetcher is now pulling pairs of 64-byte cache --// lines at a time, so we have to align to 128 bytes rather than 64. --// --// Sources: --// - https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf --// - https://github.com/facebook/folly/blob/1b5288e6eea6df074758f877c849b6e73bbb9fbb/folly/lang/Align.h#L107 --#[cfg_attr(target_arch = "x86_64", repr(align(128)))] --#[cfg_attr(not(target_arch = "x86_64"), repr(align(64)))] --pub(crate) struct CachePadded { -- value: T, --} -- --unsafe impl Send for CachePadded {} --unsafe impl Sync for CachePadded {} -- --impl CachePadded { -- pub(crate) fn new(t: T) -> CachePadded { -- CachePadded:: { value: t } -- } --} -- --impl Deref for CachePadded { -- type Target = T; -- -- fn deref(&self) -> &T { -- &self.value -- } --} -- --impl DerefMut for CachePadded { -- fn deref_mut(&mut self) -> &mut T { -- &mut self.value -- } --} -- --impl fmt::Debug for CachePadded { -- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -- f.debug_struct("CachePadded") -- .field("value", &self.value) -- .finish() -- } --} -- --impl From for CachePadded { -- fn from(t: T) -> Self { -- CachePadded::new(t) -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/util/rand.rs b/KubeOS-Rust/vendor/tokio/src/util/rand.rs -index 6b19c8be..7018c1ee 100644 ---- a/KubeOS-Rust/vendor/tokio/src/util/rand.rs -+++ b/KubeOS-Rust/vendor/tokio/src/util/rand.rs -@@ -1,5 +1,103 @@ - use std::cell::Cell; - -+cfg_rt! { -+ use std::sync::Mutex; -+ -+ /// A deterministic generator for seeds (and other generators). -+ /// -+ /// Given the same initial seed, the generator will output the same sequence of seeds. -+ /// -+ /// Since the seed generator will be kept in a runtime handle, we need to wrap `FastRand` -+ /// in a Mutex to make it thread safe. Different to the `FastRand` that we keep in a -+ /// thread local store, the expectation is that seed generation will not need to happen -+ /// very frequently, so the cost of the mutex should be minimal. -+ #[derive(Debug)] -+ pub(crate) struct RngSeedGenerator { -+ /// Internal state for the seed generator. We keep it in a Mutex so that we can safely -+ /// use it across multiple threads. -+ state: Mutex, -+ } -+ -+ impl RngSeedGenerator { -+ /// Returns a new generator from the provided seed. -+ pub(crate) fn new(seed: RngSeed) -> Self { -+ Self { -+ state: Mutex::new(FastRand::new(seed)), -+ } -+ } -+ -+ /// Returns the next seed in the sequence. -+ pub(crate) fn next_seed(&self) -> RngSeed { -+ let rng = self -+ .state -+ .lock() -+ .expect("RNG seed generator is internally corrupt"); -+ -+ let s = rng.fastrand(); -+ let r = rng.fastrand(); -+ -+ RngSeed::from_pair(s, r) -+ } -+ -+ /// Directly creates a generator using the next seed. -+ pub(crate) fn next_generator(&self) -> Self { -+ RngSeedGenerator::new(self.next_seed()) -+ } -+ } -+} -+ -+/// A seed for random number generation. -+/// -+/// In order to make certain functions within a runtime deterministic, a seed -+/// can be specified at the time of creation. -+#[allow(unreachable_pub)] -+#[derive(Clone, Debug)] -+pub struct RngSeed { -+ s: u32, -+ r: u32, -+} -+ -+impl RngSeed { -+ /// Creates a random seed using loom internally. -+ pub(crate) fn new() -> Self { -+ Self::from_u64(crate::loom::rand::seed()) -+ } -+ -+ cfg_unstable! { -+ /// Generates a seed from the provided byte slice. -+ /// -+ /// # Example -+ /// -+ /// ``` -+ /// # use tokio::runtime::RngSeed; -+ /// let seed = RngSeed::from_bytes(b"make me a seed"); -+ /// ``` -+ #[cfg(feature = "rt")] -+ pub fn from_bytes(bytes: &[u8]) -> Self { -+ use std::{collections::hash_map::DefaultHasher, hash::Hasher}; -+ -+ let mut hasher = DefaultHasher::default(); -+ hasher.write(bytes); -+ Self::from_u64(hasher.finish()) -+ } -+ } -+ -+ fn from_u64(seed: u64) -> Self { -+ let one = (seed >> 32) as u32; -+ let mut two = seed as u32; -+ -+ if two == 0 { -+ // This value cannot be zero -+ two = 1; -+ } -+ -+ Self::from_pair(one, two) -+ } -+ -+ fn from_pair(s: u32, r: u32) -> Self { -+ Self { s, r } -+ } -+} - /// Fast random number generate. - /// - /// Implement xorshift64+: 2 32-bit xorshift sequences added together. -@@ -15,21 +113,33 @@ pub(crate) struct FastRand { - - impl FastRand { - /// Initializes a new, thread-local, fast random number generator. -- pub(crate) fn new(seed: u64) -> FastRand { -- let one = (seed >> 32) as u32; -- let mut two = seed as u32; -- -- if two == 0 { -- // This value cannot be zero -- two = 1; -- } -- -+ pub(crate) fn new(seed: RngSeed) -> FastRand { - FastRand { -- one: Cell::new(one), -- two: Cell::new(two), -+ one: Cell::new(seed.s), -+ two: Cell::new(seed.r), - } - } - -+ /// Replaces the state of the random number generator with the provided seed, returning -+ /// the seed that represents the previous state of the random number generator. -+ /// -+ /// The random number generator will become equivalent to one created with -+ /// the same seed. -+ #[cfg(feature = "rt")] -+ pub(crate) fn replace_seed(&self, seed: RngSeed) -> RngSeed { -+ let old_seed = RngSeed::from_pair(self.one.get(), self.two.get()); -+ -+ self.one.replace(seed.s); -+ self.two.replace(seed.r); -+ -+ old_seed -+ } -+ -+ #[cfg(any( -+ feature = "macros", -+ feature = "rt-multi-thread", -+ all(feature = "sync", feature = "rt") -+ ))] - pub(crate) fn fastrand_n(&self, n: u32) -> u32 { - // This is similar to fastrand() % n, but faster. - // See https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/ -@@ -50,15 +160,3 @@ impl FastRand { - s0.wrapping_add(s1) - } - } -- --// Used by the select macro and `StreamMap` --#[cfg(any(feature = "macros"))] --#[doc(hidden)] --#[cfg_attr(not(feature = "macros"), allow(unreachable_pub))] --pub fn thread_rng_n(n: u32) -> u32 { -- thread_local! { -- static THREAD_RNG: FastRand = FastRand::new(crate::loom::rand::seed()); -- } -- -- THREAD_RNG.with(|rng| rng.fastrand_n(n)) --} -diff --git a/KubeOS-Rust/vendor/tokio/src/util/rc_cell.rs b/KubeOS-Rust/vendor/tokio/src/util/rc_cell.rs -new file mode 100644 -index 00000000..44724926 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/src/util/rc_cell.rs -@@ -0,0 +1,57 @@ -+use crate::loom::cell::UnsafeCell; -+ -+use std::rc::Rc; -+ -+/// This is exactly like `Cell>>`, except that it provides a `get` -+/// method even though `Rc` is not `Copy`. -+pub(crate) struct RcCell { -+ inner: UnsafeCell>>, -+} -+ -+impl RcCell { -+ #[cfg(not(all(loom, test)))] -+ pub(crate) const fn new() -> Self { -+ Self { -+ inner: UnsafeCell::new(None), -+ } -+ } -+ -+ // The UnsafeCell in loom does not have a const `new` fn. -+ #[cfg(all(loom, test))] -+ pub(crate) fn new() -> Self { -+ Self { -+ inner: UnsafeCell::new(None), -+ } -+ } -+ -+ /// Safety: This method may not be called recursively. -+ #[inline] -+ unsafe fn with_inner(&self, f: F) -> R -+ where -+ F: FnOnce(&mut Option>) -> R, -+ { -+ // safety: This type is not Sync, so concurrent calls of this method -+ // cannot happen. Furthermore, the caller guarantees that the method is -+ // not called recursively. Finally, this is the only place that can -+ // create mutable references to the inner Rc. This ensures that any -+ // mutable references created here are exclusive. -+ self.inner.with_mut(|ptr| f(&mut *ptr)) -+ } -+ -+ pub(crate) fn get(&self) -> Option> { -+ // safety: The `Rc::clone` method will not call any unknown user-code, -+ // so it will not result in a recursive call to `with_inner`. -+ unsafe { self.with_inner(|rc| rc.clone()) } -+ } -+ -+ pub(crate) fn replace(&self, val: Option>) -> Option> { -+ // safety: No destructors or other unknown user-code will run inside the -+ // `with_inner` call, so no recursive call to `with_inner` can happen. -+ unsafe { self.with_inner(|rc| std::mem::replace(rc, val)) } -+ } -+ -+ pub(crate) fn set(&self, val: Option>) { -+ let old = self.replace(val); -+ drop(old); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/src/util/slab.rs b/KubeOS-Rust/vendor/tokio/src/util/slab.rs -index 97355d50..cc1208eb 100644 ---- a/KubeOS-Rust/vendor/tokio/src/util/slab.rs -+++ b/KubeOS-Rust/vendor/tokio/src/util/slab.rs -@@ -157,6 +157,12 @@ struct Slot { - - /// Next entry in the free list. - next: u32, -+ -+ /// Makes miri happy by making mutable references not take exclusive access. -+ /// -+ /// Could probably also be fixed by replacing `slots` with a raw-pointer -+ /// based equivalent. -+ _pin: std::marker::PhantomPinned, - } - - /// Value paired with a reference to the page. -@@ -409,7 +415,7 @@ impl Page { - slot.value.with(|ptr| unsafe { (*ptr).value.reset() }); - - // Return a reference to the slot -- Some((me.addr(idx), slot.gen_ref(me))) -+ Some((me.addr(idx), locked.gen_ref(idx, me))) - } else if me.len == locked.slots.len() { - // The page is full - None -@@ -428,9 +434,10 @@ impl Page { - locked.slots.push(Slot { - value: UnsafeCell::new(Value { - value: Default::default(), -- page: &**me as *const _, -+ page: Arc::as_ptr(me), - }), - next: 0, -+ _pin: std::marker::PhantomPinned, - }); - - // Increment the head to indicate the free stack is empty -@@ -443,7 +450,7 @@ impl Page { - - debug_assert_eq!(locked.slots.len(), locked.head); - -- Some((me.addr(idx), locked.slots[idx].gen_ref(me))) -+ Some((me.addr(idx), locked.gen_ref(idx, me))) - } - } - } -@@ -544,32 +551,28 @@ impl Slots { - fn index_for(&self, slot: *const Value) -> usize { - use std::mem; - -- let base = &self.slots[0] as *const _ as usize; -- -- assert!(base != 0, "page is unallocated"); -+ assert_ne!(self.slots.capacity(), 0, "page is unallocated"); - -+ let base = self.slots.as_ptr() as usize; - let slot = slot as usize; - let width = mem::size_of::>(); - - assert!(slot >= base, "unexpected pointer"); - - let idx = (slot - base) / width; -- assert!(idx < self.slots.len() as usize); -+ assert!(idx < self.slots.len()); - - idx - } --} - --impl Slot { -- /// Generates a `Ref` for the slot. This involves bumping the page's ref count. -- fn gen_ref(&self, page: &Arc>) -> Ref { -- // The ref holds a ref on the page. The `Arc` is forgotten here and is -- // resurrected in `release` when the `Ref` is dropped. By avoiding to -- // hold on to an explicit `Arc` value, the struct size of `Ref` is -- // reduced. -+ /// Generates a `Ref` for the slot at the given index. This involves bumping the page's ref count. -+ fn gen_ref(&self, idx: usize, page: &Arc>) -> Ref { -+ assert!(idx < self.slots.len()); - mem::forget(page.clone()); -- let slot = self as *const Slot; -- let value = slot as *const Value; -+ -+ let vec_ptr = self.slots.as_ptr(); -+ let slot: *const Slot = unsafe { vec_ptr.add(idx) }; -+ let value: *const Value = slot as *const Value; - - Ref { value } - } -@@ -691,11 +694,13 @@ mod test { - - #[test] - fn insert_many() { -+ const MANY: usize = normal_or_miri(10_000, 50); -+ - let mut slab = Slab::::new(); - let alloc = slab.allocator(); - let mut entries = vec![]; - -- for i in 0..10_000 { -+ for i in 0..MANY { - let (addr, val) = alloc.allocate().unwrap(); - val.id.store(i, SeqCst); - entries.push((addr, val)); -@@ -708,15 +713,15 @@ mod test { - - entries.clear(); - -- for i in 0..10_000 { -+ for i in 0..MANY { - let (addr, val) = alloc.allocate().unwrap(); -- val.id.store(10_000 - i, SeqCst); -+ val.id.store(MANY - i, SeqCst); - entries.push((addr, val)); - } - - for (i, (addr, v)) in entries.iter().enumerate() { -- assert_eq!(10_000 - i, v.id.load(SeqCst)); -- assert_eq!(10_000 - i, slab.get(*addr).unwrap().id.load(SeqCst)); -+ assert_eq!(MANY - i, v.id.load(SeqCst)); -+ assert_eq!(MANY - i, slab.get(*addr).unwrap().id.load(SeqCst)); - } - } - -@@ -726,7 +731,7 @@ mod test { - let alloc = slab.allocator(); - let mut entries = vec![]; - -- for i in 0..10_000 { -+ for i in 0..normal_or_miri(10_000, 100) { - let (addr, val) = alloc.allocate().unwrap(); - val.id.store(i, SeqCst); - entries.push((addr, val)); -@@ -734,7 +739,7 @@ mod test { - - for _ in 0..10 { - // Drop 1000 in reverse -- for _ in 0..1_000 { -+ for _ in 0..normal_or_miri(1_000, 10) { - entries.pop(); - } - -@@ -753,7 +758,7 @@ mod test { - let mut entries1 = vec![]; - let mut entries2 = vec![]; - -- for i in 0..10_000 { -+ for i in 0..normal_or_miri(10_000, 100) { - let (addr, val) = alloc.allocate().unwrap(); - val.id.store(i, SeqCst); - -@@ -771,6 +776,14 @@ mod test { - } - } - -+ const fn normal_or_miri(normal: usize, miri: usize) -> usize { -+ if cfg!(miri) { -+ miri -+ } else { -+ normal -+ } -+ } -+ - #[test] - fn compact_all() { - let mut slab = Slab::::new(); -@@ -780,7 +793,7 @@ mod test { - for _ in 0..2 { - entries.clear(); - -- for i in 0..10_000 { -+ for i in 0..normal_or_miri(10_000, 100) { - let (addr, val) = alloc.allocate().unwrap(); - val.id.store(i, SeqCst); - -@@ -808,7 +821,7 @@ mod test { - let alloc = slab.allocator(); - let mut entries = vec![]; - -- for _ in 0..5 { -+ for _ in 0..normal_or_miri(5, 2) { - entries.clear(); - - // Allocate a few pages + 1 -diff --git a/KubeOS-Rust/vendor/tokio/src/util/trace.rs b/KubeOS-Rust/vendor/tokio/src/util/trace.rs -index e3c26f9d..76e8a6cb 100644 ---- a/KubeOS-Rust/vendor/tokio/src/util/trace.rs -+++ b/KubeOS-Rust/vendor/tokio/src/util/trace.rs -@@ -1,40 +1,90 @@ - cfg_trace! { - cfg_rt! { -+ use core::{ -+ pin::Pin, -+ task::{Context, Poll}, -+ }; -+ use pin_project_lite::pin_project; -+ use std::future::Future; - pub(crate) use tracing::instrument::Instrumented; - - #[inline] -- #[cfg_attr(tokio_track_caller, track_caller)] -- pub(crate) fn task(task: F, kind: &'static str, name: Option<&str>) -> Instrumented { -+ #[track_caller] -+ pub(crate) fn task(task: F, kind: &'static str, name: Option<&str>, id: u64) -> Instrumented { - use tracing::instrument::Instrument; -- #[cfg(tokio_track_caller)] - let location = std::panic::Location::caller(); -- #[cfg(tokio_track_caller)] - let span = tracing::trace_span!( - target: "tokio::task", - "runtime.spawn", - %kind, - task.name = %name.unwrap_or_default(), -+ task.id = id, - loc.file = location.file(), - loc.line = location.line(), - loc.col = location.column(), - ); -- #[cfg(not(tokio_track_caller))] -- let span = tracing::trace_span!( -- target: "tokio::task", -- "runtime.spawn", -- %kind, -- task.name = %name.unwrap_or_default(), -- ); - task.instrument(span) - } -+ -+ pub(crate) fn async_op(inner: P, resource_span: tracing::Span, source: &str, poll_op_name: &'static str, inherits_child_attrs: bool) -> InstrumentedAsyncOp -+ where P: FnOnce() -> F { -+ resource_span.in_scope(|| { -+ let async_op_span = tracing::trace_span!("runtime.resource.async_op", source = source, inherits_child_attrs = inherits_child_attrs); -+ let enter = async_op_span.enter(); -+ let async_op_poll_span = tracing::trace_span!("runtime.resource.async_op.poll"); -+ let inner = inner(); -+ drop(enter); -+ let tracing_ctx = AsyncOpTracingCtx { -+ async_op_span, -+ async_op_poll_span, -+ resource_span: resource_span.clone(), -+ }; -+ InstrumentedAsyncOp { -+ inner, -+ tracing_ctx, -+ poll_op_name, -+ } -+ }) -+ } -+ -+ #[derive(Debug, Clone)] -+ pub(crate) struct AsyncOpTracingCtx { -+ pub(crate) async_op_span: tracing::Span, -+ pub(crate) async_op_poll_span: tracing::Span, -+ pub(crate) resource_span: tracing::Span, -+ } -+ -+ -+ pin_project! { -+ #[derive(Debug, Clone)] -+ pub(crate) struct InstrumentedAsyncOp { -+ #[pin] -+ pub(crate) inner: F, -+ pub(crate) tracing_ctx: AsyncOpTracingCtx, -+ pub(crate) poll_op_name: &'static str -+ } -+ } -+ -+ impl Future for InstrumentedAsyncOp { -+ type Output = F::Output; -+ -+ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { -+ let this = self.project(); -+ let poll_op_name = &*this.poll_op_name; -+ let _res_enter = this.tracing_ctx.resource_span.enter(); -+ let _async_op_enter = this.tracing_ctx.async_op_span.enter(); -+ let _async_op_poll_enter = this.tracing_ctx.async_op_poll_span.enter(); -+ trace_poll_op!(poll_op_name, this.inner.poll(cx)) -+ } -+ } - } - } - cfg_time! { -- #[cfg_attr(tokio_track_caller, track_caller)] -+ #[track_caller] - pub(crate) fn caller_location() -> Option<&'static std::panic::Location<'static>> { -- #[cfg(all(tokio_track_caller, tokio_unstable, feature = "tracing"))] -+ #[cfg(all(tokio_unstable, feature = "tracing"))] - return Some(std::panic::Location::caller()); -- #[cfg(not(all(tokio_track_caller, tokio_unstable, feature = "tracing")))] -+ #[cfg(not(all(tokio_unstable, feature = "tracing")))] - None - } - } -@@ -42,7 +92,7 @@ cfg_time! { - cfg_not_trace! { - cfg_rt! { - #[inline] -- pub(crate) fn task(task: F, _: &'static str, _name: Option<&str>) -> F { -+ pub(crate) fn task(task: F, _: &'static str, _name: Option<&str>, _: u64) -> F { - // nop - task - } -diff --git a/KubeOS-Rust/vendor/tokio/src/util/vec_deque_cell.rs b/KubeOS-Rust/vendor/tokio/src/util/vec_deque_cell.rs -deleted file mode 100644 -index b4e124c1..00000000 ---- a/KubeOS-Rust/vendor/tokio/src/util/vec_deque_cell.rs -+++ /dev/null -@@ -1,53 +0,0 @@ --use crate::loom::cell::UnsafeCell; -- --use std::collections::VecDeque; --use std::marker::PhantomData; -- --/// This type is like VecDeque, except that it is not Sync and can be modified --/// through immutable references. --pub(crate) struct VecDequeCell { -- inner: UnsafeCell>, -- _not_sync: PhantomData<*const ()>, --} -- --// This is Send for the same reasons that RefCell> is Send. --unsafe impl Send for VecDequeCell {} -- --impl VecDequeCell { -- pub(crate) fn with_capacity(cap: usize) -> Self { -- Self { -- inner: UnsafeCell::new(VecDeque::with_capacity(cap)), -- _not_sync: PhantomData, -- } -- } -- -- /// Safety: This method may not be called recursively. -- #[inline] -- unsafe fn with_inner(&self, f: F) -> R -- where -- F: FnOnce(&mut VecDeque) -> R, -- { -- // safety: This type is not Sync, so concurrent calls of this method -- // cannot happen. Furthermore, the caller guarantees that the method is -- // not called recursively. Finally, this is the only place that can -- // create mutable references to the inner VecDeque. This ensures that -- // any mutable references created here are exclusive. -- self.inner.with_mut(|ptr| f(&mut *ptr)) -- } -- -- pub(crate) fn pop_front(&self) -> Option { -- unsafe { self.with_inner(VecDeque::pop_front) } -- } -- -- pub(crate) fn push_back(&self, item: T) { -- unsafe { -- self.with_inner(|inner| inner.push_back(item)); -- } -- } -- -- /// Replaces the inner VecDeque with an empty VecDeque and return the current -- /// contents. -- pub(crate) fn take(&self) -> VecDeque { -- unsafe { self.with_inner(|inner| std::mem::take(inner)) } -- } --} -diff --git a/KubeOS-Rust/vendor/tokio/src/util/wake.rs b/KubeOS-Rust/vendor/tokio/src/util/wake.rs -index 8f89668c..5526cbc6 100644 ---- a/KubeOS-Rust/vendor/tokio/src/util/wake.rs -+++ b/KubeOS-Rust/vendor/tokio/src/util/wake.rs -@@ -1,13 +1,14 @@ -+use crate::loom::sync::Arc; -+ - use std::marker::PhantomData; - use std::mem::ManuallyDrop; - use std::ops::Deref; --use std::sync::Arc; - use std::task::{RawWaker, RawWakerVTable, Waker}; - - /// Simplified waking interface based on Arcs. --pub(crate) trait Wake: Send + Sync { -+pub(crate) trait Wake: Send + Sync + Sized + 'static { - /// Wake by value. -- fn wake(self: Arc); -+ fn wake(arc_self: Arc); - - /// Wake by reference. - fn wake_by_ref(arc_self: &Arc); -@@ -30,7 +31,7 @@ impl Deref for WakerRef<'_> { - - /// Creates a reference to a `Waker` from a reference to `Arc`. - pub(crate) fn waker_ref(wake: &Arc) -> WakerRef<'_> { -- let ptr = &**wake as *const _ as *const (); -+ let ptr = Arc::as_ptr(wake) as *const (); - - let waker = unsafe { Waker::from_raw(RawWaker::new(ptr, waker_vtable::())) }; - -diff --git a/KubeOS-Rust/vendor/tokio/tests/_require_full.rs b/KubeOS-Rust/vendor/tokio/tests/_require_full.rs -index 98455bed..4b9698af 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/_require_full.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/_require_full.rs -@@ -1,2 +1,8 @@ --#![cfg(not(feature = "full"))] -+#[cfg(not(any(feature = "full", tokio_wasm)))] - compile_error!("run main Tokio tests with `--features full`"); -+ -+// CI sets `--cfg tokio_no_parking_lot` when trying to run tests with -+// `parking_lot` disabled. This check prevents "silent failure" if `parking_lot` -+// accidentally gets enabled. -+#[cfg(all(tokio_no_parking_lot, feature = "parking_lot"))] -+compile_error!("parking_lot feature enabled when it should not be"); -diff --git a/KubeOS-Rust/vendor/tokio/tests/async_send_sync.rs b/KubeOS-Rust/vendor/tokio/tests/async_send_sync.rs -index aa14970e..0c2c34a0 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/async_send_sync.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/async_send_sync.rs -@@ -127,70 +127,111 @@ macro_rules! assert_value { - }; - } - --assert_value!(tokio::fs::DirBuilder: Send & Sync & Unpin); --assert_value!(tokio::fs::DirEntry: Send & Sync & Unpin); --assert_value!(tokio::fs::File: Send & Sync & Unpin); --assert_value!(tokio::fs::OpenOptions: Send & Sync & Unpin); --assert_value!(tokio::fs::ReadDir: Send & Sync & Unpin); -- --async_assert_fn!(tokio::fs::canonicalize(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::copy(&str, &str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::create_dir(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::create_dir_all(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::hard_link(&str, &str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::metadata(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::read(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::read_dir(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::read_link(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::read_to_string(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::remove_dir(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::remove_dir_all(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::remove_file(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::rename(&str, &str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::set_permissions(&str, std::fs::Permissions): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::symlink_metadata(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::write(&str, Vec): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::ReadDir::next_entry(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::OpenOptions::open(_, &str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::DirBuilder::create(_, &str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::DirEntry::metadata(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::DirEntry::file_type(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::open(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::create(&str): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::sync_all(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::sync_data(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::set_len(_, u64): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::metadata(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::try_clone(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::into_std(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::fs::File::set_permissions(_, std::fs::Permissions): Send & Sync & !Unpin); -+macro_rules! cfg_not_wasi { -+ ($($item:item)*) => { -+ $( -+ #[cfg(not(tokio_wasi))] -+ $item -+ )* -+ } -+} -+ -+// Manually re-implementation of `async_assert_fn` for `poll_fn`. The macro -+// doesn't work for this particular case because constructing the closure -+// is too complicated. -+const _: fn() = || { -+ let pinned = std::marker::PhantomPinned; -+ let f = tokio::macros::support::poll_fn(move |_| { -+ // Use `pinned` to take ownership of it. -+ let _ = &pinned; -+ std::task::Poll::Pending::<()> -+ }); -+ require_send(&f); -+ require_sync(&f); -+ AmbiguousIfUnpin::some_item(&f); -+}; -+ -+cfg_not_wasi! { -+ mod fs { -+ use super::*; -+ assert_value!(tokio::fs::DirBuilder: Send & Sync & Unpin); -+ assert_value!(tokio::fs::DirEntry: Send & Sync & Unpin); -+ assert_value!(tokio::fs::File: Send & Sync & Unpin); -+ assert_value!(tokio::fs::OpenOptions: Send & Sync & Unpin); -+ assert_value!(tokio::fs::ReadDir: Send & Sync & Unpin); -+ -+ async_assert_fn!(tokio::fs::canonicalize(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::copy(&str, &str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::create_dir(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::create_dir_all(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::hard_link(&str, &str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::metadata(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::read(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::read_dir(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::read_link(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::read_to_string(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::remove_dir(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::remove_dir_all(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::remove_file(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::rename(&str, &str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::set_permissions(&str, std::fs::Permissions): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::symlink_metadata(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::write(&str, Vec): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::ReadDir::next_entry(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::OpenOptions::open(_, &str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::DirBuilder::create(_, &str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::DirEntry::metadata(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::DirEntry::file_type(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::File::open(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::File::create(&str): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::File::sync_all(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::File::sync_data(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::File::set_len(_, u64): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::File::metadata(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::File::try_clone(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::fs::File::into_std(_): Send & Sync & !Unpin); -+ async_assert_fn!( -+ tokio::fs::File::set_permissions(_, std::fs::Permissions): Send & Sync & !Unpin -+ ); -+ } -+} -+ -+cfg_not_wasi! { -+ assert_value!(tokio::net::TcpSocket: Send & Sync & Unpin); -+ async_assert_fn!(tokio::net::TcpListener::bind(SocketAddr): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::TcpStream::connect(SocketAddr): Send & Sync & !Unpin); -+} - - assert_value!(tokio::net::TcpListener: Send & Sync & Unpin); --assert_value!(tokio::net::TcpSocket: Send & Sync & Unpin); - assert_value!(tokio::net::TcpStream: Send & Sync & Unpin); --assert_value!(tokio::net::UdpSocket: Send & Sync & Unpin); - assert_value!(tokio::net::tcp::OwnedReadHalf: Send & Sync & Unpin); - assert_value!(tokio::net::tcp::OwnedWriteHalf: Send & Sync & Unpin); - assert_value!(tokio::net::tcp::ReadHalf<'_>: Send & Sync & Unpin); - assert_value!(tokio::net::tcp::ReuniteError: Send & Sync & Unpin); - assert_value!(tokio::net::tcp::WriteHalf<'_>: Send & Sync & Unpin); - async_assert_fn!(tokio::net::TcpListener::accept(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::TcpListener::bind(SocketAddr): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::TcpStream::connect(SocketAddr): Send & Sync & !Unpin); - async_assert_fn!(tokio::net::TcpStream::peek(_, &mut [u8]): Send & Sync & !Unpin); - async_assert_fn!(tokio::net::TcpStream::readable(_): Send & Sync & !Unpin); - async_assert_fn!(tokio::net::TcpStream::ready(_, tokio::io::Interest): Send & Sync & !Unpin); - async_assert_fn!(tokio::net::TcpStream::writable(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::bind(SocketAddr): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::connect(_, SocketAddr): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::peek_from(_, &mut [u8]): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::readable(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::ready(_, tokio::io::Interest): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::recv(_, &mut [u8]): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::recv_from(_, &mut [u8]): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::send(_, &[u8]): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::send_to(_, &[u8], SocketAddr): Send & Sync & !Unpin); --async_assert_fn!(tokio::net::UdpSocket::writable(_): Send & Sync & !Unpin); -+ -+// Wasi does not support UDP -+cfg_not_wasi! { -+ mod udp_socket { -+ use super::*; -+ assert_value!(tokio::net::UdpSocket: Send & Sync & Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::bind(SocketAddr): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::connect(_, SocketAddr): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::peek_from(_, &mut [u8]): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::readable(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::ready(_, tokio::io::Interest): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::recv(_, &mut [u8]): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::recv_from(_, &mut [u8]): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::send(_, &[u8]): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::send_to(_, &[u8], SocketAddr): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::net::UdpSocket::writable(_): Send & Sync & !Unpin); -+ } -+} - async_assert_fn!(tokio::net::lookup_host(SocketAddr): Send & Sync & !Unpin); - async_assert_fn!(tokio::net::tcp::ReadHalf::peek(_, &mut [u8]): Send & Sync & !Unpin); - -@@ -222,6 +263,19 @@ mod unix_datagram { - async_assert_fn!(UnixStream::writable(_): Send & Sync & !Unpin); - } - -+#[cfg(unix)] -+mod unix_pipe { -+ use super::*; -+ use tokio::net::unix::pipe::*; -+ assert_value!(OpenOptions: Send & Sync & Unpin); -+ assert_value!(Receiver: Send & Sync & Unpin); -+ assert_value!(Sender: Send & Sync & Unpin); -+ async_assert_fn!(Receiver::readable(_): Send & Sync & !Unpin); -+ async_assert_fn!(Receiver::ready(_, tokio::io::Interest): Send & Sync & !Unpin); -+ async_assert_fn!(Sender::ready(_, tokio::io::Interest): Send & Sync & !Unpin); -+ async_assert_fn!(Sender::writable(_): Send & Sync & !Unpin); -+} -+ - #[cfg(windows)] - mod windows_named_pipe { - use super::*; -@@ -242,16 +296,22 @@ mod windows_named_pipe { - async_assert_fn!(NamedPipeServer::writable(_): Send & Sync & !Unpin); - } - --assert_value!(tokio::process::Child: Send & Sync & Unpin); --assert_value!(tokio::process::ChildStderr: Send & Sync & Unpin); --assert_value!(tokio::process::ChildStdin: Send & Sync & Unpin); --assert_value!(tokio::process::ChildStdout: Send & Sync & Unpin); --assert_value!(tokio::process::Command: Send & Sync & Unpin); --async_assert_fn!(tokio::process::Child::kill(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::process::Child::wait(_): Send & Sync & !Unpin); --async_assert_fn!(tokio::process::Child::wait_with_output(_): Send & Sync & !Unpin); -+cfg_not_wasi! { -+ mod test_process { -+ use super::*; -+ assert_value!(tokio::process::Child: Send & Sync & Unpin); -+ assert_value!(tokio::process::ChildStderr: Send & Sync & Unpin); -+ assert_value!(tokio::process::ChildStdin: Send & Sync & Unpin); -+ assert_value!(tokio::process::ChildStdout: Send & Sync & Unpin); -+ assert_value!(tokio::process::Command: Send & Sync & Unpin); -+ async_assert_fn!(tokio::process::Child::kill(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::process::Child::wait(_): Send & Sync & !Unpin); -+ async_assert_fn!(tokio::process::Child::wait_with_output(_): Send & Sync & !Unpin); -+ } -+ -+ async_assert_fn!(tokio::signal::ctrl_c(): Send & Sync & !Unpin); -+} - --async_assert_fn!(tokio::signal::ctrl_c(): Send & Sync & !Unpin); - #[cfg(unix)] - mod unix_signal { - use super::*; -@@ -287,6 +347,15 @@ assert_value!(tokio::sync::OnceCell: Send & Sync & Unpin); - assert_value!(tokio::sync::OwnedMutexGuard: !Send & !Sync & Unpin); - assert_value!(tokio::sync::OwnedMutexGuard: Send & !Sync & Unpin); - assert_value!(tokio::sync::OwnedMutexGuard: Send & Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: !Send & !Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: !Send & !Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: !Send & !Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: !Send & !Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: Send & !Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: Send & !Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: !Send & !Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: Send & !Sync & Unpin); -+assert_value!(tokio::sync::OwnedMappedMutexGuard: Send & Sync & Unpin); - assert_value!(tokio::sync::OwnedRwLockMappedWriteGuard: !Send & !Sync & Unpin); - assert_value!(tokio::sync::OwnedRwLockMappedWriteGuard: !Send & !Sync & Unpin); - assert_value!(tokio::sync::OwnedRwLockMappedWriteGuard: Send & Sync & Unpin); -@@ -362,6 +431,14 @@ assert_value!(tokio::sync::watch::Ref<'_, YY>: !Send & Sync & Unpin); - assert_value!(tokio::sync::watch::Sender: !Send & !Sync & Unpin); - assert_value!(tokio::sync::watch::Sender: !Send & !Sync & Unpin); - assert_value!(tokio::sync::watch::Sender: Send & Sync & Unpin); -+assert_value!(tokio::task::JoinError: Send & Sync & Unpin); -+assert_value!(tokio::task::JoinHandle: !Send & !Sync & Unpin); -+assert_value!(tokio::task::JoinHandle: Send & Sync & Unpin); -+assert_value!(tokio::task::JoinHandle: Send & Sync & Unpin); -+assert_value!(tokio::task::JoinSet: !Send & !Sync & Unpin); -+assert_value!(tokio::task::JoinSet: Send & Sync & Unpin); -+assert_value!(tokio::task::JoinSet: Send & Sync & Unpin); -+assert_value!(tokio::task::LocalSet: !Send & !Sync & Unpin); - async_assert_fn!(tokio::sync::Barrier::wait(_): Send & Sync & !Unpin); - async_assert_fn!(tokio::sync::Mutex::lock(_): !Send & !Sync & !Unpin); - async_assert_fn!(tokio::sync::Mutex::lock_owned(_): !Send & !Sync & !Unpin); -@@ -434,25 +511,25 @@ async_assert_fn!(tokio::sync::watch::Receiver::changed(_): Send & Sync & !Un - async_assert_fn!(tokio::sync::watch::Sender::closed(_): !Send & !Sync & !Unpin); - async_assert_fn!(tokio::sync::watch::Sender::closed(_): !Send & !Sync & !Unpin); - async_assert_fn!(tokio::sync::watch::Sender::closed(_): Send & Sync & !Unpin); -- --async_assert_fn!(tokio::task::LocalKey::scope(_, u32, BoxFutureSync<()>): Send & Sync & !Unpin); --async_assert_fn!(tokio::task::LocalKey::scope(_, u32, BoxFutureSend<()>): Send & !Sync & !Unpin); --async_assert_fn!(tokio::task::LocalKey::scope(_, u32, BoxFuture<()>): !Send & !Sync & !Unpin); --async_assert_fn!(tokio::task::LocalKey>::scope(_, Cell, BoxFutureSync<()>): Send & !Sync & !Unpin); --async_assert_fn!(tokio::task::LocalKey>::scope(_, Cell, BoxFutureSend<()>): Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::JoinSet>::join_next(_): Send & Sync & !Unpin); -+async_assert_fn!(tokio::task::JoinSet>::shutdown(_): Send & Sync & !Unpin); -+async_assert_fn!(tokio::task::JoinSet>::join_next(_): !Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::JoinSet>::shutdown(_): !Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::JoinSet::join_next(_): Send & Sync & !Unpin); -+async_assert_fn!(tokio::task::JoinSet::shutdown(_): Send & Sync & !Unpin); - async_assert_fn!(tokio::task::LocalKey>::scope(_, Cell, BoxFuture<()>): !Send & !Sync & !Unpin); --async_assert_fn!(tokio::task::LocalKey>::scope(_, Rc, BoxFutureSync<()>): !Send & !Sync & !Unpin); --async_assert_fn!(tokio::task::LocalKey>::scope(_, Rc, BoxFutureSend<()>): !Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::LocalKey>::scope(_, Cell, BoxFutureSend<()>): Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::LocalKey>::scope(_, Cell, BoxFutureSync<()>): Send & !Sync & !Unpin); - async_assert_fn!(tokio::task::LocalKey>::scope(_, Rc, BoxFuture<()>): !Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::LocalKey>::scope(_, Rc, BoxFutureSend<()>): !Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::LocalKey>::scope(_, Rc, BoxFutureSync<()>): !Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::LocalKey::scope(_, u32, BoxFuture<()>): !Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::LocalKey::scope(_, u32, BoxFutureSend<()>): Send & !Sync & !Unpin); -+async_assert_fn!(tokio::task::LocalKey::scope(_, u32, BoxFutureSync<()>): Send & Sync & !Unpin); - async_assert_fn!(tokio::task::LocalSet::run_until(_, BoxFutureSync<()>): !Send & !Sync & !Unpin); - async_assert_fn!(tokio::task::unconstrained(BoxFuture<()>): !Send & !Sync & Unpin); - async_assert_fn!(tokio::task::unconstrained(BoxFutureSend<()>): Send & !Sync & Unpin); - async_assert_fn!(tokio::task::unconstrained(BoxFutureSync<()>): Send & Sync & Unpin); --assert_value!(tokio::task::LocalSet: !Send & !Sync & Unpin); --assert_value!(tokio::task::JoinHandle: Send & Sync & Unpin); --assert_value!(tokio::task::JoinHandle: Send & Sync & Unpin); --assert_value!(tokio::task::JoinHandle: !Send & !Sync & Unpin); --assert_value!(tokio::task::JoinError: Send & Sync & Unpin); - - assert_value!(tokio::runtime::Builder: Send & Sync & Unpin); - assert_value!(tokio::runtime::EnterGuard<'_>: Send & Sync & Unpin); -diff --git a/KubeOS-Rust/vendor/tokio/tests/buffered.rs b/KubeOS-Rust/vendor/tokio/tests/buffered.rs -index 98b6d5f3..4251c3fc 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/buffered.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/buffered.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support bind() - - use tokio::net::TcpListener; - use tokio_test::assert_ok; -@@ -18,10 +18,10 @@ async fn echo_server() { - let msg = "foo bar baz"; - - let t = thread::spawn(move || { -- let mut s = assert_ok!(TcpStream::connect(&addr)); -+ let mut s = assert_ok!(TcpStream::connect(addr)); - - let t2 = thread::spawn(move || { -- let mut s = assert_ok!(TcpStream::connect(&addr)); -+ let mut s = assert_ok!(TcpStream::connect(addr)); - let mut b = vec![0; msg.len() * N]; - assert_ok!(s.read_exact(&mut b)); - b -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs.rs b/KubeOS-Rust/vendor/tokio/tests/fs.rs -index 13c44c08..ba38b719 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/fs.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/fs.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support file operations - - use tokio::fs; - use tokio_test::assert_ok; -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_canonicalize_dir.rs b/KubeOS-Rust/vendor/tokio/tests/fs_canonicalize_dir.rs -new file mode 100644 -index 00000000..83f0d813 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_canonicalize_dir.rs -@@ -0,0 +1,22 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+ -+use tokio::fs; -+ -+#[tokio::test] -+#[cfg(unix)] -+async fn canonicalize_root_dir_unix() { -+ assert_eq!(fs::canonicalize("/.").await.unwrap().to_str().unwrap(), "/"); -+} -+ -+#[tokio::test] -+#[cfg(windows)] -+async fn canonicalize_root_dir_windows() { -+ // 2-step let bindings due to Rust memory semantics -+ let dir_path = fs::canonicalize("C:\\.\\").await.unwrap(); -+ -+ let dir_name = dir_path.to_str().unwrap(); -+ -+ assert!(dir_name.starts_with("\\\\")); -+ assert!(dir_name.ends_with("C:\\")); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_copy.rs b/KubeOS-Rust/vendor/tokio/tests/fs_copy.rs -index 8d163201..e6e5b666 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/fs_copy.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_copy.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations - - use tempfile::tempdir; - use tokio::fs; -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_dir.rs b/KubeOS-Rust/vendor/tokio/tests/fs_dir.rs -index 21efe8c0..5f653cb2 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/fs_dir.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_dir.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations - - use tokio::fs; - use tokio_test::{assert_err, assert_ok}; -@@ -45,6 +45,27 @@ async fn build_dir() { - ); - } - -+#[tokio::test] -+#[cfg(unix)] -+async fn build_dir_mode_read_only() { -+ let base_dir = tempdir().unwrap(); -+ let new_dir = base_dir.path().join("abc"); -+ -+ assert_ok!( -+ fs::DirBuilder::new() -+ .recursive(true) -+ .mode(0o444) -+ .create(&new_dir) -+ .await -+ ); -+ -+ assert!(fs::metadata(new_dir) -+ .await -+ .expect("metadata result") -+ .permissions() -+ .readonly()); -+} -+ - #[tokio::test] - async fn remove() { - let base_dir = tempdir().unwrap(); -@@ -85,3 +106,21 @@ async fn read_inherent() { - vec!["aa".to_string(), "bb".to_string(), "cc".to_string()] - ); - } -+ -+#[tokio::test] -+async fn read_dir_entry_info() { -+ let temp_dir = tempdir().unwrap(); -+ -+ let file_path = temp_dir.path().join("a.txt"); -+ -+ fs::write(&file_path, b"Hello File!").await.unwrap(); -+ -+ let mut dir = fs::read_dir(temp_dir.path()).await.unwrap(); -+ -+ let first_entry = dir.next_entry().await.unwrap().unwrap(); -+ -+ assert_eq!(first_entry.path(), file_path); -+ assert_eq!(first_entry.file_name(), "a.txt"); -+ assert!(first_entry.metadata().await.unwrap().is_file()); -+ assert!(first_entry.file_type().await.unwrap().is_file()); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_file.rs b/KubeOS-Rust/vendor/tokio/tests/fs_file.rs -index f645e61a..94d872a5 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/fs_file.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_file.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations - - use std::io::prelude::*; - use tempfile::NamedTempFile; -@@ -73,7 +73,7 @@ async fn coop() { - let mut buf = [0; 1024]; - - loop { -- file.read(&mut buf).await.unwrap(); -+ let _ = file.read(&mut buf).await.unwrap(); - file.seek(std::io::SeekFrom::Start(0)).await.unwrap(); - } - }); -@@ -87,13 +87,93 @@ async fn coop() { - panic!("did not yield"); - } - -+#[tokio::test] -+async fn write_to_clone() { -+ let tempfile = tempfile(); -+ -+ let file = File::create(tempfile.path()).await.unwrap(); -+ let mut clone = file.try_clone().await.unwrap(); -+ -+ clone.write_all(HELLO).await.unwrap(); -+ clone.flush().await.unwrap(); -+ -+ let contents = std::fs::read(tempfile.path()).unwrap(); -+ assert_eq!(contents, HELLO); -+} -+ -+#[tokio::test] -+async fn write_into_std() { -+ let tempfile = tempfile(); -+ -+ let file = File::create(tempfile.path()).await.unwrap(); -+ let mut std_file = file.into_std().await; -+ -+ std_file.write_all(HELLO).unwrap(); -+ -+ let contents = std::fs::read(tempfile.path()).unwrap(); -+ assert_eq!(contents, HELLO); -+} -+ -+#[tokio::test] -+async fn write_into_std_immediate() { -+ let tempfile = tempfile(); -+ -+ let file = File::create(tempfile.path()).await.unwrap(); -+ let mut std_file = file.try_into_std().unwrap(); -+ -+ std_file.write_all(HELLO).unwrap(); -+ -+ let contents = std::fs::read(tempfile.path()).unwrap(); -+ assert_eq!(contents, HELLO); -+} -+ -+#[tokio::test] -+async fn read_file_from_std() { -+ let mut tempfile = tempfile(); -+ tempfile.write_all(HELLO).unwrap(); -+ -+ let std_file = std::fs::File::open(tempfile.path()).unwrap(); -+ let mut file = File::from(std_file); -+ -+ let mut buf = [0; 1024]; -+ let n = file.read(&mut buf).await.unwrap(); -+ assert_eq!(n, HELLO.len()); -+ assert_eq!(&buf[..n], HELLO); -+} -+ - fn tempfile() -> NamedTempFile { - NamedTempFile::new().unwrap() - } - - #[tokio::test] - #[cfg(unix)] --async fn unix_fd() { -+async fn file_debug_fmt() { -+ let tempfile = tempfile(); -+ -+ let file = File::open(tempfile.path()).await.unwrap(); -+ -+ assert_eq!( -+ &format!("{:?}", file)[0..33], -+ "tokio::fs::File { std: File { fd:" -+ ); -+} -+ -+#[tokio::test] -+#[cfg(windows)] -+async fn file_debug_fmt() { -+ let tempfile = tempfile(); -+ -+ let file = File::open(tempfile.path()).await.unwrap(); -+ -+ assert_eq!( -+ &format!("{:?}", file)[0..37], -+ "tokio::fs::File { std: File { handle:" -+ ); -+} -+ -+#[tokio::test] -+#[cfg(unix)] -+async fn unix_fd_is_valid() { - use std::os::unix::io::AsRawFd; - let tempfile = tempfile(); - -@@ -101,6 +181,26 @@ async fn unix_fd() { - assert!(file.as_raw_fd() as u64 > 0); - } - -+#[tokio::test] -+#[cfg(unix)] -+async fn read_file_from_unix_fd() { -+ use std::os::unix::io::{FromRawFd, IntoRawFd}; -+ -+ let mut tempfile = tempfile(); -+ tempfile.write_all(HELLO).unwrap(); -+ -+ let file1 = File::open(tempfile.path()).await.unwrap(); -+ let raw_fd = file1.into_std().await.into_raw_fd(); -+ assert!(raw_fd > 0); -+ -+ let mut file2 = unsafe { File::from_raw_fd(raw_fd) }; -+ -+ let mut buf = [0; 1024]; -+ let n = file2.read(&mut buf).await.unwrap(); -+ assert_eq!(n, HELLO.len()); -+ assert_eq!(&buf[..n], HELLO); -+} -+ - #[tokio::test] - #[cfg(windows)] - async fn windows_handle() { -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_link.rs b/KubeOS-Rust/vendor/tokio/tests/fs_link.rs -index 2ef666fb..681b5666 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/fs_link.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_link.rs -@@ -1,10 +1,9 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations - - use tokio::fs; - --use std::io::prelude::*; --use std::io::BufReader; -+use std::io::Write; - use tempfile::tempdir; - - #[tokio::test] -@@ -13,24 +12,23 @@ async fn test_hard_link() { - let src = dir.path().join("src.txt"); - let dst = dir.path().join("dst.txt"); - -- { -- let mut file = std::fs::File::create(&src).unwrap(); -- file.write_all(b"hello").unwrap(); -- } -+ std::fs::File::create(&src) -+ .unwrap() -+ .write_all(b"hello") -+ .unwrap(); - -- let dst_2 = dst.clone(); -+ fs::hard_link(&src, &dst).await.unwrap(); - -- assert!(fs::hard_link(src, dst_2.clone()).await.is_ok()); -+ std::fs::File::create(&src) -+ .unwrap() -+ .write_all(b"new-data") -+ .unwrap(); - -- let mut content = String::new(); -+ let content = fs::read(&dst).await.unwrap(); -+ assert_eq!(content, b"new-data"); - -- { -- let file = std::fs::File::open(dst).unwrap(); -- let mut reader = BufReader::new(file); -- reader.read_to_string(&mut content).unwrap(); -- } -- -- assert!(content == "hello"); -+ // test that this is not a symlink: -+ assert!(fs::read_link(&dst).await.is_err()); - } - - #[cfg(unix)] -@@ -40,25 +38,20 @@ async fn test_symlink() { - let src = dir.path().join("src.txt"); - let dst = dir.path().join("dst.txt"); - -- { -- let mut file = std::fs::File::create(&src).unwrap(); -- file.write_all(b"hello").unwrap(); -- } -- -- let src_2 = src.clone(); -- let dst_2 = dst.clone(); -- -- assert!(fs::symlink(src_2.clone(), dst_2.clone()).await.is_ok()); -+ std::fs::File::create(&src) -+ .unwrap() -+ .write_all(b"hello") -+ .unwrap(); - -- let mut content = String::new(); -+ fs::symlink(&src, &dst).await.unwrap(); - -- { -- let file = std::fs::File::open(dst.clone()).unwrap(); -- let mut reader = BufReader::new(file); -- reader.read_to_string(&mut content).unwrap(); -- } -+ std::fs::File::create(&src) -+ .unwrap() -+ .write_all(b"new-data") -+ .unwrap(); - -- assert!(content == "hello"); -+ let content = fs::read(&dst).await.unwrap(); -+ assert_eq!(content, b"new-data"); - - let read = fs::read_link(dst.clone()).await.unwrap(); - assert!(read == src); -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_open_options.rs b/KubeOS-Rust/vendor/tokio/tests/fs_open_options.rs -new file mode 100644 -index 00000000..e8d8b51b ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_open_options.rs -@@ -0,0 +1,80 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+ -+use std::io::Write; -+use tempfile::NamedTempFile; -+use tokio::fs::OpenOptions; -+use tokio::io::AsyncReadExt; -+ -+const HELLO: &[u8] = b"hello world..."; -+ -+#[tokio::test] -+async fn open_with_open_options_and_read() { -+ let mut tempfile = NamedTempFile::new().unwrap(); -+ tempfile.write_all(HELLO).unwrap(); -+ -+ let mut file = OpenOptions::new().read(true).open(tempfile).await.unwrap(); -+ -+ let mut buf = [0; 1024]; -+ let n = file.read(&mut buf).await.unwrap(); -+ -+ assert_eq!(n, HELLO.len()); -+ assert_eq!(&buf[..n], HELLO); -+} -+ -+#[tokio::test] -+async fn open_options_write() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!("{:?}", OpenOptions::new().write(true)).contains("write: true")); -+} -+ -+#[tokio::test] -+async fn open_options_append() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!("{:?}", OpenOptions::new().append(true)).contains("append: true")); -+} -+ -+#[tokio::test] -+async fn open_options_truncate() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!("{:?}", OpenOptions::new().truncate(true)).contains("truncate: true")); -+} -+ -+#[tokio::test] -+async fn open_options_create() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!("{:?}", OpenOptions::new().create(true)).contains("create: true")); -+} -+ -+#[tokio::test] -+async fn open_options_create_new() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!("{:?}", OpenOptions::new().create_new(true)).contains("create_new: true")); -+} -+ -+#[tokio::test] -+#[cfg(unix)] -+async fn open_options_mode() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!("{:?}", OpenOptions::new().mode(0o644)).contains("mode: 420 ")); -+} -+ -+#[tokio::test] -+#[cfg(target_os = "linux")] -+async fn open_options_custom_flags_linux() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!( -+ format!("{:?}", OpenOptions::new().custom_flags(libc::O_TRUNC)) -+ .contains("custom_flags: 512,") -+ ); -+} -+ -+#[tokio::test] -+#[cfg(any(target_os = "freebsd", target_os = "macos"))] -+async fn open_options_custom_flags_bsd_family() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!( -+ format!("{:?}", OpenOptions::new().custom_flags(libc::O_NOFOLLOW)) -+ .contains("custom_flags: 256,") -+ ); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_open_options_windows.rs b/KubeOS-Rust/vendor/tokio/tests/fs_open_options_windows.rs -new file mode 100644 -index 00000000..398e6a12 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_open_options_windows.rs -@@ -0,0 +1,51 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+#![cfg(windows)] -+ -+use tokio::fs::OpenOptions; -+use windows_sys::Win32::Storage::FileSystem; -+ -+#[tokio::test] -+#[cfg(windows)] -+async fn open_options_windows_access_mode() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!("{:?}", OpenOptions::new().access_mode(0)).contains("access_mode: Some(0)")); -+} -+ -+#[tokio::test] -+#[cfg(windows)] -+async fn open_options_windows_share_mode() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!("{:?}", OpenOptions::new().share_mode(0)).contains("share_mode: 0,")); -+} -+ -+#[tokio::test] -+#[cfg(windows)] -+async fn open_options_windows_custom_flags() { -+ // TESTING HACK: use Debug output to check the stored data -+ assert!(format!( -+ "{:?}", -+ OpenOptions::new().custom_flags(FileSystem::FILE_FLAG_DELETE_ON_CLOSE) -+ ) -+ .contains("custom_flags: 67108864,")); -+} -+ -+#[tokio::test] -+#[cfg(windows)] -+async fn open_options_windows_attributes() { -+ assert!(format!( -+ "{:?}", -+ OpenOptions::new().attributes(FileSystem::FILE_ATTRIBUTE_HIDDEN) -+ ) -+ .contains("attributes: 2,")); -+} -+ -+#[tokio::test] -+#[cfg(windows)] -+async fn open_options_windows_security_qos_flags() { -+ assert!(format!( -+ "{:?}", -+ OpenOptions::new().security_qos_flags(FileSystem::SECURITY_IDENTIFICATION) -+ ) -+ .contains("security_qos_flags: 1114112,")); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_remove_dir_all.rs b/KubeOS-Rust/vendor/tokio/tests/fs_remove_dir_all.rs -new file mode 100644 -index 00000000..53a2fd34 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_remove_dir_all.rs -@@ -0,0 +1,31 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+ -+use tempfile::tempdir; -+use tokio::fs; -+ -+#[tokio::test] -+async fn remove_dir_all() { -+ let temp_dir = tempdir().unwrap(); -+ -+ let test_dir = temp_dir.path().join("test"); -+ fs::create_dir(&test_dir).await.unwrap(); -+ -+ let file_path = test_dir.as_path().join("a.txt"); -+ -+ fs::write(&file_path, b"Hello File!").await.unwrap(); -+ -+ fs::remove_dir_all(test_dir.as_path()).await.unwrap(); -+ -+ // test dir should no longer exist -+ match fs::try_exists(test_dir).await { -+ Ok(exists) => assert!(!exists), -+ Err(_) => println!("ignored try_exists error after remove_dir_all"), -+ }; -+ -+ // contents should no longer exist -+ match fs::try_exists(file_path).await { -+ Ok(exists) => assert!(!exists), -+ Err(_) => println!("ignored try_exists error after remove_dir_all"), -+ }; -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_remove_file.rs b/KubeOS-Rust/vendor/tokio/tests/fs_remove_file.rs -new file mode 100644 -index 00000000..14fd680d ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_remove_file.rs -@@ -0,0 +1,24 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+ -+use tempfile::tempdir; -+use tokio::fs; -+ -+#[tokio::test] -+async fn remove_file() { -+ let temp_dir = tempdir().unwrap(); -+ -+ let file_path = temp_dir.path().join("a.txt"); -+ -+ fs::write(&file_path, b"Hello File!").await.unwrap(); -+ -+ assert!(fs::try_exists(&file_path).await.unwrap()); -+ -+ fs::remove_file(&file_path).await.unwrap(); -+ -+ // should no longer exist -+ match fs::try_exists(file_path).await { -+ Ok(exists) => assert!(!exists), -+ Err(_) => println!("ignored try_exists error after remove_file"), -+ }; -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_rename.rs b/KubeOS-Rust/vendor/tokio/tests/fs_rename.rs -new file mode 100644 -index 00000000..382fea07 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_rename.rs -@@ -0,0 +1,28 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+ -+use tempfile::tempdir; -+use tokio::fs; -+ -+#[tokio::test] -+async fn rename_file() { -+ let temp_dir = tempdir().unwrap(); -+ -+ let file_path = temp_dir.path().join("a.txt"); -+ -+ fs::write(&file_path, b"Hello File!").await.unwrap(); -+ -+ assert!(fs::try_exists(&file_path).await.unwrap()); -+ -+ let new_file_path = temp_dir.path().join("b.txt"); -+ -+ fs::rename(&file_path, &new_file_path).await.unwrap(); -+ -+ assert!(fs::try_exists(new_file_path).await.unwrap()); -+ -+ // original file should no longer exist -+ match fs::try_exists(file_path).await { -+ Ok(exists) => assert!(!exists), -+ Err(_) => println!("ignored try_exists error after rename"), -+ }; -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_symlink_dir_windows.rs b/KubeOS-Rust/vendor/tokio/tests/fs_symlink_dir_windows.rs -new file mode 100644 -index 00000000..d8035426 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_symlink_dir_windows.rs -@@ -0,0 +1,31 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+#![cfg(windows)] -+ -+use tempfile::tempdir; -+use tokio::fs; -+ -+#[tokio::test] -+async fn symlink_file_windows() { -+ const FILE_NAME: &str = "abc.txt"; -+ -+ let temp_dir = tempdir().unwrap(); -+ -+ let dir1 = temp_dir.path().join("a"); -+ fs::create_dir(&dir1).await.unwrap(); -+ -+ let file1 = dir1.as_path().join(FILE_NAME); -+ fs::write(&file1, b"Hello File!").await.unwrap(); -+ -+ let dir2 = temp_dir.path().join("b"); -+ fs::symlink_dir(&dir1, &dir2).await.unwrap(); -+ -+ fs::write(&file1, b"new data!").await.unwrap(); -+ -+ let file2 = dir2.as_path().join(FILE_NAME); -+ -+ let from = fs::read(&file1).await.unwrap(); -+ let to = fs::read(&file2).await.unwrap(); -+ -+ assert_eq!(from, to); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_symlink_file_windows.rs b/KubeOS-Rust/vendor/tokio/tests/fs_symlink_file_windows.rs -new file mode 100644 -index 00000000..50eaf8aa ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_symlink_file_windows.rs -@@ -0,0 +1,24 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+#![cfg(windows)] -+ -+use tempfile::tempdir; -+use tokio::fs; -+ -+#[tokio::test] -+async fn symlink_file_windows() { -+ let dir = tempdir().unwrap(); -+ -+ let source_path = dir.path().join("foo.txt"); -+ let dest_path = dir.path().join("bar.txt"); -+ -+ fs::write(&source_path, b"Hello File!").await.unwrap(); -+ fs::symlink_file(&source_path, &dest_path).await.unwrap(); -+ -+ fs::write(&source_path, b"new data!").await.unwrap(); -+ -+ let from = fs::read(&source_path).await.unwrap(); -+ let to = fs::read(&dest_path).await.unwrap(); -+ -+ assert_eq!(from, to); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/fs_try_exists.rs b/KubeOS-Rust/vendor/tokio/tests/fs_try_exists.rs -new file mode 100644 -index 00000000..00d23650 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/fs_try_exists.rs -@@ -0,0 +1,44 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // WASI does not support all fs operations -+ -+use tempfile::tempdir; -+use tokio::fs; -+ -+#[tokio::test] -+async fn try_exists() { -+ let dir = tempdir().unwrap(); -+ -+ let existing_path = dir.path().join("foo.txt"); -+ fs::write(&existing_path, b"Hello File!").await.unwrap(); -+ let nonexisting_path = dir.path().join("bar.txt"); -+ -+ assert!(fs::try_exists(existing_path).await.unwrap()); -+ assert!(!fs::try_exists(nonexisting_path).await.unwrap()); -+ // FreeBSD root user always has permission to stat. -+ #[cfg(all(unix, not(target_os = "freebsd")))] -+ { -+ use std::os::unix::prelude::PermissionsExt; -+ let permission_denied_directory_path = dir.path().join("baz"); -+ fs::create_dir(&permission_denied_directory_path) -+ .await -+ .unwrap(); -+ let permission_denied_file_path = permission_denied_directory_path.join("baz.txt"); -+ fs::write(&permission_denied_file_path, b"Hello File!") -+ .await -+ .unwrap(); -+ let mut perms = tokio::fs::metadata(&permission_denied_directory_path) -+ .await -+ .unwrap() -+ .permissions(); -+ -+ perms.set_mode(0o244); -+ fs::set_permissions(&permission_denied_directory_path, perms) -+ .await -+ .unwrap(); -+ let permission_denied_result = fs::try_exists(permission_denied_file_path).await; -+ assert_eq!( -+ permission_denied_result.err().unwrap().kind(), -+ std::io::ErrorKind::PermissionDenied -+ ); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_buf_writer.rs b/KubeOS-Rust/vendor/tokio/tests/io_buf_writer.rs -index 47a0d466..d3acf62c 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_buf_writer.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_buf_writer.rs -@@ -70,15 +70,15 @@ where - async fn buf_writer() { - let mut writer = BufWriter::with_capacity(2, Vec::new()); - -- writer.write(&[0, 1]).await.unwrap(); -+ assert_eq!(writer.write(&[0, 1]).await.unwrap(), 2); - assert_eq!(writer.buffer(), []); - assert_eq!(*writer.get_ref(), [0, 1]); - -- writer.write(&[2]).await.unwrap(); -+ assert_eq!(writer.write(&[2]).await.unwrap(), 1); - assert_eq!(writer.buffer(), [2]); - assert_eq!(*writer.get_ref(), [0, 1]); - -- writer.write(&[3]).await.unwrap(); -+ assert_eq!(writer.write(&[3]).await.unwrap(), 1); - assert_eq!(writer.buffer(), [2, 3]); - assert_eq!(*writer.get_ref(), [0, 1]); - -@@ -86,20 +86,20 @@ async fn buf_writer() { - assert_eq!(writer.buffer(), []); - assert_eq!(*writer.get_ref(), [0, 1, 2, 3]); - -- writer.write(&[4]).await.unwrap(); -- writer.write(&[5]).await.unwrap(); -+ assert_eq!(writer.write(&[4]).await.unwrap(), 1); -+ assert_eq!(writer.write(&[5]).await.unwrap(), 1); - assert_eq!(writer.buffer(), [4, 5]); - assert_eq!(*writer.get_ref(), [0, 1, 2, 3]); - -- writer.write(&[6]).await.unwrap(); -+ assert_eq!(writer.write(&[6]).await.unwrap(), 1); - assert_eq!(writer.buffer(), [6]); - assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]); - -- writer.write(&[7, 8]).await.unwrap(); -+ assert_eq!(writer.write(&[7, 8]).await.unwrap(), 2); - assert_eq!(writer.buffer(), []); - assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]); - -- writer.write(&[9, 10, 11]).await.unwrap(); -+ assert_eq!(writer.write(&[9, 10, 11]).await.unwrap(), 3); - assert_eq!(writer.buffer(), []); - assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]); - -@@ -111,7 +111,7 @@ async fn buf_writer() { - #[tokio::test] - async fn buf_writer_inner_flushes() { - let mut w = BufWriter::with_capacity(3, Vec::new()); -- w.write(&[0, 1]).await.unwrap(); -+ assert_eq!(w.write(&[0, 1]).await.unwrap(), 2); - assert_eq!(*w.get_ref(), []); - w.flush().await.unwrap(); - let w = w.into_inner(); -@@ -135,15 +135,15 @@ async fn buf_writer_seek() { - async fn maybe_pending_buf_writer() { - let mut writer = BufWriter::with_capacity(2, MaybePending::new(Vec::new())); - -- writer.write(&[0, 1]).await.unwrap(); -+ assert_eq!(writer.write(&[0, 1]).await.unwrap(), 2); - assert_eq!(writer.buffer(), []); - assert_eq!(&writer.get_ref().inner, &[0, 1]); - -- writer.write(&[2]).await.unwrap(); -+ assert_eq!(writer.write(&[2]).await.unwrap(), 1); - assert_eq!(writer.buffer(), [2]); - assert_eq!(&writer.get_ref().inner, &[0, 1]); - -- writer.write(&[3]).await.unwrap(); -+ assert_eq!(writer.write(&[3]).await.unwrap(), 1); - assert_eq!(writer.buffer(), [2, 3]); - assert_eq!(&writer.get_ref().inner, &[0, 1]); - -@@ -151,20 +151,20 @@ async fn maybe_pending_buf_writer() { - assert_eq!(writer.buffer(), []); - assert_eq!(&writer.get_ref().inner, &[0, 1, 2, 3]); - -- writer.write(&[4]).await.unwrap(); -- writer.write(&[5]).await.unwrap(); -+ assert_eq!(writer.write(&[4]).await.unwrap(), 1); -+ assert_eq!(writer.write(&[5]).await.unwrap(), 1); - assert_eq!(writer.buffer(), [4, 5]); - assert_eq!(&writer.get_ref().inner, &[0, 1, 2, 3]); - -- writer.write(&[6]).await.unwrap(); -+ assert_eq!(writer.write(&[6]).await.unwrap(), 1); - assert_eq!(writer.buffer(), [6]); - assert_eq!(writer.get_ref().inner, &[0, 1, 2, 3, 4, 5]); - -- writer.write(&[7, 8]).await.unwrap(); -+ assert_eq!(writer.write(&[7, 8]).await.unwrap(), 2); - assert_eq!(writer.buffer(), []); - assert_eq!(writer.get_ref().inner, &[0, 1, 2, 3, 4, 5, 6, 7, 8]); - -- writer.write(&[9, 10, 11]).await.unwrap(); -+ assert_eq!(writer.write(&[9, 10, 11]).await.unwrap(), 3); - assert_eq!(writer.buffer(), []); - assert_eq!( - writer.get_ref().inner, -@@ -182,7 +182,7 @@ async fn maybe_pending_buf_writer() { - #[tokio::test] - async fn maybe_pending_buf_writer_inner_flushes() { - let mut w = BufWriter::with_capacity(3, MaybePending::new(Vec::new())); -- w.write(&[0, 1]).await.unwrap(); -+ assert_eq!(w.write(&[0, 1]).await.unwrap(), 2); - assert_eq!(&w.get_ref().inner, &[]); - w.flush().await.unwrap(); - let w = w.into_inner().inner; -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_copy_bidirectional.rs b/KubeOS-Rust/vendor/tokio/tests/io_copy_bidirectional.rs -index 0e82b29e..c5496759 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_copy_bidirectional.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_copy_bidirectional.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support bind() - - use std::time::Duration; - use tokio::io::{self, copy_bidirectional, AsyncReadExt, AsyncWriteExt}; -@@ -111,18 +111,30 @@ async fn blocking_one_side_does_not_block_other() { - } - - #[tokio::test] --async fn immediate_exit_on_error() { -- symmetric(|handle, mut a, mut b| async move { -- block_write(&mut a).await; -+async fn immediate_exit_on_write_error() { -+ let payload = b"here, take this"; -+ let error = || io::Error::new(io::ErrorKind::Other, "no thanks!"); - -- // Fill up the b->copy->a path. We expect that this will _not_ drain -- // before we exit the copy task. -- let _bytes_written = block_write(&mut b).await; -+ let mut a = tokio_test::io::Builder::new() -+ .read(payload) -+ .write_error(error()) -+ .build(); - -- // Drop b. We should not wait for a to consume the data buffered in the -- // copy loop, since b will be failing writes. -- drop(b); -- assert!(handle.await.unwrap().is_err()); -- }) -- .await -+ let mut b = tokio_test::io::Builder::new() -+ .read(payload) -+ .write_error(error()) -+ .build(); -+ -+ assert!(copy_bidirectional(&mut a, &mut b).await.is_err()); -+} -+ -+#[tokio::test] -+async fn immediate_exit_on_read_error() { -+ let error = || io::Error::new(io::ErrorKind::Other, "got nothing!"); -+ -+ let mut a = tokio_test::io::Builder::new().read_error(error()).build(); -+ -+ let mut b = tokio_test::io::Builder::new().read_error(error()).build(); -+ -+ assert!(copy_bidirectional(&mut a, &mut b).await.is_err()); - } -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_driver.rs b/KubeOS-Rust/vendor/tokio/tests/io_driver.rs -index 6fb566de..97018e0f 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_driver.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_driver.rs -@@ -1,5 +1,6 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+// Wasi does not support panic recovery or threading -+#![cfg(all(feature = "full", not(tokio_wasi)))] - - use tokio::net::TcpListener; - use tokio::runtime; -@@ -79,7 +80,7 @@ fn test_drop_on_notify() { - drop(task); - - // Establish a connection to the acceptor -- let _s = TcpStream::connect(&addr).unwrap(); -+ let _s = TcpStream::connect(addr).unwrap(); - - // Force the reactor to turn - rt.block_on(async {}); -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_driver_drop.rs b/KubeOS-Rust/vendor/tokio/tests/io_driver_drop.rs -index 631e66e9..0a384d41 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_driver_drop.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_driver_drop.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support bind - - use tokio::net::TcpListener; - use tokio::runtime; -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_fill_buf.rs b/KubeOS-Rust/vendor/tokio/tests/io_fill_buf.rs -index 0b2ebd78..62c3f1b3 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_fill_buf.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_fill_buf.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support file operations - - use tempfile::NamedTempFile; - use tokio::fs::File; -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_mem_stream.rs b/KubeOS-Rust/vendor/tokio/tests/io_mem_stream.rs -index 01baa536..e79ec4e9 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_mem_stream.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_mem_stream.rs -@@ -100,3 +100,22 @@ async fn max_write_size() { - // drop b only after task t1 finishes writing - drop(b); - } -+ -+#[tokio::test] -+async fn duplex_is_cooperative() { -+ let (mut tx, mut rx) = tokio::io::duplex(1024 * 8); -+ -+ tokio::select! { -+ biased; -+ -+ _ = async { -+ loop { -+ let buf = [3u8; 4096]; -+ tx.write_all(&buf).await.unwrap(); -+ let mut buf = [0u8; 4096]; -+ let _ = rx.read(&mut buf).await.unwrap(); -+ } -+ } => {}, -+ _ = tokio::task::yield_now() => {} -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_panic.rs b/KubeOS-Rust/vendor/tokio/tests/io_panic.rs -new file mode 100644 -index 00000000..922d7c07 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/io_panic.rs -@@ -0,0 +1,176 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support panic recovery -+ -+use std::task::{Context, Poll}; -+use std::{error::Error, pin::Pin}; -+use tokio::io::{self, split, AsyncRead, AsyncWrite, ReadBuf}; -+ -+mod support { -+ pub mod panic; -+} -+use support::panic::test_panic; -+ -+struct RW; -+ -+impl AsyncRead for RW { -+ fn poll_read( -+ self: Pin<&mut Self>, -+ _cx: &mut Context<'_>, -+ buf: &mut ReadBuf<'_>, -+ ) -> Poll> { -+ buf.put_slice(&[b'z']); -+ Poll::Ready(Ok(())) -+ } -+} -+ -+impl AsyncWrite for RW { -+ fn poll_write( -+ self: Pin<&mut Self>, -+ _cx: &mut Context<'_>, -+ _buf: &[u8], -+ ) -> Poll> { -+ Poll::Ready(Ok(1)) -+ } -+ -+ fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { -+ Poll::Ready(Ok(())) -+ } -+ -+ fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { -+ Poll::Ready(Ok(())) -+ } -+} -+ -+#[cfg(unix)] -+mod unix { -+ use std::os::unix::prelude::{AsRawFd, RawFd}; -+ -+ pub struct MockFd; -+ -+ impl AsRawFd for MockFd { -+ fn as_raw_fd(&self) -> RawFd { -+ 0 -+ } -+ } -+} -+ -+#[test] -+fn read_buf_initialize_unfilled_to_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let mut buffer = Vec::::new(); -+ let mut read_buf = ReadBuf::new(&mut buffer); -+ -+ read_buf.initialize_unfilled_to(2); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn read_buf_advance_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let mut buffer = Vec::::new(); -+ let mut read_buf = ReadBuf::new(&mut buffer); -+ -+ read_buf.advance(2); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn read_buf_set_filled_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let mut buffer = Vec::::new(); -+ let mut read_buf = ReadBuf::new(&mut buffer); -+ -+ read_buf.set_filled(2); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn read_buf_put_slice_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let mut buffer = Vec::::new(); -+ let mut read_buf = ReadBuf::new(&mut buffer); -+ -+ let new_slice = [0x40_u8, 0x41_u8]; -+ -+ read_buf.put_slice(&new_slice); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn unsplit_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let (r1, _w1) = split(RW); -+ let (_r2, w2) = split(RW); -+ r1.unsplit(w2); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+#[cfg(unix)] -+fn async_fd_new_panic_caller() -> Result<(), Box> { -+ use tokio::io::unix::AsyncFd; -+ use tokio::runtime::Builder; -+ -+ let panic_location_file = test_panic(|| { -+ // Runtime without `enable_io` so it has no IO driver set. -+ let rt = Builder::new_current_thread().build().unwrap(); -+ rt.block_on(async { -+ let fd = unix::MockFd; -+ -+ let _ = AsyncFd::new(fd); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+#[cfg(unix)] -+fn async_fd_with_interest_panic_caller() -> Result<(), Box> { -+ use tokio::io::unix::AsyncFd; -+ use tokio::io::Interest; -+ use tokio::runtime::Builder; -+ -+ let panic_location_file = test_panic(|| { -+ // Runtime without `enable_io` so it has no IO driver set. -+ let rt = Builder::new_current_thread().build().unwrap(); -+ rt.block_on(async { -+ let fd = unix::MockFd; -+ -+ let _ = AsyncFd::with_interest(fd, Interest::READABLE); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_read.rs b/KubeOS-Rust/vendor/tokio/tests/io_read.rs -index cb1aa705..7f74c5e8 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_read.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_read.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support panic recovery - - use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf}; - use tokio_test::assert_ok; -@@ -8,6 +8,11 @@ use std::io; - use std::pin::Pin; - use std::task::{Context, Poll}; - -+mod support { -+ pub(crate) mod leaked_buffers; -+} -+use support::leaked_buffers::LeakedBuffers; -+ - #[tokio::test] - async fn read() { - #[derive(Default)] -@@ -37,16 +42,27 @@ async fn read() { - assert_eq!(buf[..], b"hello world"[..]); - } - --struct BadAsyncRead; -+struct BadAsyncRead { -+ leaked_buffers: LeakedBuffers, -+} -+ -+impl BadAsyncRead { -+ fn new() -> Self { -+ Self { -+ leaked_buffers: LeakedBuffers::new(), -+ } -+ } -+} - - impl AsyncRead for BadAsyncRead { - fn poll_read( -- self: Pin<&mut Self>, -+ mut self: Pin<&mut Self>, - _cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { -- *buf = ReadBuf::new(Box::leak(vec![0; buf.capacity()].into_boxed_slice())); -+ *buf = ReadBuf::new(unsafe { self.leaked_buffers.create(buf.capacity()) }); - buf.advance(buf.capacity()); -+ - Poll::Ready(Ok(())) - } - } -@@ -55,5 +71,5 @@ impl AsyncRead for BadAsyncRead { - #[should_panic] - async fn read_buf_bad_async_read() { - let mut buf = Vec::with_capacity(10); -- BadAsyncRead.read_buf(&mut buf).await.unwrap(); -+ BadAsyncRead::new().read_buf(&mut buf).await.unwrap(); - } -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_read_buf.rs b/KubeOS-Rust/vendor/tokio/tests/io_read_buf.rs -index 0328168d..49a4f86f 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_read_buf.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_read_buf.rs -@@ -34,3 +34,61 @@ async fn read_buf() { - assert_eq!(n, 11); - assert_eq!(buf[..], b"hello world"[..]); - } -+ -+#[tokio::test] -+#[cfg(feature = "io-util")] -+async fn issue_5588() { -+ use bytes::BufMut; -+ -+ // steps to zero -+ let mut buf = [0; 8]; -+ let mut read_buf = ReadBuf::new(&mut buf); -+ assert_eq!(read_buf.remaining_mut(), 8); -+ assert_eq!(read_buf.chunk_mut().len(), 8); -+ unsafe { -+ read_buf.advance_mut(1); -+ } -+ assert_eq!(read_buf.remaining_mut(), 7); -+ assert_eq!(read_buf.chunk_mut().len(), 7); -+ unsafe { -+ read_buf.advance_mut(5); -+ } -+ assert_eq!(read_buf.remaining_mut(), 2); -+ assert_eq!(read_buf.chunk_mut().len(), 2); -+ unsafe { -+ read_buf.advance_mut(2); -+ } -+ assert_eq!(read_buf.remaining_mut(), 0); -+ assert_eq!(read_buf.chunk_mut().len(), 0); -+ -+ // directly to zero -+ let mut buf = [0; 8]; -+ let mut read_buf = ReadBuf::new(&mut buf); -+ assert_eq!(read_buf.remaining_mut(), 8); -+ assert_eq!(read_buf.chunk_mut().len(), 8); -+ unsafe { -+ read_buf.advance_mut(8); -+ } -+ assert_eq!(read_buf.remaining_mut(), 0); -+ assert_eq!(read_buf.chunk_mut().len(), 0); -+ -+ // uninit -+ let mut buf = [std::mem::MaybeUninit::new(1); 8]; -+ let mut uninit = ReadBuf::uninit(&mut buf); -+ assert_eq!(uninit.remaining_mut(), 8); -+ assert_eq!(uninit.chunk_mut().len(), 8); -+ -+ let mut buf = [std::mem::MaybeUninit::uninit(); 8]; -+ let mut uninit = ReadBuf::uninit(&mut buf); -+ unsafe { -+ uninit.advance_mut(4); -+ } -+ assert_eq!(uninit.remaining_mut(), 4); -+ assert_eq!(uninit.chunk_mut().len(), 4); -+ uninit.put_u8(1); -+ assert_eq!(uninit.remaining_mut(), 3); -+ assert_eq!(uninit.chunk_mut().len(), 3); -+ uninit.put_slice(&[1, 2, 3]); -+ assert_eq!(uninit.remaining_mut(), 0); -+ assert_eq!(uninit.chunk_mut().len(), 0); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_read_to_end.rs b/KubeOS-Rust/vendor/tokio/tests/io_read_to_end.rs -index 171e6d64..29b60bec 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_read_to_end.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_read_to_end.rs -@@ -5,6 +5,7 @@ use std::pin::Pin; - use std::task::{Context, Poll}; - use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf}; - use tokio_test::assert_ok; -+use tokio_test::io::Builder; - - #[tokio::test] - async fn read_to_end() { -@@ -76,3 +77,48 @@ async fn read_to_end_uninit() { - test.read_to_end(&mut buf).await.unwrap(); - assert_eq!(buf.len(), 33); - } -+ -+#[tokio::test] -+async fn read_to_end_doesnt_grow_with_capacity() { -+ let arr: Vec = (0..100).collect(); -+ -+ // We only test from 32 since we allocate at least 32 bytes each time -+ for len in 32..100 { -+ let bytes = &arr[..len]; -+ for split in 0..len { -+ for cap in 0..101 { -+ let mut mock = if split == 0 { -+ Builder::new().read(bytes).build() -+ } else { -+ Builder::new() -+ .read(&bytes[..split]) -+ .read(&bytes[split..]) -+ .build() -+ }; -+ let mut buf = Vec::with_capacity(cap); -+ AsyncReadExt::read_to_end(&mut mock, &mut buf) -+ .await -+ .unwrap(); -+ // It has the right data. -+ assert_eq!(buf.as_slice(), bytes); -+ // Unless cap was smaller than length, then we did not reallocate. -+ if cap >= len { -+ assert_eq!(buf.capacity(), cap); -+ } -+ } -+ } -+ } -+} -+ -+#[tokio::test] -+async fn read_to_end_grows_capacity_if_unfit() { -+ let bytes = b"the_vector_startingcap_will_be_smaller"; -+ let mut mock = Builder::new().read(bytes).build(); -+ let initial_capacity = bytes.len() - 4; -+ let mut buf = Vec::with_capacity(initial_capacity); -+ AsyncReadExt::read_to_end(&mut mock, &mut buf) -+ .await -+ .unwrap(); -+ // *4 since it doubles when it doesn't fit and again when reaching EOF -+ assert_eq!(buf.capacity(), initial_capacity * 4); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_split.rs b/KubeOS-Rust/vendor/tokio/tests/io_split.rs -index a0121667..4cbd2a2d 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_split.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_split.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support panic recovery - - use tokio::io::{split, AsyncRead, AsyncWrite, ReadBuf, ReadHalf, WriteHalf}; - -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_take.rs b/KubeOS-Rust/vendor/tokio/tests/io_take.rs -index 683606f7..fba01d2e 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/io_take.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/io_take.rs -@@ -1,9 +1,16 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support panic recovery - --use tokio::io::AsyncReadExt; -+use std::pin::Pin; -+use std::task::{Context, Poll}; -+use tokio::io::{self, AsyncRead, AsyncReadExt, ReadBuf}; - use tokio_test::assert_ok; - -+mod support { -+ pub(crate) mod leaked_buffers; -+} -+use support::leaked_buffers::LeakedBuffers; -+ - #[tokio::test] - async fn take() { - let mut buf = [0; 6]; -@@ -14,3 +21,54 @@ async fn take() { - assert_eq!(n, 4); - assert_eq!(&buf, &b"hell\0\0"[..]); - } -+ -+#[tokio::test] -+async fn issue_4435() { -+ let mut buf = [0; 8]; -+ let rd: &[u8] = b"hello world"; -+ -+ let rd = rd.take(4); -+ tokio::pin!(rd); -+ -+ let mut read_buf = ReadBuf::new(&mut buf); -+ read_buf.put_slice(b"AB"); -+ -+ futures::future::poll_fn(|cx| rd.as_mut().poll_read(cx, &mut read_buf)) -+ .await -+ .unwrap(); -+ assert_eq!(&buf, &b"ABhell\0\0"[..]); -+} -+ -+struct BadReader { -+ leaked_buffers: LeakedBuffers, -+} -+ -+impl BadReader { -+ fn new() -> Self { -+ Self { -+ leaked_buffers: LeakedBuffers::new(), -+ } -+ } -+} -+ -+impl AsyncRead for BadReader { -+ fn poll_read( -+ mut self: Pin<&mut Self>, -+ _cx: &mut Context<'_>, -+ read_buf: &mut ReadBuf<'_>, -+ ) -> Poll> { -+ let mut buf = ReadBuf::new(unsafe { self.leaked_buffers.create(10) }); -+ buf.put_slice(&[123; 10]); -+ *read_buf = buf; -+ -+ Poll::Ready(Ok(())) -+ } -+} -+ -+#[tokio::test] -+#[should_panic] -+async fn bad_reader_fails() { -+ let mut buf = Vec::with_capacity(10); -+ -+ BadReader::new().take(10).read_buf(&mut buf).await.unwrap(); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/io_util_empty.rs b/KubeOS-Rust/vendor/tokio/tests/io_util_empty.rs -new file mode 100644 -index 00000000..e49cd17f ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/io_util_empty.rs -@@ -0,0 +1,32 @@ -+#![cfg(feature = "full")] -+use tokio::io::{AsyncBufReadExt, AsyncReadExt}; -+ -+#[tokio::test] -+async fn empty_read_is_cooperative() { -+ tokio::select! { -+ biased; -+ -+ _ = async { -+ loop { -+ let mut buf = [0u8; 4096]; -+ let _ = tokio::io::empty().read(&mut buf).await; -+ } -+ } => {}, -+ _ = tokio::task::yield_now() => {} -+ } -+} -+ -+#[tokio::test] -+async fn empty_buf_reads_are_cooperative() { -+ tokio::select! { -+ biased; -+ -+ _ = async { -+ loop { -+ let mut buf = String::new(); -+ let _ = tokio::io::empty().read_line(&mut buf).await; -+ } -+ } => {}, -+ _ = tokio::task::yield_now() => {} -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/join_handle_panic.rs b/KubeOS-Rust/vendor/tokio/tests/join_handle_panic.rs -new file mode 100644 -index 00000000..bc34fd0e ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/join_handle_panic.rs -@@ -0,0 +1,20 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support panic recovery -+ -+struct PanicsOnDrop; -+ -+impl Drop for PanicsOnDrop { -+ fn drop(&mut self) { -+ panic!("I told you so"); -+ } -+} -+ -+#[tokio::test] -+async fn test_panics_do_not_propagate_when_dropping_join_handle() { -+ let join_handle = tokio::spawn(async move { PanicsOnDrop }); -+ -+ // only drop the JoinHandle when the task has completed -+ // (which is difficult to synchronize precisely) -+ tokio::time::sleep(std::time::Duration::from_millis(3)).await; -+ drop(join_handle); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/macros_join.rs b/KubeOS-Rust/vendor/tokio/tests/macros_join.rs -index 169e898f..7866ac08 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/macros_join.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/macros_join.rs -@@ -1,36 +1,48 @@ --#![allow(clippy::blacklisted_name)] --use tokio::sync::oneshot; -+#![cfg(feature = "macros")] -+#![allow(clippy::disallowed_names)] -+use std::sync::Arc; -+ -+#[cfg(tokio_wasm_not_wasi)] -+#[cfg(target_pointer_width = "64")] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; -+ -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; -+ -+use tokio::sync::{oneshot, Semaphore}; - use tokio_test::{assert_pending, assert_ready, task}; - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_one_lit_expr_comma() { - let foo = tokio::join!(async { 1 },); - - assert_eq!(foo, (1,)); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_one_lit_expr_no_comma() { - let foo = tokio::join!(async { 1 }); - - assert_eq!(foo, (1,)); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_two_lit_expr_comma() { - let foo = tokio::join!(async { 1 }, async { 2 },); - - assert_eq!(foo, (1, 2)); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_two_lit_expr_no_comma() { - let foo = tokio::join!(async { 1 }, async { 2 }); - - assert_eq!(foo, (1, 2)); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn two_await() { - let (tx1, rx1) = oneshot::channel::<&str>(); - let (tx2, rx2) = oneshot::channel::(); -@@ -53,6 +65,7 @@ async fn two_await() { - } - - #[test] -+#[cfg(target_pointer_width = "64")] - fn join_size() { - use futures::future; - use std::mem; -@@ -61,12 +74,88 @@ fn join_size() { - let ready = future::ready(0i32); - tokio::join!(ready) - }; -- assert_eq!(mem::size_of_val(&fut), 16); -+ assert_eq!(mem::size_of_val(&fut), 32); - - let fut = async { - let ready1 = future::ready(0i32); - let ready2 = future::ready(0i32); - tokio::join!(ready1, ready2) - }; -- assert_eq!(mem::size_of_val(&fut), 28); -+ assert_eq!(mem::size_of_val(&fut), 40); -+} -+ -+async fn non_cooperative_task(permits: Arc) -> usize { -+ let mut exceeded_budget = 0; -+ -+ for _ in 0..5 { -+ // Another task should run after this task uses its whole budget -+ for _ in 0..128 { -+ let _permit = permits.clone().acquire_owned().await.unwrap(); -+ } -+ -+ exceeded_budget += 1; -+ } -+ -+ exceeded_budget -+} -+ -+async fn poor_little_task(permits: Arc) -> usize { -+ let mut how_many_times_i_got_to_run = 0; -+ -+ for _ in 0..5 { -+ let _permit = permits.clone().acquire_owned().await.unwrap(); -+ how_many_times_i_got_to_run += 1; -+ } -+ -+ how_many_times_i_got_to_run -+} -+ -+#[tokio::test] -+async fn join_does_not_allow_tasks_to_starve() { -+ let permits = Arc::new(Semaphore::new(1)); -+ -+ // non_cooperative_task should yield after its budget is exceeded and then poor_little_task should run. -+ let (non_cooperative_result, little_task_result) = tokio::join!( -+ non_cooperative_task(Arc::clone(&permits)), -+ poor_little_task(permits) -+ ); -+ -+ assert_eq!(5, non_cooperative_result); -+ assert_eq!(5, little_task_result); -+} -+ -+#[tokio::test] -+async fn a_different_future_is_polled_first_every_time_poll_fn_is_polled() { -+ let poll_order = Arc::new(std::sync::Mutex::new(vec![])); -+ -+ let fut = |x, poll_order: Arc>>| async move { -+ for _ in 0..4 { -+ { -+ let mut guard = poll_order.lock().unwrap(); -+ -+ guard.push(x); -+ } -+ -+ tokio::task::yield_now().await; -+ } -+ }; -+ -+ tokio::join!( -+ fut(1, Arc::clone(&poll_order)), -+ fut(2, Arc::clone(&poll_order)), -+ fut(3, Arc::clone(&poll_order)), -+ ); -+ -+ // Each time the future created by join! is polled, it should start -+ // by polling a different future first. -+ assert_eq!( -+ vec![1, 2, 3, 2, 3, 1, 3, 1, 2, 1, 2, 3], -+ *poll_order.lock().unwrap() -+ ); -+} -+ -+#[tokio::test] -+#[allow(clippy::unit_cmp)] -+async fn empty_join() { -+ assert_eq!(tokio::join!(), ()); - } -diff --git a/KubeOS-Rust/vendor/tokio/tests/macros_pin.rs b/KubeOS-Rust/vendor/tokio/tests/macros_pin.rs -index da6e0be6..e99a3ee2 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/macros_pin.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/macros_pin.rs -@@ -1,7 +1,15 @@ -+#![cfg(feature = "macros")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; -+ -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; -+ - async fn one() {} - async fn two() {} - --#[tokio::test] -+#[maybe_tokio_test] - async fn multi_pin() { - tokio::pin! { - let f1 = one(); -diff --git a/KubeOS-Rust/vendor/tokio/tests/macros_rename_test.rs b/KubeOS-Rust/vendor/tokio/tests/macros_rename_test.rs -new file mode 100644 -index 00000000..6c2ce2f5 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/macros_rename_test.rs -@@ -0,0 +1,35 @@ -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threading -+ -+#[allow(unused_imports)] -+use std as tokio; -+ -+use ::tokio as tokio1; -+ -+mod test { -+ pub use ::tokio; -+} -+ -+async fn compute() -> usize { -+ let join = tokio1::spawn(async { 1 }); -+ join.await.unwrap() -+} -+ -+#[tokio1::main(crate = "tokio1")] -+async fn compute_main() -> usize { -+ compute().await -+} -+ -+#[test] -+fn crate_rename_main() { -+ assert_eq!(1, compute_main()); -+} -+ -+#[tokio1::test(crate = "tokio1")] -+async fn crate_rename_test() { -+ assert_eq!(1, compute().await); -+} -+ -+#[test::tokio::test(crate = "test::tokio")] -+async fn crate_path_test() { -+ assert_eq!(1, compute().await); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/macros_select.rs b/KubeOS-Rust/vendor/tokio/tests/macros_select.rs -index b4f85440..0514c864 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/macros_select.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/macros_select.rs -@@ -1,12 +1,19 @@ --#![allow(clippy::blacklisted_name)] --use tokio::sync::{mpsc, oneshot}; --use tokio::task; -+#![cfg(feature = "macros")] -+#![allow(clippy::disallowed_names)] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; -+ -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; -+ -+use tokio::sync::oneshot; - use tokio_test::{assert_ok, assert_pending, assert_ready}; - - use futures::future::poll_fn; - use std::task::Poll::Ready; - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_one_lit_expr_comma() { - let foo = tokio::select! { - foo = async { 1 } => foo, -@@ -15,7 +22,7 @@ async fn sync_one_lit_expr_comma() { - assert_eq!(foo, 1); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn nested_one() { - let foo = tokio::select! { - foo = async { 1 } => tokio::select! { -@@ -26,7 +33,7 @@ async fn nested_one() { - assert_eq!(foo, 1); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_one_lit_expr_no_comma() { - let foo = tokio::select! { - foo = async { 1 } => foo -@@ -35,7 +42,7 @@ async fn sync_one_lit_expr_no_comma() { - assert_eq!(foo, 1); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_one_lit_expr_block() { - let foo = tokio::select! { - foo = async { 1 } => { foo } -@@ -44,7 +51,7 @@ async fn sync_one_lit_expr_block() { - assert_eq!(foo, 1); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_one_await() { - let foo = tokio::select! { - foo = one() => foo, -@@ -53,7 +60,7 @@ async fn sync_one_await() { - assert_eq!(foo, 1); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_one_ident() { - let one = one(); - -@@ -64,7 +71,7 @@ async fn sync_one_ident() { - assert_eq!(foo, 1); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_two() { - use std::cell::Cell; - -@@ -85,7 +92,7 @@ async fn sync_two() { - assert!(res == 1 || res == 2); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn drop_in_fut() { - let s = "hello".to_string(); - -@@ -100,7 +107,8 @@ async fn drop_in_fut() { - assert_eq!(res, 1); - } - --#[tokio::test] -+#[maybe_tokio_test] -+#[cfg(feature = "full")] - async fn one_ready() { - let (tx1, rx1) = oneshot::channel::(); - let (_tx2, rx2) = oneshot::channel::(); -@@ -117,20 +125,23 @@ async fn one_ready() { - assert_eq!(1, v); - } - --#[tokio::test] -+#[maybe_tokio_test] -+#[cfg(feature = "full")] - async fn select_streams() { -+ use tokio::sync::mpsc; -+ - let (tx1, mut rx1) = mpsc::unbounded_channel::(); - let (tx2, mut rx2) = mpsc::unbounded_channel::(); - - tokio::spawn(async move { - assert_ok!(tx2.send(1)); -- task::yield_now().await; -+ tokio::task::yield_now().await; - - assert_ok!(tx1.send(2)); -- task::yield_now().await; -+ tokio::task::yield_now().await; - - assert_ok!(tx2.send(3)); -- task::yield_now().await; -+ tokio::task::yield_now().await; - - drop((tx1, tx2)); - }); -@@ -156,7 +167,7 @@ async fn select_streams() { - assert_eq!(&msgs[..], &[1, 2, 3]); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn move_uncompleted_futures() { - let (tx1, mut rx1) = oneshot::channel::(); - let (tx2, mut rx2) = oneshot::channel::(); -@@ -182,7 +193,7 @@ async fn move_uncompleted_futures() { - assert!(ran); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn nested() { - let res = tokio::select! { - x = async { 1 } => { -@@ -195,49 +206,59 @@ async fn nested() { - assert_eq!(res, 3); - } - --#[tokio::test] --async fn struct_size() { -+#[cfg(target_pointer_width = "64")] -+mod pointer_64_tests { -+ use super::maybe_tokio_test; - use futures::future; - use std::mem; - -- let fut = async { -- let ready = future::ready(0i32); -+ #[maybe_tokio_test] -+ async fn struct_size_1() { -+ let fut = async { -+ let ready = future::ready(0i32); - -- tokio::select! { -- _ = ready => {}, -- } -- }; -+ tokio::select! { -+ _ = ready => {}, -+ } -+ }; - -- assert!(mem::size_of_val(&fut) <= 32); -+ assert_eq!(mem::size_of_val(&fut), 32); -+ } - -- let fut = async { -- let ready1 = future::ready(0i32); -- let ready2 = future::ready(0i32); -+ #[maybe_tokio_test] -+ async fn struct_size_2() { -+ let fut = async { -+ let ready1 = future::ready(0i32); -+ let ready2 = future::ready(0i32); - -- tokio::select! { -- _ = ready1 => {}, -- _ = ready2 => {}, -- } -- }; -+ tokio::select! { -+ _ = ready1 => {}, -+ _ = ready2 => {}, -+ } -+ }; - -- assert!(mem::size_of_val(&fut) <= 40); -+ assert_eq!(mem::size_of_val(&fut), 40); -+ } - -- let fut = async { -- let ready1 = future::ready(0i32); -- let ready2 = future::ready(0i32); -- let ready3 = future::ready(0i32); -+ #[maybe_tokio_test] -+ async fn struct_size_3() { -+ let fut = async { -+ let ready1 = future::ready(0i32); -+ let ready2 = future::ready(0i32); -+ let ready3 = future::ready(0i32); - -- tokio::select! { -- _ = ready1 => {}, -- _ = ready2 => {}, -- _ = ready3 => {}, -- } -- }; -+ tokio::select! { -+ _ = ready1 => {}, -+ _ = ready2 => {}, -+ _ = ready3 => {}, -+ } -+ }; - -- assert!(mem::size_of_val(&fut) <= 48); -+ assert_eq!(mem::size_of_val(&fut), 48); -+ } - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn mutable_borrowing_future_with_same_borrow_in_block() { - let mut value = 234; - -@@ -251,7 +272,7 @@ async fn mutable_borrowing_future_with_same_borrow_in_block() { - assert!(value >= 234); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn mutable_borrowing_future_with_same_borrow_in_block_and_else() { - let mut value = 234; - -@@ -268,7 +289,7 @@ async fn mutable_borrowing_future_with_same_borrow_in_block_and_else() { - assert!(value >= 234); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn future_panics_after_poll() { - use tokio_test::task; - -@@ -298,7 +319,7 @@ async fn future_panics_after_poll() { - assert_eq!(1, res); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn disable_with_if() { - use tokio_test::task; - -@@ -320,7 +341,7 @@ async fn disable_with_if() { - assert_ready!(f.poll()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn join_with_select() { - use tokio_test::task; - -@@ -356,6 +377,7 @@ async fn join_with_select() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn use_future_in_if_condition() { - use tokio::time::{self, Duration}; - -@@ -369,6 +391,7 @@ async fn use_future_in_if_condition() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn use_future_in_if_condition_biased() { - use tokio::time::{self, Duration}; - -@@ -382,7 +405,7 @@ async fn use_future_in_if_condition_biased() { - } - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn many_branches() { - let num = tokio::select! { - x = async { 1 } => x, -@@ -448,12 +471,13 @@ async fn many_branches() { - x = async { 1 } => x, - x = async { 1 } => x, - x = async { 1 } => x, -+ x = async { 1 } => x, - }; - - assert_eq!(1, num); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn never_branch_no_warnings() { - let t = tokio::select! { - _ = async_never() => 0, -@@ -474,7 +498,7 @@ async fn async_never() -> ! { - } - - // From https://github.com/tokio-rs/tokio/issues/2857 --#[tokio::test] -+#[maybe_tokio_test] - async fn mut_on_left_hand_side() { - let v = async move { - let ok = async { 1 }; -@@ -490,7 +514,7 @@ async fn mut_on_left_hand_side() { - assert_eq!(v, 2); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn biased_one_not_ready() { - let (_tx1, rx1) = oneshot::channel::(); - let (tx2, rx2) = oneshot::channel::(); -@@ -514,7 +538,8 @@ async fn biased_one_not_ready() { - assert_eq!(2, v); - } - --#[tokio::test] -+#[maybe_tokio_test] -+#[cfg(feature = "full")] - async fn biased_eventually_ready() { - use tokio::task::yield_now; - -@@ -560,7 +585,7 @@ pub async fn default_numeric_fallback() { - } - - // https://github.com/tokio-rs/tokio/issues/4182 --#[tokio::test] -+#[maybe_tokio_test] - async fn mut_ref_patterns() { - tokio::select! { - Some(mut foo) = async { Some("1".to_string()) } => { -@@ -584,3 +609,66 @@ async fn mut_ref_patterns() { - }, - }; - } -+ -+#[cfg(tokio_unstable)] -+mod unstable { -+ use tokio::runtime::RngSeed; -+ -+ #[test] -+ fn deterministic_select_current_thread() { -+ let seed = b"bytes used to generate seed"; -+ let rt1 = tokio::runtime::Builder::new_current_thread() -+ .rng_seed(RngSeed::from_bytes(seed)) -+ .build() -+ .unwrap(); -+ let rt1_values = rt1.block_on(async { (select_0_to_9().await, select_0_to_9().await) }); -+ -+ let rt2 = tokio::runtime::Builder::new_current_thread() -+ .rng_seed(RngSeed::from_bytes(seed)) -+ .build() -+ .unwrap(); -+ let rt2_values = rt2.block_on(async { (select_0_to_9().await, select_0_to_9().await) }); -+ -+ assert_eq!(rt1_values, rt2_values); -+ } -+ -+ #[test] -+ #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] -+ fn deterministic_select_multi_thread() { -+ let seed = b"bytes used to generate seed"; -+ let rt1 = tokio::runtime::Builder::new_multi_thread() -+ .worker_threads(1) -+ .rng_seed(RngSeed::from_bytes(seed)) -+ .build() -+ .unwrap(); -+ let rt1_values = rt1.block_on(async { -+ let _ = tokio::spawn(async { (select_0_to_9().await, select_0_to_9().await) }).await; -+ }); -+ -+ let rt2 = tokio::runtime::Builder::new_multi_thread() -+ .worker_threads(1) -+ .rng_seed(RngSeed::from_bytes(seed)) -+ .build() -+ .unwrap(); -+ let rt2_values = rt2.block_on(async { -+ let _ = tokio::spawn(async { (select_0_to_9().await, select_0_to_9().await) }).await; -+ }); -+ -+ assert_eq!(rt1_values, rt2_values); -+ } -+ -+ async fn select_0_to_9() -> u32 { -+ tokio::select!( -+ x = async { 0 } => x, -+ x = async { 1 } => x, -+ x = async { 2 } => x, -+ x = async { 3 } => x, -+ x = async { 4 } => x, -+ x = async { 5 } => x, -+ x = async { 6 } => x, -+ x = async { 7 } => x, -+ x = async { 8 } => x, -+ x = async { 9 } => x, -+ ) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/macros_test.rs b/KubeOS-Rust/vendor/tokio/tests/macros_test.rs -index bca2c919..85279b7e 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/macros_test.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/macros_test.rs -@@ -1,3 +1,5 @@ -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threading -+ - use tokio::test; - - #[test] -@@ -46,3 +48,41 @@ pub async fn issue_4175_test() -> std::io::Result<()> { - return Ok(()); - panic!(); - } -+ -+// https://github.com/tokio-rs/tokio/issues/4175 -+#[allow(clippy::let_unit_value)] -+pub mod clippy_semicolon_if_nothing_returned { -+ #![deny(clippy::semicolon_if_nothing_returned)] -+ -+ #[tokio::main] -+ pub async fn local() { -+ let _x = (); -+ } -+ #[tokio::main] -+ pub async fn item() { -+ fn _f() {} -+ } -+ #[tokio::main] -+ pub async fn semi() { -+ panic!(); -+ } -+ #[tokio::main] -+ pub async fn empty() { -+ // To trigger clippy::semicolon_if_nothing_returned lint, the block needs to contain newline. -+ } -+} -+ -+// https://github.com/tokio-rs/tokio/issues/5243 -+pub mod issue_5243 { -+ macro_rules! mac { -+ (async fn $name:ident() $b:block) => { -+ #[::tokio::test] -+ async fn $name() { -+ $b -+ } -+ }; -+ } -+ mac!( -+ async fn foo() {} -+ ); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/macros_try_join.rs b/KubeOS-Rust/vendor/tokio/tests/macros_try_join.rs -index a9251532..74b1c9f9 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/macros_try_join.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/macros_try_join.rs -@@ -1,36 +1,46 @@ --#![allow(clippy::blacklisted_name)] --use tokio::sync::oneshot; -+#![cfg(feature = "macros")] -+#![allow(clippy::disallowed_names)] -+ -+use std::sync::Arc; -+ -+use tokio::sync::{oneshot, Semaphore}; - use tokio_test::{assert_pending, assert_ready, task}; - --#[tokio::test] -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; -+ -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; -+ -+#[maybe_tokio_test] - async fn sync_one_lit_expr_comma() { - let foo = tokio::try_join!(async { ok(1) },); - - assert_eq!(foo, Ok((1,))); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_one_lit_expr_no_comma() { - let foo = tokio::try_join!(async { ok(1) }); - - assert_eq!(foo, Ok((1,))); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_two_lit_expr_comma() { - let foo = tokio::try_join!(async { ok(1) }, async { ok(2) },); - - assert_eq!(foo, Ok((1, 2))); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn sync_two_lit_expr_no_comma() { - let foo = tokio::try_join!(async { ok(1) }, async { ok(2) }); - - assert_eq!(foo, Ok((1, 2))); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn two_await() { - let (tx1, rx1) = oneshot::channel::<&str>(); - let (tx2, rx2) = oneshot::channel::(); -@@ -51,7 +61,7 @@ async fn two_await() { - assert_eq!(Ok(("hello", 123)), res); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn err_abort_early() { - let (tx1, rx1) = oneshot::channel::<&str>(); - let (tx2, rx2) = oneshot::channel::(); -@@ -78,6 +88,7 @@ async fn err_abort_early() { - } - - #[test] -+#[cfg(target_pointer_width = "64")] - fn join_size() { - use futures::future; - use std::mem; -@@ -86,16 +97,94 @@ fn join_size() { - let ready = future::ready(ok(0i32)); - tokio::try_join!(ready) - }; -- assert_eq!(mem::size_of_val(&fut), 16); -+ assert_eq!(mem::size_of_val(&fut), 32); - - let fut = async { - let ready1 = future::ready(ok(0i32)); - let ready2 = future::ready(ok(0i32)); - tokio::try_join!(ready1, ready2) - }; -- assert_eq!(mem::size_of_val(&fut), 28); -+ assert_eq!(mem::size_of_val(&fut), 48); - } - - fn ok(val: T) -> Result { - Ok(val) - } -+ -+async fn non_cooperative_task(permits: Arc) -> Result { -+ let mut exceeded_budget = 0; -+ -+ for _ in 0..5 { -+ // Another task should run after this task uses its whole budget -+ for _ in 0..128 { -+ let _permit = permits.clone().acquire_owned().await.unwrap(); -+ } -+ -+ exceeded_budget += 1; -+ } -+ -+ Ok(exceeded_budget) -+} -+ -+async fn poor_little_task(permits: Arc) -> Result { -+ let mut how_many_times_i_got_to_run = 0; -+ -+ for _ in 0..5 { -+ let _permit = permits.clone().acquire_owned().await.unwrap(); -+ -+ how_many_times_i_got_to_run += 1; -+ } -+ -+ Ok(how_many_times_i_got_to_run) -+} -+ -+#[tokio::test] -+async fn try_join_does_not_allow_tasks_to_starve() { -+ let permits = Arc::new(Semaphore::new(10)); -+ -+ // non_cooperative_task should yield after its budget is exceeded and then poor_little_task should run. -+ let result = tokio::try_join!( -+ non_cooperative_task(Arc::clone(&permits)), -+ poor_little_task(permits) -+ ); -+ -+ let (non_cooperative_result, little_task_result) = result.unwrap(); -+ -+ assert_eq!(5, non_cooperative_result); -+ assert_eq!(5, little_task_result); -+} -+ -+#[tokio::test] -+async fn a_different_future_is_polled_first_every_time_poll_fn_is_polled() { -+ let poll_order = Arc::new(std::sync::Mutex::new(vec![])); -+ -+ let fut = |x, poll_order: Arc>>| async move { -+ for _ in 0..4 { -+ { -+ let mut guard = poll_order.lock().unwrap(); -+ -+ guard.push(x); -+ } -+ -+ tokio::task::yield_now().await; -+ } -+ }; -+ -+ tokio::join!( -+ fut(1, Arc::clone(&poll_order)), -+ fut(2, Arc::clone(&poll_order)), -+ fut(3, Arc::clone(&poll_order)), -+ ); -+ -+ // Each time the future created by join! is polled, it should start -+ // by polling a different future first. -+ assert_eq!( -+ vec![1, 2, 3, 2, 3, 1, 3, 1, 2, 1, 2, 3], -+ *poll_order.lock().unwrap() -+ ); -+} -+ -+#[tokio::test] -+async fn empty_try_join() { -+ assert_eq!(tokio::try_join!() as Result<_, ()>, Ok(())); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/net_bind_resource.rs b/KubeOS-Rust/vendor/tokio/tests/net_bind_resource.rs -index d4a0b8da..76378b3e 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/net_bind_resource.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/net_bind_resource.rs -@@ -1,9 +1,8 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support panic recovery or bind - - use tokio::net::TcpListener; - --use std::convert::TryFrom; - use std::net; - - #[test] -diff --git a/KubeOS-Rust/vendor/tokio/tests/net_lookup_host.rs b/KubeOS-Rust/vendor/tokio/tests/net_lookup_host.rs -index 4d064029..2b346e65 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/net_lookup_host.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/net_lookup_host.rs -@@ -1,3 +1,5 @@ -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support direct socket operations -+ - use tokio::net; - use tokio_test::assert_ok; - -diff --git a/KubeOS-Rust/vendor/tokio/tests/named_pipe.rs b/KubeOS-Rust/vendor/tokio/tests/net_named_pipe.rs -similarity index 78% -rename from KubeOS-Rust/vendor/tokio/tests/named_pipe.rs -rename to KubeOS-Rust/vendor/tokio/tests/net_named_pipe.rs -index 2055c3ce..02eda48e 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/named_pipe.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/net_named_pipe.rs -@@ -2,13 +2,11 @@ - #![cfg(all(windows))] - - use std::io; --use std::mem; --use std::os::windows::io::AsRawHandle; - use std::time::Duration; --use tokio::io::AsyncWriteExt; -+use tokio::io::{AsyncReadExt, AsyncWriteExt}; - use tokio::net::windows::named_pipe::{ClientOptions, PipeMode, ServerOptions}; - use tokio::time; --use winapi::shared::winerror; -+use windows_sys::Win32::Foundation::{ERROR_NO_DATA, ERROR_PIPE_BUSY}; - - #[tokio::test] - async fn test_named_pipe_client_drop() -> io::Result<()> { -@@ -16,8 +14,6 @@ async fn test_named_pipe_client_drop() -> io::Result<()> { - - let mut server = ServerOptions::new().create(PIPE_NAME)?; - -- assert_eq!(num_instances("test-named-pipe-client-drop")?, 1); -- - let client = ClientOptions::new().open(PIPE_NAME)?; - - server.connect().await?; -@@ -25,7 +21,7 @@ async fn test_named_pipe_client_drop() -> io::Result<()> { - - // instance will be broken because client is gone - match server.write_all(b"ping").await { -- Err(e) if e.raw_os_error() == Some(winerror::ERROR_NO_DATA as i32) => (), -+ Err(e) if e.raw_os_error() == Some(ERROR_NO_DATA as i32) => (), - x => panic!("{:?}", x), - } - -@@ -120,7 +116,7 @@ async fn test_named_pipe_multi_client() -> io::Result<()> { - let client = loop { - match ClientOptions::new().open(PIPE_NAME) { - Ok(client) => break client, -- Err(e) if e.raw_os_error() == Some(winerror::ERROR_PIPE_BUSY as i32) => (), -+ Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (), - Err(e) if e.kind() == io::ErrorKind::NotFound => (), - Err(e) => return Err(e), - } -@@ -249,7 +245,7 @@ async fn test_named_pipe_multi_client_ready() -> io::Result<()> { - let client = loop { - match ClientOptions::new().open(PIPE_NAME) { - Ok(client) => break client, -- Err(e) if e.raw_os_error() == Some(winerror::ERROR_PIPE_BUSY as i32) => (), -+ Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (), - Err(e) if e.kind() == io::ErrorKind::NotFound => (), - Err(e) => return Err(e), - } -@@ -327,67 +323,77 @@ async fn test_named_pipe_multi_client_ready() -> io::Result<()> { - Ok(()) - } - --// This tests what happens when a client tries to disconnect. -+// This tests that message mode works as expected. - #[tokio::test] - async fn test_named_pipe_mode_message() -> io::Result<()> { -- const PIPE_NAME: &str = r"\\.\pipe\test-named-pipe-mode-message"; -+ // it's easy to accidentally get a seemingly working test here because byte pipes -+ // often return contents at write boundaries. to make sure we're doing the right thing we -+ // explicitly test that it doesn't work in byte mode. -+ _named_pipe_mode_message(PipeMode::Message).await?; -+ _named_pipe_mode_message(PipeMode::Byte).await -+} -+ -+async fn _named_pipe_mode_message(mode: PipeMode) -> io::Result<()> { -+ let pipe_name = format!( -+ r"\\.\pipe\test-named-pipe-mode-message-{}", -+ matches!(mode, PipeMode::Message) -+ ); -+ let mut buf = [0u8; 32]; - -- let server = ServerOptions::new() -- .pipe_mode(PipeMode::Message) -- .create(PIPE_NAME)?; -+ let mut server = ServerOptions::new() -+ .first_pipe_instance(true) -+ .pipe_mode(mode) -+ .create(&pipe_name)?; -+ -+ let mut client = ClientOptions::new().pipe_mode(mode).open(&pipe_name)?; - -- let _ = ClientOptions::new().open(PIPE_NAME)?; - server.connect().await?; -+ -+ // this needs a few iterations, presumably Windows waits for a few calls before merging buffers -+ for _ in 0..10 { -+ client.write_all(b"hello").await?; -+ server.write_all(b"world").await?; -+ } -+ for _ in 0..10 { -+ let n = server.read(&mut buf).await?; -+ if buf[..n] != b"hello"[..] { -+ assert!(matches!(mode, PipeMode::Byte)); -+ return Ok(()); -+ } -+ let n = client.read(&mut buf).await?; -+ if buf[..n] != b"world"[..] { -+ assert!(matches!(mode, PipeMode::Byte)); -+ return Ok(()); -+ } -+ } -+ // byte mode should have errored before. -+ assert!(matches!(mode, PipeMode::Message)); - Ok(()) - } - --fn num_instances(pipe_name: impl AsRef) -> io::Result { -- use ntapi::ntioapi; -- use winapi::shared::ntdef; -- -- let mut name = pipe_name.as_ref().encode_utf16().collect::>(); -- let mut name = ntdef::UNICODE_STRING { -- Length: (name.len() * mem::size_of::()) as u16, -- MaximumLength: (name.len() * mem::size_of::()) as u16, -- Buffer: name.as_mut_ptr(), -- }; -- let root = std::fs::File::open(r"\\.\Pipe\")?; -- let mut io_status_block = unsafe { mem::zeroed() }; -- let mut file_directory_information = [0_u8; 1024]; -- -- let status = unsafe { -- ntioapi::NtQueryDirectoryFile( -- root.as_raw_handle(), -- std::ptr::null_mut(), -- None, -- std::ptr::null_mut(), -- &mut io_status_block, -- &mut file_directory_information as *mut _ as *mut _, -- 1024, -- ntioapi::FileDirectoryInformation, -- 0, -- &mut name, -- 0, -- ) -- }; -- -- if status as u32 != winerror::NO_ERROR { -- return Err(io::Error::last_os_error()); -+// This tests `NamedPipeServer::connect` with various access settings. -+#[tokio::test] -+async fn test_named_pipe_access() -> io::Result<()> { -+ const PIPE_NAME: &str = r"\\.\pipe\test-named-pipe-access"; -+ -+ for (inb, outb) in [(true, true), (true, false), (false, true)] { -+ let (tx, rx) = tokio::sync::oneshot::channel(); -+ let server = tokio::spawn(async move { -+ let s = ServerOptions::new() -+ .access_inbound(inb) -+ .access_outbound(outb) -+ .create(PIPE_NAME)?; -+ let mut connect_fut = tokio_test::task::spawn(s.connect()); -+ assert!(connect_fut.poll().is_pending()); -+ tx.send(()).unwrap(); -+ connect_fut.await -+ }); -+ -+ // Wait for the server to call connect. -+ rx.await.unwrap(); -+ let _ = ClientOptions::new().read(outb).write(inb).open(PIPE_NAME)?; -+ -+ server.await??; - } -- -- let info = unsafe { -- mem::transmute::<_, &ntioapi::FILE_DIRECTORY_INFORMATION>(&file_directory_information) -- }; -- let raw_name = unsafe { -- std::slice::from_raw_parts( -- info.FileName.as_ptr(), -- info.FileNameLength as usize / mem::size_of::(), -- ) -- }; -- let name = String::from_utf16(raw_name).unwrap(); -- let num_instances = unsafe { *info.EndOfFile.QuadPart() }; -- -- assert_eq!(name, pipe_name.as_ref()); -- -- Ok(num_instances as u32) -+ Ok(()) - } -diff --git a/KubeOS-Rust/vendor/tokio/tests/net_panic.rs b/KubeOS-Rust/vendor/tokio/tests/net_panic.rs -new file mode 100644 -index 00000000..fc2209ad ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/net_panic.rs -@@ -0,0 +1,188 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] -+ -+use std::error::Error; -+use tokio::net::{TcpListener, TcpStream}; -+use tokio::runtime::{Builder, Runtime}; -+ -+mod support { -+ pub mod panic; -+} -+use support::panic::test_panic; -+ -+#[test] -+fn udp_socket_from_std_panic_caller() -> Result<(), Box> { -+ use std::net::SocketAddr; -+ use tokio::net::UdpSocket; -+ -+ let addr = "127.0.0.1:0".parse::().unwrap(); -+ let std_sock = std::net::UdpSocket::bind(addr).unwrap(); -+ std_sock.set_nonblocking(true).unwrap(); -+ -+ let panic_location_file = test_panic(|| { -+ let rt = runtime_without_io(); -+ rt.block_on(async { -+ let _sock = UdpSocket::from_std(std_sock); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn tcp_listener_from_std_panic_caller() -> Result<(), Box> { -+ let std_listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); -+ std_listener.set_nonblocking(true).unwrap(); -+ -+ let panic_location_file = test_panic(|| { -+ let rt = runtime_without_io(); -+ rt.block_on(async { -+ let _ = TcpListener::from_std(std_listener); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn tcp_stream_from_std_panic_caller() -> Result<(), Box> { -+ let std_listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); -+ -+ let std_stream = std::net::TcpStream::connect(std_listener.local_addr().unwrap()).unwrap(); -+ std_stream.set_nonblocking(true).unwrap(); -+ -+ let panic_location_file = test_panic(|| { -+ let rt = runtime_without_io(); -+ rt.block_on(async { -+ let _ = TcpStream::from_std(std_stream); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+#[cfg(unix)] -+fn unix_listener_bind_panic_caller() -> Result<(), Box> { -+ use tokio::net::UnixListener; -+ -+ let dir = tempfile::tempdir().unwrap(); -+ let sock_path = dir.path().join("socket"); -+ -+ let panic_location_file = test_panic(|| { -+ let rt = runtime_without_io(); -+ rt.block_on(async { -+ let _ = UnixListener::bind(&sock_path); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+#[cfg(unix)] -+fn unix_listener_from_std_panic_caller() -> Result<(), Box> { -+ use tokio::net::UnixListener; -+ -+ let dir = tempfile::tempdir().unwrap(); -+ let sock_path = dir.path().join("socket"); -+ let std_listener = std::os::unix::net::UnixListener::bind(&sock_path).unwrap(); -+ -+ let panic_location_file = test_panic(|| { -+ let rt = runtime_without_io(); -+ rt.block_on(async { -+ let _ = UnixListener::from_std(std_listener); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+#[cfg(unix)] -+fn unix_stream_from_std_panic_caller() -> Result<(), Box> { -+ use tokio::net::UnixStream; -+ -+ let dir = tempfile::tempdir().unwrap(); -+ let sock_path = dir.path().join("socket"); -+ let _std_listener = std::os::unix::net::UnixListener::bind(&sock_path).unwrap(); -+ let std_stream = std::os::unix::net::UnixStream::connect(&sock_path).unwrap(); -+ -+ let panic_location_file = test_panic(|| { -+ let rt = runtime_without_io(); -+ rt.block_on(async { -+ let _ = UnixStream::from_std(std_stream); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+#[cfg(unix)] -+fn unix_datagram_from_std_panic_caller() -> Result<(), Box> { -+ use std::os::unix::net::UnixDatagram as StdUDS; -+ use tokio::net::UnixDatagram; -+ -+ let dir = tempfile::tempdir().unwrap(); -+ let sock_path = dir.path().join("socket"); -+ -+ // Bind the socket to a filesystem path -+ // /let socket_path = tmp.path().join("socket"); -+ let std_socket = StdUDS::bind(&sock_path).unwrap(); -+ std_socket.set_nonblocking(true).unwrap(); -+ -+ let panic_location_file = test_panic(move || { -+ let rt = runtime_without_io(); -+ rt.block_on(async { -+ let _ = UnixDatagram::from_std(std_socket); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+#[cfg(windows)] -+fn server_options_max_instances_panic_caller() -> Result<(), Box> { -+ use tokio::net::windows::named_pipe::ServerOptions; -+ -+ let panic_location_file = test_panic(move || { -+ let rt = runtime_without_io(); -+ rt.block_on(async { -+ let mut options = ServerOptions::new(); -+ options.max_instances(255); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+// Runtime without `enable_io` so it has no IO driver set. -+fn runtime_without_io() -> Runtime { -+ Builder::new_current_thread().build().unwrap() -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/net_unix_pipe.rs b/KubeOS-Rust/vendor/tokio/tests/net_unix_pipe.rs -new file mode 100644 -index 00000000..c96d6e70 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/net_unix_pipe.rs -@@ -0,0 +1,429 @@ -+#![cfg(feature = "full")] -+#![cfg(unix)] -+ -+use tokio::io::{AsyncReadExt, AsyncWriteExt, Interest}; -+use tokio::net::unix::pipe; -+use tokio_test::task; -+use tokio_test::{assert_err, assert_ok, assert_pending, assert_ready_ok}; -+ -+use std::fs::File; -+use std::io; -+use std::os::unix::fs::OpenOptionsExt; -+use std::os::unix::io::AsRawFd; -+use std::path::{Path, PathBuf}; -+ -+/// Helper struct which will clean up temporary files once dropped. -+struct TempFifo { -+ path: PathBuf, -+ _dir: tempfile::TempDir, -+} -+ -+impl TempFifo { -+ fn new(name: &str) -> io::Result { -+ let dir = tempfile::Builder::new() -+ .prefix("tokio-fifo-tests") -+ .tempdir()?; -+ let path = dir.path().join(name); -+ nix::unistd::mkfifo(&path, nix::sys::stat::Mode::S_IRWXU)?; -+ -+ Ok(TempFifo { path, _dir: dir }) -+ } -+} -+ -+impl AsRef for TempFifo { -+ fn as_ref(&self) -> &Path { -+ self.path.as_ref() -+ } -+} -+ -+#[tokio::test] -+async fn fifo_simple_send() -> io::Result<()> { -+ const DATA: &[u8] = b"this is some data to write to the fifo"; -+ -+ let fifo = TempFifo::new("simple_send")?; -+ -+ // Create a reading task which should wait for data from the pipe. -+ let mut reader = pipe::OpenOptions::new().open_receiver(&fifo)?; -+ let mut read_fut = task::spawn(async move { -+ let mut buf = vec![0; DATA.len()]; -+ reader.read_exact(&mut buf).await?; -+ Ok::<_, io::Error>(buf) -+ }); -+ assert_pending!(read_fut.poll()); -+ -+ let mut writer = pipe::OpenOptions::new().open_sender(&fifo)?; -+ writer.write_all(DATA).await?; -+ -+ // Let the IO driver poll events for the reader. -+ while !read_fut.is_woken() { -+ tokio::task::yield_now().await; -+ } -+ -+ // Reading task should be ready now. -+ let read_data = assert_ready_ok!(read_fut.poll()); -+ assert_eq!(&read_data, DATA); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+#[cfg(target_os = "linux")] -+async fn fifo_simple_send_sender_first() -> io::Result<()> { -+ const DATA: &[u8] = b"this is some data to write to the fifo"; -+ -+ // Create a new fifo file with *no reading ends open*. -+ let fifo = TempFifo::new("simple_send_sender_first")?; -+ -+ // Simple `open_sender` should fail with ENXIO (no such device or address). -+ let err = assert_err!(pipe::OpenOptions::new().open_sender(&fifo)); -+ assert_eq!(err.raw_os_error(), Some(libc::ENXIO)); -+ -+ // `open_sender` in read-write mode should succeed and the pipe should be ready to write. -+ let mut writer = pipe::OpenOptions::new() -+ .read_write(true) -+ .open_sender(&fifo)?; -+ writer.write_all(DATA).await?; -+ -+ // Read the written data and validate. -+ let mut reader = pipe::OpenOptions::new().open_receiver(&fifo)?; -+ let mut read_data = vec![0; DATA.len()]; -+ reader.read_exact(&mut read_data).await?; -+ assert_eq!(&read_data, DATA); -+ -+ Ok(()) -+} -+ -+// Opens a FIFO file, write and *close the writer*. -+async fn write_and_close(path: impl AsRef, msg: &[u8]) -> io::Result<()> { -+ let mut writer = pipe::OpenOptions::new().open_sender(path)?; -+ writer.write_all(msg).await?; -+ drop(writer); // Explicit drop. -+ Ok(()) -+} -+ -+/// Checks EOF behavior with single reader and writers sequentially opening -+/// and closing a FIFO. -+#[tokio::test] -+async fn fifo_multiple_writes() -> io::Result<()> { -+ const DATA: &[u8] = b"this is some data to write to the fifo"; -+ -+ let fifo = TempFifo::new("fifo_multiple_writes")?; -+ -+ let mut reader = pipe::OpenOptions::new().open_receiver(&fifo)?; -+ -+ write_and_close(&fifo, DATA).await?; -+ let ev = reader.ready(Interest::READABLE).await?; -+ assert!(ev.is_readable()); -+ let mut read_data = vec![0; DATA.len()]; -+ assert_ok!(reader.read_exact(&mut read_data).await); -+ -+ // Check that reader hits EOF. -+ let err = assert_err!(reader.read_exact(&mut read_data).await); -+ assert_eq!(err.kind(), io::ErrorKind::UnexpectedEof); -+ -+ // Write more data and read again. -+ write_and_close(&fifo, DATA).await?; -+ assert_ok!(reader.read_exact(&mut read_data).await); -+ -+ Ok(()) -+} -+ -+/// Checks behavior of a resilient reader (Receiver in O_RDWR access mode) -+/// with writers sequentially opening and closing a FIFO. -+#[tokio::test] -+#[cfg(target_os = "linux")] -+async fn fifo_resilient_reader() -> io::Result<()> { -+ const DATA: &[u8] = b"this is some data to write to the fifo"; -+ -+ let fifo = TempFifo::new("fifo_resilient_reader")?; -+ -+ // Open reader in read-write access mode. -+ let mut reader = pipe::OpenOptions::new() -+ .read_write(true) -+ .open_receiver(&fifo)?; -+ -+ write_and_close(&fifo, DATA).await?; -+ let ev = reader.ready(Interest::READABLE).await?; -+ let mut read_data = vec![0; DATA.len()]; -+ reader.read_exact(&mut read_data).await?; -+ -+ // Check that reader didn't hit EOF. -+ assert!(!ev.is_read_closed()); -+ -+ // Resilient reader can asynchronously wait for the next writer. -+ let mut second_read_fut = task::spawn(reader.read_exact(&mut read_data)); -+ assert_pending!(second_read_fut.poll()); -+ -+ // Write more data and read again. -+ write_and_close(&fifo, DATA).await?; -+ assert_ok!(second_read_fut.await); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+async fn open_detects_not_a_fifo() -> io::Result<()> { -+ let dir = tempfile::Builder::new() -+ .prefix("tokio-fifo-tests") -+ .tempdir() -+ .unwrap(); -+ let path = dir.path().join("not_a_fifo"); -+ -+ // Create an ordinary file. -+ File::create(&path)?; -+ -+ // Check if Sender detects invalid file type. -+ let err = assert_err!(pipe::OpenOptions::new().open_sender(&path)); -+ assert_eq!(err.kind(), io::ErrorKind::InvalidInput); -+ -+ // Check if Receiver detects invalid file type. -+ let err = assert_err!(pipe::OpenOptions::new().open_sender(&path)); -+ assert_eq!(err.kind(), io::ErrorKind::InvalidInput); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+async fn from_file() -> io::Result<()> { -+ const DATA: &[u8] = b"this is some data to write to the fifo"; -+ -+ let fifo = TempFifo::new("from_file")?; -+ -+ // Construct a Receiver from a File. -+ let file = std::fs::OpenOptions::new() -+ .read(true) -+ .custom_flags(libc::O_NONBLOCK) -+ .open(&fifo)?; -+ let mut reader = pipe::Receiver::from_file(file)?; -+ -+ // Construct a Sender from a File. -+ let file = std::fs::OpenOptions::new() -+ .write(true) -+ .custom_flags(libc::O_NONBLOCK) -+ .open(&fifo)?; -+ let mut writer = pipe::Sender::from_file(file)?; -+ -+ // Write and read some data to test async. -+ let mut read_fut = task::spawn(async move { -+ let mut buf = vec![0; DATA.len()]; -+ reader.read_exact(&mut buf).await?; -+ Ok::<_, io::Error>(buf) -+ }); -+ assert_pending!(read_fut.poll()); -+ -+ writer.write_all(DATA).await?; -+ -+ let read_data = assert_ok!(read_fut.await); -+ assert_eq!(&read_data, DATA); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+async fn from_file_detects_not_a_fifo() -> io::Result<()> { -+ let dir = tempfile::Builder::new() -+ .prefix("tokio-fifo-tests") -+ .tempdir() -+ .unwrap(); -+ let path = dir.path().join("not_a_fifo"); -+ -+ // Create an ordinary file. -+ File::create(&path)?; -+ -+ // Check if Sender detects invalid file type. -+ let file = std::fs::OpenOptions::new().write(true).open(&path)?; -+ let err = assert_err!(pipe::Sender::from_file(file)); -+ assert_eq!(err.kind(), io::ErrorKind::InvalidInput); -+ -+ // Check if Receiver detects invalid file type. -+ let file = std::fs::OpenOptions::new().read(true).open(&path)?; -+ let err = assert_err!(pipe::Receiver::from_file(file)); -+ assert_eq!(err.kind(), io::ErrorKind::InvalidInput); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+async fn from_file_detects_wrong_access_mode() -> io::Result<()> { -+ let fifo = TempFifo::new("wrong_access_mode")?; -+ -+ // Open a read end to open the fifo for writing. -+ let _reader = pipe::OpenOptions::new().open_receiver(&fifo)?; -+ -+ // Check if Receiver detects write-only access mode. -+ let wronly = std::fs::OpenOptions::new() -+ .write(true) -+ .custom_flags(libc::O_NONBLOCK) -+ .open(&fifo)?; -+ let err = assert_err!(pipe::Receiver::from_file(wronly)); -+ assert_eq!(err.kind(), io::ErrorKind::InvalidInput); -+ -+ // Check if Sender detects read-only access mode. -+ let rdonly = std::fs::OpenOptions::new() -+ .read(true) -+ .custom_flags(libc::O_NONBLOCK) -+ .open(&fifo)?; -+ let err = assert_err!(pipe::Sender::from_file(rdonly)); -+ assert_eq!(err.kind(), io::ErrorKind::InvalidInput); -+ -+ Ok(()) -+} -+ -+fn is_nonblocking(fd: &T) -> io::Result { -+ let flags = nix::fcntl::fcntl(fd.as_raw_fd(), nix::fcntl::F_GETFL)?; -+ Ok((flags & libc::O_NONBLOCK) != 0) -+} -+ -+#[tokio::test] -+async fn from_file_sets_nonblock() -> io::Result<()> { -+ let fifo = TempFifo::new("sets_nonblock")?; -+ -+ // Open read and write ends to let blocking files open. -+ let _reader = pipe::OpenOptions::new().open_receiver(&fifo)?; -+ let _writer = pipe::OpenOptions::new().open_sender(&fifo)?; -+ -+ // Check if Receiver sets the pipe in non-blocking mode. -+ let rdonly = std::fs::OpenOptions::new().read(true).open(&fifo)?; -+ assert!(!is_nonblocking(&rdonly)?); -+ let reader = pipe::Receiver::from_file(rdonly)?; -+ assert!(is_nonblocking(&reader)?); -+ -+ // Check if Sender sets the pipe in non-blocking mode. -+ let wronly = std::fs::OpenOptions::new().write(true).open(&fifo)?; -+ assert!(!is_nonblocking(&wronly)?); -+ let writer = pipe::Sender::from_file(wronly)?; -+ assert!(is_nonblocking(&writer)?); -+ -+ Ok(()) -+} -+ -+fn writable_by_poll(writer: &pipe::Sender) -> bool { -+ task::spawn(writer.writable()).poll().is_ready() -+} -+ -+#[tokio::test] -+async fn try_read_write() -> io::Result<()> { -+ const DATA: &[u8] = b"this is some data to write to the fifo"; -+ -+ // Create a pipe pair over a fifo file. -+ let fifo = TempFifo::new("try_read_write")?; -+ let reader = pipe::OpenOptions::new().open_receiver(&fifo)?; -+ let writer = pipe::OpenOptions::new().open_sender(&fifo)?; -+ -+ // Fill the pipe buffer with `try_write`. -+ let mut write_data = Vec::new(); -+ while writable_by_poll(&writer) { -+ match writer.try_write(DATA) { -+ Ok(n) => write_data.extend(&DATA[..n]), -+ Err(e) => { -+ assert_eq!(e.kind(), io::ErrorKind::WouldBlock); -+ break; -+ } -+ } -+ } -+ -+ // Drain the pipe buffer with `try_read`. -+ let mut read_data = vec![0; write_data.len()]; -+ let mut i = 0; -+ while i < write_data.len() { -+ reader.readable().await?; -+ match reader.try_read(&mut read_data[i..]) { -+ Ok(n) => i += n, -+ Err(e) => { -+ assert_eq!(e.kind(), io::ErrorKind::WouldBlock); -+ continue; -+ } -+ } -+ } -+ -+ assert_eq!(read_data, write_data); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+async fn try_read_write_vectored() -> io::Result<()> { -+ const DATA: &[u8] = b"this is some data to write to the fifo"; -+ -+ // Create a pipe pair over a fifo file. -+ let fifo = TempFifo::new("try_read_write_vectored")?; -+ let reader = pipe::OpenOptions::new().open_receiver(&fifo)?; -+ let writer = pipe::OpenOptions::new().open_sender(&fifo)?; -+ -+ let write_bufs: Vec<_> = DATA.chunks(3).map(io::IoSlice::new).collect(); -+ -+ // Fill the pipe buffer with `try_write_vectored`. -+ let mut write_data = Vec::new(); -+ while writable_by_poll(&writer) { -+ match writer.try_write_vectored(&write_bufs) { -+ Ok(n) => write_data.extend(&DATA[..n]), -+ Err(e) => { -+ assert_eq!(e.kind(), io::ErrorKind::WouldBlock); -+ break; -+ } -+ } -+ } -+ -+ // Drain the pipe buffer with `try_read_vectored`. -+ let mut read_data = vec![0; write_data.len()]; -+ let mut i = 0; -+ while i < write_data.len() { -+ reader.readable().await?; -+ -+ let mut read_bufs: Vec<_> = read_data[i..] -+ .chunks_mut(0x10000) -+ .map(io::IoSliceMut::new) -+ .collect(); -+ match reader.try_read_vectored(&mut read_bufs) { -+ Ok(n) => i += n, -+ Err(e) => { -+ assert_eq!(e.kind(), io::ErrorKind::WouldBlock); -+ continue; -+ } -+ } -+ } -+ -+ assert_eq!(read_data, write_data); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+async fn try_read_buf() -> std::io::Result<()> { -+ const DATA: &[u8] = b"this is some data to write to the fifo"; -+ -+ // Create a pipe pair over a fifo file. -+ let fifo = TempFifo::new("try_read_write_vectored")?; -+ let reader = pipe::OpenOptions::new().open_receiver(&fifo)?; -+ let writer = pipe::OpenOptions::new().open_sender(&fifo)?; -+ -+ // Fill the pipe buffer with `try_write`. -+ let mut write_data = Vec::new(); -+ while writable_by_poll(&writer) { -+ match writer.try_write(DATA) { -+ Ok(n) => write_data.extend(&DATA[..n]), -+ Err(e) => { -+ assert_eq!(e.kind(), io::ErrorKind::WouldBlock); -+ break; -+ } -+ } -+ } -+ -+ // Drain the pipe buffer with `try_read_buf`. -+ let mut read_data = vec![0; write_data.len()]; -+ let mut i = 0; -+ while i < write_data.len() { -+ reader.readable().await?; -+ match reader.try_read_buf(&mut read_data) { -+ Ok(n) => i += n, -+ Err(e) => { -+ assert_eq!(e.kind(), io::ErrorKind::WouldBlock); -+ continue; -+ } -+ } -+ } -+ -+ assert_eq!(read_data, write_data); -+ -+ Ok(()) -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/no_rt.rs b/KubeOS-Rust/vendor/tokio/tests/no_rt.rs -index 6845850a..747fab6a 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/no_rt.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/no_rt.rs -@@ -1,3 +1,5 @@ -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support panic recovery -+ - use tokio::net::TcpStream; - use tokio::sync::oneshot; - use tokio::time::{timeout, Duration}; -diff --git a/KubeOS-Rust/vendor/tokio/tests/process_kill_on_drop.rs b/KubeOS-Rust/vendor/tokio/tests/process_kill_on_drop.rs -index 658e4add..d919b1a2 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/process_kill_on_drop.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/process_kill_on_drop.rs -@@ -12,7 +12,7 @@ use tokio_test::assert_ok; - #[tokio::test] - async fn kill_on_drop() { - let mut cmd = Command::new("bash"); -- cmd.args(&[ -+ cmd.args([ - "-c", - " - # Fork another child that won't get killed -diff --git a/KubeOS-Rust/vendor/tokio/tests/process_raw_handle.rs b/KubeOS-Rust/vendor/tokio/tests/process_raw_handle.rs -index 727e66d6..fbe22b07 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/process_raw_handle.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/process_raw_handle.rs -@@ -3,7 +3,7 @@ - #![cfg(windows)] - - use tokio::process::Command; --use winapi::um::processthreadsapi::GetProcessId; -+use windows_sys::Win32::System::Threading::GetProcessId; - - #[tokio::test] - async fn obtain_raw_handle() { -diff --git a/KubeOS-Rust/vendor/tokio/tests/process_smoke.rs b/KubeOS-Rust/vendor/tokio/tests/process_smoke.rs -index fae5793f..81d2020a 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/process_smoke.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/process_smoke.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi cannot run system commands - - use tokio::process::Command; - use tokio_test::assert_ok; -diff --git a/KubeOS-Rust/vendor/tokio/tests/rt_basic.rs b/KubeOS-Rust/vendor/tokio/tests/rt_basic.rs -index 70056b16..6caf0a44 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/rt_basic.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/rt_basic.rs -@@ -16,6 +16,15 @@ mod support { - pub(crate) mod mpsc_stream; - } - -+macro_rules! cfg_metrics { -+ ($($t:tt)*) => { -+ #[cfg(tokio_unstable)] -+ { -+ $( $t )* -+ } -+ } -+} -+ - #[test] - fn spawned_task_does_not_progress_without_block_on() { - let (tx, mut rx) = oneshot::channel(); -@@ -169,6 +178,105 @@ fn drop_tasks_in_context() { - } - - #[test] -+#[cfg_attr(tokio_wasi, ignore = "Wasi does not support panic recovery")] -+#[should_panic(expected = "boom")] -+fn wake_in_drop_after_panic() { -+ let (tx, rx) = oneshot::channel::<()>(); -+ -+ struct WakeOnDrop(Option>); -+ -+ impl Drop for WakeOnDrop { -+ fn drop(&mut self) { -+ self.0.take().unwrap().send(()).unwrap(); -+ } -+ } -+ -+ let rt = rt(); -+ -+ rt.spawn(async move { -+ let _wake_on_drop = WakeOnDrop(Some(tx)); -+ // wait forever -+ futures::future::pending::<()>().await; -+ }); -+ -+ let _join = rt.spawn(async move { rx.await }); -+ -+ rt.block_on(async { -+ tokio::task::yield_now().await; -+ panic!("boom"); -+ }); -+} -+ -+#[test] -+fn spawn_two() { -+ let rt = rt(); -+ -+ let out = rt.block_on(async { -+ let (tx, rx) = oneshot::channel(); -+ -+ tokio::spawn(async move { -+ tokio::spawn(async move { -+ tx.send("ZOMG").unwrap(); -+ }); -+ }); -+ -+ assert_ok!(rx.await) -+ }); -+ -+ assert_eq!(out, "ZOMG"); -+ -+ cfg_metrics! { -+ let metrics = rt.metrics(); -+ drop(rt); -+ assert_eq!(0, metrics.remote_schedule_count()); -+ -+ let mut local = 0; -+ for i in 0..metrics.num_workers() { -+ local += metrics.worker_local_schedule_count(i); -+ } -+ -+ assert_eq!(2, local); -+ } -+} -+ -+#[cfg_attr(tokio_wasi, ignore = "WASI: std::thread::spawn not supported")] -+#[test] -+fn spawn_remote() { -+ let rt = rt(); -+ -+ let out = rt.block_on(async { -+ let (tx, rx) = oneshot::channel(); -+ -+ let handle = tokio::spawn(async move { -+ std::thread::spawn(move || { -+ std::thread::sleep(Duration::from_millis(10)); -+ tx.send("ZOMG").unwrap(); -+ }); -+ -+ rx.await.unwrap() -+ }); -+ -+ handle.await.unwrap() -+ }); -+ -+ assert_eq!(out, "ZOMG"); -+ -+ cfg_metrics! { -+ let metrics = rt.metrics(); -+ drop(rt); -+ assert_eq!(1, metrics.remote_schedule_count()); -+ -+ let mut local = 0; -+ for i in 0..metrics.num_workers() { -+ local += metrics.worker_local_schedule_count(i); -+ } -+ -+ assert_eq!(1, local); -+ } -+} -+ -+#[test] -+#[cfg_attr(tokio_wasi, ignore = "Wasi does not support panic recovery")] - #[should_panic( - expected = "A Tokio 1.x context was found, but timers are disabled. Call `enable_time` on the runtime builder to enable timers." - )] -@@ -183,6 +291,155 @@ fn timeout_panics_when_no_time_handle() { - }); - } - -+#[cfg(tokio_unstable)] -+mod unstable { -+ use tokio::runtime::{Builder, RngSeed, UnhandledPanic}; -+ -+ #[test] -+ #[should_panic( -+ expected = "a spawned task panicked and the runtime is configured to shut down on unhandled panic" -+ )] -+ fn shutdown_on_panic() { -+ let rt = Builder::new_current_thread() -+ .unhandled_panic(UnhandledPanic::ShutdownRuntime) -+ .build() -+ .unwrap(); -+ -+ rt.block_on(async { -+ tokio::spawn(async { -+ panic!("boom"); -+ }); -+ -+ futures::future::pending::<()>().await; -+ }) -+ } -+ -+ #[test] -+ #[cfg_attr(tokio_wasi, ignore = "Wasi does not support panic recovery")] -+ fn spawns_do_nothing() { -+ use std::sync::Arc; -+ -+ let rt = Builder::new_current_thread() -+ .unhandled_panic(UnhandledPanic::ShutdownRuntime) -+ .build() -+ .unwrap(); -+ -+ let rt1 = Arc::new(rt); -+ let rt2 = rt1.clone(); -+ -+ let _ = std::thread::spawn(move || { -+ rt2.block_on(async { -+ tokio::spawn(async { -+ panic!("boom"); -+ }); -+ -+ futures::future::pending::<()>().await; -+ }) -+ }) -+ .join(); -+ -+ let task = rt1.spawn(async {}); -+ let res = futures::executor::block_on(task); -+ assert!(res.is_err()); -+ } -+ -+ #[test] -+ #[cfg_attr(tokio_wasi, ignore = "Wasi does not support panic recovery")] -+ fn shutdown_all_concurrent_block_on() { -+ const N: usize = 2; -+ use std::sync::{mpsc, Arc}; -+ -+ let rt = Builder::new_current_thread() -+ .unhandled_panic(UnhandledPanic::ShutdownRuntime) -+ .build() -+ .unwrap(); -+ -+ let rt = Arc::new(rt); -+ let mut ths = vec![]; -+ let (tx, rx) = mpsc::channel(); -+ -+ for _ in 0..N { -+ let rt = rt.clone(); -+ let tx = tx.clone(); -+ ths.push(std::thread::spawn(move || { -+ rt.block_on(async { -+ tx.send(()).unwrap(); -+ futures::future::pending::<()>().await; -+ }); -+ })); -+ } -+ -+ for _ in 0..N { -+ rx.recv().unwrap(); -+ } -+ -+ rt.spawn(async { -+ panic!("boom"); -+ }); -+ -+ for th in ths { -+ assert!(th.join().is_err()); -+ } -+ } -+ -+ #[test] -+ fn rng_seed() { -+ let seed = b"bytes used to generate seed"; -+ let rt1 = tokio::runtime::Builder::new_current_thread() -+ .rng_seed(RngSeed::from_bytes(seed)) -+ .build() -+ .unwrap(); -+ let rt1_values = rt1.block_on(async { -+ let rand_1 = tokio::macros::support::thread_rng_n(100); -+ let rand_2 = tokio::macros::support::thread_rng_n(100); -+ -+ (rand_1, rand_2) -+ }); -+ -+ let rt2 = tokio::runtime::Builder::new_current_thread() -+ .rng_seed(RngSeed::from_bytes(seed)) -+ .build() -+ .unwrap(); -+ let rt2_values = rt2.block_on(async { -+ let rand_1 = tokio::macros::support::thread_rng_n(100); -+ let rand_2 = tokio::macros::support::thread_rng_n(100); -+ -+ (rand_1, rand_2) -+ }); -+ -+ assert_eq!(rt1_values, rt2_values); -+ } -+ -+ #[test] -+ fn rng_seed_multi_enter() { -+ let seed = b"bytes used to generate seed"; -+ -+ fn two_rand_values() -> (u32, u32) { -+ let rand_1 = tokio::macros::support::thread_rng_n(100); -+ let rand_2 = tokio::macros::support::thread_rng_n(100); -+ -+ (rand_1, rand_2) -+ } -+ -+ let rt1 = tokio::runtime::Builder::new_current_thread() -+ .rng_seed(RngSeed::from_bytes(seed)) -+ .build() -+ .unwrap(); -+ let rt1_values_1 = rt1.block_on(async { two_rand_values() }); -+ let rt1_values_2 = rt1.block_on(async { two_rand_values() }); -+ -+ let rt2 = tokio::runtime::Builder::new_current_thread() -+ .rng_seed(RngSeed::from_bytes(seed)) -+ .build() -+ .unwrap(); -+ let rt2_values_1 = rt2.block_on(async { two_rand_values() }); -+ let rt2_values_2 = rt2.block_on(async { two_rand_values() }); -+ -+ assert_eq!(rt1_values_1, rt2_values_1); -+ assert_eq!(rt1_values_2, rt2_values_2); -+ } -+} -+ - fn rt() -> Runtime { - tokio::runtime::Builder::new_current_thread() - .enable_all() -diff --git a/KubeOS-Rust/vendor/tokio/tests/rt_common.rs b/KubeOS-Rust/vendor/tokio/tests/rt_common.rs -index cb1d0f66..039e27e9 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/rt_common.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/rt_common.rs -@@ -2,13 +2,16 @@ - #![warn(rust_2018_idioms)] - #![cfg(feature = "full")] - --// Tests to run on both current-thread & thread-pool runtime variants. -+// Tests to run on both current-thread & multi-thread runtime variants. - - macro_rules! rt_test { - ($($t:tt)*) => { - mod current_thread_scheduler { - $($t)* - -+ #[cfg(not(target_os="wasi"))] -+ const NUM_WORKERS: usize = 1; -+ - fn rt() -> Arc { - tokio::runtime::Builder::new_current_thread() - .enable_all() -@@ -18,9 +21,12 @@ macro_rules! rt_test { - } - } - -+ #[cfg(not(tokio_wasi))] // Wasi doesn't support threads - mod threaded_scheduler_4_threads { - $($t)* - -+ const NUM_WORKERS: usize = 4; -+ - fn rt() -> Arc { - tokio::runtime::Builder::new_multi_thread() - .worker_threads(4) -@@ -31,9 +37,12 @@ macro_rules! rt_test { - } - } - -+ #[cfg(not(tokio_wasi))] // Wasi doesn't support threads - mod threaded_scheduler_1_thread { - $($t)* - -+ const NUM_WORKERS: usize = 1; -+ - fn rt() -> Arc { - tokio::runtime::Builder::new_multi_thread() - .worker_threads(1) -@@ -55,18 +64,30 @@ fn send_sync_bound() { - } - - rt_test! { -- use tokio::net::{TcpListener, TcpStream, UdpSocket}; -+ #[cfg(not(target_os="wasi"))] -+ use tokio::net::{TcpListener, TcpStream}; -+ #[cfg(not(target_os="wasi"))] - use tokio::io::{AsyncReadExt, AsyncWriteExt}; -+ - use tokio::runtime::Runtime; - use tokio::sync::oneshot; - use tokio::{task, time}; -- use tokio_test::{assert_err, assert_ok}; -+ -+ #[cfg(not(target_os="wasi"))] -+ use tokio_test::assert_err; -+ use tokio_test::assert_ok; - - use futures::future::poll_fn; - use std::future::Future; - use std::pin::Pin; -- use std::sync::{mpsc, Arc}; -+ -+ #[cfg(not(target_os="wasi"))] -+ use std::sync::mpsc; -+ -+ use std::sync::Arc; - use std::task::{Context, Poll}; -+ -+ #[cfg(not(target_os="wasi"))] - use std::thread; - use std::time::{Duration, Instant}; - -@@ -83,6 +104,7 @@ rt_test! { - } - - -+ #[cfg(not(target_os="wasi"))] - #[test] - fn block_on_async() { - let rt = rt(); -@@ -164,6 +186,7 @@ rt_test! { - assert_eq!(out, "ZOMG"); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn spawn_many_from_block_on() { - use tokio::sync::mpsc; -@@ -214,6 +237,7 @@ rt_test! { - } - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn spawn_many_from_task() { - use tokio::sync::mpsc; -@@ -226,14 +250,6 @@ rt_test! { - tokio::spawn(async move { - let (done_tx, mut done_rx) = mpsc::unbounded_channel(); - -- /* -- for _ in 0..100 { -- tokio::spawn(async move { }); -- } -- -- tokio::task::yield_now().await; -- */ -- - let mut txs = (0..ITER) - .map(|i| { - let (tx, rx) = oneshot::channel(); -@@ -274,6 +290,31 @@ rt_test! { - } - } - -+ #[test] -+ fn spawn_one_from_block_on_called_on_handle() { -+ let rt = rt(); -+ let (tx, rx) = oneshot::channel(); -+ -+ #[allow(clippy::async_yields_async)] -+ let handle = rt.handle().block_on(async { -+ tokio::spawn(async move { -+ tx.send("ZOMG").unwrap(); -+ "DONE" -+ }) -+ }); -+ -+ let out = rt.block_on(async { -+ let msg = assert_ok!(rx.await); -+ -+ let out = assert_ok!(handle.await); -+ assert_eq!(out, "DONE"); -+ -+ msg -+ }); -+ -+ assert_eq!(out, "ZOMG"); -+ } -+ - #[test] - fn spawn_await_chain() { - let rt = rt(); -@@ -329,6 +370,7 @@ rt_test! { - assert_eq!(out, "ZOMG"); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn complete_block_on_under_load() { - let rt = rt(); -@@ -352,6 +394,7 @@ rt_test! { - }); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn complete_task_under_load() { - let rt = rt(); -@@ -381,6 +424,7 @@ rt_test! { - }); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn spawn_from_other_thread_idle() { - let rt = rt(); -@@ -401,6 +445,7 @@ rt_test! { - }); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn spawn_from_other_thread_under_load() { - let rt = rt(); -@@ -461,6 +506,7 @@ rt_test! { - assert!(now.elapsed() >= dur); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support bind - #[test] - fn block_on_socket() { - let rt = rt(); -@@ -481,6 +527,7 @@ rt_test! { - }); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn spawn_from_blocking() { - let rt = rt(); -@@ -496,6 +543,7 @@ rt_test! { - assert_eq!(out, "hello") - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn spawn_blocking_from_blocking() { - let rt = rt(); -@@ -511,6 +559,7 @@ rt_test! { - assert_eq!(out, "hello") - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn sleep_from_blocking() { - let rt = rt(); -@@ -531,6 +580,7 @@ rt_test! { - }); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support bind - #[test] - fn socket_from_blocking() { - let rt = rt(); -@@ -554,6 +604,7 @@ rt_test! { - }); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn always_active_parker() { - // This test it to show that we will always have -@@ -600,6 +651,7 @@ rt_test! { - // concern. There also isn't a great/obvious solution to take. For now, the - // test is disabled. - #[cfg(not(windows))] -+ #[cfg(not(target_os="wasi"))] // Wasi does not support bind or threads - fn io_driver_called_when_under_load() { - let rt = rt(); - -@@ -607,7 +659,12 @@ rt_test! { - for _ in 0..100 { - rt.spawn(async { - loop { -- tokio::task::yield_now().await; -+ // Don't use Tokio's `yield_now()` to avoid special defer -+ // logic. -+ futures::future::poll_fn::<(), _>(|cx| { -+ cx.waker().wake_by_ref(); -+ std::task::Poll::Pending -+ }).await; - } - }); - } -@@ -635,6 +692,113 @@ rt_test! { - }); - } - -+ /// Tests that yielded tasks are not scheduled until **after** resource -+ /// drivers are polled. -+ /// -+ /// The OS does not guarantee when I/O events are delivered, so there may be -+ /// more yields than anticipated. This makes the test slightly flaky. To -+ /// help avoid flakiness, we run the test 10 times and only fail it after -+ /// 10 failures in a row. -+ /// -+ /// Note that if the test fails by panicking rather than by returning false, -+ /// then we fail it immediately. That kind of failure should not happen -+ /// spuriously. -+ #[test] -+ #[cfg(not(target_os="wasi"))] -+ fn yield_defers_until_park() { -+ for _ in 0..10 { -+ if yield_defers_until_park_inner() { -+ // test passed -+ return; -+ } -+ -+ // Wait a bit and run the test again. -+ std::thread::sleep(std::time::Duration::from_secs(2)); -+ } -+ -+ panic!("yield_defers_until_park is failing consistently"); -+ } -+ -+ /// Implementation of `yield_defers_until_park` test. Returns `true` if the -+ /// test passed. -+ #[cfg(not(target_os="wasi"))] -+ fn yield_defers_until_park_inner() -> bool { -+ use std::sync::atomic::{AtomicBool, Ordering::SeqCst}; -+ use std::sync::Barrier; -+ -+ let rt = rt(); -+ -+ let flag = Arc::new(AtomicBool::new(false)); -+ let barrier = Arc::new(Barrier::new(NUM_WORKERS)); -+ -+ rt.block_on(async { -+ // Make sure other workers cannot steal tasks -+ #[allow(clippy::reversed_empty_ranges)] -+ for _ in 0..(NUM_WORKERS-1) { -+ let flag = flag.clone(); -+ let barrier = barrier.clone(); -+ -+ tokio::spawn(async move { -+ barrier.wait(); -+ -+ while !flag.load(SeqCst) { -+ std::thread::sleep(std::time::Duration::from_millis(1)); -+ } -+ }); -+ } -+ -+ barrier.wait(); -+ -+ let (fail_test, fail_test_recv) = oneshot::channel::<()>(); -+ -+ let jh = tokio::spawn(async move { -+ // Create a TCP litener -+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); -+ let addr = listener.local_addr().unwrap(); -+ -+ tokio::join!( -+ async { -+ // Done in a blocking manner intentionally. -+ let _socket = std::net::TcpStream::connect(addr).unwrap(); -+ -+ // Yield until connected -+ let mut cnt = 0; -+ while !flag.load(SeqCst){ -+ tokio::task::yield_now().await; -+ cnt += 1; -+ -+ if cnt >= 10 { -+ // yielded too many times; report failure and -+ // sleep forever so that the `fail_test` branch -+ // of the `select!` below triggers. -+ let _ = fail_test.send(()); -+ futures::future::pending::<()>().await; -+ break; -+ } -+ } -+ }, -+ async { -+ let _ = listener.accept().await.unwrap(); -+ flag.store(true, SeqCst); -+ } -+ ); -+ }); -+ -+ // Wait until the spawned task completes or fails. If no message is -+ // sent on `fail_test`, then the test succeeds. Otherwise, it fails. -+ let success = fail_test_recv.await.is_err(); -+ -+ if success { -+ // Check for panics in spawned task. -+ jh.abort(); -+ jh.await.unwrap(); -+ } -+ -+ success -+ }) -+ } -+ -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn client_server_block_on() { - let rt = rt(); -@@ -646,6 +810,7 @@ rt_test! { - assert_err!(rx.try_recv()); - } - -+ #[cfg_attr(tokio_wasi, ignore = "Wasi does not support threads or panic recovery")] - #[test] - fn panic_in_task() { - let rt = rt(); -@@ -674,11 +839,13 @@ rt_test! { - - #[test] - #[should_panic] -+ #[cfg_attr(tokio_wasi, ignore = "Wasi does not support panic recovery")] - fn panic_in_block_on() { - let rt = rt(); - rt.block_on(async { panic!() }); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - async fn yield_once() { - let mut yielded = false; - poll_fn(|cx| { -@@ -748,7 +915,11 @@ rt_test! { - - #[test] - fn wake_while_rt_is_dropping() { -- use tokio::task; -+ use tokio::sync::Barrier; -+ use core::sync::atomic::{AtomicBool, Ordering}; -+ -+ let drop_triggered = Arc::new(AtomicBool::new(false)); -+ let set_drop_triggered = drop_triggered.clone(); - - struct OnDrop(F); - -@@ -762,17 +933,21 @@ rt_test! { - let (tx2, rx2) = oneshot::channel(); - let (tx3, rx3) = oneshot::channel(); - -- let rt = rt(); -+ let barrier = Arc::new(Barrier::new(4)); -+ let barrier1 = barrier.clone(); -+ let barrier2 = barrier.clone(); -+ let barrier3 = barrier.clone(); - -- let h1 = rt.clone(); -+ let rt = rt(); - - rt.spawn(async move { - // Ensure a waker gets stored in oneshot 1. -- let _ = rx1.await; -+ let _ = tokio::join!(rx1, barrier1.wait()); - tx3.send(()).unwrap(); - }); - - rt.spawn(async move { -+ let h1 = tokio::runtime::Handle::current(); - // When this task is dropped, we'll be "closing remotes". - // We spawn a new task that owns the `tx1`, to move its Drop - // out of here. -@@ -785,36 +960,40 @@ rt_test! { - h1.spawn(async move { - tx1.send(()).unwrap(); - }); -+ // Just a sanity check that this entire thing actually happened -+ set_drop_triggered.store(true, Ordering::Relaxed); - }); -- let _ = rx2.await; -+ let _ = tokio::join!(rx2, barrier2.wait()); - }); - - rt.spawn(async move { -- let _ = rx3.await; -+ let _ = tokio::join!(rx3, barrier3.wait()); - // We'll never get here, but once task 3 drops, this will - // force task 2 to re-schedule since it's waiting on oneshot 2. - tx2.send(()).unwrap(); - }); - -- // Tick the loop -- rt.block_on(async { -- task::yield_now().await; -- }); -+ // Wait until every oneshot channel has been polled. -+ rt.block_on(barrier.wait()); - - // Drop the rt - drop(rt); -+ -+ // Make sure that the spawn actually happened -+ assert!(drop_triggered.load(Ordering::Relaxed)); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi doesn't support UDP or bind() - #[test] - fn io_notify_while_shutting_down() { -- use std::net::Ipv6Addr; -+ use tokio::net::UdpSocket; - use std::sync::Arc; - - for _ in 1..10 { - let runtime = rt(); - - runtime.block_on(async { -- let socket = UdpSocket::bind((Ipv6Addr::LOCALHOST, 0)).await.unwrap(); -+ let socket = UdpSocket::bind("127.0.0.1:0").await.unwrap(); - let addr = socket.local_addr().unwrap(); - let send_half = Arc::new(socket); - let recv_half = send_half.clone(); -@@ -840,6 +1019,7 @@ rt_test! { - } - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn shutdown_timeout() { - let (tx, rx) = oneshot::channel(); -@@ -857,6 +1037,7 @@ rt_test! { - Arc::try_unwrap(runtime).unwrap().shutdown_timeout(Duration::from_millis(100)); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support threads - #[test] - fn shutdown_timeout_0() { - let runtime = rt(); -@@ -888,6 +1069,7 @@ rt_test! { - // See https://github.com/rust-lang/rust/issues/74875 - #[test] - #[cfg(not(windows))] -+ #[cfg_attr(tokio_wasi, ignore = "Wasi does not support threads")] - fn runtime_in_thread_local() { - use std::cell::RefCell; - use std::thread; -@@ -907,6 +1089,7 @@ rt_test! { - }).join().unwrap(); - } - -+ #[cfg(not(target_os="wasi"))] // Wasi does not support bind - async fn client_server(tx: mpsc::Sender<()>) { - let server = assert_ok!(TcpListener::bind("127.0.0.1:0").await); - -@@ -931,6 +1114,7 @@ rt_test! { - tx.send(()).unwrap(); - } - -+ #[cfg(not(tokio_wasi))] // Wasi does not support bind - #[test] - fn local_set_block_on_socket() { - let rt = rt(); -@@ -952,6 +1136,7 @@ rt_test! { - }); - } - -+ #[cfg(not(tokio_wasi))] // Wasi does not support bind - #[test] - fn local_set_client_server_block_on() { - let rt = rt(); -@@ -965,6 +1150,7 @@ rt_test! { - assert_err!(rx.try_recv()); - } - -+ #[cfg(not(tokio_wasi))] // Wasi does not support bind - async fn client_server_local(tx: mpsc::Sender<()>) { - let server = assert_ok!(TcpListener::bind("127.0.0.1:0").await); - -@@ -992,22 +1178,22 @@ rt_test! { - #[test] - fn coop() { - use std::task::Poll::Ready; -+ use tokio::sync::mpsc; - - let rt = rt(); - - rt.block_on(async { -- // Create a bunch of tasks -- let mut tasks = (0..1_000).map(|_| { -- tokio::spawn(async { }) -- }).collect::>(); -+ let (send, mut recv) = mpsc::unbounded_channel(); - -- // Hope that all the tasks complete... -- time::sleep(Duration::from_millis(100)).await; -+ // Send a bunch of messages. -+ for _ in 0..1_000 { -+ send.send(()).unwrap(); -+ } - - poll_fn(|cx| { -- // At least one task should not be ready -- for task in &mut tasks { -- if Pin::new(task).poll(cx).is_pending() { -+ // At least one response should return pending. -+ for _ in 0..1_000 { -+ if recv.poll_recv(cx).is_pending() { - return Ready(()); - } - } -@@ -1020,22 +1206,22 @@ rt_test! { - #[test] - fn coop_unconstrained() { - use std::task::Poll::Ready; -+ use tokio::sync::mpsc; - - let rt = rt(); - - rt.block_on(async { -- // Create a bunch of tasks -- let mut tasks = (0..1_000).map(|_| { -- tokio::spawn(async { }) -- }).collect::>(); -+ let (send, mut recv) = mpsc::unbounded_channel(); - -- // Hope that all the tasks complete... -- time::sleep(Duration::from_millis(100)).await; -+ // Send a bunch of messages. -+ for _ in 0..1_000 { -+ send.send(()).unwrap(); -+ } - - tokio::task::unconstrained(poll_fn(|cx| { -- // All the tasks should be ready -- for task in &mut tasks { -- assert!(Pin::new(task).poll(cx).is_ready()); -+ // All the responses should be ready. -+ for _ in 0..1_000 { -+ assert_eq!(recv.poll_recv(cx), Poll::Ready(Some(()))); - } - - Ready(()) -@@ -1043,6 +1229,31 @@ rt_test! { - }); - } - -+ #[cfg(tokio_unstable)] -+ #[test] -+ fn coop_consume_budget() { -+ let rt = rt(); -+ -+ rt.block_on(async { -+ poll_fn(|cx| { -+ let counter = Arc::new(std::sync::Mutex::new(0)); -+ let counter_clone = Arc::clone(&counter); -+ let mut worker = Box::pin(async move { -+ // Consume the budget until a yield happens -+ for _ in 0..1000 { -+ *counter.lock().unwrap() += 1; -+ task::consume_budget().await -+ } -+ }); -+ // Assert that the worker was yielded and it didn't manage -+ // to finish the whole work (assuming the total budget of 128) -+ assert!(Pin::new(&mut worker).poll(cx).is_pending()); -+ assert!(*counter_clone.lock().unwrap() < 1000); -+ std::task::Poll::Ready(()) -+ }).await; -+ }); -+ } -+ - // Tests that the "next task" scheduler optimization is not able to starve - // other tasks. - #[test] -@@ -1060,7 +1271,7 @@ rt_test! { - let (spawned_tx, mut spawned_rx) = mpsc::unbounded_channel(); - - let mut tasks = vec![]; -- // Spawn a bunch of tasks that ping ping between each other to -+ // Spawn a bunch of tasks that ping-pong between each other to - // saturate the runtime. - for _ in 0..NUM { - let (tx1, mut rx1) = mpsc::unbounded_channel(); -diff --git a/KubeOS-Rust/vendor/tokio/tests/rt_handle_block_on.rs b/KubeOS-Rust/vendor/tokio/tests/rt_handle_block_on.rs -index 17878c8d..5ec783e5 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/rt_handle_block_on.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/rt_handle_block_on.rs -@@ -10,9 +10,10 @@ - use std::time::Duration; - use tokio::runtime::{Handle, Runtime}; - use tokio::sync::mpsc; --use tokio::task::spawn_blocking; --use tokio::{fs, net, time}; -+#[cfg(not(tokio_wasi))] -+use tokio::{net, time}; - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - macro_rules! multi_threaded_rt_test { - ($($t:tt)*) => { - mod threaded_scheduler_4_threads_only { -@@ -45,6 +46,7 @@ macro_rules! multi_threaded_rt_test { - } - } - -+#[cfg(not(tokio_wasi))] - macro_rules! rt_test { - ($($t:tt)*) => { - mod current_thread_scheduler { -@@ -124,7 +126,9 @@ fn unbounded_mpsc_channel() { - }) - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support file operations or bind - rt_test! { -+ use tokio::fs; - // ==== spawn blocking futures ====== - - #[test] -@@ -135,7 +139,7 @@ rt_test! { - let contents = Handle::current() - .block_on(fs::read_to_string("Cargo.toml")) - .unwrap(); -- assert!(contents.contains("Cargo.toml")); -+ assert!(contents.contains("https://tokio.rs")); - } - - #[test] -@@ -156,6 +160,7 @@ rt_test! { - - #[test] - fn basic_spawn_blocking() { -+ use tokio::task::spawn_blocking; - let rt = rt(); - let _enter = rt.enter(); - -@@ -171,6 +176,7 @@ rt_test! { - - #[test] - fn spawn_blocking_after_shutdown_fails() { -+ use tokio::task::spawn_blocking; - let rt = rt(); - let _enter = rt.enter(); - rt.shutdown_timeout(Duration::from_secs(1000)); -@@ -187,6 +193,7 @@ rt_test! { - - #[test] - fn spawn_blocking_started_before_shutdown_continues() { -+ use tokio::task::spawn_blocking; - let rt = rt(); - let _enter = rt.enter(); - -@@ -412,6 +419,7 @@ rt_test! { - } - } - -+#[cfg(not(tokio_wasi))] - multi_threaded_rt_test! { - #[cfg(unix)] - #[test] -@@ -474,6 +482,7 @@ multi_threaded_rt_test! { - // ==== utils ====== - - /// Create a new multi threaded runtime -+#[cfg(not(tokio_wasi))] - fn new_multi_thread(n: usize) -> Runtime { - tokio::runtime::Builder::new_multi_thread() - .worker_threads(n) -@@ -496,37 +505,30 @@ where - F: Fn(), - { - { -- println!("current thread runtime"); -- - let rt = new_current_thread(); - let _enter = rt.enter(); - f(); - -- println!("current thread runtime after shutdown"); - rt.shutdown_timeout(Duration::from_secs(1000)); - f(); - } - -+ #[cfg(not(tokio_wasi))] - { -- println!("multi thread (1 thread) runtime"); -- - let rt = new_multi_thread(1); - let _enter = rt.enter(); - f(); - -- println!("multi thread runtime after shutdown"); - rt.shutdown_timeout(Duration::from_secs(1000)); - f(); - } - -+ #[cfg(not(tokio_wasi))] - { -- println!("multi thread (4 threads) runtime"); -- - let rt = new_multi_thread(4); - let _enter = rt.enter(); - f(); - -- println!("multi thread runtime after shutdown"); - rt.shutdown_timeout(Duration::from_secs(1000)); - f(); - } -diff --git a/KubeOS-Rust/vendor/tokio/tests/rt_metrics.rs b/KubeOS-Rust/vendor/tokio/tests/rt_metrics.rs -new file mode 100644 -index 00000000..d238808c ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/rt_metrics.rs -@@ -0,0 +1,557 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", tokio_unstable, not(tokio_wasi)))] -+ -+use std::future::Future; -+use std::sync::{Arc, Mutex}; -+use std::task::Poll; -+use tokio::macros::support::poll_fn; -+ -+use tokio::runtime::Runtime; -+use tokio::task::consume_budget; -+use tokio::time::{self, Duration}; -+ -+#[test] -+fn num_workers() { -+ let rt = current_thread(); -+ assert_eq!(1, rt.metrics().num_workers()); -+ -+ let rt = threaded(); -+ assert_eq!(2, rt.metrics().num_workers()); -+} -+ -+#[test] -+fn num_blocking_threads() { -+ let rt = current_thread(); -+ assert_eq!(0, rt.metrics().num_blocking_threads()); -+ let _ = rt.block_on(rt.spawn_blocking(move || {})); -+ assert_eq!(1, rt.metrics().num_blocking_threads()); -+} -+ -+#[test] -+fn num_idle_blocking_threads() { -+ let rt = current_thread(); -+ assert_eq!(0, rt.metrics().num_idle_blocking_threads()); -+ let _ = rt.block_on(rt.spawn_blocking(move || {})); -+ rt.block_on(async { -+ time::sleep(Duration::from_millis(5)).await; -+ }); -+ -+ // We need to wait until the blocking thread has become idle. Usually 5ms is -+ // enough for this to happen, but not always. When it isn't enough, sleep -+ // for another second. We don't always wait for a whole second since we want -+ // the test suite to finish quickly. -+ // -+ // Note that the timeout for idle threads to be killed is 10 seconds. -+ if 0 == rt.metrics().num_idle_blocking_threads() { -+ rt.block_on(async { -+ time::sleep(Duration::from_secs(1)).await; -+ }); -+ } -+ -+ assert_eq!(1, rt.metrics().num_idle_blocking_threads()); -+} -+ -+#[test] -+fn blocking_queue_depth() { -+ let rt = tokio::runtime::Builder::new_current_thread() -+ .enable_all() -+ .max_blocking_threads(1) -+ .build() -+ .unwrap(); -+ -+ assert_eq!(0, rt.metrics().blocking_queue_depth()); -+ -+ let ready = Arc::new(Mutex::new(())); -+ let guard = ready.lock().unwrap(); -+ -+ let ready_cloned = ready.clone(); -+ let wait_until_ready = move || { -+ let _unused = ready_cloned.lock().unwrap(); -+ }; -+ -+ let h1 = rt.spawn_blocking(wait_until_ready.clone()); -+ let h2 = rt.spawn_blocking(wait_until_ready); -+ assert!(rt.metrics().blocking_queue_depth() > 0); -+ -+ drop(guard); -+ -+ let _ = rt.block_on(h1); -+ let _ = rt.block_on(h2); -+ -+ assert_eq!(0, rt.metrics().blocking_queue_depth()); -+} -+ -+#[test] -+fn remote_schedule_count() { -+ use std::thread; -+ -+ let rt = current_thread(); -+ let handle = rt.handle().clone(); -+ let task = thread::spawn(move || { -+ handle.spawn(async { -+ // DO nothing -+ }) -+ }) -+ .join() -+ .unwrap(); -+ -+ rt.block_on(task).unwrap(); -+ -+ assert_eq!(1, rt.metrics().remote_schedule_count()); -+ -+ let rt = threaded(); -+ let handle = rt.handle().clone(); -+ let task = thread::spawn(move || { -+ handle.spawn(async { -+ // DO nothing -+ }) -+ }) -+ .join() -+ .unwrap(); -+ -+ rt.block_on(task).unwrap(); -+ -+ assert_eq!(1, rt.metrics().remote_schedule_count()); -+} -+ -+#[test] -+fn worker_park_count() { -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ time::sleep(Duration::from_millis(1)).await; -+ }); -+ drop(rt); -+ assert!(1 <= metrics.worker_park_count(0)); -+ -+ let rt = threaded(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ time::sleep(Duration::from_millis(1)).await; -+ }); -+ drop(rt); -+ assert!(1 <= metrics.worker_park_count(0)); -+ assert!(1 <= metrics.worker_park_count(1)); -+} -+ -+#[test] -+fn worker_noop_count() { -+ // There isn't really a great way to generate no-op parks as they happen as -+ // false-positive events under concurrency. -+ -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ time::sleep(Duration::from_millis(1)).await; -+ }); -+ drop(rt); -+ assert!(0 < metrics.worker_noop_count(0)); -+ -+ let rt = threaded(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ time::sleep(Duration::from_millis(1)).await; -+ }); -+ drop(rt); -+ assert!(0 < metrics.worker_noop_count(0)); -+ assert!(0 < metrics.worker_noop_count(1)); -+} -+ -+#[test] -+fn worker_steal_count() { -+ // This metric only applies to the multi-threaded runtime. -+ // -+ // We use a blocking channel to backup one worker thread. -+ use std::sync::mpsc::channel; -+ -+ let rt = threaded(); -+ let metrics = rt.metrics(); -+ -+ rt.block_on(async { -+ let (tx, rx) = channel(); -+ -+ // Move to the runtime. -+ tokio::spawn(async move { -+ // Spawn the task that sends to the channel -+ tokio::spawn(async move { -+ tx.send(()).unwrap(); -+ }); -+ -+ // Spawn a task that bumps the previous task out of the "next -+ // scheduled" slot. -+ tokio::spawn(async {}); -+ -+ // Blocking receive on the channel. -+ rx.recv().unwrap(); -+ }) -+ .await -+ .unwrap(); -+ }); -+ -+ drop(rt); -+ -+ let n: u64 = (0..metrics.num_workers()) -+ .map(|i| metrics.worker_steal_count(i)) -+ .sum(); -+ -+ assert_eq!(1, n); -+} -+ -+#[test] -+fn worker_poll_count() { -+ const N: u64 = 5; -+ -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ for _ in 0..N { -+ tokio::spawn(async {}).await.unwrap(); -+ } -+ }); -+ drop(rt); -+ assert_eq!(N, metrics.worker_poll_count(0)); -+ -+ let rt = threaded(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ for _ in 0..N { -+ tokio::spawn(async {}).await.unwrap(); -+ } -+ }); -+ drop(rt); -+ // Account for the `block_on` task -+ let n = (0..metrics.num_workers()) -+ .map(|i| metrics.worker_poll_count(i)) -+ .sum(); -+ -+ assert_eq!(N, n); -+} -+ -+#[test] -+fn worker_total_busy_duration() { -+ const N: usize = 5; -+ -+ let zero = Duration::from_millis(0); -+ -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ -+ rt.block_on(async { -+ for _ in 0..N { -+ tokio::spawn(async { -+ tokio::task::yield_now().await; -+ }) -+ .await -+ .unwrap(); -+ } -+ }); -+ -+ drop(rt); -+ -+ assert!(zero < metrics.worker_total_busy_duration(0)); -+ -+ let rt = threaded(); -+ let metrics = rt.metrics(); -+ -+ rt.block_on(async { -+ for _ in 0..N { -+ tokio::spawn(async { -+ tokio::task::yield_now().await; -+ }) -+ .await -+ .unwrap(); -+ } -+ }); -+ -+ drop(rt); -+ -+ for i in 0..metrics.num_workers() { -+ assert!(zero < metrics.worker_total_busy_duration(i)); -+ } -+} -+ -+#[test] -+fn worker_local_schedule_count() { -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ tokio::spawn(async {}).await.unwrap(); -+ }); -+ drop(rt); -+ -+ assert_eq!(1, metrics.worker_local_schedule_count(0)); -+ assert_eq!(0, metrics.remote_schedule_count()); -+ -+ let rt = threaded(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ // Move to the runtime -+ tokio::spawn(async { -+ tokio::spawn(async {}).await.unwrap(); -+ }) -+ .await -+ .unwrap(); -+ }); -+ drop(rt); -+ -+ let n: u64 = (0..metrics.num_workers()) -+ .map(|i| metrics.worker_local_schedule_count(i)) -+ .sum(); -+ -+ assert_eq!(2, n); -+ assert_eq!(1, metrics.remote_schedule_count()); -+} -+ -+#[test] -+fn worker_overflow_count() { -+ // Only applies to the threaded worker -+ let rt = threaded(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ // Move to the runtime -+ tokio::spawn(async { -+ let (tx1, rx1) = std::sync::mpsc::channel(); -+ let (tx2, rx2) = std::sync::mpsc::channel(); -+ -+ // First, we need to block the other worker until all tasks have -+ // been spawned. -+ tokio::spawn(async move { -+ tx1.send(()).unwrap(); -+ rx2.recv().unwrap(); -+ }); -+ -+ // Bump the next-run spawn -+ tokio::spawn(async {}); -+ -+ rx1.recv().unwrap(); -+ -+ // Spawn many tasks -+ for _ in 0..300 { -+ tokio::spawn(async {}); -+ } -+ -+ tx2.send(()).unwrap(); -+ }) -+ .await -+ .unwrap(); -+ }); -+ drop(rt); -+ -+ let n: u64 = (0..metrics.num_workers()) -+ .map(|i| metrics.worker_overflow_count(i)) -+ .sum(); -+ -+ assert_eq!(1, n); -+} -+ -+#[test] -+fn injection_queue_depth() { -+ use std::thread; -+ -+ let rt = current_thread(); -+ let handle = rt.handle().clone(); -+ let metrics = rt.metrics(); -+ -+ thread::spawn(move || { -+ handle.spawn(async {}); -+ }) -+ .join() -+ .unwrap(); -+ -+ assert_eq!(1, metrics.injection_queue_depth()); -+ -+ let rt = threaded(); -+ let handle = rt.handle().clone(); -+ let metrics = rt.metrics(); -+ -+ // First we need to block the runtime workers -+ let (tx1, rx1) = std::sync::mpsc::channel(); -+ let (tx2, rx2) = std::sync::mpsc::channel(); -+ -+ rt.spawn(async move { rx1.recv().unwrap() }); -+ rt.spawn(async move { rx2.recv().unwrap() }); -+ -+ thread::spawn(move || { -+ handle.spawn(async {}); -+ }) -+ .join() -+ .unwrap(); -+ -+ let n = metrics.injection_queue_depth(); -+ assert!(1 <= n, "{}", n); -+ assert!(3 >= n, "{}", n); -+ -+ tx1.send(()).unwrap(); -+ tx2.send(()).unwrap(); -+} -+ -+#[test] -+fn worker_local_queue_depth() { -+ const N: usize = 100; -+ -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ rt.block_on(async { -+ for _ in 0..N { -+ tokio::spawn(async {}); -+ } -+ -+ assert_eq!(N, metrics.worker_local_queue_depth(0)); -+ }); -+ -+ let rt = threaded(); -+ let metrics = rt.metrics(); -+ rt.block_on(async move { -+ // Move to the runtime -+ tokio::spawn(async move { -+ let (tx1, rx1) = std::sync::mpsc::channel(); -+ let (tx2, rx2) = std::sync::mpsc::channel(); -+ -+ // First, we need to block the other worker until all tasks have -+ // been spawned. -+ tokio::spawn(async move { -+ tx1.send(()).unwrap(); -+ rx2.recv().unwrap(); -+ }); -+ -+ // Bump the next-run spawn -+ tokio::spawn(async {}); -+ -+ rx1.recv().unwrap(); -+ -+ // Spawn some tasks -+ for _ in 0..100 { -+ tokio::spawn(async {}); -+ } -+ -+ let n: usize = (0..metrics.num_workers()) -+ .map(|i| metrics.worker_local_queue_depth(i)) -+ .sum(); -+ -+ assert_eq!(n, N); -+ -+ tx2.send(()).unwrap(); -+ }) -+ .await -+ .unwrap(); -+ }); -+} -+ -+#[test] -+fn budget_exhaustion_yield() { -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ -+ assert_eq!(0, metrics.budget_forced_yield_count()); -+ -+ let mut did_yield = false; -+ -+ // block on a task which consumes budget until it yields -+ rt.block_on(poll_fn(|cx| loop { -+ if did_yield { -+ return Poll::Ready(()); -+ } -+ -+ let fut = consume_budget(); -+ tokio::pin!(fut); -+ -+ if fut.poll(cx).is_pending() { -+ did_yield = true; -+ return Poll::Pending; -+ } -+ })); -+ -+ assert_eq!(1, rt.metrics().budget_forced_yield_count()); -+} -+ -+#[test] -+fn budget_exhaustion_yield_with_joins() { -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ -+ assert_eq!(0, metrics.budget_forced_yield_count()); -+ -+ let mut did_yield_1 = false; -+ let mut did_yield_2 = false; -+ -+ // block on a task which consumes budget until it yields -+ rt.block_on(async { -+ tokio::join!( -+ poll_fn(|cx| loop { -+ if did_yield_1 { -+ return Poll::Ready(()); -+ } -+ -+ let fut = consume_budget(); -+ tokio::pin!(fut); -+ -+ if fut.poll(cx).is_pending() { -+ did_yield_1 = true; -+ return Poll::Pending; -+ } -+ }), -+ poll_fn(|cx| loop { -+ if did_yield_2 { -+ return Poll::Ready(()); -+ } -+ -+ let fut = consume_budget(); -+ tokio::pin!(fut); -+ -+ if fut.poll(cx).is_pending() { -+ did_yield_2 = true; -+ return Poll::Pending; -+ } -+ }) -+ ) -+ }); -+ -+ assert_eq!(1, rt.metrics().budget_forced_yield_count()); -+} -+ -+#[cfg(any(target_os = "linux", target_os = "macos"))] -+#[test] -+fn io_driver_fd_count() { -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ -+ assert_eq!(metrics.io_driver_fd_registered_count(), 0); -+ -+ let stream = tokio::net::TcpStream::connect("google.com:80"); -+ let stream = rt.block_on(async move { stream.await.unwrap() }); -+ -+ assert_eq!(metrics.io_driver_fd_registered_count(), 1); -+ assert_eq!(metrics.io_driver_fd_deregistered_count(), 0); -+ -+ drop(stream); -+ -+ assert_eq!(metrics.io_driver_fd_deregistered_count(), 1); -+ assert_eq!(metrics.io_driver_fd_registered_count(), 1); -+} -+ -+#[cfg(any(target_os = "linux", target_os = "macos"))] -+#[test] -+fn io_driver_ready_count() { -+ let rt = current_thread(); -+ let metrics = rt.metrics(); -+ -+ let stream = tokio::net::TcpStream::connect("google.com:80"); -+ let _stream = rt.block_on(async move { stream.await.unwrap() }); -+ -+ assert_eq!(metrics.io_driver_ready_count(), 1); -+} -+ -+fn current_thread() -> Runtime { -+ tokio::runtime::Builder::new_current_thread() -+ .enable_all() -+ .build() -+ .unwrap() -+} -+ -+fn threaded() -> Runtime { -+ tokio::runtime::Builder::new_multi_thread() -+ .worker_threads(2) -+ .enable_all() -+ .build() -+ .unwrap() -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/rt_panic.rs b/KubeOS-Rust/vendor/tokio/tests/rt_panic.rs -new file mode 100644 -index 00000000..f9a684fd ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/rt_panic.rs -@@ -0,0 +1,77 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(feature = "full")] -+#![cfg(not(tokio_wasi))] // Wasi doesn't support panic recovery -+ -+use futures::future; -+use std::error::Error; -+use tokio::runtime::{Builder, Handle, Runtime}; -+ -+mod support { -+ pub mod panic; -+} -+use support::panic::test_panic; -+ -+#[test] -+fn current_handle_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let _ = Handle::current(); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn into_panic_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(move || { -+ let rt = current_thread(); -+ rt.block_on(async { -+ let handle = tokio::spawn(future::pending::<()>()); -+ -+ handle.abort(); -+ -+ let err = handle.await.unwrap_err(); -+ assert!(!&err.is_panic()); -+ -+ let _ = err.into_panic(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn builder_worker_threads_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let _ = Builder::new_multi_thread().worker_threads(0).build(); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn builder_max_blocking_threads_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let _ = Builder::new_multi_thread().max_blocking_threads(0).build(); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+fn current_thread() -> Runtime { -+ tokio::runtime::Builder::new_current_thread() -+ .enable_all() -+ .build() -+ .unwrap() -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/rt_threaded.rs b/KubeOS-Rust/vendor/tokio/tests/rt_threaded.rs -index 5f047a79..c5984182 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/rt_threaded.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/rt_threaded.rs -@@ -1,9 +1,9 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] - - use tokio::io::{AsyncReadExt, AsyncWriteExt}; - use tokio::net::{TcpListener, TcpStream}; --use tokio::runtime::{self, Runtime}; -+use tokio::runtime; - use tokio::sync::oneshot; - use tokio_test::{assert_err, assert_ok}; - -@@ -15,6 +15,15 @@ use std::sync::atomic::Ordering::Relaxed; - use std::sync::{mpsc, Arc, Mutex}; - use std::task::{Context, Poll, Waker}; - -+macro_rules! cfg_metrics { -+ ($($t:tt)*) => { -+ #[cfg(tokio_unstable)] -+ { -+ $( $t )* -+ } -+ } -+} -+ - #[test] - fn single_thread() { - // No panic when starting a runtime w/ a single thread -@@ -55,6 +64,38 @@ fn many_oneshot_futures() { - } - } - -+#[test] -+fn spawn_two() { -+ let rt = rt(); -+ -+ let out = rt.block_on(async { -+ let (tx, rx) = oneshot::channel(); -+ -+ tokio::spawn(async move { -+ tokio::spawn(async move { -+ tx.send("ZOMG").unwrap(); -+ }); -+ }); -+ -+ assert_ok!(rx.await) -+ }); -+ -+ assert_eq!(out, "ZOMG"); -+ -+ cfg_metrics! { -+ let metrics = rt.metrics(); -+ drop(rt); -+ assert_eq!(1, metrics.remote_schedule_count()); -+ -+ let mut local = 0; -+ for i in 0..metrics.num_workers() { -+ local += metrics.worker_local_schedule_count(i); -+ } -+ -+ assert_eq!(1, local); -+ } -+} -+ - #[test] - fn many_multishot_futures() { - const CHAIN: usize = 200; -@@ -374,6 +415,32 @@ fn coop_and_block_in_place() { - }); - } - -+#[test] -+fn yield_after_block_in_place() { -+ let rt = tokio::runtime::Builder::new_multi_thread() -+ .worker_threads(1) -+ .build() -+ .unwrap(); -+ -+ rt.block_on(async { -+ tokio::spawn(async move { -+ // Block in place then enter a new runtime -+ tokio::task::block_in_place(|| { -+ let rt = tokio::runtime::Builder::new_current_thread() -+ .build() -+ .unwrap(); -+ -+ rt.block_on(async {}); -+ }); -+ -+ // Yield, then complete -+ tokio::task::yield_now().await; -+ }) -+ .await -+ .unwrap() -+ }); -+} -+ - // Testing this does not panic - #[test] - fn max_blocking_threads() { -@@ -439,9 +506,7 @@ fn wake_during_shutdown() { - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> { - let me = Pin::into_inner(self); - let mut lock = me.shared.lock().unwrap(); -- println!("poll {}", me.put_waker); - if me.put_waker { -- println!("putting"); - lock.waker = Some(cx.waker().clone()); - } - Poll::Pending -@@ -450,13 +515,11 @@ fn wake_during_shutdown() { - - impl Drop for MyFuture { - fn drop(&mut self) { -- println!("drop {} start", self.put_waker); - let mut lock = self.shared.lock().unwrap(); - if !self.put_waker { - lock.waker.take().unwrap().wake(); - } - drop(lock); -- println!("drop {} stop", self.put_waker); - } - } - -@@ -498,6 +561,30 @@ async fn test_block_in_place4() { - tokio::task::block_in_place(|| {}); - } - --fn rt() -> Runtime { -- Runtime::new().unwrap() -+fn rt() -> runtime::Runtime { -+ runtime::Runtime::new().unwrap() -+} -+ -+#[cfg(tokio_unstable)] -+mod unstable { -+ use super::*; -+ -+ #[test] -+ fn test_disable_lifo_slot() { -+ let rt = runtime::Builder::new_multi_thread() -+ .disable_lifo_slot() -+ .worker_threads(2) -+ .build() -+ .unwrap(); -+ -+ rt.block_on(async { -+ tokio::spawn(async { -+ // Spawn another task and block the thread until completion. If the LIFO slot -+ // is used then the test doesn't complete. -+ futures::executor::block_on(tokio::spawn(async {})).unwrap(); -+ }) -+ .await -+ .unwrap(); -+ }) -+ } - } -diff --git a/KubeOS-Rust/vendor/tokio/tests/rt_time_start_paused.rs b/KubeOS-Rust/vendor/tokio/tests/rt_time_start_paused.rs -new file mode 100644 -index 00000000..283f4748 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/rt_time_start_paused.rs -@@ -0,0 +1,14 @@ -+#![cfg(all(feature = "full"))] -+ -+use tokio::time::{Duration, Instant}; -+ -+#[tokio::test(start_paused = true)] -+async fn test_start_paused() { -+ let now = Instant::now(); -+ -+ // Pause a few times w/ std sleep and ensure `now` stays the same -+ for _ in 0..5 { -+ std::thread::sleep(Duration::from_millis(1)); -+ assert_eq!(now, Instant::now()); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/signal_no_rt.rs b/KubeOS-Rust/vendor/tokio/tests/signal_no_rt.rs -index b0f32b2d..ffcc6651 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/signal_no_rt.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/signal_no_rt.rs -@@ -4,6 +4,7 @@ - - use tokio::signal::unix::{signal, SignalKind}; - -+#[cfg_attr(tokio_wasi, ignore = "Wasi does not support panic recovery")] - #[test] - #[should_panic] - fn no_runtime_panics_creating_signals() { -diff --git a/KubeOS-Rust/vendor/tokio/tests/signal_panic.rs b/KubeOS-Rust/vendor/tokio/tests/signal_panic.rs -new file mode 100644 -index 00000000..ce1ec3e4 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/signal_panic.rs -@@ -0,0 +1,29 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(feature = "full")] -+#![cfg(unix)] -+ -+use std::error::Error; -+use tokio::runtime::Builder; -+use tokio::signal::unix::{signal, SignalKind}; -+ -+mod support { -+ pub mod panic; -+} -+use support::panic::test_panic; -+ -+#[test] -+fn signal_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = Builder::new_current_thread().build().unwrap(); -+ -+ rt.block_on(async { -+ let kind = SignalKind::from_raw(-1); -+ let _ = signal(kind); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/support/leaked_buffers.rs b/KubeOS-Rust/vendor/tokio/tests/support/leaked_buffers.rs -new file mode 100644 -index 00000000..a6079fb7 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/support/leaked_buffers.rs -@@ -0,0 +1,26 @@ -+/// Can create buffers of arbitrary lifetime. -+/// Frees created buffers when dropped. -+/// -+/// This struct is of course unsafe and the fact that -+/// it must outlive the created slices has to be ensured by -+/// the programmer. -+/// -+/// Used at certain test scenarios as a safer version of -+/// Vec::leak, to satisfy the address sanitizer. -+pub struct LeakedBuffers { -+ leaked_vecs: Vec>, -+} -+ -+impl LeakedBuffers { -+ pub fn new() -> Self { -+ Self { -+ leaked_vecs: vec![], -+ } -+ } -+ pub unsafe fn create<'a>(&mut self, size: usize) -> &'a mut [u8] { -+ let new_mem = vec![0u8; size].into_boxed_slice(); -+ self.leaked_vecs.push(new_mem); -+ let new_mem = self.leaked_vecs.last_mut().unwrap(); -+ std::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), new_mem.len()) -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/support/panic.rs b/KubeOS-Rust/vendor/tokio/tests/support/panic.rs -new file mode 100644 -index 00000000..df2f59d3 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/support/panic.rs -@@ -0,0 +1,34 @@ -+use std::panic; -+use std::sync::{Arc, Mutex}; -+ -+pub fn test_panic(func: Func) -> Option { -+ static PANIC_MUTEX: Mutex<()> = Mutex::new(()); -+ -+ { -+ let _guard = PANIC_MUTEX.lock(); -+ let panic_file: Arc>> = Arc::new(Mutex::new(None)); -+ -+ let prev_hook = panic::take_hook(); -+ { -+ let panic_file = panic_file.clone(); -+ panic::set_hook(Box::new(move |panic_info| { -+ let panic_location = panic_info.location().unwrap(); -+ panic_file -+ .lock() -+ .unwrap() -+ .clone_from(&Some(panic_location.file().to_string())); -+ })); -+ } -+ -+ let result = panic::catch_unwind(func); -+ // Return to the previously set panic hook (maybe default) so that we get nice error -+ // messages in the tests. -+ panic::set_hook(prev_hook); -+ -+ if result.is_err() { -+ panic_file.lock().unwrap().clone() -+ } else { -+ None -+ } -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_barrier.rs b/KubeOS-Rust/vendor/tokio/tests/sync_barrier.rs -index f280fe86..2001c359 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_barrier.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_barrier.rs -@@ -1,6 +1,9 @@ - #![allow(clippy::unnecessary_operation)] - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; - - use tokio::sync::Barrier; - -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_broadcast.rs b/KubeOS-Rust/vendor/tokio/tests/sync_broadcast.rs -index 5f79800a..feed0314 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_broadcast.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_broadcast.rs -@@ -2,6 +2,9 @@ - #![warn(rust_2018_idioms)] - #![cfg(feature = "sync")] - -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+ - use tokio::sync::broadcast; - use tokio_test::task; - use tokio_test::{ -@@ -44,7 +47,7 @@ macro_rules! assert_closed { - ($e:expr) => { - match assert_err!($e) { - broadcast::error::TryRecvError::Closed => {} -- _ => panic!("did not lag"), -+ _ => panic!("is not closed"), - } - }; - } -@@ -273,12 +276,14 @@ fn send_no_rx() { - - #[test] - #[should_panic] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - fn zero_capacity() { - broadcast::channel::<()>(0); - } - - #[test] - #[should_panic] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - fn capacity_too_big() { - use std::usize; - -@@ -286,6 +291,8 @@ fn capacity_too_big() { - } - - #[test] -+#[cfg(panic = "unwind")] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - fn panic_in_clone() { - use std::panic::{self, AssertUnwindSafe}; - -@@ -451,6 +458,186 @@ fn lagging_receiver_recovers_after_wrap_open() { - assert_empty!(rx); - } - -+#[test] -+fn receiver_len_with_lagged() { -+ let (tx, mut rx) = broadcast::channel(3); -+ -+ tx.send(10).unwrap(); -+ tx.send(20).unwrap(); -+ tx.send(30).unwrap(); -+ tx.send(40).unwrap(); -+ -+ assert_eq!(rx.len(), 4); -+ assert_eq!(assert_recv!(rx), 10); -+ -+ tx.send(50).unwrap(); -+ tx.send(60).unwrap(); -+ -+ assert_eq!(rx.len(), 5); -+ assert_lagged!(rx.try_recv(), 1); -+} -+ - fn is_closed(err: broadcast::error::RecvError) -> bool { - matches!(err, broadcast::error::RecvError::Closed) - } -+ -+#[test] -+fn resubscribe_points_to_tail() { -+ let (tx, mut rx) = broadcast::channel(3); -+ tx.send(1).unwrap(); -+ -+ let mut rx_resub = rx.resubscribe(); -+ -+ // verify we're one behind at the start -+ assert_empty!(rx_resub); -+ assert_eq!(assert_recv!(rx), 1); -+ -+ // verify we do not affect rx -+ tx.send(2).unwrap(); -+ assert_eq!(assert_recv!(rx_resub), 2); -+ tx.send(3).unwrap(); -+ assert_eq!(assert_recv!(rx), 2); -+ assert_eq!(assert_recv!(rx), 3); -+ assert_empty!(rx); -+ -+ assert_eq!(assert_recv!(rx_resub), 3); -+ assert_empty!(rx_resub); -+} -+ -+#[test] -+fn resubscribe_lagged() { -+ let (tx, mut rx) = broadcast::channel(1); -+ tx.send(1).unwrap(); -+ tx.send(2).unwrap(); -+ -+ let mut rx_resub = rx.resubscribe(); -+ assert_lagged!(rx.try_recv(), 1); -+ assert_empty!(rx_resub); -+ -+ assert_eq!(assert_recv!(rx), 2); -+ assert_empty!(rx); -+ assert_empty!(rx_resub); -+} -+ -+#[test] -+fn resubscribe_to_closed_channel() { -+ let (tx, rx) = tokio::sync::broadcast::channel::(2); -+ drop(tx); -+ -+ let mut rx_resub = rx.resubscribe(); -+ assert_closed!(rx_resub.try_recv()); -+} -+ -+#[test] -+fn sender_len() { -+ let (tx, mut rx1) = broadcast::channel(4); -+ let mut rx2 = tx.subscribe(); -+ -+ assert_eq!(tx.len(), 0); -+ assert!(tx.is_empty()); -+ -+ tx.send(1).unwrap(); -+ tx.send(2).unwrap(); -+ tx.send(3).unwrap(); -+ -+ assert_eq!(tx.len(), 3); -+ assert!(!tx.is_empty()); -+ -+ assert_recv!(rx1); -+ assert_recv!(rx1); -+ -+ assert_eq!(tx.len(), 3); -+ assert!(!tx.is_empty()); -+ -+ assert_recv!(rx2); -+ -+ assert_eq!(tx.len(), 2); -+ assert!(!tx.is_empty()); -+ -+ tx.send(4).unwrap(); -+ tx.send(5).unwrap(); -+ tx.send(6).unwrap(); -+ -+ assert_eq!(tx.len(), 4); -+ assert!(!tx.is_empty()); -+} -+ -+#[test] -+#[cfg(not(tokio_wasm_not_wasi))] -+fn sender_len_random() { -+ use rand::Rng; -+ -+ let (tx, mut rx1) = broadcast::channel(16); -+ let mut rx2 = tx.subscribe(); -+ -+ for _ in 0..1000 { -+ match rand::thread_rng().gen_range(0..4) { -+ 0 => { -+ let _ = rx1.try_recv(); -+ } -+ 1 => { -+ let _ = rx2.try_recv(); -+ } -+ _ => { -+ tx.send(0).unwrap(); -+ } -+ } -+ -+ let expected_len = usize::min(usize::max(rx1.len(), rx2.len()), 16); -+ assert_eq!(tx.len(), expected_len); -+ } -+} -+ -+#[test] -+fn send_in_waker_drop() { -+ use futures::task::ArcWake; -+ use std::future::Future; -+ use std::task::Context; -+ -+ struct SendOnDrop(broadcast::Sender<()>); -+ -+ impl Drop for SendOnDrop { -+ fn drop(&mut self) { -+ let _ = self.0.send(()); -+ } -+ } -+ -+ impl ArcWake for SendOnDrop { -+ fn wake_by_ref(_arc_self: &Arc) {} -+ } -+ -+ // Test if there is no deadlock when replacing the old waker. -+ -+ let (tx, mut rx) = broadcast::channel(16); -+ -+ let mut fut = Box::pin(async { -+ let _ = rx.recv().await; -+ }); -+ -+ // Store our special waker in the receiving future. -+ let waker = futures::task::waker(Arc::new(SendOnDrop(tx))); -+ let mut cx = Context::from_waker(&waker); -+ assert!(fut.as_mut().poll(&mut cx).is_pending()); -+ drop(waker); -+ -+ // Second poll shouldn't deadlock. -+ let mut cx = Context::from_waker(futures::task::noop_waker_ref()); -+ let _ = fut.as_mut().poll(&mut cx); -+ -+ // Test if there is no deadlock when calling waker.wake(). -+ -+ let (tx, mut rx) = broadcast::channel(16); -+ -+ let mut fut = Box::pin(async { -+ let _ = rx.recv().await; -+ }); -+ -+ // Store our special waker in the receiving future. -+ let waker = futures::task::waker(Arc::new(SendOnDrop(tx.clone()))); -+ let mut cx = Context::from_waker(&waker); -+ assert!(fut.as_mut().poll(&mut cx).is_pending()); -+ drop(waker); -+ -+ // Shouldn't deadlock. -+ let _ = tx.send(()); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_errors.rs b/KubeOS-Rust/vendor/tokio/tests/sync_errors.rs -index 66e8f0c0..bf0a6cf7 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_errors.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_errors.rs -@@ -1,5 +1,8 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; - - fn is_error() {} - -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_mpsc.rs b/KubeOS-Rust/vendor/tokio/tests/sync_mpsc.rs -index 1947d260..6e870964 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_mpsc.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_mpsc.rs -@@ -1,18 +1,21 @@ - #![allow(clippy::redundant_clone)] - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] - --use std::thread; --use tokio::runtime::Runtime; --use tokio::sync::mpsc; --use tokio::sync::mpsc::error::{TryRecvError, TrySendError}; --use tokio_test::task; --use tokio_test::{ -- assert_err, assert_ok, assert_pending, assert_ready, assert_ready_err, assert_ready_ok, --}; -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; - -+use std::fmt; - use std::sync::Arc; -+use tokio::sync::mpsc; -+use tokio::sync::mpsc::error::{TryRecvError, TrySendError}; -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; -+use tokio_test::*; - -+#[cfg(not(tokio_wasm))] - mod support { - pub(crate) mod mpsc_stream; - } -@@ -21,7 +24,7 @@ trait AssertSend: Send {} - impl AssertSend for mpsc::Sender {} - impl AssertSend for mpsc::Receiver {} - --#[tokio::test] -+#[maybe_tokio_test] - async fn send_recv_with_buffer() { - let (tx, mut rx) = mpsc::channel::(16); - -@@ -46,6 +49,7 @@ async fn send_recv_with_buffer() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn reserve_disarm() { - let (tx, mut rx) = mpsc::channel::(2); - let tx1 = tx.clone(); -@@ -58,10 +62,10 @@ async fn reserve_disarm() { - let permit2 = assert_ok!(tx2.reserve().await); - - // But a third should not be ready -- let mut r3 = task::spawn(tx3.reserve()); -+ let mut r3 = tokio_test::task::spawn(tx3.reserve()); - assert_pending!(r3.poll()); - -- let mut r4 = task::spawn(tx4.reserve()); -+ let mut r4 = tokio_test::task::spawn(tx4.reserve()); - assert_pending!(r4.poll()); - - // Using one of the reserved slots should allow a new handle to become ready -@@ -78,11 +82,12 @@ async fn reserve_disarm() { - drop(permit2); - assert!(r4.is_woken()); - -- let mut r1 = task::spawn(tx1.reserve()); -+ let mut r1 = tokio_test::task::spawn(tx1.reserve()); - assert_pending!(r1.poll()); - } - - #[tokio::test] -+#[cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads - async fn send_recv_stream_with_buffer() { - use tokio_stream::StreamExt; - -@@ -100,6 +105,7 @@ async fn send_recv_stream_with_buffer() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn async_send_recv_with_buffer() { - let (tx, mut rx) = mpsc::channel(16); - -@@ -114,10 +120,11 @@ async fn async_send_recv_with_buffer() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn start_send_past_cap() { - use std::future::Future; - -- let mut t1 = task::spawn(()); -+ let mut t1 = tokio_test::task::spawn(()); - - let (tx1, mut rx) = mpsc::channel(1); - let tx2 = tx1.clone(); -@@ -128,7 +135,7 @@ async fn start_send_past_cap() { - t1.enter(|cx, _| assert_pending!(r1.as_mut().poll(cx))); - - { -- let mut r2 = task::spawn(tx2.reserve()); -+ let mut r2 = tokio_test::task::spawn(tx2.reserve()); - assert_pending!(r2.poll()); - - drop(r1); -@@ -147,11 +154,12 @@ async fn start_send_past_cap() { - - #[test] - #[should_panic] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - fn buffer_gteq_one() { - mpsc::channel::(0); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn send_recv_unbounded() { - let (tx, mut rx) = mpsc::unbounded_channel::(); - -@@ -168,6 +176,7 @@ async fn send_recv_unbounded() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn async_send_recv_unbounded() { - let (tx, mut rx) = mpsc::unbounded_channel(); - -@@ -182,6 +191,7 @@ async fn async_send_recv_unbounded() { - } - - #[tokio::test] -+#[cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads - async fn send_recv_stream_unbounded() { - use tokio_stream::StreamExt; - -@@ -199,32 +209,32 @@ async fn send_recv_stream_unbounded() { - assert_eq!(None, rx.next().await); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn no_t_bounds_buffer() { - struct NoImpls; - - let (tx, mut rx) = mpsc::channel(100); - - // sender should be Debug even though T isn't Debug -- println!("{:?}", tx); -+ is_debug(&tx); - // same with Receiver -- println!("{:?}", rx); -+ is_debug(&rx); - // and sender should be Clone even though T isn't Clone - assert!(tx.clone().try_send(NoImpls).is_ok()); - - assert!(rx.recv().await.is_some()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn no_t_bounds_unbounded() { - struct NoImpls; - - let (tx, mut rx) = mpsc::unbounded_channel(); - - // sender should be Debug even though T isn't Debug -- println!("{:?}", tx); -+ is_debug(&tx); - // same with Receiver -- println!("{:?}", rx); -+ is_debug(&rx); - // and sender should be Clone even though T isn't Clone - assert!(tx.clone().send(NoImpls).is_ok()); - -@@ -232,6 +242,7 @@ async fn no_t_bounds_unbounded() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn send_recv_buffer_limited() { - let (tx, mut rx) = mpsc::channel::(1); - -@@ -242,7 +253,7 @@ async fn send_recv_buffer_limited() { - p1.send(1); - - // Not ready -- let mut p2 = task::spawn(tx.reserve()); -+ let mut p2 = tokio_test::task::spawn(tx.reserve()); - assert_pending!(p2.poll()); - - // Take the value -@@ -261,7 +272,7 @@ async fn send_recv_buffer_limited() { - assert!(rx.recv().await.is_some()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn recv_close_gets_none_idle() { - let (tx, mut rx) = mpsc::channel::(10); - -@@ -273,12 +284,13 @@ async fn recv_close_gets_none_idle() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn recv_close_gets_none_reserved() { - let (tx1, mut rx) = mpsc::channel::(1); - let tx2 = tx1.clone(); - - let permit1 = assert_ok!(tx1.reserve().await); -- let mut permit2 = task::spawn(tx2.reserve()); -+ let mut permit2 = tokio_test::task::spawn(tx2.reserve()); - assert_pending!(permit2.poll()); - - rx.close(); -@@ -287,7 +299,7 @@ async fn recv_close_gets_none_reserved() { - assert_ready_err!(permit2.poll()); - - { -- let mut recv = task::spawn(rx.recv()); -+ let mut recv = tokio_test::task::spawn(rx.recv()); - assert_pending!(recv.poll()); - - permit1.send(123); -@@ -300,13 +312,13 @@ async fn recv_close_gets_none_reserved() { - assert!(rx.recv().await.is_none()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn tx_close_gets_none() { - let (_, mut rx) = mpsc::channel::(10); - assert!(rx.recv().await.is_none()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn try_send_fail() { - let (tx, mut rx) = mpsc::channel(1); - -@@ -327,7 +339,7 @@ async fn try_send_fail() { - assert!(rx.recv().await.is_none()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn try_send_fail_with_try_recv() { - let (tx, mut rx) = mpsc::channel(1); - -@@ -348,7 +360,7 @@ async fn try_send_fail_with_try_recv() { - assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected)); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn try_reserve_fails() { - let (tx, mut rx) = mpsc::channel(1); - -@@ -372,6 +384,7 @@ async fn try_reserve_fails() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn drop_permit_releases_permit() { - // poll_ready reserves capacity, ensure that the capacity is released if tx - // is dropped w/o sending a value. -@@ -380,7 +393,7 @@ async fn drop_permit_releases_permit() { - - let permit = assert_ok!(tx1.reserve().await); - -- let mut reserve2 = task::spawn(tx2.reserve()); -+ let mut reserve2 = tokio_test::task::spawn(tx2.reserve()); - assert_pending!(reserve2.poll()); - - drop(permit); -@@ -389,7 +402,7 @@ async fn drop_permit_releases_permit() { - assert_ready_ok!(reserve2.poll()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn dropping_rx_closes_channel() { - let (tx, rx) = mpsc::channel(100); - -@@ -439,48 +452,57 @@ fn unconsumed_messages_are_dropped() { - } - - #[test] -+#[cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads - fn blocking_recv() { - let (tx, mut rx) = mpsc::channel::(1); - -- let sync_code = thread::spawn(move || { -+ let sync_code = std::thread::spawn(move || { - assert_eq!(Some(10), rx.blocking_recv()); - }); - -- Runtime::new().unwrap().block_on(async move { -- let _ = tx.send(10).await; -- }); -+ tokio::runtime::Runtime::new() -+ .unwrap() -+ .block_on(async move { -+ let _ = tx.send(10).await; -+ }); - sync_code.join().unwrap() - } - - #[tokio::test] - #[should_panic] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - async fn blocking_recv_async() { - let (_tx, mut rx) = mpsc::channel::<()>(1); - let _ = rx.blocking_recv(); - } - - #[test] -+#[cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads - fn blocking_send() { - let (tx, mut rx) = mpsc::channel::(1); - -- let sync_code = thread::spawn(move || { -+ let sync_code = std::thread::spawn(move || { - tx.blocking_send(10).unwrap(); - }); - -- Runtime::new().unwrap().block_on(async move { -- assert_eq!(Some(10), rx.recv().await); -- }); -+ tokio::runtime::Runtime::new() -+ .unwrap() -+ .block_on(async move { -+ assert_eq!(Some(10), rx.recv().await); -+ }); - sync_code.join().unwrap() - } - - #[tokio::test] - #[should_panic] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - async fn blocking_send_async() { - let (tx, _rx) = mpsc::channel::<()>(1); - let _ = tx.blocking_send(()); - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn ready_close_cancel_bounded() { - let (tx, mut rx) = mpsc::channel::<()>(100); - let _tx2 = tx.clone(); -@@ -489,7 +511,7 @@ async fn ready_close_cancel_bounded() { - - rx.close(); - -- let mut recv = task::spawn(rx.recv()); -+ let mut recv = tokio_test::task::spawn(rx.recv()); - assert_pending!(recv.poll()); - - drop(permit); -@@ -500,13 +522,14 @@ async fn ready_close_cancel_bounded() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn permit_available_not_acquired_close() { - let (tx1, mut rx) = mpsc::channel::<()>(1); - let tx2 = tx1.clone(); - - let permit1 = assert_ok!(tx1.reserve().await); - -- let mut permit2 = task::spawn(tx2.reserve()); -+ let mut permit2 = tokio_test::task::spawn(tx2.reserve()); - assert_pending!(permit2.poll()); - - rx.close(); -@@ -597,3 +620,60 @@ fn try_recv_close_while_empty_unbounded() { - drop(tx); - assert_eq!(Err(TryRecvError::Disconnected), rx.try_recv()); - } -+ -+#[tokio::test(start_paused = true)] -+#[cfg(feature = "full")] -+async fn recv_timeout() { -+ use tokio::sync::mpsc::error::SendTimeoutError::{Closed, Timeout}; -+ use tokio::time::Duration; -+ -+ let (tx, rx) = mpsc::channel(5); -+ -+ assert_eq!(tx.send_timeout(10, Duration::from_secs(1)).await, Ok(())); -+ assert_eq!(tx.send_timeout(20, Duration::from_secs(1)).await, Ok(())); -+ assert_eq!(tx.send_timeout(30, Duration::from_secs(1)).await, Ok(())); -+ assert_eq!(tx.send_timeout(40, Duration::from_secs(1)).await, Ok(())); -+ assert_eq!(tx.send_timeout(50, Duration::from_secs(1)).await, Ok(())); -+ assert_eq!( -+ tx.send_timeout(60, Duration::from_secs(1)).await, -+ Err(Timeout(60)) -+ ); -+ -+ drop(rx); -+ assert_eq!( -+ tx.send_timeout(70, Duration::from_secs(1)).await, -+ Err(Closed(70)) -+ ); -+} -+ -+#[test] -+#[should_panic = "there is no reactor running, must be called from the context of a Tokio 1.x runtime"] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding -+fn recv_timeout_panic() { -+ use futures::future::FutureExt; -+ use tokio::time::Duration; -+ -+ let (tx, _rx) = mpsc::channel(5); -+ tx.send_timeout(10, Duration::from_secs(1)).now_or_never(); -+} -+ -+// Tests that channel `capacity` changes and `max_capacity` stays the same -+#[tokio::test] -+async fn test_tx_capacity() { -+ let (tx, _rx) = mpsc::channel::<()>(10); -+ // both capacities are same before -+ assert_eq!(tx.capacity(), 10); -+ assert_eq!(tx.max_capacity(), 10); -+ -+ let _permit = tx.reserve().await.unwrap(); -+ // after reserve, only capacity should drop by one -+ assert_eq!(tx.capacity(), 9); -+ assert_eq!(tx.max_capacity(), 10); -+ -+ tx.send(()).await.unwrap(); -+ // after send, capacity should drop by one again -+ assert_eq!(tx.capacity(), 8); -+ assert_eq!(tx.max_capacity(), 10); -+} -+ -+fn is_debug(_: &T) {} -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_mpsc_weak.rs b/KubeOS-Rust/vendor/tokio/tests/sync_mpsc_weak.rs -new file mode 100644 -index 00000000..0fdfc007 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_mpsc_weak.rs -@@ -0,0 +1,513 @@ -+#![allow(clippy::redundant_clone)] -+#![warn(rust_2018_idioms)] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+ -+use std::sync::atomic::AtomicUsize; -+use std::sync::atomic::Ordering::{Acquire, Release}; -+use tokio::sync::mpsc::{self, channel, unbounded_channel}; -+use tokio::sync::oneshot; -+ -+#[tokio::test] -+async fn weak_sender() { -+ let (tx, mut rx) = channel(11); -+ -+ let tx_weak = tokio::spawn(async move { -+ let tx_weak = tx.clone().downgrade(); -+ -+ for i in 0..10 { -+ if tx.send(i).await.is_err() { -+ return None; -+ } -+ } -+ -+ let tx2 = tx_weak -+ .upgrade() -+ .expect("expected to be able to upgrade tx_weak"); -+ let _ = tx2.send(20).await; -+ let tx_weak = tx2.downgrade(); -+ -+ Some(tx_weak) -+ }) -+ .await -+ .unwrap(); -+ -+ for i in 0..12 { -+ let recvd = rx.recv().await; -+ -+ match recvd { -+ Some(msg) => { -+ if i == 10 { -+ assert_eq!(msg, 20); -+ } -+ } -+ None => { -+ assert_eq!(i, 11); -+ break; -+ } -+ } -+ } -+ -+ let tx_weak = tx_weak.unwrap(); -+ let upgraded = tx_weak.upgrade(); -+ assert!(upgraded.is_none()); -+} -+ -+#[tokio::test] -+async fn actor_weak_sender() { -+ pub struct MyActor { -+ receiver: mpsc::Receiver, -+ sender: mpsc::WeakSender, -+ next_id: u32, -+ pub received_self_msg: bool, -+ } -+ -+ enum ActorMessage { -+ GetUniqueId { respond_to: oneshot::Sender }, -+ SelfMessage {}, -+ } -+ -+ impl MyActor { -+ fn new( -+ receiver: mpsc::Receiver, -+ sender: mpsc::WeakSender, -+ ) -> Self { -+ MyActor { -+ receiver, -+ sender, -+ next_id: 0, -+ received_self_msg: false, -+ } -+ } -+ -+ fn handle_message(&mut self, msg: ActorMessage) { -+ match msg { -+ ActorMessage::GetUniqueId { respond_to } => { -+ self.next_id += 1; -+ -+ // The `let _ =` ignores any errors when sending. -+ // -+ // This can happen if the `select!` macro is used -+ // to cancel waiting for the response. -+ let _ = respond_to.send(self.next_id); -+ } -+ ActorMessage::SelfMessage { .. } => { -+ self.received_self_msg = true; -+ } -+ } -+ } -+ -+ async fn send_message_to_self(&mut self) { -+ let msg = ActorMessage::SelfMessage {}; -+ -+ let sender = self.sender.clone(); -+ -+ // cannot move self.sender here -+ if let Some(sender) = sender.upgrade() { -+ let _ = sender.send(msg).await; -+ self.sender = sender.downgrade(); -+ } -+ } -+ -+ async fn run(&mut self) { -+ let mut i = 0; -+ while let Some(msg) = self.receiver.recv().await { -+ self.handle_message(msg); -+ -+ if i == 0 { -+ self.send_message_to_self().await; -+ } -+ -+ i += 1 -+ } -+ -+ assert!(self.received_self_msg); -+ } -+ } -+ -+ #[derive(Clone)] -+ pub struct MyActorHandle { -+ sender: mpsc::Sender, -+ } -+ -+ impl MyActorHandle { -+ pub fn new() -> (Self, MyActor) { -+ let (sender, receiver) = mpsc::channel(8); -+ let actor = MyActor::new(receiver, sender.clone().downgrade()); -+ -+ (Self { sender }, actor) -+ } -+ -+ pub async fn get_unique_id(&self) -> u32 { -+ let (send, recv) = oneshot::channel(); -+ let msg = ActorMessage::GetUniqueId { respond_to: send }; -+ -+ // Ignore send errors. If this send fails, so does the -+ // recv.await below. There's no reason to check the -+ // failure twice. -+ let _ = self.sender.send(msg).await; -+ recv.await.expect("Actor task has been killed") -+ } -+ } -+ -+ let (handle, mut actor) = MyActorHandle::new(); -+ -+ let actor_handle = tokio::spawn(async move { actor.run().await }); -+ -+ let _ = tokio::spawn(async move { -+ let _ = handle.get_unique_id().await; -+ drop(handle); -+ }) -+ .await; -+ -+ let _ = actor_handle.await; -+} -+ -+static NUM_DROPPED: AtomicUsize = AtomicUsize::new(0); -+ -+#[derive(Debug)] -+struct Msg; -+ -+impl Drop for Msg { -+ fn drop(&mut self) { -+ NUM_DROPPED.fetch_add(1, Release); -+ } -+} -+ -+// Tests that no pending messages are put onto the channel after `Rx` was -+// dropped. -+// -+// Note: After the introduction of `WeakSender`, which internally -+// used `Arc` and doesn't call a drop of the channel after the last strong -+// `Sender` was dropped while more than one `WeakSender` remains, we want to -+// ensure that no messages are kept in the channel, which were sent after -+// the receiver was dropped. -+#[tokio::test] -+async fn test_msgs_dropped_on_rx_drop() { -+ let (tx, mut rx) = mpsc::channel(3); -+ -+ tx.send(Msg {}).await.unwrap(); -+ tx.send(Msg {}).await.unwrap(); -+ -+ // This msg will be pending and should be dropped when `rx` is dropped -+ let sent_fut = tx.send(Msg {}); -+ -+ let _ = rx.recv().await.unwrap(); -+ let _ = rx.recv().await.unwrap(); -+ -+ sent_fut.await.unwrap(); -+ -+ drop(rx); -+ -+ assert_eq!(NUM_DROPPED.load(Acquire), 3); -+ -+ // This msg will not be put onto `Tx` list anymore, since `Rx` is closed. -+ assert!(tx.send(Msg {}).await.is_err()); -+ -+ assert_eq!(NUM_DROPPED.load(Acquire), 4); -+} -+ -+// Tests that a `WeakSender` is upgradeable when other `Sender`s exist. -+#[test] -+fn downgrade_upgrade_sender_success() { -+ let (tx, _rx) = mpsc::channel::(1); -+ let weak_tx = tx.downgrade(); -+ assert!(weak_tx.upgrade().is_some()); -+} -+ -+// Tests that a `WeakSender` fails to upgrade when no other `Sender` exists. -+#[test] -+fn downgrade_upgrade_sender_failure() { -+ let (tx, _rx) = mpsc::channel::(1); -+ let weak_tx = tx.downgrade(); -+ drop(tx); -+ assert!(weak_tx.upgrade().is_none()); -+} -+ -+// Tests that a `WeakSender` cannot be upgraded after a `Sender` was dropped, -+// which existed at the time of the `downgrade` call. -+#[test] -+fn downgrade_drop_upgrade() { -+ let (tx, _rx) = mpsc::channel::(1); -+ -+ // the cloned `Tx` is dropped right away -+ let weak_tx = tx.clone().downgrade(); -+ drop(tx); -+ assert!(weak_tx.upgrade().is_none()); -+} -+ -+// Tests that we can upgrade a weak sender with an outstanding permit -+// but no other strong senders. -+#[tokio::test] -+async fn downgrade_get_permit_upgrade_no_senders() { -+ let (tx, _rx) = mpsc::channel::(1); -+ let weak_tx = tx.downgrade(); -+ let _permit = tx.reserve_owned().await.unwrap(); -+ assert!(weak_tx.upgrade().is_some()); -+} -+ -+// Tests that you can downgrade and upgrade a sender with an outstanding permit -+// but no other senders left. -+#[tokio::test] -+async fn downgrade_upgrade_get_permit_no_senders() { -+ let (tx, _rx) = mpsc::channel::(1); -+ let tx2 = tx.clone(); -+ let _permit = tx.reserve_owned().await.unwrap(); -+ let weak_tx = tx2.downgrade(); -+ drop(tx2); -+ assert!(weak_tx.upgrade().is_some()); -+} -+ -+// Tests that `downgrade` does not change the `tx_count` of the channel. -+#[test] -+fn test_tx_count_weak_sender() { -+ let (tx, _rx) = mpsc::channel::(1); -+ let tx_weak = tx.downgrade(); -+ let tx_weak2 = tx.downgrade(); -+ drop(tx); -+ -+ assert!(tx_weak.upgrade().is_none() && tx_weak2.upgrade().is_none()); -+} -+ -+#[tokio::test] -+async fn weak_unbounded_sender() { -+ let (tx, mut rx) = unbounded_channel(); -+ -+ let tx_weak = tokio::spawn(async move { -+ let tx_weak = tx.clone().downgrade(); -+ -+ for i in 0..10 { -+ if tx.send(i).is_err() { -+ return None; -+ } -+ } -+ -+ let tx2 = tx_weak -+ .upgrade() -+ .expect("expected to be able to upgrade tx_weak"); -+ let _ = tx2.send(20); -+ let tx_weak = tx2.downgrade(); -+ -+ Some(tx_weak) -+ }) -+ .await -+ .unwrap(); -+ -+ for i in 0..12 { -+ let recvd = rx.recv().await; -+ -+ match recvd { -+ Some(msg) => { -+ if i == 10 { -+ assert_eq!(msg, 20); -+ } -+ } -+ None => { -+ assert_eq!(i, 11); -+ break; -+ } -+ } -+ } -+ -+ let tx_weak = tx_weak.unwrap(); -+ let upgraded = tx_weak.upgrade(); -+ assert!(upgraded.is_none()); -+} -+ -+#[tokio::test] -+async fn actor_weak_unbounded_sender() { -+ pub struct MyActor { -+ receiver: mpsc::UnboundedReceiver, -+ sender: mpsc::WeakUnboundedSender, -+ next_id: u32, -+ pub received_self_msg: bool, -+ } -+ -+ enum ActorMessage { -+ GetUniqueId { respond_to: oneshot::Sender }, -+ SelfMessage {}, -+ } -+ -+ impl MyActor { -+ fn new( -+ receiver: mpsc::UnboundedReceiver, -+ sender: mpsc::WeakUnboundedSender, -+ ) -> Self { -+ MyActor { -+ receiver, -+ sender, -+ next_id: 0, -+ received_self_msg: false, -+ } -+ } -+ -+ fn handle_message(&mut self, msg: ActorMessage) { -+ match msg { -+ ActorMessage::GetUniqueId { respond_to } => { -+ self.next_id += 1; -+ -+ // The `let _ =` ignores any errors when sending. -+ // -+ // This can happen if the `select!` macro is used -+ // to cancel waiting for the response. -+ let _ = respond_to.send(self.next_id); -+ } -+ ActorMessage::SelfMessage { .. } => { -+ self.received_self_msg = true; -+ } -+ } -+ } -+ -+ async fn send_message_to_self(&mut self) { -+ let msg = ActorMessage::SelfMessage {}; -+ -+ let sender = self.sender.clone(); -+ -+ // cannot move self.sender here -+ if let Some(sender) = sender.upgrade() { -+ let _ = sender.send(msg); -+ self.sender = sender.downgrade(); -+ } -+ } -+ -+ async fn run(&mut self) { -+ let mut i = 0; -+ while let Some(msg) = self.receiver.recv().await { -+ self.handle_message(msg); -+ -+ if i == 0 { -+ self.send_message_to_self().await; -+ } -+ -+ i += 1 -+ } -+ -+ assert!(self.received_self_msg); -+ } -+ } -+ -+ #[derive(Clone)] -+ pub struct MyActorHandle { -+ sender: mpsc::UnboundedSender, -+ } -+ -+ impl MyActorHandle { -+ pub fn new() -> (Self, MyActor) { -+ let (sender, receiver) = mpsc::unbounded_channel(); -+ let actor = MyActor::new(receiver, sender.clone().downgrade()); -+ -+ (Self { sender }, actor) -+ } -+ -+ pub async fn get_unique_id(&self) -> u32 { -+ let (send, recv) = oneshot::channel(); -+ let msg = ActorMessage::GetUniqueId { respond_to: send }; -+ -+ // Ignore send errors. If this send fails, so does the -+ // recv.await below. There's no reason to check the -+ // failure twice. -+ let _ = self.sender.send(msg); -+ recv.await.expect("Actor task has been killed") -+ } -+ } -+ -+ let (handle, mut actor) = MyActorHandle::new(); -+ -+ let actor_handle = tokio::spawn(async move { actor.run().await }); -+ -+ let _ = tokio::spawn(async move { -+ let _ = handle.get_unique_id().await; -+ drop(handle); -+ }) -+ .await; -+ -+ let _ = actor_handle.await; -+} -+ -+static NUM_DROPPED_UNBOUNDED: AtomicUsize = AtomicUsize::new(0); -+ -+#[derive(Debug)] -+struct MsgUnbounded; -+ -+impl Drop for MsgUnbounded { -+ fn drop(&mut self) { -+ NUM_DROPPED_UNBOUNDED.fetch_add(1, Release); -+ } -+} -+ -+// Tests that no pending messages are put onto the channel after `Rx` was -+// dropped. -+// -+// Note: After the introduction of `UnboundedWeakSender`, which internally -+// used `Arc` and doesn't call a drop of the channel after the last strong -+// `UnboundedSender` was dropped while more than one `UnboundedWeakSender` -+// remains, we want to ensure that no messages are kept in the channel, which -+// were sent after the receiver was dropped. -+#[tokio::test] -+async fn test_msgs_dropped_on_unbounded_rx_drop() { -+ let (tx, mut rx) = mpsc::unbounded_channel(); -+ -+ tx.send(MsgUnbounded {}).unwrap(); -+ tx.send(MsgUnbounded {}).unwrap(); -+ -+ // This msg will be pending and should be dropped when `rx` is dropped -+ let sent = tx.send(MsgUnbounded {}); -+ -+ let _ = rx.recv().await.unwrap(); -+ let _ = rx.recv().await.unwrap(); -+ -+ sent.unwrap(); -+ -+ drop(rx); -+ -+ assert_eq!(NUM_DROPPED_UNBOUNDED.load(Acquire), 3); -+ -+ // This msg will not be put onto `Tx` list anymore, since `Rx` is closed. -+ assert!(tx.send(MsgUnbounded {}).is_err()); -+ -+ assert_eq!(NUM_DROPPED_UNBOUNDED.load(Acquire), 4); -+} -+ -+// Tests that an `WeakUnboundedSender` is upgradeable when other -+// `UnboundedSender`s exist. -+#[test] -+fn downgrade_upgrade_unbounded_sender_success() { -+ let (tx, _rx) = mpsc::unbounded_channel::(); -+ let weak_tx = tx.downgrade(); -+ assert!(weak_tx.upgrade().is_some()); -+} -+ -+// Tests that a `WeakUnboundedSender` fails to upgrade when no other -+// `UnboundedSender` exists. -+#[test] -+fn downgrade_upgrade_unbounded_sender_failure() { -+ let (tx, _rx) = mpsc::unbounded_channel::(); -+ let weak_tx = tx.downgrade(); -+ drop(tx); -+ assert!(weak_tx.upgrade().is_none()); -+} -+ -+// Tests that an `WeakUnboundedSender` cannot be upgraded after an -+// `UnboundedSender` was dropped, which existed at the time of the `downgrade` call. -+#[test] -+fn downgrade_drop_upgrade_unbounded() { -+ let (tx, _rx) = mpsc::unbounded_channel::(); -+ -+ // the cloned `Tx` is dropped right away -+ let weak_tx = tx.clone().downgrade(); -+ drop(tx); -+ assert!(weak_tx.upgrade().is_none()); -+} -+ -+// Tests that `downgrade` does not change the `tx_count` of the channel. -+#[test] -+fn test_tx_count_weak_unbounded_sender() { -+ let (tx, _rx) = mpsc::unbounded_channel::(); -+ let tx_weak = tx.downgrade(); -+ let tx_weak2 = tx.downgrade(); -+ drop(tx); -+ -+ assert!(tx_weak.upgrade().is_none() && tx_weak2.upgrade().is_none()); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_mutex.rs b/KubeOS-Rust/vendor/tokio/tests/sync_mutex.rs -index 090db94b..1e35a558 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_mutex.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_mutex.rs -@@ -1,13 +1,19 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; -+ -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; - - use tokio::sync::Mutex; --use tokio::time::{interval, timeout}; - use tokio_test::task::spawn; - use tokio_test::{assert_pending, assert_ready}; - - use std::sync::Arc; --use std::time::Duration; - - #[test] - fn straight_execution() { -@@ -47,7 +53,7 @@ fn readiness() { - // But once g unlocks, we can acquire it - drop(g); - assert!(t2.is_woken()); -- assert_ready!(t2.poll()); -+ let _t2 = assert_ready!(t2.poll()); - } - - /* -@@ -82,10 +88,14 @@ fn lock() { - } - */ - --#[tokio::test] - /// Ensure a mutex is unlocked if a future holding the lock - /// is aborted prematurely. -+#[tokio::test] -+#[cfg(feature = "full")] - async fn aborted_future_1() { -+ use std::time::Duration; -+ use tokio::time::{interval, timeout}; -+ - let m1: Arc> = Arc::new(Mutex::new(0)); - { - let m2 = m1.clone(); -@@ -93,7 +103,7 @@ async fn aborted_future_1() { - timeout(Duration::from_millis(1u64), async move { - let iv = interval(Duration::from_millis(1000)); - tokio::pin!(iv); -- m2.lock().await; -+ let _g = m2.lock().await; - iv.as_mut().tick().await; - iv.as_mut().tick().await; - }) -@@ -102,16 +112,20 @@ async fn aborted_future_1() { - } - // This should succeed as there is no lock left for the mutex. - timeout(Duration::from_millis(1u64), async move { -- m1.lock().await; -+ let _g = m1.lock().await; - }) - .await - .expect("Mutex is locked"); - } - --#[tokio::test] - /// This test is similar to `aborted_future_1` but this time the - /// aborted future is waiting for the lock. -+#[tokio::test] -+#[cfg(feature = "full")] - async fn aborted_future_2() { -+ use std::time::Duration; -+ use tokio::time::timeout; -+ - let m1: Arc> = Arc::new(Mutex::new(0)); - { - // Lock mutex -@@ -120,7 +134,7 @@ async fn aborted_future_2() { - let m2 = m1.clone(); - // Try to lock mutex in a future that is aborted prematurely - timeout(Duration::from_millis(1u64), async move { -- m2.lock().await; -+ let _g = m2.lock().await; - }) - .await - .unwrap_err(); -@@ -128,7 +142,7 @@ async fn aborted_future_2() { - } - // This should succeed as there is no lock left for the mutex. - timeout(Duration::from_millis(1u64), async move { -- m1.lock().await; -+ let _g = m1.lock().await; - }) - .await - .expect("Mutex is locked"); -@@ -141,20 +155,20 @@ fn try_lock() { - let g1 = m.try_lock(); - assert!(g1.is_ok()); - let g2 = m.try_lock(); -- assert!(!g2.is_ok()); -+ assert!(g2.is_err()); - } - let g3 = m.try_lock(); - assert!(g3.is_ok()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn debug_format() { - let s = "debug"; - let m = Mutex::new(s.to_string()); - assert_eq!(format!("{:?}", s), format!("{:?}", m.lock().await)); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn mutex_debug() { - let s = "data"; - let m = Mutex::new(s.to_string()); -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_mutex_owned.rs b/KubeOS-Rust/vendor/tokio/tests/sync_mutex_owned.rs -index 898bf352..ba472fee 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_mutex_owned.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_mutex_owned.rs -@@ -1,13 +1,19 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; -+ -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; - - use tokio::sync::Mutex; --use tokio::time::{interval, timeout}; - use tokio_test::task::spawn; - use tokio_test::{assert_pending, assert_ready}; - - use std::sync::Arc; --use std::time::Duration; - - #[test] - fn straight_execution() { -@@ -49,10 +55,14 @@ fn readiness() { - assert_ready!(t2.poll()); - } - --#[tokio::test] - /// Ensure a mutex is unlocked if a future holding the lock - /// is aborted prematurely. -+#[tokio::test] -+#[cfg(feature = "full")] - async fn aborted_future_1() { -+ use std::time::Duration; -+ use tokio::time::{interval, timeout}; -+ - let m1: Arc> = Arc::new(Mutex::new(0)); - { - let m2 = m1.clone(); -@@ -75,10 +85,14 @@ async fn aborted_future_1() { - .expect("Mutex is locked"); - } - --#[tokio::test] - /// This test is similar to `aborted_future_1` but this time the - /// aborted future is waiting for the lock. -+#[tokio::test] -+#[cfg(feature = "full")] - async fn aborted_future_2() { -+ use std::time::Duration; -+ use tokio::time::timeout; -+ - let m1: Arc> = Arc::new(Mutex::new(0)); - { - // Lock mutex -@@ -108,13 +122,13 @@ fn try_lock_owned() { - let g1 = m.clone().try_lock_owned(); - assert!(g1.is_ok()); - let g2 = m.clone().try_lock_owned(); -- assert!(!g2.is_ok()); -+ assert!(g2.is_err()); - } - let g3 = m.try_lock_owned(); - assert!(g3.is_ok()); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn debug_format() { - let s = "debug"; - let m = Arc::new(Mutex::new(s.to_string())); -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_notify.rs b/KubeOS-Rust/vendor/tokio/tests/sync_notify.rs -index 6c6620b2..aa58039f 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_notify.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_notify.rs -@@ -1,5 +1,8 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; - - use tokio::sync::Notify; - use tokio_test::task::spawn; -@@ -151,3 +154,74 @@ fn notify_one_after_dropped_all() { - - assert_ready!(notified2.poll()); - } -+ -+#[test] -+fn test_notify_one_not_enabled() { -+ let notify = Notify::new(); -+ let mut future = spawn(notify.notified()); -+ -+ notify.notify_one(); -+ assert_ready!(future.poll()); -+} -+ -+#[test] -+fn test_notify_one_after_enable() { -+ let notify = Notify::new(); -+ let mut future = spawn(notify.notified()); -+ -+ future.enter(|_, fut| assert!(!fut.enable())); -+ -+ notify.notify_one(); -+ assert_ready!(future.poll()); -+ future.enter(|_, fut| assert!(fut.enable())); -+} -+ -+#[test] -+fn test_poll_after_enable() { -+ let notify = Notify::new(); -+ let mut future = spawn(notify.notified()); -+ -+ future.enter(|_, fut| assert!(!fut.enable())); -+ assert_pending!(future.poll()); -+} -+ -+#[test] -+fn test_enable_after_poll() { -+ let notify = Notify::new(); -+ let mut future = spawn(notify.notified()); -+ -+ assert_pending!(future.poll()); -+ future.enter(|_, fut| assert!(!fut.enable())); -+} -+ -+#[test] -+fn test_enable_consumes_permit() { -+ let notify = Notify::new(); -+ -+ // Add a permit. -+ notify.notify_one(); -+ -+ let mut future1 = spawn(notify.notified()); -+ future1.enter(|_, fut| assert!(fut.enable())); -+ -+ let mut future2 = spawn(notify.notified()); -+ future2.enter(|_, fut| assert!(!fut.enable())); -+} -+ -+#[test] -+fn test_waker_update() { -+ use futures::task::noop_waker; -+ use std::future::Future; -+ use std::task::Context; -+ -+ let notify = Notify::new(); -+ let mut future = spawn(notify.notified()); -+ -+ let noop = noop_waker(); -+ future.enter(|_, fut| assert_pending!(fut.poll(&mut Context::from_waker(&noop)))); -+ -+ assert_pending!(future.poll()); -+ notify.notify_one(); -+ -+ assert!(future.is_woken()); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_once_cell.rs b/KubeOS-Rust/vendor/tokio/tests/sync_once_cell.rs -index 18eaf938..38dfa7ca 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_once_cell.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_once_cell.rs -@@ -4,178 +4,7 @@ - use std::mem; - use std::ops::Drop; - use std::sync::atomic::{AtomicU32, Ordering}; --use std::time::Duration; --use tokio::runtime; --use tokio::sync::{OnceCell, SetError}; --use tokio::time; -- --async fn func1() -> u32 { -- 5 --} -- --async fn func2() -> u32 { -- time::sleep(Duration::from_millis(1)).await; -- 10 --} -- --async fn func_err() -> Result { -- Err(()) --} -- --async fn func_ok() -> Result { -- Ok(10) --} -- --async fn func_panic() -> u32 { -- time::sleep(Duration::from_millis(1)).await; -- panic!(); --} -- --async fn sleep_and_set() -> u32 { -- // Simulate sleep by pausing time and waiting for another thread to -- // resume clock when calling `set`, then finding the cell being initialized -- // by this call -- time::sleep(Duration::from_millis(2)).await; -- 5 --} -- --async fn advance_time_and_set(cell: &'static OnceCell, v: u32) -> Result<(), SetError> { -- time::advance(Duration::from_millis(1)).await; -- cell.set(v) --} -- --#[test] --fn get_or_init() { -- let rt = runtime::Builder::new_current_thread() -- .enable_time() -- .start_paused(true) -- .build() -- .unwrap(); -- -- static ONCE: OnceCell = OnceCell::const_new(); -- -- rt.block_on(async { -- let handle1 = rt.spawn(async { ONCE.get_or_init(func1).await }); -- let handle2 = rt.spawn(async { ONCE.get_or_init(func2).await }); -- -- time::advance(Duration::from_millis(1)).await; -- time::resume(); -- -- let result1 = handle1.await.unwrap(); -- let result2 = handle2.await.unwrap(); -- -- assert_eq!(*result1, 5); -- assert_eq!(*result2, 5); -- }); --} -- --#[test] --fn get_or_init_panic() { -- let rt = runtime::Builder::new_current_thread() -- .enable_time() -- .build() -- .unwrap(); -- -- static ONCE: OnceCell = OnceCell::const_new(); -- -- rt.block_on(async { -- time::pause(); -- -- let handle1 = rt.spawn(async { ONCE.get_or_init(func1).await }); -- let handle2 = rt.spawn(async { ONCE.get_or_init(func_panic).await }); -- -- time::advance(Duration::from_millis(1)).await; -- -- let result1 = handle1.await.unwrap(); -- let result2 = handle2.await.unwrap(); -- -- assert_eq!(*result1, 5); -- assert_eq!(*result2, 5); -- }); --} -- --#[test] --fn set_and_get() { -- let rt = runtime::Builder::new_current_thread() -- .enable_time() -- .build() -- .unwrap(); -- -- static ONCE: OnceCell = OnceCell::const_new(); -- -- rt.block_on(async { -- let _ = rt.spawn(async { ONCE.set(5) }).await; -- let value = ONCE.get().unwrap(); -- assert_eq!(*value, 5); -- }); --} -- --#[test] --fn get_uninit() { -- static ONCE: OnceCell = OnceCell::const_new(); -- let uninit = ONCE.get(); -- assert!(uninit.is_none()); --} -- --#[test] --fn set_twice() { -- static ONCE: OnceCell = OnceCell::const_new(); -- -- let first = ONCE.set(5); -- assert_eq!(first, Ok(())); -- let second = ONCE.set(6); -- assert!(second.err().unwrap().is_already_init_err()); --} -- --#[test] --fn set_while_initializing() { -- let rt = runtime::Builder::new_current_thread() -- .enable_time() -- .build() -- .unwrap(); -- -- static ONCE: OnceCell = OnceCell::const_new(); -- -- rt.block_on(async { -- time::pause(); -- -- let handle1 = rt.spawn(async { ONCE.get_or_init(sleep_and_set).await }); -- let handle2 = rt.spawn(async { advance_time_and_set(&ONCE, 10).await }); -- -- time::advance(Duration::from_millis(2)).await; -- -- let result1 = handle1.await.unwrap(); -- let result2 = handle2.await.unwrap(); -- -- assert_eq!(*result1, 5); -- assert!(result2.err().unwrap().is_initializing_err()); -- }); --} -- --#[test] --fn get_or_try_init() { -- let rt = runtime::Builder::new_current_thread() -- .enable_time() -- .start_paused(true) -- .build() -- .unwrap(); -- -- static ONCE: OnceCell = OnceCell::const_new(); -- -- rt.block_on(async { -- let handle1 = rt.spawn(async { ONCE.get_or_try_init(func_err).await }); -- let handle2 = rt.spawn(async { ONCE.get_or_try_init(func_ok).await }); -- -- time::advance(Duration::from_millis(1)).await; -- time::resume(); -- -- let result1 = handle1.await.unwrap(); -- assert!(result1.is_err()); -- -- let result2 = handle2.await.unwrap(); -- assert_eq!(*result2.unwrap(), 10); -- }); --} -+use tokio::sync::OnceCell; - - #[test] - fn drop_cell() { -@@ -272,3 +101,185 @@ fn from() { - let cell = OnceCell::from(2); - assert_eq!(*cell.get().unwrap(), 2); - } -+ -+#[cfg(feature = "parking_lot")] -+mod parking_lot { -+ use super::*; -+ -+ use tokio::runtime; -+ use tokio::sync::SetError; -+ use tokio::time; -+ -+ use std::time::Duration; -+ -+ async fn func1() -> u32 { -+ 5 -+ } -+ -+ async fn func2() -> u32 { -+ time::sleep(Duration::from_millis(1)).await; -+ 10 -+ } -+ -+ async fn func_err() -> Result { -+ Err(()) -+ } -+ -+ async fn func_ok() -> Result { -+ Ok(10) -+ } -+ -+ async fn func_panic() -> u32 { -+ time::sleep(Duration::from_millis(1)).await; -+ panic!(); -+ } -+ -+ async fn sleep_and_set() -> u32 { -+ // Simulate sleep by pausing time and waiting for another thread to -+ // resume clock when calling `set`, then finding the cell being initialized -+ // by this call -+ time::sleep(Duration::from_millis(2)).await; -+ 5 -+ } -+ -+ async fn advance_time_and_set( -+ cell: &'static OnceCell, -+ v: u32, -+ ) -> Result<(), SetError> { -+ time::advance(Duration::from_millis(1)).await; -+ cell.set(v) -+ } -+ -+ #[test] -+ fn get_or_init() { -+ let rt = runtime::Builder::new_current_thread() -+ .enable_time() -+ .start_paused(true) -+ .build() -+ .unwrap(); -+ -+ static ONCE: OnceCell = OnceCell::const_new(); -+ -+ rt.block_on(async { -+ let handle1 = rt.spawn(async { ONCE.get_or_init(func1).await }); -+ let handle2 = rt.spawn(async { ONCE.get_or_init(func2).await }); -+ -+ time::advance(Duration::from_millis(1)).await; -+ time::resume(); -+ -+ let result1 = handle1.await.unwrap(); -+ let result2 = handle2.await.unwrap(); -+ -+ assert_eq!(*result1, 5); -+ assert_eq!(*result2, 5); -+ }); -+ } -+ -+ #[test] -+ fn get_or_init_panic() { -+ let rt = runtime::Builder::new_current_thread() -+ .enable_time() -+ .build() -+ .unwrap(); -+ -+ static ONCE: OnceCell = OnceCell::const_new(); -+ -+ rt.block_on(async { -+ time::pause(); -+ -+ let handle1 = rt.spawn(async { ONCE.get_or_init(func1).await }); -+ let handle2 = rt.spawn(async { ONCE.get_or_init(func_panic).await }); -+ -+ time::advance(Duration::from_millis(1)).await; -+ -+ let result1 = handle1.await.unwrap(); -+ let result2 = handle2.await.unwrap(); -+ -+ assert_eq!(*result1, 5); -+ assert_eq!(*result2, 5); -+ }); -+ } -+ -+ #[test] -+ fn set_and_get() { -+ let rt = runtime::Builder::new_current_thread() -+ .enable_time() -+ .build() -+ .unwrap(); -+ -+ static ONCE: OnceCell = OnceCell::const_new(); -+ -+ rt.block_on(async { -+ let _ = rt.spawn(async { ONCE.set(5) }).await; -+ let value = ONCE.get().unwrap(); -+ assert_eq!(*value, 5); -+ }); -+ } -+ -+ #[test] -+ fn get_uninit() { -+ static ONCE: OnceCell = OnceCell::const_new(); -+ let uninit = ONCE.get(); -+ assert!(uninit.is_none()); -+ } -+ -+ #[test] -+ fn set_twice() { -+ static ONCE: OnceCell = OnceCell::const_new(); -+ -+ let first = ONCE.set(5); -+ assert_eq!(first, Ok(())); -+ let second = ONCE.set(6); -+ assert!(second.err().unwrap().is_already_init_err()); -+ } -+ -+ #[test] -+ fn set_while_initializing() { -+ let rt = runtime::Builder::new_current_thread() -+ .enable_time() -+ .build() -+ .unwrap(); -+ -+ static ONCE: OnceCell = OnceCell::const_new(); -+ -+ rt.block_on(async { -+ time::pause(); -+ -+ let handle1 = rt.spawn(async { ONCE.get_or_init(sleep_and_set).await }); -+ let handle2 = rt.spawn(async { advance_time_and_set(&ONCE, 10).await }); -+ -+ time::advance(Duration::from_millis(2)).await; -+ -+ let result1 = handle1.await.unwrap(); -+ let result2 = handle2.await.unwrap(); -+ -+ assert_eq!(*result1, 5); -+ assert!(result2.err().unwrap().is_initializing_err()); -+ }); -+ } -+ -+ #[test] -+ fn get_or_try_init() { -+ let rt = runtime::Builder::new_current_thread() -+ .enable_time() -+ .start_paused(true) -+ .build() -+ .unwrap(); -+ -+ static ONCE: OnceCell = OnceCell::const_new(); -+ -+ rt.block_on(async { -+ let handle1 = rt.spawn(async { ONCE.get_or_try_init(func_err).await }); -+ let handle2 = rt.spawn(async { ONCE.get_or_try_init(func_ok).await }); -+ -+ time::advance(Duration::from_millis(1)).await; -+ time::resume(); -+ -+ let result1 = handle1.await.unwrap(); -+ assert!(result1.is_err()); -+ -+ let result2 = handle2.await.unwrap(); -+ assert_eq!(*result2.unwrap(), 10); -+ }); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_oneshot.rs b/KubeOS-Rust/vendor/tokio/tests/sync_oneshot.rs -index 1aab810e..15b69237 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_oneshot.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_oneshot.rs -@@ -1,5 +1,13 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; -+ -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; - - use tokio::sync::oneshot; - use tokio::sync::oneshot::error::TryRecvError; -@@ -40,7 +48,7 @@ fn send_recv() { - assert_eq!(val, 1); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn async_send_recv() { - let (tx, rx) = oneshot::channel(); - -@@ -86,6 +94,7 @@ fn close_rx() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn async_rx_closed() { - let (mut tx, rx) = oneshot::channel::<()>(); - -@@ -170,6 +179,7 @@ fn explicit_close_try_recv() { - - #[test] - #[should_panic] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - fn close_try_recv_poll() { - let (_tx, rx) = oneshot::channel::(); - let mut rx = task::spawn(rx); -@@ -202,6 +212,18 @@ fn try_recv_after_completion() { - rx.close(); - } - -+#[test] -+fn try_recv_after_completion_await() { -+ let (tx, rx) = oneshot::channel::(); -+ let mut rx = task::spawn(rx); -+ -+ tx.send(17).unwrap(); -+ -+ assert_eq!(Ok(17), assert_ready!(rx.poll())); -+ assert_eq!(Err(TryRecvError::Closed), rx.try_recv()); -+ rx.close(); -+} -+ - #[test] - fn drops_tasks() { - let (mut tx, mut rx) = oneshot::channel::(); -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_panic.rs b/KubeOS-Rust/vendor/tokio/tests/sync_panic.rs -new file mode 100644 -index 00000000..6c236649 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_panic.rs -@@ -0,0 +1,197 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] -+ -+use std::{error::Error, sync::Arc}; -+use tokio::{ -+ runtime::{Builder, Runtime}, -+ sync::{broadcast, mpsc, oneshot, Mutex, RwLock, Semaphore}, -+}; -+ -+mod support { -+ pub mod panic; -+} -+use support::panic::test_panic; -+ -+#[test] -+fn broadcast_channel_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let (_, _) = broadcast::channel::(0); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn mutex_blocking_lock_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ rt.block_on(async { -+ let mutex = Mutex::new(5_u32); -+ let _g = mutex.blocking_lock(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn oneshot_blocking_recv_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ rt.block_on(async { -+ let (_tx, rx) = oneshot::channel::(); -+ let _ = rx.blocking_recv(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn rwlock_with_max_readers_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let _ = RwLock::::with_max_readers(0, (u32::MAX >> 3) + 1); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn rwlock_blocking_read_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ rt.block_on(async { -+ let lock = RwLock::::new(0); -+ let _ = lock.blocking_read(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn rwlock_blocking_write_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ rt.block_on(async { -+ let lock = RwLock::::new(0); -+ let _ = lock.blocking_write(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn mpsc_bounded_channel_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let (_, _) = mpsc::channel::(0); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn mpsc_bounded_receiver_blocking_recv_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ let (_tx, mut rx) = mpsc::channel::(1); -+ rt.block_on(async { -+ let _ = rx.blocking_recv(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn mpsc_bounded_sender_blocking_send_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ let (tx, _rx) = mpsc::channel::(1); -+ rt.block_on(async { -+ let _ = tx.blocking_send(3); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn mpsc_unbounded_receiver_blocking_recv_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ let (_tx, mut rx) = mpsc::unbounded_channel::(); -+ rt.block_on(async { -+ let _ = rx.blocking_recv(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn semaphore_merge_unrelated_owned_permits() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let sem1 = Arc::new(Semaphore::new(42)); -+ let sem2 = Arc::new(Semaphore::new(42)); -+ let mut p1 = sem1.try_acquire_owned().unwrap(); -+ let p2 = sem2.try_acquire_owned().unwrap(); -+ p1.merge(p2); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn semaphore_merge_unrelated_permits() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let sem1 = Semaphore::new(42); -+ let sem2 = Semaphore::new(42); -+ let mut p1 = sem1.try_acquire().unwrap(); -+ let p2 = sem2.try_acquire().unwrap(); -+ p1.merge(p2); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+fn current_thread() -> Runtime { -+ Builder::new_current_thread().enable_all().build().unwrap() -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_rwlock.rs b/KubeOS-Rust/vendor/tokio/tests/sync_rwlock.rs -index 7d05086b..667f6217 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_rwlock.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_rwlock.rs -@@ -1,13 +1,19 @@ - #![warn(rust_2018_idioms)] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test; -+ -+#[cfg(not(tokio_wasm_not_wasi))] -+use tokio::test as maybe_tokio_test; - --use std::sync::Arc; - use std::task::Poll; - - use futures::future::FutureExt; --use futures::stream; --use futures::stream::StreamExt; - --use tokio::sync::{Barrier, RwLock}; -+use tokio::sync::{RwLock, RwLockWriteGuard}; - use tokio_test::task::spawn; - use tokio_test::{assert_pending, assert_ready}; - -@@ -25,7 +31,7 @@ fn read_shared() { - let mut t1 = spawn(rwlock.read()); - let _g1 = assert_ready!(t1.poll()); - let mut t2 = spawn(rwlock.read()); -- assert_ready!(t2.poll()); -+ let _g2 = assert_ready!(t2.poll()); - } - - // When there is an active shared owner, exclusive access should not be possible -@@ -69,7 +75,7 @@ fn exhaust_reading() { - let g2 = reads.pop().unwrap(); - drop(g2); - assert!(t1.is_woken()); -- assert_ready!(t1.poll()); -+ let _g1 = assert_ready!(t1.poll()); - } - - // When there is an active exclusive owner, subsequent exclusive access should not be possible -@@ -94,7 +100,7 @@ fn write_shared_drop() { - assert_pending!(t2.poll()); - drop(g1); - assert!(t2.is_woken()); -- assert_ready!(t2.poll()); -+ let _g2 = assert_ready!(t2.poll()); - } - - // when there is an active shared owner, and exclusive access is triggered, -@@ -106,7 +112,7 @@ fn write_read_shared_pending() { - let _g1 = assert_ready!(t1.poll()); - - let mut t2 = spawn(rwlock.read()); -- assert_ready!(t2.poll()); -+ let _g2 = assert_ready!(t2.poll()); - - let mut t3 = spawn(rwlock.write()); - assert_pending!(t3.poll()); -@@ -131,11 +137,11 @@ fn write_read_shared_drop_pending() { - drop(t2); - - assert!(t3.is_woken()); -- assert_ready!(t3.poll()); -+ let _t3 = assert_ready!(t3.poll()); - } - - // Acquire an RwLock nonexclusively by a single task --#[tokio::test] -+#[maybe_tokio_test] - async fn read_uncontested() { - let rwlock = RwLock::new(100); - let result = *rwlock.read().await; -@@ -144,7 +150,7 @@ async fn read_uncontested() { - } - - // Acquire an uncontested RwLock in exclusive mode --#[tokio::test] -+#[maybe_tokio_test] - async fn write_uncontested() { - let rwlock = RwLock::new(100); - let mut result = rwlock.write().await; -@@ -153,7 +159,7 @@ async fn write_uncontested() { - } - - // RwLocks should be acquired in the order that their Futures are waited upon. --#[tokio::test] -+#[maybe_tokio_test] - async fn write_order() { - let rwlock = RwLock::>::new(vec![]); - let fut2 = rwlock.write().map(|mut guard| guard.push(2)); -@@ -166,8 +172,13 @@ async fn write_order() { - } - - // A single RwLock is contested by tasks in multiple threads -+#[cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread", worker_threads = 8)] - async fn multithreaded() { -+ use futures::stream::{self, StreamExt}; -+ use std::sync::Arc; -+ use tokio::sync::Barrier; -+ - let barrier = Arc::new(Barrier::new(5)); - let rwlock = Arc::new(RwLock::::new(0)); - let rwclone1 = rwlock.clone(); -@@ -236,7 +247,7 @@ async fn multithreaded() { - assert_eq!(*g, 17_000); - } - --#[tokio::test] -+#[maybe_tokio_test] - async fn try_write() { - let lock = RwLock::new(0); - let read_guard = lock.read().await; -@@ -268,3 +279,53 @@ fn try_read_try_write() { - - assert_eq!(*lock.try_read().unwrap(), 1515); - } -+ -+#[maybe_tokio_test] -+async fn downgrade_map() { -+ let lock = RwLock::new(0); -+ let write_guard = lock.write().await; -+ let mut read_t = spawn(lock.read()); -+ -+ // We can't create a read when a write exists -+ assert_pending!(read_t.poll()); -+ -+ // During the call to `f`, `read_t` doesn't have access yet. -+ let read_guard1 = RwLockWriteGuard::downgrade_map(write_guard, |v| { -+ assert_pending!(read_t.poll()); -+ v -+ }); -+ -+ // After the downgrade, `read_t` got the lock -+ let read_guard2 = assert_ready!(read_t.poll()); -+ -+ // Ensure they're equal, as we return the original value -+ assert_eq!(&*read_guard1 as *const _, &*read_guard2 as *const _); -+} -+ -+#[maybe_tokio_test] -+async fn try_downgrade_map() { -+ let lock = RwLock::new(0); -+ let write_guard = lock.write().await; -+ let mut read_t = spawn(lock.read()); -+ -+ // We can't create a read when a write exists -+ assert_pending!(read_t.poll()); -+ -+ // During the call to `f`, `read_t` doesn't have access yet. -+ let write_guard = RwLockWriteGuard::try_downgrade_map(write_guard, |_| { -+ assert_pending!(read_t.poll()); -+ None::<&()> -+ }) -+ .expect_err("downgrade didn't fail"); -+ -+ // After `f` returns `None`, `read_t` doesn't have access -+ assert_pending!(read_t.poll()); -+ -+ // After `f` returns `Some`, `read_t` does have access -+ let read_guard1 = RwLockWriteGuard::try_downgrade_map(write_guard, |v| Some(v)) -+ .expect("downgrade didn't succeed"); -+ let read_guard2 = assert_ready!(read_t.poll()); -+ -+ // Ensure they're equal, as we return the original value -+ assert_eq!(&*read_guard1 as *const _, &*read_guard2 as *const _); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_semaphore.rs b/KubeOS-Rust/vendor/tokio/tests/sync_semaphore.rs -index a33b878b..3d47ed0e 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_semaphore.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_semaphore.rs -@@ -1,4 +1,7 @@ --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; - - use std::sync::Arc; - use tokio::sync::Semaphore; -@@ -23,6 +26,7 @@ fn try_acquire() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn acquire() { - let sem = Arc::new(Semaphore::new(1)); - let p1 = sem.try_acquire().unwrap(); -@@ -35,6 +39,7 @@ async fn acquire() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn add_permits() { - let sem = Arc::new(Semaphore::new(0)); - let sem_clone = sem.clone(); -@@ -58,8 +63,34 @@ fn forget() { - assert!(sem.try_acquire().is_err()); - } - -+#[test] -+fn merge() { -+ let sem = Arc::new(Semaphore::new(3)); -+ { -+ let mut p1 = sem.try_acquire().unwrap(); -+ assert_eq!(sem.available_permits(), 2); -+ let p2 = sem.try_acquire_many(2).unwrap(); -+ assert_eq!(sem.available_permits(), 0); -+ p1.merge(p2); -+ assert_eq!(sem.available_permits(), 0); -+ } -+ assert_eq!(sem.available_permits(), 3); -+} -+ -+#[test] -+#[cfg(not(tokio_wasm))] // No stack unwinding on wasm targets -+#[should_panic] -+fn merge_unrelated_permits() { -+ let sem1 = Arc::new(Semaphore::new(3)); -+ let sem2 = Arc::new(Semaphore::new(3)); -+ let mut p1 = sem1.try_acquire().unwrap(); -+ let p2 = sem2.try_acquire().unwrap(); -+ p1.merge(p2); -+} -+ - #[tokio::test] --async fn stresstest() { -+#[cfg(feature = "full")] -+async fn stress_test() { - let sem = Arc::new(Semaphore::new(5)); - let mut join_handles = Vec::new(); - for _ in 0..1000 { -@@ -83,13 +114,37 @@ async fn stresstest() { - #[test] - fn add_max_amount_permits() { - let s = tokio::sync::Semaphore::new(0); -- s.add_permits(usize::MAX >> 3); -- assert_eq!(s.available_permits(), usize::MAX >> 3); -+ s.add_permits(tokio::sync::Semaphore::MAX_PERMITS); -+ assert_eq!(s.available_permits(), tokio::sync::Semaphore::MAX_PERMITS); - } - -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding - #[test] - #[should_panic] --fn add_more_than_max_amount_permits() { -+fn add_more_than_max_amount_permits1() { - let s = tokio::sync::Semaphore::new(1); -- s.add_permits(usize::MAX >> 3); -+ s.add_permits(tokio::sync::Semaphore::MAX_PERMITS); -+} -+ -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding -+#[test] -+#[should_panic] -+fn add_more_than_max_amount_permits2() { -+ let s = Semaphore::new(Semaphore::MAX_PERMITS - 1); -+ s.add_permits(1); -+ s.add_permits(1); -+} -+ -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding -+#[test] -+#[should_panic] -+fn panic_when_exceeds_maxpermits() { -+ let _ = Semaphore::new(Semaphore::MAX_PERMITS + 1); -+} -+ -+#[test] -+fn no_panic_at_maxpermits() { -+ let _ = Semaphore::new(Semaphore::MAX_PERMITS); -+ let s = Semaphore::new(Semaphore::MAX_PERMITS - 1); -+ s.add_permits(1); - } -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_semaphore_owned.rs b/KubeOS-Rust/vendor/tokio/tests/sync_semaphore_owned.rs -index 478c3a33..f6945764 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_semaphore_owned.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_semaphore_owned.rs -@@ -1,4 +1,7 @@ --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; - - use std::sync::Arc; - use tokio::sync::Semaphore; -@@ -33,6 +36,7 @@ fn try_acquire_many() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn acquire() { - let sem = Arc::new(Semaphore::new(1)); - let p1 = sem.clone().try_acquire_owned().unwrap(); -@@ -45,6 +49,7 @@ async fn acquire() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn acquire_many() { - let semaphore = Arc::new(Semaphore::new(42)); - let permit32 = semaphore.clone().try_acquire_many_owned(32).unwrap(); -@@ -60,6 +65,7 @@ async fn acquire_many() { - } - - #[tokio::test] -+#[cfg(feature = "full")] - async fn add_permits() { - let sem = Arc::new(Semaphore::new(0)); - let sem_clone = sem.clone(); -@@ -83,8 +89,34 @@ fn forget() { - assert!(sem.try_acquire_owned().is_err()); - } - -+#[test] -+fn merge() { -+ let sem = Arc::new(Semaphore::new(3)); -+ { -+ let mut p1 = sem.clone().try_acquire_owned().unwrap(); -+ assert_eq!(sem.available_permits(), 2); -+ let p2 = sem.clone().try_acquire_many_owned(2).unwrap(); -+ assert_eq!(sem.available_permits(), 0); -+ p1.merge(p2); -+ assert_eq!(sem.available_permits(), 0); -+ } -+ assert_eq!(sem.available_permits(), 3); -+} -+ -+#[test] -+#[cfg(not(tokio_wasm))] // No stack unwinding on wasm targets -+#[should_panic] -+fn merge_unrelated_permits() { -+ let sem1 = Arc::new(Semaphore::new(3)); -+ let sem2 = Arc::new(Semaphore::new(3)); -+ let mut p1 = sem1.try_acquire_owned().unwrap(); -+ let p2 = sem2.try_acquire_owned().unwrap(); -+ p1.merge(p2) -+} -+ - #[tokio::test] --async fn stresstest() { -+#[cfg(feature = "full")] -+async fn stress_test() { - let sem = Arc::new(Semaphore::new(5)); - let mut join_handles = Vec::new(); - for _ in 0..1000 { -diff --git a/KubeOS-Rust/vendor/tokio/tests/sync_watch.rs b/KubeOS-Rust/vendor/tokio/tests/sync_watch.rs -index b7bbaf72..d4f8ce87 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/sync_watch.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/sync_watch.rs -@@ -1,6 +1,9 @@ - #![allow(clippy::cognitive_complexity)] - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(feature = "sync")] -+ -+#[cfg(tokio_wasm_not_wasi)] -+use wasm_bindgen_test::wasm_bindgen_test as test; - - use tokio::sync::watch; - use tokio_test::task::spawn; -@@ -174,17 +177,24 @@ fn poll_close() { - fn borrow_and_update() { - let (tx, mut rx) = watch::channel("one"); - -+ assert!(!rx.has_changed().unwrap()); -+ - tx.send("two").unwrap(); -+ assert!(rx.has_changed().unwrap()); - assert_ready!(spawn(rx.changed()).poll()).unwrap(); - assert_pending!(spawn(rx.changed()).poll()); -+ assert!(!rx.has_changed().unwrap()); - - tx.send("three").unwrap(); -+ assert!(rx.has_changed().unwrap()); - assert_eq!(*rx.borrow_and_update(), "three"); - assert_pending!(spawn(rx.changed()).poll()); -+ assert!(!rx.has_changed().unwrap()); - - drop(tx); - assert_eq!(*rx.borrow_and_update(), "three"); - assert_ready!(spawn(rx.changed()).poll()).unwrap_err(); -+ assert!(rx.has_changed().is_err()); - } - - #[test] -@@ -201,3 +211,33 @@ fn reopened_after_subscribe() { - drop(rx); - assert!(tx.is_closed()); - } -+ -+#[test] -+#[cfg(panic = "unwind")] -+#[cfg(not(tokio_wasm))] // wasm currently doesn't support unwinding -+fn send_modify_panic() { -+ let (tx, mut rx) = watch::channel("one"); -+ -+ tx.send_modify(|old| *old = "two"); -+ assert_eq!(*rx.borrow_and_update(), "two"); -+ -+ let mut rx2 = rx.clone(); -+ assert_eq!(*rx2.borrow_and_update(), "two"); -+ -+ let mut task = spawn(rx2.changed()); -+ -+ let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { -+ tx.send_modify(|old| { -+ *old = "panicked"; -+ panic!(); -+ }) -+ })); -+ assert!(result.is_err()); -+ -+ assert_pending!(task.poll()); -+ assert_eq!(*rx.borrow(), "panicked"); -+ -+ tx.send_modify(|old| *old = "three"); -+ assert_ready_ok!(task.poll()); -+ assert_eq!(*rx.borrow_and_update(), "three"); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/task_abort.rs b/KubeOS-Rust/vendor/tokio/tests/task_abort.rs -index fe6b50cd..492f8b55 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/task_abort.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/task_abort.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support panic recovery - - use std::sync::Arc; - use std::thread::sleep; -@@ -26,10 +26,7 @@ fn test_abort_without_panic_3157() { - .unwrap(); - - rt.block_on(async move { -- let handle = tokio::spawn(async move { -- println!("task started"); -- tokio::time::sleep(Duration::new(100, 0)).await -- }); -+ let handle = tokio::spawn(async move { tokio::time::sleep(Duration::new(100, 0)).await }); - - // wait for task to sleep. - tokio::time::sleep(Duration::from_millis(10)).await; -@@ -89,7 +86,7 @@ fn test_abort_without_panic_3662() { - // Note: We do the following to trigger a deferred task cleanup. - // - // The relevant piece of code you want to look at is in: -- // `Inner::block_on` of `basic_scheduler.rs`. -+ // `Inner::block_on` of `scheduler/current_thread.rs`. - // - // We cause the cleanup to happen by having a poll return Pending once - // so that the scheduler can go into the "auxiliary tasks" mode, at -@@ -159,7 +156,6 @@ fn test_abort_wakes_task_3964() { - let handle = tokio::spawn(async move { - // Make sure the Arc is moved into the task - let _notify_dropped = notify_dropped; -- println!("task started"); - tokio::time::sleep(Duration::new(100, 0)).await - }); - -@@ -187,7 +183,6 @@ fn test_abort_task_that_panics_on_drop_contained() { - let handle = tokio::spawn(async move { - // Make sure the Arc is moved into the task - let _panic_dropped = PanicOnDrop; -- println!("task started"); - tokio::time::sleep(Duration::new(100, 0)).await - }); - -@@ -211,7 +206,6 @@ fn test_abort_task_that_panics_on_drop_returned() { - let handle = tokio::spawn(async move { - // Make sure the Arc is moved into the task - let _panic_dropped = PanicOnDrop; -- println!("task started"); - tokio::time::sleep(Duration::new(100, 0)).await - }); - -diff --git a/KubeOS-Rust/vendor/tokio/tests/task_blocking.rs b/KubeOS-Rust/vendor/tokio/tests/task_blocking.rs -index ee7e78ad..2999758f 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/task_blocking.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/task_blocking.rs -@@ -1,7 +1,7 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads - --use tokio::{runtime, task}; -+use tokio::{runtime, task, time}; - use tokio_test::assert_ok; - - use std::thread; -@@ -77,7 +77,7 @@ async fn block_in_block() { - - #[tokio::test(flavor = "current_thread")] - #[should_panic] --async fn no_block_in_basic_scheduler() { -+async fn no_block_in_current_thread_scheduler() { - task::block_in_place(|| {}); - } - -@@ -91,7 +91,7 @@ fn yes_block_in_threaded_block_on() { - - #[test] - #[should_panic] --fn no_block_in_basic_block_on() { -+fn no_block_in_current_thread_block_on() { - let rt = runtime::Builder::new_current_thread().build().unwrap(); - rt.block_on(async { - task::block_in_place(|| {}); -@@ -99,7 +99,7 @@ fn no_block_in_basic_block_on() { - } - - #[test] --fn can_enter_basic_rt_from_within_block_in_place() { -+fn can_enter_current_thread_rt_from_within_block_in_place() { - let outer = tokio::runtime::Runtime::new().unwrap(); - - outer.block_on(async { -@@ -226,3 +226,84 @@ fn coop_disabled_in_block_in_place_in_block_on() { - - done_rx.recv().unwrap().unwrap(); - } -+ -+#[cfg(feature = "test-util")] -+#[tokio::test(start_paused = true)] -+async fn blocking_when_paused() { -+ // Do not auto-advance time when we have started a blocking task that has -+ // not yet finished. -+ time::timeout( -+ Duration::from_secs(3), -+ task::spawn_blocking(|| thread::sleep(Duration::from_millis(1))), -+ ) -+ .await -+ .expect("timeout should not trigger") -+ .expect("blocking task should finish"); -+ -+ // Really: Do not auto-advance time, even if the timeout is short and the -+ // blocking task runs for longer than that. It doesn't matter: Tokio time -+ // is paused; system time is not. -+ time::timeout( -+ Duration::from_millis(1), -+ task::spawn_blocking(|| thread::sleep(Duration::from_millis(50))), -+ ) -+ .await -+ .expect("timeout should not trigger") -+ .expect("blocking task should finish"); -+} -+ -+#[cfg(feature = "test-util")] -+#[tokio::test(start_paused = true)] -+async fn blocking_task_wakes_paused_runtime() { -+ let t0 = std::time::Instant::now(); -+ time::timeout( -+ Duration::from_secs(15), -+ task::spawn_blocking(|| thread::sleep(Duration::from_millis(1))), -+ ) -+ .await -+ .expect("timeout should not trigger") -+ .expect("blocking task should finish"); -+ assert!( -+ t0.elapsed() < Duration::from_secs(10), -+ "completing a spawn_blocking should wake the scheduler if it's parked while time is paused" -+ ); -+} -+ -+#[cfg(feature = "test-util")] -+#[tokio::test(start_paused = true)] -+async fn unawaited_blocking_task_wakes_paused_runtime() { -+ let t0 = std::time::Instant::now(); -+ -+ // When this task finishes, time should auto-advance, even though the -+ // JoinHandle has not been awaited yet. -+ let a = task::spawn_blocking(|| { -+ thread::sleep(Duration::from_millis(1)); -+ }); -+ -+ crate::time::sleep(Duration::from_secs(15)).await; -+ a.await.expect("blocking task should finish"); -+ assert!( -+ t0.elapsed() < Duration::from_secs(10), -+ "completing a spawn_blocking should wake the scheduler if it's parked while time is paused" -+ ); -+} -+ -+#[cfg(feature = "test-util")] -+#[tokio::test(start_paused = true)] -+async fn panicking_blocking_task_wakes_paused_runtime() { -+ let t0 = std::time::Instant::now(); -+ let result = time::timeout( -+ Duration::from_secs(15), -+ task::spawn_blocking(|| { -+ thread::sleep(Duration::from_millis(1)); -+ panic!("blocking task panicked"); -+ }), -+ ) -+ .await -+ .expect("timeout should not trigger"); -+ assert!(result.is_err(), "blocking task should have panicked"); -+ assert!( -+ t0.elapsed() < Duration::from_secs(10), -+ "completing a spawn_blocking should wake the scheduler if it's parked while time is paused" -+ ); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/task_builder.rs b/KubeOS-Rust/vendor/tokio/tests/task_builder.rs -index 1499abf1..78329ff2 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/task_builder.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/task_builder.rs -@@ -11,6 +11,7 @@ mod tests { - let result = Builder::new() - .name("name") - .spawn(async { "task executed" }) -+ .unwrap() - .await; - - assert_eq!(result.unwrap(), "task executed"); -@@ -21,6 +22,7 @@ mod tests { - let result = Builder::new() - .name("name") - .spawn_blocking(|| "task executed") -+ .unwrap() - .await; - - assert_eq!(result.unwrap(), "task executed"); -@@ -34,6 +36,7 @@ mod tests { - Builder::new() - .name("name") - .spawn_local(async move { unsend_data }) -+ .unwrap() - .await - }) - .await; -@@ -43,14 +46,20 @@ mod tests { - - #[test] - async fn spawn_without_name() { -- let result = Builder::new().spawn(async { "task executed" }).await; -+ let result = Builder::new() -+ .spawn(async { "task executed" }) -+ .unwrap() -+ .await; - - assert_eq!(result.unwrap(), "task executed"); - } - - #[test] - async fn spawn_blocking_without_name() { -- let result = Builder::new().spawn_blocking(|| "task executed").await; -+ let result = Builder::new() -+ .spawn_blocking(|| "task executed") -+ .unwrap() -+ .await; - - assert_eq!(result.unwrap(), "task executed"); - } -@@ -59,7 +68,12 @@ mod tests { - async fn spawn_local_without_name() { - let unsend_data = Rc::new("task executed"); - let result = LocalSet::new() -- .run_until(async move { Builder::new().spawn_local(async move { unsend_data }).await }) -+ .run_until(async move { -+ Builder::new() -+ .spawn_local(async move { unsend_data }) -+ .unwrap() -+ .await -+ }) - .await; - - assert_eq!(*result.unwrap(), "task executed"); -diff --git a/KubeOS-Rust/vendor/tokio/tests/task_id.rs b/KubeOS-Rust/vendor/tokio/tests/task_id.rs -new file mode 100644 -index 00000000..d7b7c0cd ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/task_id.rs -@@ -0,0 +1,303 @@ -+#![warn(rust_2018_idioms)] -+#![allow(clippy::declare_interior_mutable_const)] -+#![cfg(all(feature = "full", tokio_unstable))] -+ -+#[cfg(not(tokio_wasi))] -+use std::error::Error; -+use std::future::Future; -+use std::pin::Pin; -+use std::task::{Context, Poll}; -+#[cfg(not(tokio_wasi))] -+use tokio::runtime::{Builder, Runtime}; -+use tokio::sync::oneshot; -+use tokio::task::{self, Id, LocalSet}; -+ -+#[cfg(not(tokio_wasi))] -+mod support { -+ pub mod panic; -+} -+#[cfg(not(tokio_wasi))] -+use support::panic::test_panic; -+ -+#[tokio::test(flavor = "current_thread")] -+async fn task_id_spawn() { -+ tokio::spawn(async { println!("task id: {}", task::id()) }) -+ .await -+ .unwrap(); -+} -+ -+#[cfg(not(tokio_wasi))] -+#[tokio::test(flavor = "current_thread")] -+async fn task_id_spawn_blocking() { -+ task::spawn_blocking(|| println!("task id: {}", task::id())) -+ .await -+ .unwrap(); -+} -+ -+#[tokio::test(flavor = "current_thread")] -+async fn task_id_collision_current_thread() { -+ let handle1 = tokio::spawn(async { task::id() }); -+ let handle2 = tokio::spawn(async { task::id() }); -+ -+ let (id1, id2) = tokio::join!(handle1, handle2); -+ assert_ne!(id1.unwrap(), id2.unwrap()); -+} -+ -+#[cfg(not(tokio_wasi))] -+#[tokio::test(flavor = "multi_thread")] -+async fn task_id_collision_multi_thread() { -+ let handle1 = tokio::spawn(async { task::id() }); -+ let handle2 = tokio::spawn(async { task::id() }); -+ -+ let (id1, id2) = tokio::join!(handle1, handle2); -+ assert_ne!(id1.unwrap(), id2.unwrap()); -+} -+ -+#[tokio::test(flavor = "current_thread")] -+async fn task_ids_match_current_thread() { -+ let (tx, rx) = oneshot::channel(); -+ let handle = tokio::spawn(async { -+ let id = rx.await.unwrap(); -+ assert_eq!(id, task::id()); -+ }); -+ tx.send(handle.id()).unwrap(); -+ handle.await.unwrap(); -+} -+ -+#[cfg(not(tokio_wasi))] -+#[tokio::test(flavor = "multi_thread")] -+async fn task_ids_match_multi_thread() { -+ let (tx, rx) = oneshot::channel(); -+ let handle = tokio::spawn(async { -+ let id = rx.await.unwrap(); -+ assert_eq!(id, task::id()); -+ }); -+ tx.send(handle.id()).unwrap(); -+ handle.await.unwrap(); -+} -+ -+#[cfg(not(tokio_wasi))] -+#[tokio::test(flavor = "multi_thread")] -+async fn task_id_future_destructor_completion() { -+ struct MyFuture { -+ tx: Option>, -+ } -+ -+ impl Future for MyFuture { -+ type Output = (); -+ -+ fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<()> { -+ Poll::Ready(()) -+ } -+ } -+ -+ impl Drop for MyFuture { -+ fn drop(&mut self) { -+ let _ = self.tx.take().unwrap().send(task::id()); -+ } -+ } -+ -+ let (tx, rx) = oneshot::channel(); -+ let handle = tokio::spawn(MyFuture { tx: Some(tx) }); -+ let id = handle.id(); -+ handle.await.unwrap(); -+ assert_eq!(rx.await.unwrap(), id); -+} -+ -+#[cfg(not(tokio_wasi))] -+#[tokio::test(flavor = "multi_thread")] -+async fn task_id_future_destructor_abort() { -+ struct MyFuture { -+ tx: Option>, -+ } -+ -+ impl Future for MyFuture { -+ type Output = (); -+ -+ fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<()> { -+ Poll::Pending -+ } -+ } -+ impl Drop for MyFuture { -+ fn drop(&mut self) { -+ let _ = self.tx.take().unwrap().send(task::id()); -+ } -+ } -+ -+ let (tx, rx) = oneshot::channel(); -+ let handle = tokio::spawn(MyFuture { tx: Some(tx) }); -+ let id = handle.id(); -+ handle.abort(); -+ assert!(handle.await.unwrap_err().is_cancelled()); -+ assert_eq!(rx.await.unwrap(), id); -+} -+ -+#[tokio::test(flavor = "current_thread")] -+async fn task_id_output_destructor_handle_dropped_before_completion() { -+ struct MyOutput { -+ tx: Option>, -+ } -+ -+ impl Drop for MyOutput { -+ fn drop(&mut self) { -+ let _ = self.tx.take().unwrap().send(task::id()); -+ } -+ } -+ -+ struct MyFuture { -+ tx: Option>, -+ } -+ -+ impl Future for MyFuture { -+ type Output = MyOutput; -+ -+ fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll { -+ Poll::Ready(MyOutput { tx: self.tx.take() }) -+ } -+ } -+ -+ let (tx, mut rx) = oneshot::channel(); -+ let handle = tokio::spawn(MyFuture { tx: Some(tx) }); -+ let id = handle.id(); -+ drop(handle); -+ assert!(rx.try_recv().is_err()); -+ assert_eq!(rx.await.unwrap(), id); -+} -+ -+#[tokio::test(flavor = "current_thread")] -+async fn task_id_output_destructor_handle_dropped_after_completion() { -+ struct MyOutput { -+ tx: Option>, -+ } -+ -+ impl Drop for MyOutput { -+ fn drop(&mut self) { -+ let _ = self.tx.take().unwrap().send(task::id()); -+ } -+ } -+ -+ struct MyFuture { -+ tx_output: Option>, -+ tx_future: Option>, -+ } -+ -+ impl Future for MyFuture { -+ type Output = MyOutput; -+ -+ fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll { -+ let _ = self.tx_future.take().unwrap().send(()); -+ Poll::Ready(MyOutput { -+ tx: self.tx_output.take(), -+ }) -+ } -+ } -+ -+ let (tx_output, mut rx_output) = oneshot::channel(); -+ let (tx_future, rx_future) = oneshot::channel(); -+ let handle = tokio::spawn(MyFuture { -+ tx_output: Some(tx_output), -+ tx_future: Some(tx_future), -+ }); -+ let id = handle.id(); -+ rx_future.await.unwrap(); -+ assert!(rx_output.try_recv().is_err()); -+ drop(handle); -+ assert_eq!(rx_output.await.unwrap(), id); -+} -+ -+#[test] -+fn task_try_id_outside_task() { -+ assert_eq!(None, task::try_id()); -+} -+ -+#[cfg(not(tokio_wasi))] -+#[test] -+fn task_try_id_inside_block_on() { -+ let rt = Runtime::new().unwrap(); -+ rt.block_on(async { -+ assert_eq!(None, task::try_id()); -+ }); -+} -+ -+#[tokio::test(flavor = "current_thread")] -+async fn task_id_spawn_local() { -+ LocalSet::new() -+ .run_until(async { -+ task::spawn_local(async { println!("task id: {}", task::id()) }) -+ .await -+ .unwrap(); -+ }) -+ .await -+} -+ -+#[tokio::test(flavor = "current_thread")] -+async fn task_id_nested_spawn_local() { -+ LocalSet::new() -+ .run_until(async { -+ task::spawn_local(async { -+ let parent_id = task::id(); -+ LocalSet::new() -+ .run_until(async { -+ task::spawn_local(async move { -+ assert_ne!(parent_id, task::id()); -+ }) -+ .await -+ .unwrap(); -+ }) -+ .await; -+ assert_eq!(parent_id, task::id()); -+ }) -+ .await -+ .unwrap(); -+ }) -+ .await; -+} -+ -+#[cfg(not(tokio_wasi))] -+#[tokio::test(flavor = "multi_thread")] -+async fn task_id_block_in_place_block_on_spawn() { -+ task::spawn(async { -+ let parent_id = task::id(); -+ -+ task::block_in_place(move || { -+ let rt = Builder::new_current_thread().build().unwrap(); -+ rt.block_on(rt.spawn(async move { -+ assert_ne!(parent_id, task::id()); -+ })) -+ .unwrap(); -+ }); -+ -+ assert_eq!(parent_id, task::id()); -+ }) -+ .await -+ .unwrap(); -+} -+ -+#[cfg(not(tokio_wasi))] -+#[test] -+fn task_id_outside_task_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let _ = task::id(); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[cfg(not(tokio_wasi))] -+#[test] -+fn task_id_inside_block_on_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = Runtime::new().unwrap(); -+ rt.block_on(async { -+ task::id(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/task_join_set.rs b/KubeOS-Rust/vendor/tokio/tests/task_join_set.rs -new file mode 100644 -index 00000000..b1b6cf96 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/task_join_set.rs -@@ -0,0 +1,235 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full"))] -+ -+use tokio::sync::oneshot; -+use tokio::task::JoinSet; -+use tokio::time::Duration; -+ -+fn rt() -> tokio::runtime::Runtime { -+ tokio::runtime::Builder::new_current_thread() -+ .build() -+ .unwrap() -+} -+ -+#[tokio::test(start_paused = true)] -+async fn test_with_sleep() { -+ let mut set = JoinSet::new(); -+ -+ for i in 0..10 { -+ set.spawn(async move { i }); -+ assert_eq!(set.len(), 1 + i); -+ } -+ set.detach_all(); -+ assert_eq!(set.len(), 0); -+ -+ assert!(matches!(set.join_next().await, None)); -+ -+ for i in 0..10 { -+ set.spawn(async move { -+ tokio::time::sleep(Duration::from_secs(i as u64)).await; -+ i -+ }); -+ assert_eq!(set.len(), 1 + i); -+ } -+ -+ let mut seen = [false; 10]; -+ while let Some(res) = set.join_next().await.transpose().unwrap() { -+ seen[res] = true; -+ } -+ -+ for was_seen in &seen { -+ assert!(was_seen); -+ } -+ assert!(matches!(set.join_next().await, None)); -+ -+ // Do it again. -+ for i in 0..10 { -+ set.spawn(async move { -+ tokio::time::sleep(Duration::from_secs(i as u64)).await; -+ i -+ }); -+ } -+ -+ let mut seen = [false; 10]; -+ while let Some(res) = set.join_next().await.transpose().unwrap() { -+ seen[res] = true; -+ } -+ -+ for was_seen in &seen { -+ assert!(was_seen); -+ } -+ assert!(matches!(set.join_next().await, None)); -+} -+ -+#[tokio::test] -+async fn test_abort_on_drop() { -+ let mut set = JoinSet::new(); -+ -+ let mut recvs = Vec::new(); -+ -+ for _ in 0..16 { -+ let (send, recv) = oneshot::channel::<()>(); -+ recvs.push(recv); -+ -+ set.spawn(async { -+ // This task will never complete on its own. -+ futures::future::pending::<()>().await; -+ drop(send); -+ }); -+ } -+ -+ drop(set); -+ -+ for recv in recvs { -+ // The task is aborted soon and we will receive an error. -+ assert!(recv.await.is_err()); -+ } -+} -+ -+#[tokio::test] -+async fn alternating() { -+ let mut set = JoinSet::new(); -+ -+ assert_eq!(set.len(), 0); -+ set.spawn(async {}); -+ assert_eq!(set.len(), 1); -+ set.spawn(async {}); -+ assert_eq!(set.len(), 2); -+ -+ for _ in 0..16 { -+ let () = set.join_next().await.unwrap().unwrap(); -+ assert_eq!(set.len(), 1); -+ set.spawn(async {}); -+ assert_eq!(set.len(), 2); -+ } -+} -+ -+#[tokio::test(start_paused = true)] -+async fn abort_tasks() { -+ let mut set = JoinSet::new(); -+ let mut num_canceled = 0; -+ let mut num_completed = 0; -+ for i in 0..16 { -+ let abort = set.spawn(async move { -+ tokio::time::sleep(Duration::from_secs(i as u64)).await; -+ i -+ }); -+ -+ if i % 2 != 0 { -+ // abort odd-numbered tasks. -+ abort.abort(); -+ } -+ } -+ loop { -+ match set.join_next().await { -+ Some(Ok(res)) => { -+ num_completed += 1; -+ assert_eq!(res % 2, 0); -+ } -+ Some(Err(e)) => { -+ assert!(e.is_cancelled()); -+ num_canceled += 1; -+ } -+ None => break, -+ } -+ } -+ -+ assert_eq!(num_canceled, 8); -+ assert_eq!(num_completed, 8); -+} -+ -+#[test] -+fn runtime_gone() { -+ let mut set = JoinSet::new(); -+ { -+ let rt = rt(); -+ set.spawn_on(async { 1 }, rt.handle()); -+ drop(rt); -+ } -+ -+ assert!(rt() -+ .block_on(set.join_next()) -+ .unwrap() -+ .unwrap_err() -+ .is_cancelled()); -+} -+ -+#[tokio::test(start_paused = true)] -+async fn abort_all() { -+ let mut set: JoinSet<()> = JoinSet::new(); -+ -+ for _ in 0..5 { -+ set.spawn(futures::future::pending()); -+ } -+ for _ in 0..5 { -+ set.spawn(async { -+ tokio::time::sleep(Duration::from_secs(1)).await; -+ }); -+ } -+ -+ // The join set will now have 5 pending tasks and 5 ready tasks. -+ tokio::time::sleep(Duration::from_secs(2)).await; -+ -+ set.abort_all(); -+ assert_eq!(set.len(), 10); -+ -+ let mut count = 0; -+ while let Some(res) = set.join_next().await { -+ if let Err(err) = res { -+ assert!(err.is_cancelled()); -+ } -+ count += 1; -+ } -+ assert_eq!(count, 10); -+ assert_eq!(set.len(), 0); -+} -+ -+#[cfg(feature = "parking_lot")] -+mod parking_lot { -+ use super::*; -+ -+ use futures::future::FutureExt; -+ -+ // This ensures that `join_next` works correctly when the coop budget is -+ // exhausted. -+ #[tokio::test(flavor = "current_thread")] -+ async fn join_set_coop() { -+ // Large enough to trigger coop. -+ const TASK_NUM: u32 = 1000; -+ -+ static SEM: tokio::sync::Semaphore = tokio::sync::Semaphore::const_new(0); -+ -+ let mut set = JoinSet::new(); -+ -+ for _ in 0..TASK_NUM { -+ set.spawn(async { -+ SEM.add_permits(1); -+ }); -+ } -+ -+ // Wait for all tasks to complete. -+ // -+ // Since this is a `current_thread` runtime, there's no race condition -+ // between the last permit being added and the task completing. -+ let _ = SEM.acquire_many(TASK_NUM).await.unwrap(); -+ -+ let mut count = 0; -+ let mut coop_count = 0; -+ loop { -+ match set.join_next().now_or_never() { -+ Some(Some(Ok(()))) => {} -+ Some(Some(Err(err))) => panic!("failed: {}", err), -+ None => { -+ coop_count += 1; -+ tokio::task::yield_now().await; -+ continue; -+ } -+ Some(None) => break, -+ } -+ -+ count += 1; -+ } -+ assert!(coop_count >= 1); -+ assert_eq!(count, TASK_NUM); -+ } -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/task_local.rs b/KubeOS-Rust/vendor/tokio/tests/task_local.rs -index 99815324..949a40c2 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/task_local.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/task_local.rs -@@ -1,10 +1,17 @@ --tokio::task_local! { -- static REQ_ID: u32; -- pub static FOO: bool; --} -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads -+#![allow(clippy::declare_interior_mutable_const)] -+use std::future::Future; -+use std::pin::Pin; -+use std::task::{Context, Poll}; -+use tokio::sync::oneshot; - - #[tokio::test(flavor = "multi_thread")] - async fn local() { -+ tokio::task_local! { -+ static REQ_ID: u32; -+ pub static FOO: bool; -+ } -+ - let j1 = tokio::spawn(REQ_ID.scope(1, async move { - assert_eq!(REQ_ID.get(), 1); - assert_eq!(REQ_ID.get(), 1); -@@ -29,3 +36,84 @@ async fn local() { - j2.await.unwrap(); - j3.await.unwrap(); - } -+ -+#[tokio::test] -+async fn task_local_available_on_abort() { -+ tokio::task_local! { -+ static KEY: u32; -+ } -+ -+ struct MyFuture { -+ tx_poll: Option>, -+ tx_drop: Option>, -+ } -+ impl Future for MyFuture { -+ type Output = (); -+ -+ fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<()> { -+ if let Some(tx_poll) = self.tx_poll.take() { -+ let _ = tx_poll.send(()); -+ } -+ Poll::Pending -+ } -+ } -+ impl Drop for MyFuture { -+ fn drop(&mut self) { -+ let _ = self.tx_drop.take().unwrap().send(KEY.get()); -+ } -+ } -+ -+ let (tx_drop, rx_drop) = oneshot::channel(); -+ let (tx_poll, rx_poll) = oneshot::channel(); -+ -+ let h = tokio::spawn(KEY.scope( -+ 42, -+ MyFuture { -+ tx_poll: Some(tx_poll), -+ tx_drop: Some(tx_drop), -+ }, -+ )); -+ -+ rx_poll.await.unwrap(); -+ h.abort(); -+ assert_eq!(rx_drop.await.unwrap(), 42); -+ -+ let err = h.await.unwrap_err(); -+ if !err.is_cancelled() { -+ if let Ok(panic) = err.try_into_panic() { -+ std::panic::resume_unwind(panic); -+ } else { -+ panic!(); -+ } -+ } -+} -+ -+#[tokio::test] -+async fn task_local_available_on_completion_drop() { -+ tokio::task_local! { -+ static KEY: u32; -+ } -+ -+ struct MyFuture { -+ tx: Option>, -+ } -+ impl Future for MyFuture { -+ type Output = (); -+ -+ fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<()> { -+ Poll::Ready(()) -+ } -+ } -+ impl Drop for MyFuture { -+ fn drop(&mut self) { -+ let _ = self.tx.take().unwrap().send(KEY.get()); -+ } -+ } -+ -+ let (tx, rx) = oneshot::channel(); -+ -+ let h = tokio::spawn(KEY.scope(42, MyFuture { tx: Some(tx) })); -+ -+ assert_eq!(rx.await.unwrap(), 42); -+ h.await.unwrap(); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/task_local_set.rs b/KubeOS-Rust/vendor/tokio/tests/task_local_set.rs -index f8a35d0e..2da87f5a 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/task_local_set.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/task_local_set.rs -@@ -6,18 +6,23 @@ use futures::{ - FutureExt, - }; - --use tokio::runtime::{self, Runtime}; -+use tokio::runtime; - use tokio::sync::{mpsc, oneshot}; - use tokio::task::{self, LocalSet}; - use tokio::time; - -+#[cfg(not(tokio_wasi))] - use std::cell::Cell; --use std::sync::atomic::Ordering::{self, SeqCst}; --use std::sync::atomic::{AtomicBool, AtomicUsize}; -+use std::sync::atomic::AtomicBool; -+#[cfg(not(tokio_wasi))] -+use std::sync::atomic::AtomicUsize; -+use std::sync::atomic::Ordering; -+#[cfg(not(tokio_wasi))] -+use std::sync::atomic::Ordering::SeqCst; - use std::time::Duration; - - #[tokio::test(flavor = "current_thread")] --async fn local_basic_scheduler() { -+async fn local_current_thread_scheduler() { - LocalSet::new() - .run_until(async { - task::spawn_local(async {}).await.unwrap(); -@@ -25,6 +30,7 @@ async fn local_basic_scheduler() { - .await; - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread")] - async fn local_threadpool() { - thread_local! { -@@ -45,6 +51,7 @@ async fn local_threadpool() { - .await; - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread")] - async fn localset_future_threadpool() { - thread_local! { -@@ -60,6 +67,7 @@ async fn localset_future_threadpool() { - local.await; - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread")] - async fn localset_future_timers() { - static RAN1: AtomicBool = AtomicBool::new(false); -@@ -104,6 +112,7 @@ async fn localset_future_drives_all_local_futs() { - assert!(RAN3.load(Ordering::SeqCst)); - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread")] - async fn local_threadpool_timer() { - // This test ensures that runtime services like the timer are properly -@@ -126,7 +135,23 @@ async fn local_threadpool_timer() { - }) - .await; - } -+#[test] -+fn enter_guard_spawn() { -+ let local = LocalSet::new(); -+ let _guard = local.enter(); -+ // Run the local task set. - -+ let join = task::spawn_local(async { true }); -+ let rt = runtime::Builder::new_current_thread() -+ .enable_all() -+ .build() -+ .unwrap(); -+ local.block_on(&rt, async move { -+ assert!(join.await.unwrap()); -+ }); -+} -+ -+#[cfg(not(tokio_wasi))] // Wasi doesn't support panic recovery - #[test] - // This will panic, since the thread that calls `block_on` cannot use - // in-place blocking inside of `block_on`. -@@ -153,6 +178,7 @@ fn local_threadpool_blocking_in_place() { - }); - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread")] - async fn local_threadpool_blocking_run() { - thread_local! { -@@ -181,6 +207,7 @@ async fn local_threadpool_blocking_run() { - .await; - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread")] - async fn all_spawns_are_local() { - use futures::future; -@@ -207,6 +234,7 @@ async fn all_spawns_are_local() { - .await; - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread")] - async fn nested_spawn_is_local() { - thread_local! { -@@ -242,6 +270,7 @@ async fn nested_spawn_is_local() { - .await; - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads - #[test] - fn join_local_future_elsewhere() { - thread_local! { -@@ -255,14 +284,12 @@ fn join_local_future_elsewhere() { - local.block_on(&rt, async move { - let (tx, rx) = oneshot::channel(); - let join = task::spawn_local(async move { -- println!("hello world running..."); - assert!( - ON_RT_THREAD.with(|cell| cell.get()), - "local task must run on local thread, no matter where it is awaited" - ); - rx.await.unwrap(); - -- println!("hello world task done"); - "hello world" - }); - let join2 = task::spawn(async move { -@@ -272,16 +299,34 @@ fn join_local_future_elsewhere() { - ); - - tx.send(()).expect("task shouldn't have ended yet"); -- println!("waking up hello world..."); - - join.await.expect("task should complete successfully"); -- -- println!("hello world task joined"); - }); - join2.await.unwrap() - }); - } - -+// Tests for -+#[cfg(not(tokio_wasi))] // Wasi doesn't support threads -+#[tokio::test(flavor = "multi_thread")] -+async fn localset_in_thread_local() { -+ thread_local! { -+ static LOCAL_SET: LocalSet = LocalSet::new(); -+ } -+ -+ // holds runtime thread until end of main fn. -+ let (_tx, rx) = oneshot::channel::<()>(); -+ let handle = tokio::runtime::Handle::current(); -+ -+ std::thread::spawn(move || { -+ LOCAL_SET.with(|local_set| { -+ handle.block_on(local_set.run_until(async move { -+ let _ = rx.await; -+ })) -+ }); -+ }); -+} -+ - #[test] - fn drop_cancels_tasks() { - use std::rc::Rc; -@@ -345,9 +390,7 @@ fn with_timeout(timeout: Duration, f: impl FnOnce() + Send + 'static) { - ), - // Did the test thread panic? We'll find out for sure when we `join` - // with it. -- Err(RecvTimeoutError::Disconnected) => { -- println!("done_rx dropped, did the test thread panic?"); -- } -+ Err(RecvTimeoutError::Disconnected) => {} - // Test completed successfully! - Ok(()) => {} - } -@@ -355,6 +398,7 @@ fn with_timeout(timeout: Duration, f: impl FnOnce() + Send + 'static) { - thread.join().expect("test thread should not panic!") - } - -+#[cfg_attr(tokio_wasi, ignore = "`unwrap()` in `with_timeout()` panics on Wasi")] - #[test] - fn drop_cancels_remote_tasks() { - // This test reproduces issue #1885. -@@ -377,6 +421,10 @@ fn drop_cancels_remote_tasks() { - }); - } - -+#[cfg_attr( -+ tokio_wasi, -+ ignore = "FIXME: `task::spawn_local().await.unwrap()` panics on Wasi" -+)] - #[test] - fn local_tasks_wake_join_all() { - // This test reproduces issue #2460. -@@ -398,6 +446,7 @@ fn local_tasks_wake_join_all() { - }); - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support panic recovery - #[test] - fn local_tasks_are_polled_after_tick() { - // This test depends on timing, so we run it up to five times. -@@ -414,6 +463,7 @@ fn local_tasks_are_polled_after_tick() { - local_tasks_are_polled_after_tick_inner(); - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support panic recovery - #[tokio::main(flavor = "current_thread")] - async fn local_tasks_are_polled_after_tick_inner() { - // Reproduces issues #1899 and #1900 -@@ -450,12 +500,15 @@ async fn local_tasks_are_polled_after_tick_inner() { - tx.send(()).unwrap(); - } - -- time::sleep(Duration::from_millis(20)).await; -- let rx1 = RX1.load(SeqCst); -- let rx2 = RX2.load(SeqCst); -- println!("EXPECT = {}; RX1 = {}; RX2 = {}", EXPECTED, rx1, rx2); -- assert_eq!(EXPECTED, rx1); -- assert_eq!(EXPECTED, rx2); -+ loop { -+ time::sleep(Duration::from_millis(20)).await; -+ let rx1 = RX1.load(SeqCst); -+ let rx2 = RX2.load(SeqCst); -+ -+ if rx1 == EXPECTED && rx2 == EXPECTED { -+ break; -+ } -+ } - }); - - while let Some(oneshot) = rx.recv().await { -@@ -517,7 +570,122 @@ async fn spawn_wakes_localset() { - } - } - --fn rt() -> Runtime { -+#[test] -+fn store_local_set_in_thread_local_with_runtime() { -+ use tokio::runtime::Runtime; -+ -+ thread_local! { -+ static CURRENT: RtAndLocalSet = RtAndLocalSet::new(); -+ } -+ -+ struct RtAndLocalSet { -+ rt: Runtime, -+ local: LocalSet, -+ } -+ -+ impl RtAndLocalSet { -+ fn new() -> RtAndLocalSet { -+ RtAndLocalSet { -+ rt: tokio::runtime::Builder::new_current_thread() -+ .enable_all() -+ .build() -+ .unwrap(), -+ local: LocalSet::new(), -+ } -+ } -+ -+ async fn inner_method(&self) { -+ self.local -+ .run_until(async move { -+ tokio::task::spawn_local(async {}); -+ }) -+ .await -+ } -+ -+ fn method(&self) { -+ self.rt.block_on(self.inner_method()); -+ } -+ } -+ -+ CURRENT.with(|f| { -+ f.method(); -+ }); -+} -+ -+#[cfg(tokio_unstable)] -+mod unstable { -+ use tokio::runtime::UnhandledPanic; -+ use tokio::task::LocalSet; -+ -+ #[tokio::test] -+ #[should_panic( -+ expected = "a spawned task panicked and the LocalSet is configured to shutdown on unhandled panic" -+ )] -+ async fn shutdown_on_panic() { -+ LocalSet::new() -+ .unhandled_panic(UnhandledPanic::ShutdownRuntime) -+ .run_until(async { -+ tokio::task::spawn_local(async { -+ panic!("boom"); -+ }); -+ -+ futures::future::pending::<()>().await; -+ }) -+ .await; -+ } -+ -+ // This test compares that, when the task driving `run_until` has already -+ // consumed budget, the `run_until` future has less budget than a "spawned" -+ // task. -+ // -+ // "Budget" is a fuzzy metric as the Tokio runtime is able to change values -+ // internally. This is why the test uses indirection to test this. -+ #[tokio::test] -+ async fn run_until_does_not_get_own_budget() { -+ // Consume some budget -+ tokio::task::consume_budget().await; -+ -+ LocalSet::new() -+ .run_until(async { -+ let spawned = tokio::spawn(async { -+ let mut spawned_n = 0; -+ -+ { -+ let mut spawned = tokio_test::task::spawn(async { -+ loop { -+ spawned_n += 1; -+ tokio::task::consume_budget().await; -+ } -+ }); -+ // Poll once -+ assert!(!spawned.poll().is_ready()); -+ } -+ -+ spawned_n -+ }); -+ -+ let mut run_until_n = 0; -+ { -+ let mut run_until = tokio_test::task::spawn(async { -+ loop { -+ run_until_n += 1; -+ tokio::task::consume_budget().await; -+ } -+ }); -+ // Poll once -+ assert!(!run_until.poll().is_ready()); -+ } -+ -+ let spawned_n = spawned.await.unwrap(); -+ assert_ne!(spawned_n, 0); -+ assert_ne!(run_until_n, 0); -+ assert!(spawned_n > run_until_n); -+ }) -+ .await -+ } -+} -+ -+fn rt() -> runtime::Runtime { - tokio::runtime::Builder::new_current_thread() - .enable_all() - .build() -diff --git a/KubeOS-Rust/vendor/tokio/tests/task_panic.rs b/KubeOS-Rust/vendor/tokio/tests/task_panic.rs -new file mode 100644 -index 00000000..e4cedce2 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/task_panic.rs -@@ -0,0 +1,123 @@ -+#![warn(rust_2018_idioms)] -+#![allow(clippy::declare_interior_mutable_const)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] -+ -+use futures::future; -+use std::error::Error; -+use tokio::runtime::Builder; -+use tokio::task::{self, block_in_place}; -+ -+mod support { -+ pub mod panic; -+} -+use support::panic::test_panic; -+ -+#[test] -+fn block_in_place_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = Builder::new_current_thread().enable_all().build().unwrap(); -+ rt.block_on(async { -+ block_in_place(|| {}); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn local_set_spawn_local_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let _local = task::LocalSet::new(); -+ -+ let _ = task::spawn_local(async {}); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn local_set_block_on_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = Builder::new_current_thread().enable_all().build().unwrap(); -+ let local = task::LocalSet::new(); -+ -+ rt.block_on(async { -+ local.block_on(&rt, future::pending::<()>()); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn spawn_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ tokio::spawn(future::pending::<()>()); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn local_key_sync_scope_panic_caller() -> Result<(), Box> { -+ tokio::task_local! { -+ static NUMBER: u32; -+ } -+ -+ let panic_location_file = test_panic(|| { -+ NUMBER.sync_scope(1, || { -+ NUMBER.with(|_| { -+ NUMBER.sync_scope(1, || {}); -+ }); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn local_key_with_panic_caller() -> Result<(), Box> { -+ tokio::task_local! { -+ static NUMBER: u32; -+ } -+ -+ let panic_location_file = test_panic(|| { -+ NUMBER.with(|_| {}); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn local_key_get_panic_caller() -> Result<(), Box> { -+ tokio::task_local! { -+ static NUMBER: u32; -+ } -+ -+ let panic_location_file = test_panic(|| { -+ NUMBER.get(); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_accept.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_accept.rs -index 5ffb946f..ba4a498d 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_accept.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_accept.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use tokio::net::{TcpListener, TcpStream}; - use tokio::sync::{mpsc, oneshot}; -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_connect.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_connect.rs -index cbe68fa2..f2384420 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_connect.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_connect.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use tokio::net::{TcpListener, TcpStream}; - use tokio::sync::oneshot; -@@ -35,6 +35,7 @@ async fn connect_v4() { - } - - #[tokio::test] -+#[cfg(not(tokio_no_ipv6))] - async fn connect_v6() { - let srv = assert_ok!(TcpListener::bind("[::1]:0").await); - let addr = assert_ok!(srv.local_addr()); -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_echo.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_echo.rs -index 5bb7ff0a..f47d4ac1 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_echo.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_echo.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use tokio::io::{self, AsyncReadExt, AsyncWriteExt}; - use tokio::net::{TcpListener, TcpStream}; -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_into_split.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_into_split.rs -index 2e06643a..010984af 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_into_split.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_into_split.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use std::io::{Error, ErrorKind, Result}; - use std::io::{Read, Write}; -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_into_std.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_into_std.rs -index 4bf24c14..320d9946 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_into_std.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_into_std.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use std::io::Read; - use std::io::Result; -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_peek.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_peek.rs -index aecc0ac1..a5fd6ba4 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_peek.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_peek.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use tokio::io::AsyncReadExt; - use tokio::net::TcpStream; -@@ -7,7 +7,7 @@ use tokio::net::TcpStream; - use tokio_test::assert_ok; - - use std::thread; --use std::{convert::TryInto, io::Write, net}; -+use std::{io::Write, net}; - - #[tokio::test] - async fn peek() { -@@ -15,7 +15,7 @@ async fn peek() { - let addr = listener.local_addr().unwrap(); - let t = thread::spawn(move || assert_ok!(listener.accept()).0); - -- let left = net::TcpStream::connect(&addr).unwrap(); -+ let left = net::TcpStream::connect(addr).unwrap(); - let mut right = t.join().unwrap(); - let _ = right.write(&[1, 2, 3, 4]).unwrap(); - -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_shutdown.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_shutdown.rs -index 536a1613..1d477f37 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_shutdown.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_shutdown.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use tokio::io::{self, AsyncReadExt, AsyncWriteExt}; - use tokio::net::{TcpListener, TcpStream}; -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_socket.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_socket.rs -index 9258864d..66309d30 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_socket.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_socket.rs -@@ -1,6 +1,7 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - -+use std::time::Duration; - use tokio::net::TcpSocket; - use tokio_test::assert_ok; - -@@ -23,6 +24,7 @@ async fn basic_usage_v4() { - } - - #[tokio::test] -+#[cfg(not(tokio_no_ipv6))] - async fn basic_usage_v6() { - // Create server - let addr = assert_ok!("[::1]:0".parse()); -@@ -58,3 +60,16 @@ async fn bind_before_connect() { - // Accept - let _ = assert_ok!(srv.accept().await); - } -+ -+#[tokio::test] -+async fn basic_linger() { -+ // Create server -+ let addr = assert_ok!("127.0.0.1:0".parse()); -+ let srv = assert_ok!(TcpSocket::new_v4()); -+ assert_ok!(srv.bind(addr)); -+ -+ assert!(srv.linger().unwrap().is_none()); -+ -+ srv.set_linger(Some(Duration::new(0, 0))).unwrap(); -+ assert_eq!(srv.linger().unwrap(), Some(Duration::new(0, 0))); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_split.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_split.rs -index 7171dac4..335b21f2 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_split.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_split.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use std::io::Result; - use std::io::{Read, Write}; -@@ -36,7 +36,7 @@ async fn split() -> Result<()> { - assert_eq!(peek_len1, read_len); - assert_eq!(&read_buf[..read_len], MSG); - -- write_half.write(MSG).await?; -+ assert_eq!(write_half.write(MSG).await?, MSG.len()); - handle.join().unwrap(); - Ok(()) - } -diff --git a/KubeOS-Rust/vendor/tokio/tests/tcp_stream.rs b/KubeOS-Rust/vendor/tokio/tests/tcp_stream.rs -index 0b5d12ae..31fe3baa 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/tcp_stream.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/tcp_stream.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support bind - - use tokio::io::{AsyncReadExt, AsyncWriteExt, Interest}; - use tokio::net::{TcpListener, TcpStream}; -@@ -254,30 +254,34 @@ async fn create_pair() -> (TcpStream, TcpStream) { - (client, server) - } - --fn read_until_pending(stream: &mut TcpStream) { -+fn read_until_pending(stream: &mut TcpStream) -> usize { - let mut buf = vec![0u8; 1024 * 1024]; -+ let mut total = 0; - loop { - match stream.try_read(&mut buf) { -- Ok(_) => (), -+ Ok(n) => total += n, - Err(err) => { - assert_eq!(err.kind(), io::ErrorKind::WouldBlock); - break; - } - } - } -+ total - } - --fn write_until_pending(stream: &mut TcpStream) { -+fn write_until_pending(stream: &mut TcpStream) -> usize { - let buf = vec![0u8; 1024 * 1024]; -+ let mut total = 0; - loop { - match stream.try_write(&buf) { -- Ok(_) => (), -+ Ok(n) => total += n, - Err(err) => { - assert_eq!(err.kind(), io::ErrorKind::WouldBlock); - break; - } - } - } -+ total - } - - #[tokio::test] -@@ -357,3 +361,40 @@ async fn try_read_buf() { - } - } - } -+ -+// read_closed is a best effort event, so test only for no false positives. -+#[tokio::test] -+async fn read_closed() { -+ let (client, mut server) = create_pair().await; -+ -+ let mut ready_fut = task::spawn(client.ready(Interest::READABLE)); -+ assert_pending!(ready_fut.poll()); -+ -+ assert_ok!(server.write_all(b"ping").await); -+ -+ let ready_event = assert_ok!(ready_fut.await); -+ -+ assert!(!ready_event.is_read_closed()); -+} -+ -+// write_closed is a best effort event, so test only for no false positives. -+#[tokio::test] -+async fn write_closed() { -+ let (mut client, mut server) = create_pair().await; -+ -+ // Fill the write buffer. -+ let write_size = write_until_pending(&mut client); -+ let mut ready_fut = task::spawn(client.ready(Interest::WRITABLE)); -+ assert_pending!(ready_fut.poll()); -+ -+ // Drain the socket to make client writable. -+ let mut read_size = 0; -+ while read_size < write_size { -+ server.readable().await.unwrap(); -+ read_size += read_until_pending(&mut server); -+ } -+ -+ let ready_event = assert_ok!(ready_fut.await); -+ -+ assert!(!ready_event.is_write_closed()); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/time_interval.rs b/KubeOS-Rust/vendor/tokio/tests/time_interval.rs -index 5f7bf55f..42285364 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/time_interval.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/time_interval.rs -@@ -1,10 +1,12 @@ - #![warn(rust_2018_idioms)] - #![cfg(feature = "full")] - --use tokio::time::{self, Duration, Instant, MissedTickBehavior}; --use tokio_test::{assert_pending, assert_ready_eq, task}; -+use std::pin::Pin; -+use std::task::{Context, Poll}; - --use std::task::Poll; -+use futures::{Stream, StreamExt}; -+use tokio::time::{self, Duration, Instant, Interval, MissedTickBehavior}; -+use tokio_test::{assert_pending, assert_ready_eq, task}; - - // Takes the `Interval` task, `start` variable, and optional time deltas - // For each time delta, it polls the `Interval` and asserts that the result is -@@ -166,6 +168,42 @@ async fn skip() { - check_interval_poll!(i, start, 1800); - } - -+#[tokio::test(start_paused = true)] -+async fn reset() { -+ let start = Instant::now(); -+ -+ // This is necessary because the timer is only so granular, and in order for -+ // all our ticks to resolve, the time needs to be 1ms ahead of what we -+ // expect, so that the runtime will see that it is time to resolve the timer -+ time::advance(ms(1)).await; -+ -+ let mut i = task::spawn(time::interval_at(start, ms(300))); -+ -+ check_interval_poll!(i, start, 0); -+ -+ time::advance(ms(100)).await; -+ check_interval_poll!(i, start); -+ -+ time::advance(ms(200)).await; -+ check_interval_poll!(i, start, 300); -+ -+ time::advance(ms(100)).await; -+ check_interval_poll!(i, start); -+ -+ i.reset(); -+ -+ time::advance(ms(250)).await; -+ check_interval_poll!(i, start); -+ -+ time::advance(ms(50)).await; -+ // We add one because when using `reset` method, `Interval` adds the -+ // `period` from `Instant::now()`, which will always be off by one -+ check_interval_poll!(i, start, 701); -+ -+ time::advance(ms(300)).await; -+ check_interval_poll!(i, start, 1001); -+} -+ - fn poll_next(interval: &mut task::Spawn) -> Poll { - interval.enter(|cx, mut interval| interval.poll_tick(cx)) - } -@@ -173,3 +211,113 @@ fn poll_next(interval: &mut task::Spawn) -> Poll { - fn ms(n: u64) -> Duration { - Duration::from_millis(n) - } -+ -+/// Helper struct to test the [tokio::time::Interval::poll_tick()] method. -+/// -+/// `poll_tick()` should register the waker in the context only if it returns -+/// `Poll::Pending`, not when returning `Poll::Ready`. This struct contains an -+/// interval timer and counts up on every tick when used as stream. When the -+/// counter is a multiple of four, it yields the current counter value. -+/// Depending on the value for `wake_on_pending`, it will reschedule itself when -+/// it returns `Poll::Pending` or not. When used with `wake_on_pending=false`, -+/// we expect that the stream stalls because the timer will **not** reschedule -+/// the next wake-up itself once it returned `Poll::Ready`. -+struct IntervalStreamer { -+ counter: u32, -+ timer: Interval, -+ wake_on_pending: bool, -+} -+ -+impl Stream for IntervalStreamer { -+ type Item = u32; -+ -+ fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { -+ let this = Pin::into_inner(self); -+ -+ if this.counter > 12 { -+ return Poll::Ready(None); -+ } -+ -+ match this.timer.poll_tick(cx) { -+ Poll::Pending => Poll::Pending, -+ Poll::Ready(_) => { -+ this.counter += 1; -+ if this.counter % 4 == 0 { -+ Poll::Ready(Some(this.counter)) -+ } else { -+ if this.wake_on_pending { -+ // Schedule this task for wake-up -+ cx.waker().wake_by_ref(); -+ } -+ Poll::Pending -+ } -+ } -+ } -+ } -+} -+ -+#[tokio::test(start_paused = true)] -+async fn stream_with_interval_poll_tick_self_waking() { -+ let stream = IntervalStreamer { -+ counter: 0, -+ timer: tokio::time::interval(tokio::time::Duration::from_millis(10)), -+ wake_on_pending: true, -+ }; -+ -+ let (res_tx, mut res_rx) = tokio::sync::mpsc::channel(12); -+ -+ // Wrap task in timeout so that it will finish eventually even if the stream -+ // stalls. -+ tokio::spawn(tokio::time::timeout( -+ tokio::time::Duration::from_millis(150), -+ async move { -+ tokio::pin!(stream); -+ -+ while let Some(item) = stream.next().await { -+ res_tx.send(item).await.ok(); -+ } -+ }, -+ )); -+ -+ let mut items = Vec::with_capacity(3); -+ while let Some(result) = res_rx.recv().await { -+ items.push(result); -+ } -+ -+ // We expect the stream to yield normally and thus three items. -+ assert_eq!(items, vec![4, 8, 12]); -+} -+ -+#[tokio::test(start_paused = true)] -+async fn stream_with_interval_poll_tick_no_waking() { -+ let stream = IntervalStreamer { -+ counter: 0, -+ timer: tokio::time::interval(tokio::time::Duration::from_millis(10)), -+ wake_on_pending: false, -+ }; -+ -+ let (res_tx, mut res_rx) = tokio::sync::mpsc::channel(12); -+ -+ // Wrap task in timeout so that it will finish eventually even if the stream -+ // stalls. -+ tokio::spawn(tokio::time::timeout( -+ tokio::time::Duration::from_millis(150), -+ async move { -+ tokio::pin!(stream); -+ -+ while let Some(item) = stream.next().await { -+ res_tx.send(item).await.ok(); -+ } -+ }, -+ )); -+ -+ let mut items = Vec::with_capacity(0); -+ while let Some(result) = res_rx.recv().await { -+ items.push(result); -+ } -+ -+ // We expect the stream to stall because it does not reschedule itself on -+ // `Poll::Pending` and neither does [tokio::time::Interval] reschedule the -+ // task when returning `Poll::Ready`. -+ assert_eq!(items, vec![]); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/time_panic.rs b/KubeOS-Rust/vendor/tokio/tests/time_panic.rs -new file mode 100644 -index 00000000..aaff11bb ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/time_panic.rs -@@ -0,0 +1,93 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support panic recovery -+ -+use futures::future; -+use std::error::Error; -+use std::time::Duration; -+use tokio::runtime::{Builder, Runtime}; -+use tokio::time::{self, interval, interval_at, timeout, Instant}; -+ -+mod support { -+ pub mod panic; -+} -+use support::panic::test_panic; -+ -+#[test] -+fn pause_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ -+ rt.block_on(async { -+ time::pause(); -+ time::pause(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn resume_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let rt = current_thread(); -+ -+ rt.block_on(async { -+ time::resume(); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn interval_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let _ = interval(Duration::from_millis(0)); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn interval_at_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ let _ = interval_at(Instant::now(), Duration::from_millis(0)); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+#[test] -+fn timeout_panic_caller() -> Result<(), Box> { -+ let panic_location_file = test_panic(|| { -+ // Runtime without `enable_time` so it has no current timer set. -+ let rt = Builder::new_current_thread().build().unwrap(); -+ rt.block_on(async { -+ let _ = timeout(Duration::from_millis(5), future::pending::<()>()); -+ }); -+ }); -+ -+ // The panic location should be in this file -+ assert_eq!(&panic_location_file.unwrap(), file!()); -+ -+ Ok(()) -+} -+ -+fn current_thread() -> Runtime { -+ tokio::runtime::Builder::new_current_thread() -+ .enable_all() -+ .build() -+ .unwrap() -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/time_pause.rs b/KubeOS-Rust/vendor/tokio/tests/time_pause.rs -index 02e050a2..c772e387 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/time_pause.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/time_pause.rs -@@ -4,7 +4,10 @@ - use rand::SeedableRng; - use rand::{rngs::StdRng, Rng}; - use tokio::time::{self, Duration, Instant, Sleep}; --use tokio_test::{assert_elapsed, assert_err, assert_pending, assert_ready, assert_ready_eq, task}; -+use tokio_test::{assert_elapsed, assert_pending, assert_ready, assert_ready_eq, task}; -+ -+#[cfg(not(tokio_wasi))] -+use tokio_test::assert_err; - - use std::{ - future::Future, -@@ -26,12 +29,14 @@ async fn pause_time_in_task() { - t.await.unwrap(); - } - -+#[cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread", worker_threads = 1)] - #[should_panic] - async fn pause_time_in_main_threads() { - tokio::time::pause(); - } - -+#[cfg(all(feature = "full", not(tokio_wasi)))] // Wasi doesn't support threads - #[tokio::test(flavor = "multi_thread", worker_threads = 1)] - async fn pause_time_in_spawn_threads() { - let t = tokio::spawn(async { -diff --git a/KubeOS-Rust/vendor/tokio/tests/time_rt.rs b/KubeOS-Rust/vendor/tokio/tests/time_rt.rs -index 23367be4..20f9e181 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/time_rt.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/time_rt.rs -@@ -5,6 +5,7 @@ use tokio::time::*; - - use std::sync::mpsc; - -+#[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))] // Wasi doesn't support threads - #[test] - fn timer_with_threaded_runtime() { - use tokio::runtime::Runtime; -@@ -25,7 +26,7 @@ fn timer_with_threaded_runtime() { - } - - #[test] --fn timer_with_basic_scheduler() { -+fn timer_with_current_thread_scheduler() { - use tokio::runtime::Builder; - - let rt = Builder::new_current_thread().enable_all().build().unwrap(); -diff --git a/KubeOS-Rust/vendor/tokio/tests/time_sleep.rs b/KubeOS-Rust/vendor/tokio/tests/time_sleep.rs -index 20477d26..4174a73b 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/time_sleep.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/time_sleep.rs -@@ -168,6 +168,7 @@ async fn reset_sleep_to_past() { - assert_ready!(sleep.poll()); - } - -+#[cfg(not(tokio_wasi))] // Wasi doesn't support panic recovery - #[test] - #[should_panic] - fn creating_sleep_outside_of_context() { -@@ -188,10 +189,7 @@ async fn greater_than_max() { - - #[tokio::test] - async fn short_sleeps() { -- for i in 0..10000 { -- if (i % 10) == 0 { -- eprintln!("=== {}", i); -- } -+ for _ in 0..10000 { - tokio::time::sleep(std::time::Duration::from_millis(0)).await; - } - } -@@ -235,22 +233,6 @@ async fn long_sleeps() { - assert!(tokio::time::Instant::now() <= deadline + Duration::from_millis(1)); - } - --#[tokio::test] --#[should_panic(expected = "Duration too far into the future")] --async fn very_long_sleeps() { -- tokio::time::pause(); -- -- // Some platforms (eg macos) can't represent times this far in the future -- if let Some(deadline) = tokio::time::Instant::now().checked_add(Duration::from_secs(1u64 << 62)) -- { -- tokio::time::sleep_until(deadline).await; -- } else { -- // make it pass anyway (we can't skip/ignore the test based on the -- // result of checked_add) -- panic!("Duration too far into the future (test ignored)") -- } --} -- - #[tokio::test] - async fn reset_after_firing() { - let timer = tokio::time::sleep(std::time::Duration::from_millis(1)); -@@ -333,18 +315,18 @@ async fn drop_from_wake() { - - tokio::time::pause(); - -- let mut lock = list.lock().unwrap(); -+ { -+ let mut lock = list.lock().unwrap(); - -- for _ in 0..100 { -- let mut timer = Box::pin(tokio::time::sleep(Duration::from_millis(10))); -+ for _ in 0..100 { -+ let mut timer = Box::pin(tokio::time::sleep(Duration::from_millis(10))); - -- let _ = timer.as_mut().poll(&mut Context::from_waker(&arc_wake)); -+ let _ = timer.as_mut().poll(&mut Context::from_waker(&arc_wake)); - -- lock.push(timer); -+ lock.push(timer); -+ } - } - -- drop(lock); -- - tokio::time::sleep(Duration::from_millis(11)).await; - - assert!( -diff --git a/KubeOS-Rust/vendor/tokio/tests/time_timeout.rs b/KubeOS-Rust/vendor/tokio/tests/time_timeout.rs -index dbd80eb8..be6b8fb4 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/time_timeout.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/time_timeout.rs -@@ -17,6 +17,7 @@ async fn simultaneous_deadline_future_completion() { - assert_ready_ok!(fut.poll()); - } - -+#[cfg_attr(tokio_wasi, ignore = "FIXME: `fut.poll()` panics on Wasi")] - #[tokio::test] - async fn completed_future_past_deadline() { - // Wrap it with a deadline -@@ -135,3 +136,16 @@ async fn deadline_future_elapses() { - fn ms(n: u64) -> Duration { - Duration::from_millis(n) - } -+ -+#[tokio::test] -+async fn timeout_is_not_exhausted_by_future() { -+ let fut = timeout(ms(1), async { -+ let mut buffer = [0u8; 1]; -+ loop { -+ use tokio::io::AsyncReadExt; -+ let _ = tokio::io::empty().read(&mut buffer).await; -+ } -+ }); -+ -+ assert!(fut.await.is_err()); -+} -diff --git a/KubeOS-Rust/vendor/tokio/tests/udp.rs b/KubeOS-Rust/vendor/tokio/tests/udp.rs -index ec2a1e96..565323b3 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/udp.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/udp.rs -@@ -1,5 +1,5 @@ - #![warn(rust_2018_idioms)] --#![cfg(feature = "full")] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support bind or UDP - - use futures::future::poll_fn; - use std::io; -@@ -39,7 +39,7 @@ async fn send_recv_poll() -> std::io::Result<()> { - - let mut recv_buf = [0u8; 32]; - let mut read = ReadBuf::new(&mut recv_buf); -- let _len = poll_fn(|cx| receiver.poll_recv(cx, &mut read)).await?; -+ poll_fn(|cx| receiver.poll_recv(cx, &mut read)).await?; - - assert_eq!(read.filled(), MSG); - Ok(()) -@@ -106,6 +106,45 @@ async fn send_to_peek_from() -> std::io::Result<()> { - Ok(()) - } - -+#[tokio::test] -+async fn send_to_try_peek_from() -> std::io::Result<()> { -+ let sender = UdpSocket::bind("127.0.0.1:0").await?; -+ let receiver = UdpSocket::bind("127.0.0.1:0").await?; -+ -+ let receiver_addr = receiver.local_addr()?; -+ poll_fn(|cx| sender.poll_send_to(cx, MSG, receiver_addr)).await?; -+ -+ // peek -+ let mut recv_buf = [0u8; 32]; -+ -+ loop { -+ match receiver.try_peek_from(&mut recv_buf) { -+ Ok((n, addr)) => { -+ assert_eq!(&recv_buf[..n], MSG); -+ assert_eq!(addr, sender.local_addr()?); -+ break; -+ } -+ Err(e) if e.kind() == io::ErrorKind::WouldBlock => { -+ receiver.readable().await?; -+ } -+ Err(e) => return Err(e), -+ } -+ } -+ -+ // peek -+ let mut recv_buf = [0u8; 32]; -+ let (n, addr) = receiver.peek_from(&mut recv_buf).await?; -+ assert_eq!(&recv_buf[..n], MSG); -+ assert_eq!(addr, sender.local_addr()?); -+ -+ let mut recv_buf = [0u8; 32]; -+ let (n, addr) = receiver.recv_from(&mut recv_buf).await?; -+ assert_eq!(&recv_buf[..n], MSG); -+ assert_eq!(addr, sender.local_addr()?); -+ -+ Ok(()) -+} -+ - #[tokio::test] - async fn send_to_peek_from_poll() -> std::io::Result<()> { - let sender = UdpSocket::bind("127.0.0.1:0").await?; -@@ -134,6 +173,92 @@ async fn send_to_peek_from_poll() -> std::io::Result<()> { - Ok(()) - } - -+#[tokio::test] -+async fn peek_sender() -> std::io::Result<()> { -+ let sender = UdpSocket::bind("127.0.0.1:0").await?; -+ let receiver = UdpSocket::bind("127.0.0.1:0").await?; -+ -+ let sender_addr = sender.local_addr()?; -+ let receiver_addr = receiver.local_addr()?; -+ -+ let msg = b"Hello, world!"; -+ sender.send_to(msg, receiver_addr).await?; -+ -+ let peeked_sender = receiver.peek_sender().await?; -+ assert_eq!(peeked_sender, sender_addr); -+ -+ // Assert that `peek_sender()` returns the right sender but -+ // doesn't remove from the receive queue. -+ let mut recv_buf = [0u8; 32]; -+ let (read, received_sender) = receiver.recv_from(&mut recv_buf).await?; -+ -+ assert_eq!(&recv_buf[..read], msg); -+ assert_eq!(received_sender, peeked_sender); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+async fn poll_peek_sender() -> std::io::Result<()> { -+ let sender = UdpSocket::bind("127.0.0.1:0").await?; -+ let receiver = UdpSocket::bind("127.0.0.1:0").await?; -+ -+ let sender_addr = sender.local_addr()?; -+ let receiver_addr = receiver.local_addr()?; -+ -+ let msg = b"Hello, world!"; -+ poll_fn(|cx| sender.poll_send_to(cx, msg, receiver_addr)).await?; -+ -+ let peeked_sender = poll_fn(|cx| receiver.poll_peek_sender(cx)).await?; -+ assert_eq!(peeked_sender, sender_addr); -+ -+ // Assert that `poll_peek_sender()` returns the right sender but -+ // doesn't remove from the receive queue. -+ let mut recv_buf = [0u8; 32]; -+ let mut read = ReadBuf::new(&mut recv_buf); -+ let received_sender = poll_fn(|cx| receiver.poll_recv_from(cx, &mut read)).await?; -+ -+ assert_eq!(read.filled(), msg); -+ assert_eq!(received_sender, peeked_sender); -+ -+ Ok(()) -+} -+ -+#[tokio::test] -+async fn try_peek_sender() -> std::io::Result<()> { -+ let sender = UdpSocket::bind("127.0.0.1:0").await?; -+ let receiver = UdpSocket::bind("127.0.0.1:0").await?; -+ -+ let sender_addr = sender.local_addr()?; -+ let receiver_addr = receiver.local_addr()?; -+ -+ let msg = b"Hello, world!"; -+ sender.send_to(msg, receiver_addr).await?; -+ -+ let peeked_sender = loop { -+ match receiver.try_peek_sender() { -+ Ok(peeked_sender) => break peeked_sender, -+ Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { -+ receiver.readable().await?; -+ } -+ Err(e) => return Err(e), -+ } -+ }; -+ -+ assert_eq!(peeked_sender, sender_addr); -+ -+ // Assert that `try_peek_sender()` returns the right sender but -+ // didn't remove from the receive queue. -+ let mut recv_buf = [0u8; 32]; -+ // We already peeked the sender so there must be data in the receive queue. -+ let (read, received_sender) = receiver.try_recv_from(&mut recv_buf).unwrap(); -+ -+ assert_eq!(&recv_buf[..read], msg); -+ assert_eq!(received_sender, peeked_sender); -+ -+ Ok(()) -+} -+ - #[tokio::test] - async fn split() -> std::io::Result<()> { - let socket = UdpSocket::bind("127.0.0.1:0").await?; -@@ -399,6 +524,23 @@ async fn try_recv_buf() { - } - } - -+#[tokio::test] -+async fn recv_buf() -> std::io::Result<()> { -+ let sender = UdpSocket::bind("127.0.0.1:0").await?; -+ let receiver = UdpSocket::bind("127.0.0.1:0").await?; -+ -+ sender.connect(receiver.local_addr()?).await?; -+ receiver.connect(sender.local_addr()?).await?; -+ -+ sender.send(MSG).await?; -+ let mut recv_buf = Vec::with_capacity(32); -+ let len = receiver.recv_buf(&mut recv_buf).await?; -+ -+ assert_eq!(len, MSG_LEN); -+ assert_eq!(&recv_buf[..len], MSG); -+ Ok(()) -+} -+ - #[tokio::test] - async fn try_recv_buf_from() { - // Create listener -@@ -442,6 +584,23 @@ async fn try_recv_buf_from() { - } - } - -+#[tokio::test] -+async fn recv_buf_from() -> std::io::Result<()> { -+ let sender = UdpSocket::bind("127.0.0.1:0").await?; -+ let receiver = UdpSocket::bind("127.0.0.1:0").await?; -+ -+ sender.connect(receiver.local_addr()?).await?; -+ -+ sender.send(MSG).await?; -+ let mut recv_buf = Vec::with_capacity(32); -+ let (len, caddr) = receiver.recv_buf_from(&mut recv_buf).await?; -+ -+ assert_eq!(len, MSG_LEN); -+ assert_eq!(&recv_buf[..len], MSG); -+ assert_eq!(caddr, sender.local_addr()?); -+ Ok(()) -+} -+ - #[tokio::test] - async fn poll_ready() { - // Create listener -diff --git a/KubeOS-Rust/vendor/tokio/tests/uds_datagram.rs b/KubeOS-Rust/vendor/tokio/tests/uds_datagram.rs -index 5e5486ba..ad22a0b9 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/uds_datagram.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/uds_datagram.rs -@@ -29,9 +29,7 @@ async fn echo() -> io::Result<()> { - let server_socket = UnixDatagram::bind(server_path.clone())?; - - tokio::spawn(async move { -- if let Err(e) = echo_server(server_socket).await { -- eprintln!("Error in echo server: {}", e); -- } -+ let _ = echo_server(server_socket).await; - }); - - { -@@ -55,9 +53,7 @@ async fn echo_from() -> io::Result<()> { - let server_socket = UnixDatagram::bind(server_path.clone())?; - - tokio::spawn(async move { -- if let Err(e) = echo_server(server_socket).await { -- eprintln!("Error in echo server: {}", e); -- } -+ let _ = echo_server(server_socket).await; - }); - - { -@@ -181,7 +177,7 @@ async fn send_recv_poll() -> std::io::Result<()> { - - let mut recv_buf = [0u8; 32]; - let mut read = ReadBuf::new(&mut recv_buf); -- let _len = poll_fn(|cx| receiver.poll_recv(cx, &mut read)).await?; -+ poll_fn(|cx| receiver.poll_recv(cx, &mut read)).await?; - - assert_eq!(read.filled(), msg); - Ok(()) -@@ -281,6 +277,28 @@ async fn try_recv_buf_from() -> std::io::Result<()> { - Ok(()) - } - -+#[tokio::test] -+async fn recv_buf_from() -> std::io::Result<()> { -+ let tmp = tempfile::tempdir()?; -+ -+ // Bind each socket to a filesystem path -+ let tx_path = tmp.path().join("tx"); -+ let tx = UnixDatagram::bind(&tx_path)?; -+ let rx_path = tmp.path().join("rx"); -+ let rx = UnixDatagram::bind(&rx_path)?; -+ -+ let bytes = b"hello world"; -+ tx.send_to(bytes, &rx_path).await?; -+ -+ let mut buf = Vec::with_capacity(24); -+ let (size, addr) = rx.recv_buf_from(&mut buf).await?; -+ -+ let dgram = &buf[..size]; -+ assert_eq!(dgram, bytes); -+ assert_eq!(addr.as_pathname().unwrap(), &tx_path); -+ Ok(()) -+} -+ - // Even though we use sync non-blocking io we still need a reactor. - #[tokio::test] - async fn try_recv_buf_never_block() -> io::Result<()> { -@@ -329,6 +347,24 @@ async fn try_recv_buf_never_block() -> io::Result<()> { - Ok(()) - } - -+#[tokio::test] -+async fn recv_buf() -> std::io::Result<()> { -+ // Create the pair of sockets -+ let (sock1, sock2) = UnixDatagram::pair()?; -+ -+ // Since the sockets are paired, the paired send/recv -+ // functions can be used -+ let bytes = b"hello world"; -+ sock1.send(bytes).await?; -+ -+ let mut buff = Vec::with_capacity(24); -+ let size = sock2.recv_buf(&mut buff).await?; -+ -+ let dgram = &buff[..size]; -+ assert_eq!(dgram, bytes); -+ Ok(()) -+} -+ - #[tokio::test] - async fn poll_ready() -> io::Result<()> { - let dir = tempfile::tempdir().unwrap(); -diff --git a/KubeOS-Rust/vendor/tokio/tests/uds_stream.rs b/KubeOS-Rust/vendor/tokio/tests/uds_stream.rs -index 5f1b4cff..b8c4e6a8 100644 ---- a/KubeOS-Rust/vendor/tokio/tests/uds_stream.rs -+++ b/KubeOS-Rust/vendor/tokio/tests/uds_stream.rs -@@ -25,13 +25,13 @@ async fn accept_read_write() -> std::io::Result<()> { - let connect = UnixStream::connect(&sock_path); - let ((mut server, _), mut client) = try_join(accept, connect).await?; - -- // Write to the client. TODO: Switch to write_all. -- let write_len = client.write(b"hello").await?; -- assert_eq!(write_len, 5); -+ // Write to the client. -+ client.write_all(b"hello").await?; - drop(client); -- // Read from the server. TODO: Switch to read_to_end. -- let mut buf = [0u8; 5]; -- server.read_exact(&mut buf).await?; -+ -+ // Read from the server. -+ let mut buf = vec![]; -+ server.read_to_end(&mut buf).await?; - assert_eq!(&buf, b"hello"); - let len = server.read(&mut buf).await?; - assert_eq!(len, 0); -diff --git a/KubeOS-Rust/vendor/tokio/tests/unwindsafe.rs b/KubeOS-Rust/vendor/tokio/tests/unwindsafe.rs -new file mode 100644 -index 00000000..3e638208 ---- /dev/null -+++ b/KubeOS-Rust/vendor/tokio/tests/unwindsafe.rs -@@ -0,0 +1,42 @@ -+#![warn(rust_2018_idioms)] -+#![cfg(all(feature = "full", not(tokio_wasi)))] // Wasi does not support panic recovery -+ -+use std::panic::{RefUnwindSafe, UnwindSafe}; -+ -+#[test] -+fn notify_is_unwind_safe() { -+ is_unwind_safe::(); -+} -+ -+#[test] -+fn join_handle_is_unwind_safe() { -+ is_unwind_safe::>(); -+} -+ -+#[test] -+fn net_types_are_unwind_safe() { -+ is_unwind_safe::(); -+ is_unwind_safe::(); -+ is_unwind_safe::(); -+ is_unwind_safe::(); -+} -+ -+#[test] -+#[cfg(unix)] -+fn unix_net_types_are_unwind_safe() { -+ is_unwind_safe::(); -+ is_unwind_safe::(); -+ is_unwind_safe::(); -+} -+ -+#[test] -+#[cfg(windows)] -+fn windows_net_types_are_unwind_safe() { -+ use tokio::net::windows::named_pipe::NamedPipeClient; -+ use tokio::net::windows::named_pipe::NamedPipeServer; -+ -+ is_unwind_safe::(); -+ is_unwind_safe::(); -+} -+ -+fn is_unwind_safe() {} --- -2.34.1 - diff --git a/0020-fix-mutex-locking-in-agent_impl.rs.patch b/0020-fix-mutex-locking-in-agent_impl.rs.patch deleted file mode 100644 index add40f0eb4b399a48db8f1de35cef01b9f934117..0000000000000000000000000000000000000000 --- a/0020-fix-mutex-locking-in-agent_impl.rs.patch +++ /dev/null @@ -1,84 +0,0 @@ -From 0b4843d4514cd8b7e653990025d0ecd5e80d56ba Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Tue, 20 Feb 2024 10:18:27 +0800 -Subject: [PATCH 1/2] fix: mutex locking in agent_impl.rs - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/agent/src/rpc/agent_impl.rs | 32 +++++++++++++++++++++---- - 1 file changed, 28 insertions(+), 4 deletions(-) - -diff --git a/KubeOS-Rust/agent/src/rpc/agent_impl.rs b/KubeOS-Rust/agent/src/rpc/agent_impl.rs -index 5f3a3259..ab826413 100644 ---- a/KubeOS-Rust/agent/src/rpc/agent_impl.rs -+++ b/KubeOS-Rust/agent/src/rpc/agent_impl.rs -@@ -57,7 +57,10 @@ impl Default for AgentImpl { - - impl AgentImpl { - fn prepare_upgrade_impl(&self, req: UpgradeRequest) -> Result { -- let _lock = self.mutex.lock().unwrap(); -+ let lock = self.mutex.try_lock(); -+ if lock.is_err() { -+ bail!("os-agent is processing another request"); -+ } - debug!("Received an 'prepare upgrade' request: {:?}", req); - info!("Start preparing for upgrading to version: {}", req.version); - -@@ -76,7 +79,10 @@ impl AgentImpl { - } - - fn upgrade_impl(&self) -> Result { -- let _lock = self.mutex.lock().unwrap(); -+ let lock = self.mutex.try_lock(); -+ if lock.is_err() { -+ bail!("os-agent is processing another request"); -+ } - info!("Start to upgrade"); - let command_executor = RealCommandExecutor {}; - let (_, next_partition_info) = get_partition_info(&command_executor)?; -@@ -91,7 +97,10 @@ impl AgentImpl { - } - - fn configure_impl(&self, mut req: ConfigureRequest) -> Result { -- let _lock = self.mutex.lock().unwrap(); -+ let lock = self.mutex.try_lock(); -+ if lock.is_err() { -+ bail!("os-agent is processing another request"); -+ } - debug!("Received a 'configure' request: {:?}", req); - info!("Start to configure"); - let config_map = &*CONFIG_TEMPLATE; -@@ -108,7 +117,10 @@ impl AgentImpl { - } - - fn rollback_impl(&self) -> Result { -- let _lock = self.mutex.lock().unwrap(); -+ let lock = self.mutex.try_lock(); -+ if lock.is_err() { -+ bail!("os-agent is processing another request"); -+ } - info!("Start to rollback"); - let command_executor = RealCommandExecutor {}; - let (_, next_partition_info) = get_partition_info(&command_executor)?; -@@ -172,6 +184,18 @@ mod test { - }; - let res = agent.configure(req); - assert!(res.is_err()); -+ -+ // test lock -+ let _lock = agent.mutex.lock().unwrap(); -+ let req = ConfigureRequest { -+ configs: vec![Sysconfig { -+ model: "kernel.sysctl".to_string(), -+ config_path: "".to_string(), -+ contents: HashMap::new(), -+ }], -+ }; -+ let res = agent.configure(req); -+ assert!(res.is_err()); - } - - #[test] --- -2.34.1 - diff --git a/0021-fix-partition-info-retrieval-in-get_partition_info-f.patch b/0021-fix-partition-info-retrieval-in-get_partition_info-f.patch deleted file mode 100644 index 1f12606064a49b479e082922e10d1a16787f83bf..0000000000000000000000000000000000000000 --- a/0021-fix-partition-info-retrieval-in-get_partition_info-f.patch +++ /dev/null @@ -1,38 +0,0 @@ -From 3bbb48b9e2569514caa88b9d67aa14d67a48432f Mon Sep 17 00:00:00 2001 -From: Yuhang Wei -Date: Tue, 20 Feb 2024 10:18:42 +0800 -Subject: [PATCH 2/2] fix: partition info retrieval in get_partition_info - function - -Signed-off-by: Yuhang Wei ---- - KubeOS-Rust/manager/src/utils/partition.rs | 7 ++++++- - 1 file changed, 6 insertions(+), 1 deletion(-) - -diff --git a/KubeOS-Rust/manager/src/utils/partition.rs b/KubeOS-Rust/manager/src/utils/partition.rs -index fcfa2d8b..799b4b35 100644 ---- a/KubeOS-Rust/manager/src/utils/partition.rs -+++ b/KubeOS-Rust/manager/src/utils/partition.rs -@@ -50,7 +50,7 @@ pub fn get_partition_info(executor: &T) -> Result<(Partition - } - } - } -- if cur_partition.device.is_empty() { -+ if cur_partition.menuentry.is_empty() { - bail!("Failed to get partition info, lsblk output: {}", lsblk); - } - Ok((cur_partition, next_partition)) -@@ -108,5 +108,10 @@ mod tests { - mock.expect_run_command_with_output().times(1).returning(|_, _| Ok(command_output3.to_string())); - let res = get_partition_info(&mock); - assert!(res.is_err()); -+ -+ let command_output4 = "sda4 / ext4"; -+ mock.expect_run_command_with_output().times(1).returning(|_, _| Ok(command_output4.to_string())); -+ let res = get_partition_info(&mock); -+ assert!(res.is_err()); - } - } --- -2.34.1 - diff --git a/KubeOS.spec b/KubeOS.spec index 50ba0c05edc9c3fec68272942a5d55d74655fd16..38f8b785f453ee6bef466269e3b9d4a3ef829798 100644 --- a/KubeOS.spec +++ b/KubeOS.spec @@ -1,32 +1,13 @@ # Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved. Name: KubeOS -Version: 1.0.5 -Release: 4 +Version: 1.0.6 +Release: 2 Summary: O&M platform used to update the whole OS as an entirety License: Mulan PSL v2 Source0: https://gitee.com/openeuler/KubeOS/repository/archive/v%{version}.tar.gz -Patch1: 0001-build-rust-os-agent-remove-useless-dependency.patch -Patch2: 0002-docs-Add-the-content-of-the-user-guide.patch -Patch3: 0003-Remove-cleanup-method-and-related-code.patch -Patch4: 0004-test-rust-proxy-add-drain-integration-test.patch -Patch5: 0005-refactor-rust-os-agent-fix-code-check.patch -Patch6: 0006-fix-agent-proxy-transform-log-timestamp-to-human-rea.patch -Patch7: 0007-build-update-vendor.patch -Patch8: 0008-test-rust-os-agent-add-os-agent-unit-tests.patch -Patch9: 0009-fix-checksum-comparison-log-format.patch -Patch10: 0010-fix-check-image-name-is-valid-regex.patch -Patch11: 0011-Bump-version-from-1.0.4-to-1.0.5.patch -Patch12: 0012-perf-crd-improve-default-display-of-crd-under-kubect.patch -Patch13: 0013-fix-logs-content-grammar-and-format.patch -Patch14: 0014-fix-os-agent-add-context-when-returning-error.patch -Patch15: 0015-proxy-Add-unit-tests-and-delete-useless-dependencies.patch -Patch16: 0016-proxy-fix-code-review-issues.patch -Patch17: 0017-fix-clippy-warnings-and-fmt-code.patch -Patch18: 0018-Bump-tokio-to-1.28.0.patch -Patch19: 0019-build-update-vendor.patch -Patch20: 0020-fix-mutex-locking-in-agent_impl.rs.patch -Patch21: 0021-fix-partition-info-retrieval-in-get_partition_info-f.patch +Patch1: 0001-Bump-kubeos-version-to-1.0.6.patch +Patch2: 0002-fix-update-bootloader.sh-paths-for-EFI-boot.patch BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: make rust cargo openssl-devel @@ -138,6 +119,12 @@ install -p -m 0600 ./files/os-release %{buildroot}/opt/kubeOS/files rm -rfv %{buildroot} %changelog +* Tue Jun 18 2024 Yuhang Wei - 1.0.6-2 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:sync to v1.0.6-2 + * Fri Feb 23 2024 Yuhang Wei - 1.0.5-4 - Type:requirement - CVE:NA diff --git a/v1.0.5.tar.gz b/v1.0.6.tar.gz similarity index 75% rename from v1.0.5.tar.gz rename to v1.0.6.tar.gz index 6c7ae5f02eafba231e4dbfe69eea0f70082c22da..08a71593643b124bbc90cfa3911b6ac1e6b56f6b 100644 Binary files a/v1.0.5.tar.gz and b/v1.0.6.tar.gz differ