diff --git a/0001-Write-a-tool-to-support-KubeOS-deployment-on-physica.patch b/0001-Write-a-tool-to-support-KubeOS-deployment-on-physica.patch deleted file mode 100644 index c321333cf4c0f7067d27b0e5c5e55f44e44e4f3d..0000000000000000000000000000000000000000 --- a/0001-Write-a-tool-to-support-KubeOS-deployment-on-physica.patch +++ /dev/null @@ -1,479 +0,0 @@ -From 236b8ddeb3bc7f35eb817769f117ecd68a59335c Mon Sep 17 00:00:00 2001 -From: stedylan <836671668@qq.com> -Date: Sun, 7 Aug 2022 01:47:14 +0800 -Subject: [PATCH] Write a tool to support KubeOS deployment on physical - machines. - -This tool uses dracut module to make partitions and formatting, set network infomation, get rootfs and set boot options in initramfs before switch to the real root. - -Signed-off-by: stedylan <836671668@qq.com> ---- - scripts/00bootup/Global.cfg | 12 ++ - scripts/00bootup/module-setup.sh | 28 +++ - scripts/00bootup/mount.sh | 332 +++++++++++++++++++++++++++++++ - scripts/create/imageCreate.sh | 4 +- - scripts/create/rootfsCreate.sh | 1 + - scripts/rpmlist | 10 +- - scripts/set_in_chroot.sh | 3 + - 7 files changed, 387 insertions(+), 3 deletions(-) - create mode 100644 scripts/00bootup/Global.cfg - create mode 100644 scripts/00bootup/module-setup.sh - create mode 100644 scripts/00bootup/mount.sh - -diff --git a/scripts/00bootup/Global.cfg b/scripts/00bootup/Global.cfg -new file mode 100644 -index 0000000..cad4e33 ---- /dev/null -+++ b/scripts/00bootup/Global.cfg -@@ -0,0 +1,12 @@ -+# rootfs file name -+rootfs_name=kubeos.tar -+ -+# select the target disk to install kubeOS -+disk=/dev/sda -+ -+# address where stores the rootfs on the http server -+server_ip=192.168.1.50 -+ -+local_ip=192.168.1.100 -+ -+route_ip=192.168.1.1 -\ No newline at end of file -diff --git a/scripts/00bootup/module-setup.sh b/scripts/00bootup/module-setup.sh -new file mode 100644 -index 0000000..5460b2b ---- /dev/null -+++ b/scripts/00bootup/module-setup.sh -@@ -0,0 +1,28 @@ -+#!/bin/bash -+ -+check() { -+ return 0 -+} -+ -+depends() { -+ echo systemd -+} -+ -+install() { -+ inst_multiple -o grub2-mkimage mkfs.ext4 mkfs.vfat lsblk tar cpio gunzip lspci parted dhclient ifconfig curl hwinfo head tee arch df awk route -+ inst_hook mount 00 "$moddir/mount.sh" -+ inst_simple "$moddir/mount.sh" "/mount.sh" -+ inst_simple "$moddir/Global.cfg" "/Global.cfg" -+} -+ -+installkernel() { -+ hostonly='' \ -+ instmods \ -+ =drivers/ata \ -+ =drivers/nvme \ -+ =drivers/scsi \ -+ =drivers/net \ -+ =fs/fat \ -+ =fs/nls -+} -+ -diff --git a/scripts/00bootup/mount.sh b/scripts/00bootup/mount.sh -new file mode 100644 -index 0000000..a04a364 ---- /dev/null -+++ b/scripts/00bootup/mount.sh -@@ -0,0 +1,332 @@ -+#!/bin/bash -+arch=$(arch) -+min_size=8 -+log=/install.log -+ -+source /Global.cfg -+ -+function CheckSpace() { -+ local disk_ava="$(parted -l | grep ${disk} | awk '{print $3}')" -+ if echo "${disk_ava}" | grep [GT]B$; then -+ if echo "${disk_ava}" | grep GB$; then -+ disk_ava="$(echo ${disk_ava} | awk -F G '{print $1}' | awk -F . '{print $1}')" -+ if [ "${disk_ava}" -lt ${min_size} ]; then -+ echo "The available disk space is not enough, at least ${min_size}GB." | tee -a ${log} -+ return 1 -+ fi -+ fi -+ else -+ echo "The available disk space is not enough, at least ${min_size}G." | tee -a ${log} -+ return 1 -+ fi -+ -+ return 0 -+} -+ -+function GetDisk() { -+ disks=$(hwinfo --disk --short | grep -vi "^disk" | awk '{print $1}') -+ if [ ! -z ${disks} ]; then -+ if [ ! -z ${disk} ] && echo "${disks[@]}" | grep -wq "${disk}" ; then -+ echo "${disk} exists, start partition" | tee -a ${log} -+ else -+ echo "disk not exist, choose default disk" | tee -a ${log} -+ disk=$(echo ${disks[0]}) -+ fi -+ else -+ echo "no disk found" | tee -a ${log} -+ return 1 -+ fi -+ -+ -+ CheckSpace -+ if [ $? -ne 0 ]; then -+ echo "no enough space on ${disk}" | tee -a ${log} -+ return 1 -+ fi -+ -+ return 0 -+} -+ -+function PartitionAndFormatting() { -+ echo "Partitioning and formatting disk $disk..." -+ # partition and format -+ parted ${disk} -s mklabel gpt >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "partition failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ parted ${disk} -s mkpart primary fat16 1M 100M >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "partition failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ parted ${disk} -s mkpart primary ext4 100M 2600M >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "partition failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ parted ${disk} -s mkpart primary ext4 2600M 5100M >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "partition failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ parted ${disk} -s mkpart primary ext4 5100M 100% >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "partition failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ parted ${disk} -s set 1 boot on >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "partition failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ mkfs.vfat -n "BOOT" ${disk}1 >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "format failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ mkfs.ext4 -L "ROOT-A" ${disk}2 >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "format failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ mkfs.ext4 -L "ROOT-B" ${disk}3 >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "format failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ mkfs.ext4 -L "PERSIST" ${disk}4 >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "format failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ return 0 -+} -+ -+function InitNetwork() { -+ echo "Initializing network..." -+ # 获取网卡信息，默认只有一个网卡 -+ net_name=`ifconfig -a | awk '{print $1}' | grep : | grep '^e' | awk -F: '{print $1}'` -+ # dhclient --timeout 60 >> ${log} 2>&1 -+ -+ ifconfig ${net_name} up -+ if [ $? -ne 0 ]; then -+ echo "load net card failed" | tee -a ${log} -+ return 1 -+ fi -+ sleep 3 -+ -+ ifconfig ${net_name} ${local_ip} netmask 255.255.255.0 >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "ip set failed" | tee -a ${log} -+ return 1 -+ fi -+ sleep 3 -+ -+ route add default gw ${route_ip} >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "add route failed" | tee -a ${log} -+ return 1 -+ fi -+ sleep 3 -+ -+ -+ -+ return 0 -+} -+ -+function MountRoot() { -+ echo "Mounting rootfs..." -+ # mount rootfs -+ mount ${disk}2 /sysroot >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "mount rootfs failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ return 0 -+} -+ -+function MountPersist() { -+ echo "Mounting persist" -+ mkdir /persist -+ mount ${disk}4 /persist >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "mount persist failed" | tee -a ${log} -+ return 1 -+ fi -+ mkdir /persist/{var,etc,etcwork} -+ mkdir -p /persist/etc/KubeOS/certs -+ return 0 -+} -+ -+function MountBoot() { -+ echo "Mounting boot" -+ mkdir -p /sysroot/boot/efi -+ mount ${disk}1 /sysroot/boot/efi >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "mount boot failed" | tee -a ${log} -+ return 1 -+ fi -+ return 0 -+} -+ -+function GetRootfs() { -+ echo "Downloading rootfs..." -+ -+ curl -o /persist/${rootfs_name} http://${server_ip}/${rootfs_name} -+ if [ ! -e "/persist/${rootfs_name}" ]; then -+ echo "download rootfs failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ tar -xvf /persist/${rootfs_name} -C /sysroot -+ if [ $? -ne 0 ]; then -+ echo "decompose rootfs failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ rm -rf /persist/${rootfs_name} -+ -+ return 0 -+} -+ -+function Inst_Grub2_x86() { -+ # copy the files that boot need -+ cp -r /sysroot/usr/lib/grub/x86_64-efi /sysroot/boot/efi/EFI/openEuler -+ eval "grub2-mkimage -d /sysroot/usr/lib/grub/x86_64-efi -O x86_64-efi --output=/sysroot/boot/efi/EFI/openEuler/grubx64.efi '--prefix=(,gpt1)/EFI/openEuler' fat part_gpt part_msdos linux" >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "grub2-mkimage on x86 failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ mkdir -p /sysroot/boot/efi/EFI/BOOT/ -+ cp -f /sysroot/boot/efi/EFI/openEuler/grubx64.efi /sysroot/boot/efi/EFI/BOOT/BOOTX64.EFI -+ -+ return 0 -+} -+ -+function Inst_Grub2_aarch64() { -+ cp -r /sysroot/usr/lib/grub/arm64-efi /sysroot/boot/efi/EFI/openEuler/ -+ eval "grub2-mkimage -d /sysroot/usr/lib/grub/arm64-efi -O arm64-efi --output=/sysroot/boot/efi/EFI/openEuler/grubaa64.efi '--prefix=(,gpt1)/EFI/openEuler' fat part_gpt part_msdos linux" >> ${log} 2>&1 -+ if [ $? -ne 0 ]; then -+ echo "grub2-mkimage on aarch64 failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ mkdir -p /sysroot/boot/efi/EFI/BOOT/ -+ cp -f /sysroot/boot/efi/EFI/openEuler/grubaa64.efi /sysroot/boot/efi/EFI/BOOT/BOOTAA64.EFI -+ -+ return 0 -+} -+ -+function SetBoot() { -+ # mount boot -+ echo "Setting boot" -+ -+ if [ $arch == "x86_64" ]; then -+ Inst_Grub2_x86 -+ if [ $? -ne 0 ]; then -+ echo "install grub on x86 failed" | tee -a ${log} -+ return 1 -+ fi -+ fi -+ -+ if [ $arch == "aarch64" ]; then -+ Inst_Grub2_aarch64 -+ if [ $? -ne 0 ]; then -+ echo "install grub on aarch64 failed" | tee -a ${log} -+ return 1 -+ fi -+ fi -+ -+ return 0 -+} -+ -+function Bootup_Main() { -+ # get disk -+ echo "Checking disk info..." | tee -a ${log} -+ GetDisk -+ if [ $? -ne 0 ]; then -+ echo "Checking disk info failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ # partition and format disk -+ echo "Partion and formatting..." | tee -a ${log} -+ PartitionAndFormatting -+ if [ $? -ne 0 ]; then -+ echo "Partition and formatting disk failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ # init network -+ echo "Initializing network..." | tee -a ${log} -+ InitNetwork -+ if [ $? -ne 0 ]; then -+ echo "Initializing network failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ # mount partitions -+ echo "Mounting root..." | tee -a ${log} -+ MountRoot -+ if [ $? -ne 0 ]; then -+ echo "Mounting root failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ # mount persist -+ echo "Mounting persisst..." | tee -a ${log} -+ MountPersist -+ if [ $? -ne 0 ]; then -+ echo "Mounting persist failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ # mount boot -+ echo "Mounting boot..." | tee -a ${log} -+ MountBoot -+ if [ $? -ne 0 ]; then -+ echo "Mounting boot failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ # download rootfs -+ echo "Downloading rootfs..." | tee -a ${log} -+ GetRootfs -+ if [ $? -ne 0 ]; then -+ echo "Downloading rootfs failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ # set boot -+ echo "Setting boot..." | tee -a ${log} -+ SetBoot -+ if [ $? -ne 0 ]; then -+ echo "Setting boot failed" | tee -a ${log} -+ return 1 -+ fi -+ -+ return 0 -+} -+ -+Bootup_Main -+ret=$? -+if [ ${ret} -eq 0 ]; then -+ echo "kubeOS install success! switch to root" | tee -a ${log} -+ cp ${log} /persist -+else -+ echo "kubeOS install failed, see install.log" | tee -a ${log} -+fi -+ -diff --git a/scripts/create/imageCreate.sh b/scripts/create/imageCreate.sh -index f8dafbe..95ebcde 100644 ---- a/scripts/create/imageCreate.sh -+++ b/scripts/create/imageCreate.sh -@@ -62,12 +62,12 @@ function create_pxe_img() { - case $opt in - "repo") - create_os_tar_from_repo "$@" -- tar -xvf os.tar ./boot/initramfs.img -+ tar -xvf os.tar ./initramfs.img - tar -xvf os.tar ./boot/vmlinuz - ;; - "docker") - create_os_tar_from_docker "$@" -- tar -xvf os.tar boot/initramfs.img -+ tar -xvf os.tar initramfs.img - tar -xvf os.tar boot/vmlinuz - ;; - esac -diff --git a/scripts/create/rootfsCreate.sh b/scripts/create/rootfsCreate.sh -index 8049f09..e5c53d5 100644 ---- a/scripts/create/rootfsCreate.sh -+++ b/scripts/create/rootfsCreate.sh -@@ -61,6 +61,7 @@ EOF - mv "${RPM_ROOT}"/boot/initramfs* "${RPM_ROOT}/boot/initramfs.img" - cp grub.cfg "${RPM_ROOT}"/boot/grub2 - cp grub.cfg "${RPM_ROOT}"/boot/efi/EFI/openEuler -+ cp -r ./00bootup ${RPM_ROOT}/usr/lib/dracut/modules.d/ - cp set_in_chroot.sh "${RPM_ROOT}" - ROOT_PWD="${PASSWD}" chroot "${RPM_ROOT}" bash /set_in_chroot.sh - rm "${RPM_ROOT}/set_in_chroot.sh" -diff --git a/scripts/rpmlist b/scripts/rpmlist -index 7a9adfa..077a164 100644 ---- a/scripts/rpmlist -+++ b/scripts/rpmlist -@@ -13,4 +13,12 @@ socat - conntrack-tools - ebtables - ethtool --rsyslog -\ No newline at end of file -+rsyslog -+vi -+net-tools -+hwinfo -+dracut -+coreutils -+gawk -+parted -+dosfstools -\ No newline at end of file -diff --git a/scripts/set_in_chroot.sh b/scripts/set_in_chroot.sh -index bacef78..4b061df 100644 ---- a/scripts/set_in_chroot.sh -+++ b/scripts/set_in_chroot.sh -@@ -11,3 +11,6 @@ sed -i '/^root:/d' /etc/shadow_bak - echo "root:"${ROOT_PWD}${str:1} > /etc/shadow - cat /etc/shadow_bak >> /etc/shadow - rm -rf /etc/shadow_bak -+ -+dracut -f -v --add bootup /initramfs.img --kver `ls /lib/modules` -+rm -rf /usr/lib/dracut/modules.d/00bootup -\ No newline at end of file --- -2.33.0.windows.2 - diff --git a/0001-build-rust-os-agent-remove-useless-dependency.patch b/0001-build-rust-os-agent-remove-useless-dependency.patch new file mode 100644 index 0000000000000000000000000000000000000000..c6270b09a1bb632570c12c0b63408dce3dccc1fd --- /dev/null +++ b/0001-build-rust-os-agent-remove-useless-dependency.patch @@ -0,0 +1,56 @@ +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-KubeOS-fix-the-kbimg.sh-exception-and-pxe-installati.patch b/0002-KubeOS-fix-the-kbimg.sh-exception-and-pxe-installati.patch deleted file mode 100644 index dc36db07bcc5b2d211da7df2cde2706bab89af93..0000000000000000000000000000000000000000 --- a/0002-KubeOS-fix-the-kbimg.sh-exception-and-pxe-installati.patch +++ /dev/null @@ -1,341 +0,0 @@ -From f64c9587a20cc44036b0f622105501ff142729d7 Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Tue, 23 Aug 2022 15:32:36 +0800 -Subject: [PATCH] KubeOS:fix the kbimg.sh exception and pxe installation - problem. - -Fixed the issue of abnormal usage printing of the kbimg.sh parameter, -no verification of the -b parameter, and environment clearance in -the concurrent scenario. -Fix the problem that disks and network adapters cannot be found -due to disk and network adapter verification during PXE installation. -Fix the problem that os-proxy does not transfer imagetype and dockerimage -to the os-agent. - -Signed-off-by: liyuanr ---- - cmd/proxy/controllers/os_controller.go | 16 ++++++------ - scripts/00bootup/Global.cfg | 12 ++++++--- - scripts/00bootup/mount.sh | 35 ++++++++++++++------------ - scripts/common/utils.sh | 7 ++++++ - scripts/create/imageCreate.sh | 4 +-- - scripts/kbimg.sh | 30 +++++++++++++--------- - 6 files changed, 62 insertions(+), 42 deletions(-) - -diff --git a/cmd/proxy/controllers/os_controller.go b/cmd/proxy/controllers/os_controller.go -index f73c750..09e58f9 100644 ---- a/cmd/proxy/controllers/os_controller.go -+++ b/cmd/proxy/controllers/os_controller.go -@@ -106,13 +106,15 @@ func (r *OSReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re - case "upgrade": - version := osVersionSpec - downloadInfo := &agentclient.DownloadInfo{ -- ImageURL: osInstance.Spec.ImageURL, -- FlagSafe: osInstance.Spec.FlagSafe, -- CheckSum: osInstance.Spec.CheckSum, -- CaCert: osInstance.Spec.CaCert, -- ClientCert: osInstance.Spec.ClientCert, -- ClientKey: osInstance.Spec.ClientKey, -- MTLS: osInstance.Spec.MTLS, -+ ImageURL: osInstance.Spec.ImageURL, -+ FlagSafe: osInstance.Spec.FlagSafe, -+ CheckSum: osInstance.Spec.CheckSum, -+ CaCert: osInstance.Spec.CaCert, -+ ClientCert: osInstance.Spec.ClientCert, -+ ClientKey: osInstance.Spec.ClientKey, -+ MTLS: osInstance.Spec.MTLS, -+ ImageType: osInstance.Spec.ImageType, -+ DockerImage: osInstance.Spec.DockerImage, - } - if err := r.Connection.UpdateSpec(version, downloadInfo); err != nil { - return values.RequeueNow, err -diff --git a/scripts/00bootup/Global.cfg b/scripts/00bootup/Global.cfg -index cad4e33..dd78617 100644 ---- a/scripts/00bootup/Global.cfg -+++ b/scripts/00bootup/Global.cfg -@@ -4,9 +4,13 @@ rootfs_name=kubeos.tar - # select the target disk to install kubeOS - disk=/dev/sda - --# address where stores the rootfs on the http server -+# pxe server ip address where stores the rootfs on the http server - server_ip=192.168.1.50 -- -+# target machine ip - local_ip=192.168.1.100 -- --route_ip=192.168.1.1 -\ No newline at end of file -+# target machine route -+route_ip=192.168.1.1 -+# target machine netmask -+netmask=255.255.255.0 -+# target machine netDevice name -+net_name=eth0 -diff --git a/scripts/00bootup/mount.sh b/scripts/00bootup/mount.sh -index a04a364..1bc83ff 100644 ---- a/scripts/00bootup/mount.sh -+++ b/scripts/00bootup/mount.sh -@@ -24,20 +24,17 @@ function CheckSpace() { - } - - function GetDisk() { -- disks=$(hwinfo --disk --short | grep -vi "^disk" | awk '{print $1}') -- if [ ! -z ${disks} ]; then -- if [ ! -z ${disk} ] && echo "${disks[@]}" | grep -wq "${disk}" ; then -+ disks=(`hwinfo --disk --short 2>&1 | grep -vi "^disk" | awk '{print $1}'`) -+ if [ ${#disks[*]} -gt 0 ]; then -+ if [ -n "${disk}" ] && echo "${disks[@]}" | grep -wq "${disk}" ; then - echo "${disk} exists, start partition" | tee -a ${log} - else -- echo "disk not exist, choose default disk" | tee -a ${log} -- disk=$(echo ${disks[0]}) -+ echo "disk not exist, please choose correct disk" | tee -a ${log} - fi - else - echo "no disk found" | tee -a ${log} - return 1 - fi -- -- - CheckSpace - if [ $? -ne 0 ]; then - echo "no enough space on ${disk}" | tee -a ${log} -@@ -115,9 +112,18 @@ function PartitionAndFormatting() { - - function InitNetwork() { - echo "Initializing network..." -- # 获取网卡信息，默认只有一个网卡 -- net_name=`ifconfig -a | awk '{print $1}' | grep : | grep '^e' | awk -F: '{print $1}'` -- # dhclient --timeout 60 >> ${log} 2>&1 -+ netNames=(`ifconfig -a | awk '{print $1}' | grep : | grep '^e' | awk -F: '{print $1}'`) -+ if [ ${#netNames[*]} -gt 0 ]; then -+ if [ -n "${net_name}" ] && echo "${netNames[@]}" | grep -wq "${net_name}" ; then -+ echo "${net_name} exists, start set ip" | tee -a ${log} -+ else -+ echo "net_name not exist, choose default net" | tee -a ${log} -+ net_name=${netNames[0]} -+ fi -+ else -+ echo "no net Device found" | tee -a ${log} -+ return 1 -+ fi - - ifconfig ${net_name} up - if [ $? -ne 0 ]; then -@@ -126,7 +132,7 @@ function InitNetwork() { - fi - sleep 3 - -- ifconfig ${net_name} ${local_ip} netmask 255.255.255.0 >> ${log} 2>&1 -+ ifconfig ${net_name} ${local_ip} netmask ${netmask} >> ${log} 2>&1 - if [ $? -ne 0 ]; then - echo "ip set failed" | tee -a ${log} - return 1 -@@ -139,9 +145,6 @@ function InitNetwork() { - return 1 - fi - sleep 3 -- -- -- - return 0 - } - -@@ -249,6 +252,7 @@ function SetBoot() { - return 1 - fi - fi -+ sed -i 's#/dev/sda#'${disk}'#g' /sysroot/boot/efi/EFI/openEuler/grub.cfg - - return 0 - } -@@ -328,5 +332,4 @@ if [ ${ret} -eq 0 ]; then - cp ${log} /persist - else - echo "kubeOS install failed, see install.log" | tee -a ${log} --fi -- -+fi -\ No newline at end of file -diff --git a/scripts/common/utils.sh b/scripts/common/utils.sh -index 902a6ae..3546c8c 100644 ---- a/scripts/common/utils.sh -+++ b/scripts/common/utils.sh -@@ -87,6 +87,13 @@ function delete_file() { - return 0 - } - -+function check_binary_exist() { -+ if [ ! -f "$1" ];then -+ log_error_print "binary path is invalid." -+ exit 3 -+ fi -+} -+ - function check_repo_path() { - if [ ! -f "$1" ];then - log_error_print "REPO path is invalid." -diff --git a/scripts/create/imageCreate.sh b/scripts/create/imageCreate.sh -index 95ebcde..564c740 100644 ---- a/scripts/create/imageCreate.sh -+++ b/scripts/create/imageCreate.sh -@@ -56,19 +56,17 @@ function create_img() { - } - - function create_pxe_img() { -- rm -rf boot/ kubeos.tar -+ rm -rf initramfs.img kubeos.tar - local opt=$1 - shift - case $opt in - "repo") - create_os_tar_from_repo "$@" - tar -xvf os.tar ./initramfs.img -- tar -xvf os.tar ./boot/vmlinuz - ;; - "docker") - create_os_tar_from_docker "$@" - tar -xvf os.tar initramfs.img -- tar -xvf os.tar boot/vmlinuz - ;; - esac - mv os.tar kubeos.tar -diff --git a/scripts/kbimg.sh b/scripts/kbimg.sh -index 1268700..a77d62e 100644 ---- a/scripts/kbimg.sh -+++ b/scripts/kbimg.sh -@@ -72,12 +72,12 @@ options: - EOF - } - --function show_vm_image_usage() { -+function show_vm_pxe_image_usage() { - cat << EOF - --Usage : kbimg create vm-image -p iso-path -v os-version -b os-agent-dir -e os-password -+Usage : kbimg create [vm-image|pxe-image] -p iso-path -v os-version -b os-agent-dir -e os-password - or -- kbimg create vm-image -d repository/name:tag -+ kbimg create [vm-image|pxe-image] -d repository/name:tag - - options: - -p repo path -@@ -130,7 +130,7 @@ function clean_space() { - function clean_img() { - delete_file system.img - delete_file update.img -- delete_dir boot -+ delete_file initramfs.img - delete_file kubeos.tar - } - -@@ -170,6 +170,7 @@ function verify_upgrade_image_input() { - ;; - *) - log_error_print "option $opt not found" -+ show_upgrade_image_usage - exit 3 - ;; - esac -@@ -183,6 +184,7 @@ function verify_repo_input() { - echo "$@" | grep -q "\-$i " - if [ "$?" -ne 0 ];then - log_error_print "option -$i is mandatory, please check input" -+ show_vm_pxe_image_usage - exit 3 - fi - done -@@ -208,6 +210,7 @@ function verify_repo_input() { - ;; - *) - log_error_print "option $opt not found" -+ show_vm_pxe_image_usage - exit 3 - ;; - esac -@@ -215,7 +218,8 @@ function verify_repo_input() { - } - function verify_docker_input() { - if [ $1 != "-d" ]; then -- log_error_print "option $opt not found" -+ log_error_print "option $1 not found" -+ show_vm_pxe_image_usage - exit 3 - fi - check_param $2 -@@ -242,13 +246,14 @@ function verify_create_input() { - check_disk_space "docker" - verify_upgrade_image_input "$@" - check_repo_path "${REPO}" -+ check_binary_exist "${AGENT_PATH}" - create_docker_image "${REPO}" "${VERSION}" "${AGENT_PATH}" "${PASSWD}" "${DOCKER_IMG}" - ;; - "vm-image") - shift - if [ $# -eq 1 ]; then - if [ "$1" == "-h" ] || [ "$1" == "--help" ]; then -- show_vm_image_usage -+ show_vm_pxe_image_usage - exit 0 - fi - fi -@@ -256,6 +261,7 @@ function verify_create_input() { - if [ $# -eq 8 ]; then - verify_repo_input "$@" - check_repo_path "${REPO}" -+ check_binary_exist "${AGENT_PATH}" - create_vm_img "repo" "${REPO}" "${VERSION}" "${AGENT_PATH}" "${PASSWD}" - elif [ $# -eq 2 ]; then - verify_docker_input "$@" -@@ -263,7 +269,7 @@ function verify_create_input() { - create_vm_img "docker" "${DOCKER_IMG}" - else - log_error_print "the number of parameters is incorrect, please check it." -- show_vm_image_usage -+ show_vm_pxe_image_usage - exit 3 - fi - ;; -@@ -271,7 +277,7 @@ function verify_create_input() { - shift - if [ $# -eq 1 ]; then - if [ "$1" == "-h" ] || [ "$1" == "--help" ]; then -- show_pxe_image_usage -+ show_vm_pxe_image_usage - exit 0 - fi - fi -@@ -279,6 +285,7 @@ function verify_create_input() { - if [ $# -eq 8 ]; then - verify_repo_input "$@" - check_repo_path "${REPO}" -+ check_binary_exist "${AGENT_PATH}" - create_pxe_img "repo" "${REPO}" "${VERSION}" "${AGENT_PATH}" "${PASSWD}" - elif [ $# -eq 2 ]; then - verify_docker_input "$@" -@@ -286,7 +293,7 @@ function verify_create_input() { - create_pxe_img "docker" "${DOCKER_IMG}" - else - log_error_print "the number of parameters is incorrect, please check it." -- show_pxe_image_usage -+ show_vm_pxe_image_usage - exit 3 - fi - ;; -@@ -327,9 +334,8 @@ function kubeos_image_main() { - esac - } - -+test_lock - trap clean_space EXIT - trap clean_img ERR - --test_lock --kubeos_image_main "$@" -- -+kubeos_image_main "$@" -\ No newline at end of file --- -2.33.0.windows.2 - diff --git a/0002-docs-Add-the-content-of-the-user-guide.patch b/0002-docs-Add-the-content-of-the-user-guide.patch new file mode 100644 index 0000000000000000000000000000000000000000..e057f37f2ab9611dc2bad34b6c4a694bea1e3632 --- /dev/null +++ b/0002-docs-Add-the-content-of-the-user-guide.patch @@ -0,0 +1,617 @@ +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/0003-KubeOS-fixed-the-issue-of-VMs-images-and-add-check-o.patch b/0003-KubeOS-fixed-the-issue-of-VMs-images-and-add-check-o.patch deleted file mode 100644 index 7e9eee8c457d66f4f51445dc11aacd5f551caa6b..0000000000000000000000000000000000000000 --- a/0003-KubeOS-fixed-the-issue-of-VMs-images-and-add-check-o.patch +++ /dev/null @@ -1,300 +0,0 @@ -From fd5b3f24446c8c5dfc2fb271431ed296618eccc1 Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Sat, 27 Aug 2022 16:22:56 +0800 -Subject: [PATCH] KubeOS: fixed the issue of VMs images and add check of - Global.cfg. - -Modify the docker image creation method to fix the problem that /etc/hosts is -empty in the VM created using the docker image and that the /sys directory is -mounted abnormally. -Add checks whether configuration in the Global.cfg file are empty and whether -the IP address is valid. - -Signed-off-by: liyuanr ---- - api/v1alpha1/os_types.go | 15 +++--- - cmd/agent/server/docker_image.go | 27 +++++++---- - .../config/crd/upgrade.openeuler.org_os.yaml | 1 - - scripts/Dockerfile | 2 +- - scripts/common/utils.sh | 48 ++++++++++++++++--- - scripts/create/imageCreate.sh | 3 +- - scripts/create/rootfsCreate.sh | 12 ++--- - scripts/kbimg.sh | 19 +------- - 8 files changed, 74 insertions(+), 53 deletions(-) - -diff --git a/api/v1alpha1/os_types.go b/api/v1alpha1/os_types.go -index 5acb97a..862d408 100644 ---- a/api/v1alpha1/os_types.go -+++ b/api/v1alpha1/os_types.go -@@ -23,14 +23,13 @@ type OSSpec struct { - MaxUnavailable int `json:"maxunavailable"` - CheckSum string `json:"checksum"` - FlagSafe bool `json:"flagSafe"` -- // +kubebuilder:default=true -- MTLS bool `json:"mtls"` -- ImageType string `json:"imagetype"` -- DockerImage string `json:"dockerimage"` -- OpsType string `json:"opstype"` -- CaCert string `json:"cacert"` -- ClientCert string `json:"clientcert"` -- ClientKey string `json:"clientkey"` -+ MTLS bool `json:"mtls"` -+ ImageType string `json:"imagetype"` -+ DockerImage string `json:"dockerimage"` -+ OpsType string `json:"opstype"` -+ CaCert string `json:"cacert"` -+ ClientCert string `json:"clientcert"` -+ ClientKey string `json:"clientkey"` - } - - // +kubebuilder:subresource:status -diff --git a/cmd/agent/server/docker_image.go b/cmd/agent/server/docker_image.go -index c5ed640..11b21aa 100644 ---- a/cmd/agent/server/docker_image.go -+++ b/cmd/agent/server/docker_image.go -@@ -54,7 +54,7 @@ func pullOSImage(req *pb.UpdateRequest) (string, error) { - return "", err - } - defer cli.ContainerRemove(ctx, info.ID, types.ContainerRemoveOptions{}) -- tarStream, stat, err := cli.CopyFromContainer(ctx, info.ID, "/") -+ tarStream, stat, err := cli.CopyFromContainer(ctx, info.ID, "/os.tar") - if err != nil { - return "", err - } -@@ -71,6 +71,15 @@ func pullOSImage(req *pb.UpdateRequest) (string, error) { - return "", fmt.Errorf("space is not enough for downloaing") - } - -+ srcInfo := archive.CopyInfo{ -+ Path: "/", -+ Exists: true, -+ IsDir: stat.Mode.IsDir(), -+ } -+ if err = archive.CopyTo(tarStream, srcInfo, PersistDir); err != nil { -+ return "", err -+ } -+ - tmpMountPath := filepath.Join(PersistDir, "/kubeos-update") - if err = os.Mkdir(tmpMountPath, imgPermission); err != nil { - return "", err -@@ -80,25 +89,23 @@ func pullOSImage(req *pb.UpdateRequest) (string, error) { - if err = runCommand("dd", "if=/dev/zero", "of="+imagePath, "bs=2M", "count=1024"); err != nil { - return "", err - } -- if err = runCommand("mkfs.ext4", imagePath); err != nil { -+ _, next, err := getNextPart(partA, partB) -+ if err = runCommand("mkfs.ext4", "-L", "ROOT-"+next, imagePath); err != nil { - return "", err - } - if err = runCommand("mount", "-o", "loop", imagePath, tmpMountPath); err != nil { - return "", err - } - defer func() { -- runCommand("losetup", "-D") - syscall.Unmount(tmpMountPath, 0) -- -+ runCommand("losetup", "-D") - }() -- srcInfo := archive.CopyInfo{ -- Path: "/", -- Exists: true, -- IsDir: stat.Mode.IsDir(), -- } -+ - logrus.Infoln("downloading to file " + imagePath) -- if err = archive.CopyTo(tarStream, srcInfo, tmpMountPath); err != nil { -+ tmpTarPath := filepath.Join(PersistDir, "/os.tar") -+ if err = runCommand("tar", "-xvf", tmpTarPath, "-C", tmpMountPath); err != nil { - return "", err - } -+ defer os.Remove(tmpTarPath) - return imagePath, nil - } -diff --git a/docs/example/config/crd/upgrade.openeuler.org_os.yaml b/docs/example/config/crd/upgrade.openeuler.org_os.yaml -index 465e803..f240b8d 100644 ---- a/docs/example/config/crd/upgrade.openeuler.org_os.yaml -+++ b/docs/example/config/crd/upgrade.openeuler.org_os.yaml -@@ -51,7 +51,6 @@ spec: - maxunavailable: - type: integer - mtls: -- default: true - type: boolean - opstype: - type: string -diff --git a/scripts/Dockerfile b/scripts/Dockerfile -index 6a616f5..3da4708 100644 ---- a/scripts/Dockerfile -+++ b/scripts/Dockerfile -@@ -1,3 +1,3 @@ - FROM scratch --ADD os.tar / -+COPY os.tar / - CMD ["/bin/sh"] -diff --git a/scripts/common/utils.sh b/scripts/common/utils.sh -index 3546c8c..cf9441b 100644 ---- a/scripts/common/utils.sh -+++ b/scripts/common/utils.sh -@@ -87,19 +87,53 @@ function delete_file() { - return 0 - } - --function check_binary_exist() { -- if [ ! -f "$1" ];then -- log_error_print "binary path is invalid." -+function check_file_valid() { -+ local file="$1" -+ local mesg="$2" -+ if [ ! -e "${file}" ]; then -+ log_error_print "${mesg} is not exist." -+ exit 3 -+ fi -+ if [ ! -f "${file}" ];then -+ log_error_print "${mesg} is not a file." - exit 3 - fi - } - --function check_repo_path() { -- if [ ! -f "$1" ];then -- log_error_print "REPO path is invalid." -+function check_conf_valid() { -+ local conf_path="${PWD}/00bootup/Global.cfg" -+ check_file_valid ${conf_path} "Globab.cfg" -+ if [ $# != 7 ];then -+ log_error_print "configure configured in Global.cfg is empty." - exit 3 - fi -+ for addr in ${server_ip} ${local_ip} ${route_ip} ${netmask}; do -+ check_ip_valid $addr -+ done -+} - -+function check_ip_valid() { -+ local ipaddr="$1"; -+ if [[ ! $ipaddr =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]] ; then -+ log_error_print "ip address configured in Global.cfg is not valid." -+ exit 3; -+ fi -+ for quad in $(echo "${ipaddr//./ }"); do -+ if [ $quad -ge 0 ] && [ $quad -le 255 ];then -+ continue -+ fi -+ log_error_print "ip address configured in Global.cfg is not valid." -+ exit 3; -+ done -+ -+} -+ -+function check_binary_exist() { -+ check_file_valid "$1" "os-agent binary" -+} -+ -+function check_repo_path() { -+ check_file_valid $1 "REPO file" - if [ -d "${RPM_ROOT}" ]; then - log_error_print "there is a rootfs folder. please confirm if rootfs is being used, if not, please remove ${RPM_ROOT} first." - exit 5 -@@ -117,7 +151,7 @@ function check_disk_space() { - fi - ;; - vm) -- local maxsize=$((5*1024*1024)) -+ local maxsize=$((25*1024*1024)) - if [ "${disk_ava}" -lt "${maxsize}" ]; then - log_error_print "The available disk space is not enough, at least 25GiB." - exit 6 -diff --git a/scripts/create/imageCreate.sh b/scripts/create/imageCreate.sh -index 564c740..9689f62 100644 ---- a/scripts/create/imageCreate.sh -+++ b/scripts/create/imageCreate.sh -@@ -62,13 +62,12 @@ function create_pxe_img() { - case $opt in - "repo") - create_os_tar_from_repo "$@" -- tar -xvf os.tar ./initramfs.img - ;; - "docker") - create_os_tar_from_docker "$@" -- tar -xvf os.tar initramfs.img - ;; - esac -+ tar -xvf os.tar ./initramfs.img - mv os.tar kubeos.tar - } - function create_docker_image() { -diff --git a/scripts/create/rootfsCreate.sh b/scripts/create/rootfsCreate.sh -index e5c53d5..4c02c35 100644 ---- a/scripts/create/rootfsCreate.sh -+++ b/scripts/create/rootfsCreate.sh -@@ -65,8 +65,6 @@ EOF - cp set_in_chroot.sh "${RPM_ROOT}" - ROOT_PWD="${PASSWD}" chroot "${RPM_ROOT}" bash /set_in_chroot.sh - rm "${RPM_ROOT}/set_in_chroot.sh" -- -- #todo:chroot create initramfs.img to include install-scripts for PXE install - } - - function create_os_tar_from_repo() { -@@ -80,9 +78,9 @@ function create_os_tar_from_repo() { - tar -C "$RPM_ROOT" -cf ./os.tar . - } - function create_os_tar_from_docker() { -- local DOCKER_IMG=$1 -- container_id=$(docker create ${DOCKER_IMG}) -- echo "$container_id" -- docker export $container_id > os.tar -- docker rm $container_id -+ local DOCKER_IMG=$1 -+ container_id=$(docker create ${DOCKER_IMG}) -+ echo "$container_id" -+ docker cp $container_id:/os.tar ./ -+ docker rm $container_id - } -diff --git a/scripts/kbimg.sh b/scripts/kbimg.sh -index a77d62e..a623e3d 100644 ---- a/scripts/kbimg.sh -+++ b/scripts/kbimg.sh -@@ -24,6 +24,7 @@ source common/log.sh &>/dev/null - source common/utils.sh &>/dev/null - source create/rootfsCreate.sh &>/dev/null - source create/imageCreate.sh &>/dev/null -+source 00bootup/Global.cfg &>/dev/null - - function show_options() { - cat << EOF -@@ -89,23 +90,6 @@ options: - EOF - } - --function show_pxe_image_usage() { -- cat << EOF -- --Usage : kbimg create pxe-image -p iso-path -v os-version -b os-agent-dir -e os-password -- or -- kbimg create pxe-image -d repository/name:tag -- --options: -- -p repo path -- -v KubeOS version -- -b directory of os-agent binary -- -e os encrypted password -- -d docker image like repository/name:tag -- -h,--help show help information --EOF --} -- - function file_lock() { - local lock_file=$1 - exec {lock_fd}>"${lock_file}" -@@ -282,6 +266,7 @@ function verify_create_input() { - fi - fi - check_disk_space "pxe" -+ check_conf_valid ${rootfs_name} ${disk} ${server_ip} ${local_ip} ${route_ip} ${netmask} ${net_name} - if [ $# -eq 8 ]; then - verify_repo_input "$@" - check_repo_path "${REPO}" --- -2.33.0.windows.2 - diff --git a/0003-Remove-cleanup-method-and-related-code.patch b/0003-Remove-cleanup-method-and-related-code.patch new file mode 100644 index 0000000000000000000000000000000000000000..257e82ba85c0d160e8b286f09ff686ac6edcf18f --- /dev/null +++ b/0003-Remove-cleanup-method-and-related-code.patch @@ -0,0 +1,143 @@ +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-KubeOS-add-the-clearing-of-space-before-the-upgrade-.patch b/0004-KubeOS-add-the-clearing-of-space-before-the-upgrade-.patch deleted file mode 100644 index c183d1b2827ac39e4d4e1f8f6910cdefe3f66817..0000000000000000000000000000000000000000 --- a/0004-KubeOS-add-the-clearing-of-space-before-the-upgrade-.patch +++ /dev/null @@ -1,183 +0,0 @@ -From 54d0a0304a0f76a0e619a8adac370eb3866f52b1 Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Wed, 31 Aug 2022 18:06:28 +0800 -Subject: [PATCH] KubeOS:add the clearing of space before the upgrade and - rectifying the rollback failure. - -The pre-upgrade space clearance function is added to resolve the problem that the upgrade -fails due to residual resources when the upgrade is performed again after a power failure. -Fix the rollback failure when the upgrade fails due to the upgrade using different architectures. - -Signed-off-by: liyuanr ---- - cmd/agent/server/docker_image.go | 91 ++++++++++++++++++++++++++++---- - scripts/grub.cfg | 10 ---- - 2 files changed, 81 insertions(+), 20 deletions(-) - -diff --git a/cmd/agent/server/docker_image.go b/cmd/agent/server/docker_image.go -index 11b21aa..4f9edc1 100644 ---- a/cmd/agent/server/docker_image.go -+++ b/cmd/agent/server/docker_image.go -@@ -15,6 +15,7 @@ package server - - import ( - "context" -+ "errors" - "fmt" - "io/ioutil" - "os" -@@ -47,9 +48,18 @@ func pullOSImage(req *pb.UpdateRequest) (string, error) { - return "", err - } - -+ containerName := "kubeos-temp" -+ containers, err := cli.ContainerList(ctx, types.ContainerListOptions{All: true}) -+ for _, container := range containers { -+ if container.Names[0] == "/"+containerName { -+ if err = cli.ContainerRemove(ctx, container.ID, types.ContainerRemoveOptions{}); err != nil { -+ return "", err -+ } -+ } -+ } - info, err := cli.ContainerCreate(ctx, &container.Config{ - Image: imageName, -- }, nil, nil, "kubeos-temp") -+ }, nil, nil, containerName) - if err != nil { - return "", err - } -@@ -71,22 +81,31 @@ func pullOSImage(req *pb.UpdateRequest) (string, error) { - return "", fmt.Errorf("space is not enough for downloaing") - } - -+ tmpUpdatePath := filepath.Join(PersistDir, "/KubeOS-Update") -+ tmpMountPath := filepath.Join(tmpUpdatePath, "/kubeos-update") -+ tmpTarPath := filepath.Join(tmpUpdatePath, "/os.tar") -+ imagePath := filepath.Join(PersistDir, "/update.img") -+ -+ if err = cleanSpace(tmpUpdatePath, tmpMountPath, imagePath); err != nil { -+ return "", err -+ } -+ if err = os.MkdirAll(tmpMountPath, imgPermission); err != nil { -+ return "", err -+ } -+ defer os.RemoveAll(tmpUpdatePath) -+ - srcInfo := archive.CopyInfo{ - Path: "/", - Exists: true, - IsDir: stat.Mode.IsDir(), - } -- if err = archive.CopyTo(tarStream, srcInfo, PersistDir); err != nil { -+ if err = archive.CopyTo(tarStream, srcInfo, tmpUpdatePath); err != nil { - return "", err - } -- -- tmpMountPath := filepath.Join(PersistDir, "/kubeos-update") -- if err = os.Mkdir(tmpMountPath, imgPermission); err != nil { -+ if err = runCommand("dd", "if=/dev/zero", "of="+imagePath, "bs=2M", "count=1024"); err != nil { - return "", err - } -- defer os.Remove(tmpMountPath) -- imagePath := filepath.Join(PersistDir, "/update.img") -- if err = runCommand("dd", "if=/dev/zero", "of="+imagePath, "bs=2M", "count=1024"); err != nil { -+ if err = os.Chmod(imagePath, imgPermission); err != nil { - return "", err - } - _, next, err := getNextPart(partA, partB) -@@ -102,10 +121,62 @@ func pullOSImage(req *pb.UpdateRequest) (string, error) { - }() - - logrus.Infoln("downloading to file " + imagePath) -- tmpTarPath := filepath.Join(PersistDir, "/os.tar") - if err = runCommand("tar", "-xvf", tmpTarPath, "-C", tmpMountPath); err != nil { - return "", err - } -- defer os.Remove(tmpTarPath) - return imagePath, nil - } -+ -+func cleanSpace(updatePath, mountPath, imagePath string) error { -+ isFileExist, err := checkFileExist(mountPath) -+ if err != nil { -+ return err -+ } -+ if isFileExist { -+ var st syscall.Stat_t -+ if err := syscall.Lstat(mountPath, &st); err != nil { -+ return err -+ } -+ dev := st.Dev -+ parent := filepath.Dir(mountPath) -+ if err := syscall.Lstat(parent, &st); err != nil { -+ return err -+ } -+ if dev != st.Dev { -+ if err := syscall.Unmount(mountPath, 0); err != nil { -+ return err -+ } -+ } -+ } -+ -+ if err = deleteFile(updatePath); err != nil { -+ return err -+ } -+ -+ if err = deleteFile(imagePath); err != nil { -+ return err -+ } -+ return nil -+} -+ -+func deleteFile(path string) error { -+ isFileExist, err := checkFileExist(path) -+ if err != nil { -+ return err -+ } -+ if isFileExist { -+ if err = os.RemoveAll(path); err != nil { -+ return err -+ } -+ } -+ return nil -+} -+func checkFileExist(path string) (bool, error) { -+ if _, err := os.Stat(path); err == nil { -+ return true, nil -+ } else if errors.Is(err, os.ErrNotExist) { -+ return false, nil -+ } else { -+ return false, err -+ } -+} -diff --git a/scripts/grub.cfg b/scripts/grub.cfg -index d10e4cf..c1a2641 100644 ---- a/scripts/grub.cfg -+++ b/scripts/grub.cfg -@@ -91,11 +91,6 @@ menuentry 'A' --class KubeOS --class gnu-linux --class gnu --class os --unrestri - insmod part_msdos - insmod ext2 - set root='hd0,msdos2' -- if [ x$feature_platform_search_hint = xy ]; then -- search --no-floppy --file --set=root --hint-bios=hd0,msdos2 --hint-efi=hd0,msdos2 --hint-baremetal=ahci0,msdos2 /boot/vmlinuz -- else -- search --no-floppy --file --set=root /boot/vmlinuz -- fi - 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 - initrd /boot/initramfs.img - } -@@ -107,11 +102,6 @@ menuentry 'B' --class KubeOS --class gnu-linux --class gnu --class os --unrestri - insmod part_msdos - insmod ext2 - set root='hd0,msdos3' -- if [ x$feature_platform_search_hint = xy ]; then -- search --no-floppy --file --set=root --hint-bios=hd0,msdos3 --hint-efi=hd0,msdos3 --hint-baremetal=ahci0,msdos3 /boot/vmlinuz -- else -- search --no-floppy --file --set=root /boot/vmlinuz -- fi - linux /boot/vmlinuz root=/dev/sda3 ro rootfstype=ext4 nomodeset quiet oops=panic softlockup_panic=1 nmi_watchdog=1 rd.shell=0 selinux=0 crashkernel=256M panic=3 - initrd /boot/initramfs.img - } --- -2.33.0.windows.2 - diff --git a/0004-test-rust-proxy-add-drain-integration-test.patch b/0004-test-rust-proxy-add-drain-integration-test.patch new file mode 100644 index 0000000000000000000000000000000000000000..35afe1e43e7be7398b442901e7d5941ea9327fe3 --- /dev/null +++ b/0004-test-rust-proxy-add-drain-integration-test.patch @@ -0,0 +1,459 @@ +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-KubeOS-add-the-configuration-of-etc-resolv.conf-and-.patch b/0005-KubeOS-add-the-configuration-of-etc-resolv.conf-and-.patch deleted file mode 100644 index 7140e9e86780e376ee4c624adfcb2ed1d4f3c33a..0000000000000000000000000000000000000000 --- a/0005-KubeOS-add-the-configuration-of-etc-resolv.conf-and-.patch +++ /dev/null @@ -1,254 +0,0 @@ -From a1bf179490d33c25dd49fe6c363eec5e0e8fe532 Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Sat, 3 Sep 2022 14:21:54 +0800 -Subject: [PATCH] KubeOS:add the configuration of /etc/resolv.conf and change - the VM disk to gpt. - -Add the user-defined /etc/resolv.conf file and change the VM disk to gpt -to be the same as that on the physical machine. - -Signed-off-by: liyuanr ---- - cmd/agent/server/docker_image.go | 3 +- - scripts/00bootup/mount.sh | 50 ++++++++++++++++++-------------- - scripts/bootloader.sh | 4 +-- - scripts/create/imageCreate.sh | 12 ++++---- - scripts/create/rootfsCreate.sh | 4 +++ - scripts/grub.cfg | 8 ++--- - 6 files changed, 45 insertions(+), 36 deletions(-) - -diff --git a/cmd/agent/server/docker_image.go b/cmd/agent/server/docker_image.go -index 4f9edc1..735ace0 100644 ---- a/cmd/agent/server/docker_image.go -+++ b/cmd/agent/server/docker_image.go -@@ -108,8 +108,7 @@ func pullOSImage(req *pb.UpdateRequest) (string, error) { - if err = os.Chmod(imagePath, imgPermission); err != nil { - return "", err - } -- _, next, err := getNextPart(partA, partB) -- if err = runCommand("mkfs.ext4", "-L", "ROOT-"+next, imagePath); err != nil { -+ if err = runCommand("mkfs.ext4", "-L", "ROOT-A", imagePath); err != nil { - return "", err - } - if err = runCommand("mount", "-o", "loop", imagePath, tmpMountPath); err != nil { -diff --git a/scripts/00bootup/mount.sh b/scripts/00bootup/mount.sh -index 1bc83ff..7f00fd6 100644 ---- a/scripts/00bootup/mount.sh -+++ b/scripts/00bootup/mount.sh -@@ -23,6 +23,14 @@ function CheckSpace() { - return 0 - } - -+function mount_proc_dev_sys() { -+ local tmp_root=$1 -+ mount -t proc none "${tmp_root}/proc" -+ mount --bind /dev "${tmp_root}/dev" -+ mount --bind /dev/pts "${tmp_root}/dev/pts" -+ mount -t sysfs none "${tmp_root}/sys" -+} -+ - function GetDisk() { - disks=(`hwinfo --disk --short 2>&1 | grep -vi "^disk" | awk '{print $1}'`) - if [ ${#disks[*]} -gt 0 ]; then -@@ -162,14 +170,13 @@ function MountRoot() { - - function MountPersist() { - echo "Mounting persist" -- mkdir /persist -- mount ${disk}4 /persist >> ${log} 2>&1 -+ mount ${disk}4 /sysroot/persist >> ${log} 2>&1 - if [ $? -ne 0 ]; then - echo "mount persist failed" | tee -a ${log} - return 1 - fi -- mkdir /persist/{var,etc,etcwork} -- mkdir -p /persist/etc/KubeOS/certs -+ mkdir /sysroot/persist/{var,etc,etcwork} -+ mkdir -p /sysroot/persist/etc/KubeOS/certs - return 0 - } - -@@ -187,20 +194,20 @@ function MountBoot() { - function GetRootfs() { - echo "Downloading rootfs..." - -- curl -o /persist/${rootfs_name} http://${server_ip}/${rootfs_name} -- if [ ! -e "/persist/${rootfs_name}" ]; then -+ curl -o /${rootfs_name} http://${server_ip}/${rootfs_name} -+ if [ ! -e "/${rootfs_name}" ]; then - echo "download rootfs failed" | tee -a ${log} - return 1 - fi - -- tar -xvf /persist/${rootfs_name} -C /sysroot -+ tar -xf /${rootfs_name} -C /sysroot - if [ $? -ne 0 ]; then - echo "decompose rootfs failed" | tee -a ${log} - return 1 - fi - -- rm -rf /persist/${rootfs_name} -- -+ rm -rf /${rootfs_name} -+ mount -o remount,ro ${disk}2 /sysroot >> ${log} 2>&1 - return 0 - } - -@@ -283,6 +290,8 @@ function Bootup_Main() { - fi - - # mount partitions -+ -+ # mount boot - echo "Mounting root..." | tee -a ${log} - MountRoot - if [ $? -ne 0 ]; then -@@ -290,15 +299,6 @@ function Bootup_Main() { - return 1 - fi - -- # mount persist -- echo "Mounting persisst..." | tee -a ${log} -- MountPersist -- if [ $? -ne 0 ]; then -- echo "Mounting persist failed" | tee -a ${log} -- return 1 -- fi -- -- # mount boot - echo "Mounting boot..." | tee -a ${log} - MountBoot - if [ $? -ne 0 ]; then -@@ -313,7 +313,7 @@ function Bootup_Main() { - echo "Downloading rootfs failed" | tee -a ${log} - return 1 - fi -- -+ mount_proc_dev_sys /sysroot - # set boot - echo "Setting boot..." | tee -a ${log} - SetBoot -@@ -321,7 +321,13 @@ function Bootup_Main() { - echo "Setting boot failed" | tee -a ${log} - return 1 - fi -- -+ # mount persist -+ echo "Mounting persist..." | tee -a ${log} -+ MountPersist -+ if [ $? -ne 0 ]; then -+ echo "Mounting persist failed" | tee -a ${log} -+ return 1 -+ fi - return 0 - } - -@@ -329,7 +335,7 @@ Bootup_Main - ret=$? - if [ ${ret} -eq 0 ]; then - echo "kubeOS install success! switch to root" | tee -a ${log} -- cp ${log} /persist -+ cp ${log} /sysroot/persist - else - echo "kubeOS install failed, see install.log" | tee -a ${log} --fi -\ No newline at end of file -+fi -diff --git a/scripts/bootloader.sh b/scripts/bootloader.sh -index 0f906d4..5760f3d 100644 ---- a/scripts/bootloader.sh -+++ b/scripts/bootloader.sh -@@ -16,7 +16,7 @@ function install_grub2_x86 () - - # make efi file, and save in FAT16 partition, to support UEFI boot mode - 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=(,msdos1)/EFI/openEuler' fat part_gpt part_msdos linux" -+ 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/ - cp -f /boot/efi/EFI/openEuler/grubx64.efi /boot/efi/EFI/BOOT/BOOTX64.EFI -@@ -25,7 +25,7 @@ function install_grub2_x86 () - 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=(,msdos1)/EFI/openEuler' fat part_gpt part_msdos linux" -+ 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/ - cp -f /boot/efi/EFI/openEuler/grubaa64.efi /boot/efi/EFI/BOOT/BOOTAA64.EFI -diff --git a/scripts/create/imageCreate.sh b/scripts/create/imageCreate.sh -index 9689f62..e615d5f 100644 ---- a/scripts/create/imageCreate.sh -+++ b/scripts/create/imageCreate.sh -@@ -16,12 +16,12 @@ PWD="$(pwd)" - function create_img() { - rm -f system.img update.img - qemu-img create system.img ${IMG_SIZE}G -- parted system.img -- mklabel msdos -- parted system.img -- mkpart primary fat16 1MiB 60MiB -- parted system.img -- mkpart primary ext4 60MiB 2160MiB -- parted system.img -- mkpart primary ext4 2160MiB 4260MiB -- parted system.img -- mkpart primary ext4 4260MiB 100% -- -+ parted system.img -s mklabel gpt -+ parted system.img -s mkpart primary fat32 1MiB 60MiB -+ parted system.img -s mkpart primary ext4 60MiB 2160MiB -+ parted system.img -s mkpart primary ext4 2160MiB 4260MiB -+ parted system.img -s mkpart primary ext4 4260MiB 100% -+ parted system.img -s set 1 boot on - local device=$(losetup -f) - losetup "${device}" system.img - -diff --git a/scripts/create/rootfsCreate.sh b/scripts/create/rootfsCreate.sh -index 4c02c35..29f2762 100644 ---- a/scripts/create/rootfsCreate.sh -+++ b/scripts/create/rootfsCreate.sh -@@ -46,6 +46,7 @@ function install_misc() { - local VERSION=$1 - local AGENT_PATH=$2 - local PASSWD=$3 -+ local DNS_CONF="${PWD}/resolv.conf" - cp ../files/*mount ../files/os-agent.service "${RPM_ROOT}/usr/lib/systemd/system/" - cp ../files/os-release "${RPM_ROOT}/usr/lib/" - cp "${AGENT_PATH}" "${RPM_ROOT}/usr/bin" -@@ -65,6 +66,9 @@ EOF - cp set_in_chroot.sh "${RPM_ROOT}" - ROOT_PWD="${PASSWD}" chroot "${RPM_ROOT}" bash /set_in_chroot.sh - rm "${RPM_ROOT}/set_in_chroot.sh" -+ if [ -e "${DNS_CONF}" ]; then -+ cp "${DNS_CONF}" "${RPM_ROOT}/etc/resolv.conf" -+ fi - } - - function create_os_tar_from_repo() { -diff --git a/scripts/grub.cfg b/scripts/grub.cfg -index c1a2641..984b161 100644 ---- a/scripts/grub.cfg -+++ b/scripts/grub.cfg -@@ -88,9 +88,9 @@ menuentry 'A' --class KubeOS --class gnu-linux --class gnu --class os --unrestri - load_video - set gfxpayload=keep - insmod gzio -- insmod part_msdos -+ insmod part_gpt - insmod ext2 -- set root='hd0,msdos2' -+ set root='hd0,gpt2' - 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 - initrd /boot/initramfs.img - } -@@ -99,9 +99,9 @@ menuentry 'B' --class KubeOS --class gnu-linux --class gnu --class os --unrestri - load_video - set gfxpayload=keep - insmod gzio -- insmod part_msdos -+ insmod part_gpt - insmod ext2 -- set root='hd0,msdos3' -+ set root='hd0,gpt3' - linux /boot/vmlinuz root=/dev/sda3 ro rootfstype=ext4 nomodeset quiet oops=panic softlockup_panic=1 nmi_watchdog=1 rd.shell=0 selinux=0 crashkernel=256M panic=3 - initrd /boot/initramfs.img - } --- -2.33.0.windows.2 - diff --git a/0005-refactor-rust-os-agent-fix-code-check.patch b/0005-refactor-rust-os-agent-fix-code-check.patch new file mode 100644 index 0000000000000000000000000000000000000000..0707ba79b56e04b6af3682e03d13d0e86fbedf79 --- /dev/null +++ b/0005-refactor-rust-os-agent-fix-code-check.patch @@ -0,0 +1,35 @@ +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-KubeOS-remove-grub2-legacy-install-add-error-handlin.patch b/0006-KubeOS-remove-grub2-legacy-install-add-error-handlin.patch deleted file mode 100644 index 8dab4ab06d5fe93bbbbf171411ddb805a886908c..0000000000000000000000000000000000000000 --- a/0006-KubeOS-remove-grub2-legacy-install-add-error-handlin.patch +++ /dev/null @@ -1,104 +0,0 @@ -From d638f26cdf8f22b258e97baec83a261a2de315ee Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Tue, 29 Nov 2022 16:39:20 +0800 -Subject: [PATCH] KubeOS: remove grub2 legacy install, add error handling for - opstype and add entry for unit test in Makefile - -Remove grub2 install for legacy setup to fix failure of x86 -vm images building. Add the error handling of the abnormal value -of the opstype. Add an entry for unit testing in Makefile. - -Signed-off-by: liyuanr ---- - Makefile | 3 +++ - cmd/agent/server/docker_image_test.go | 21 --------------------- - cmd/proxy/controllers/os_controller.go | 3 +++ - scripts/bootloader.sh | 8 -------- - 4 files changed, 6 insertions(+), 29 deletions(-) - -diff --git a/Makefile b/Makefile -index 38cc2ce..9d9fbea 100644 ---- a/Makefile -+++ b/Makefile -@@ -50,6 +50,9 @@ agent: - ${ENV} ${GO_BUILD} -tags "osusergo netgo static_build" -ldflags '$(LDFLAGS)' $(BUILDFLAGS) -o bin/os-agent cmd/agent/main.go - strip bin/os-agent - -+test: -+ $(GO) test $(shell go list ./... ) -race -cover -count=1 -timeout=300s -+ - # Install CRDs into a cluster - install: manifests - kubectl apply -f confg/crd -diff --git a/cmd/agent/server/docker_image_test.go b/cmd/agent/server/docker_image_test.go -index cc77a2b..9987939 100644 ---- a/cmd/agent/server/docker_image_test.go -+++ b/cmd/agent/server/docker_image_test.go -@@ -52,24 +52,3 @@ func TestpullOSImage(t *testing.T) { - } - defer os.RemoveAll("/persist") - } -- --func TestrandStringBytesRmndr(t *testing.T) { -- type args struct { -- n int -- } -- tests := []struct { -- name string -- args args -- want string -- }{ -- {name: "normal", args: args{n: 6}, want: ""}, -- } -- for _, tt := range tests { -- t.Run(tt.name, func(t *testing.T) { -- if got := randStringBytesRmndr(tt.args.n); got == "" { -- t.Errorf("randStringBytesRmndr() not generatre random string") -- } -- -- }) -- } --} -diff --git a/cmd/proxy/controllers/os_controller.go b/cmd/proxy/controllers/os_controller.go -index 09e58f9..fdd31ea 100644 ---- a/cmd/proxy/controllers/os_controller.go -+++ b/cmd/proxy/controllers/os_controller.go -@@ -15,6 +15,7 @@ package controllers - - import ( - "context" -+ "fmt" - "os" - - corev1 "k8s.io/api/core/v1" -@@ -123,6 +124,8 @@ func (r *OSReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re - if err := r.Connection.RollbackSpec(); err != nil { - return values.RequeueNow, err - } -+ default: -+ return values.RequeueNow, fmt.Errorf("operation %s cannot be recognized", opsType) - } - } - return values.Requeue, nil -diff --git a/scripts/bootloader.sh b/scripts/bootloader.sh -index 5760f3d..16c5713 100644 ---- a/scripts/bootloader.sh -+++ b/scripts/bootloader.sh -@@ -6,14 +6,6 @@ ARCH=`arch` - - function install_grub2_x86 () - { -- # make boot.img/core.img and setup, to support legacy boot mode -- GRUBNAME=$(which grub2-install) -- echo "Installing GRUB2..." -- GRUB_OPTS=${GRUB_OPTS:-"--force"} -- GRUB_OPTS="$GRUB_OPTS --target=i386-pc" -- -- $GRUBNAME --modules="biosdisk part_msdos" $GRUB_OPTS $DEVICE -- - # make efi file, and save in FAT16 partition, to support UEFI boot mode - 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" --- -2.37.1.windows.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 new file mode 100644 index 0000000000000000000000000000000000000000..8560e393e3df541b97eb4dbaee4289482b5ce3ea --- /dev/null +++ b/0006-fix-agent-proxy-transform-log-timestamp-to-human-rea.patch @@ -0,0 +1,245 @@ +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-KubeOS-fix-usage-does-not-print-when-an-error-occurs.patch b/0007-KubeOS-fix-usage-does-not-print-when-an-error-occurs.patch deleted file mode 100644 index b17ed40f9d6736aea0e51dfed04aa6bdfd5b61a8..0000000000000000000000000000000000000000 --- a/0007-KubeOS-fix-usage-does-not-print-when-an-error-occurs.patch +++ /dev/null @@ -1,29 +0,0 @@ -From 20f66b28ea95e262f54cad1a9b65d564f91b8d12 Mon Sep 17 00:00:00 2001 -From: liyuanr -Date: Thu, 8 Dec 2022 15:08:52 +0800 -Subject: [PATCH] KubeOS:fix usage does not print when an error occurs in the - upgrade image creation - -Fix the bug that the usage does not print -when the upgrade image has parameter errors - -Signed-off-by: liyuanr ---- - scripts/kbimg.sh | 1 + - 1 file changed, 1 insertion(+) - -diff --git a/scripts/kbimg.sh b/scripts/kbimg.sh -index a623e3d..a860c06 100644 ---- a/scripts/kbimg.sh -+++ b/scripts/kbimg.sh -@@ -125,6 +125,7 @@ function verify_upgrade_image_input() { - echo "$@" | grep -q "\-$i " - if [ "$?" -ne 0 ];then - log_error_print "option -$i is mandatory, please check input" -+ show_upgrade_image_usage - exit 3 - fi - done --- -2.33.0.windows.2 - diff --git a/0007-build-update-vendor.patch b/0007-build-update-vendor.patch new file mode 100644 index 0000000000000000000000000000000000000000..a0ca713866185725273146ec1b35285f8815d950 --- /dev/null +++ b/0007-build-update-vendor.patch @@ -0,0 +1,706 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..0b29d7164307e791d10ca2738c042466df1d3785 --- /dev/null +++ b/0008-test-rust-os-agent-add-os-agent-unit-tests.patch @@ -0,0 +1,817 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..9b5dffaaabdedcc8ffadb41eda4ffe09840df311 --- /dev/null +++ b/0009-fix-checksum-comparison-log-format.patch @@ -0,0 +1,52 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..f0739e3eb4b1d0f415ee7745aab90c008cf6e1e0 --- /dev/null +++ b/0010-fix-check-image-name-is-valid-regex.patch @@ -0,0 +1,106 @@ +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/0011-Bump-version-from-1.0.4-to-1.0.5.patch b/0011-Bump-version-from-1.0.4-to-1.0.5.patch new file mode 100644 index 0000000000000000000000000000000000000000..aaebee05331b688383db4ff5426bd6adfe720452 --- /dev/null +++ b/0011-Bump-version-from-1.0.4-to-1.0.5.patch @@ -0,0 +1,116 @@ +diff --git a/KubeOS-Rust/Cargo.lock b/KubeOS-Rust/Cargo.lock +index 2087339..c44c152 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" + dependencies = [ + "anyhow", + "jsonrpc", +@@ -1092,7 +1092,7 @@ dependencies = [ + + [[package]] + name = "manager" +-version = "0.1.0" ++version = "1.0.5" + dependencies = [ + "anyhow", + "env_logger", +@@ -1335,7 +1335,7 @@ dependencies = [ + + [[package]] + name = "os-agent" +-version = "0.1.0" ++version = "1.0.5" + dependencies = [ + "anyhow", + "env_logger", +@@ -1498,7 +1498,7 @@ dependencies = [ + + [[package]] + name = "proxy" +-version = "0.1.0" ++version = "1.0.5" + dependencies = [ + "anyhow", + "assert-json-diff", +diff --git a/KubeOS-Rust/agent/Cargo.toml b/KubeOS-Rust/agent/Cargo.toml +index 6db4df4..739bbbc 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" + + # 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 +--- 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" + + # 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 +--- 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" + + # 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 +--- 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" + + # 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" + 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" } + 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" } + regex = "=1.7.3" + reqwest = { version = "=0.11.18", default-features = false, features = [ + "json", +diff --git a/VERSION b/VERSION +index ee90284..90a27f9 100644 +--- a/VERSION ++++ b/VERSION +@@ -1 +1 @@ +-1.0.4 ++1.0.5 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 new file mode 100644 index 0000000000000000000000000000000000000000..0d61cbcd1cb2f638e8e35d7adac4221ab2a42eb6 --- /dev/null +++ b/0012-perf-crd-improve-default-display-of-crd-under-kubect.patch @@ -0,0 +1,73 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..93183262f5a83b5fc8a30087ab354767a4bc0c9f --- /dev/null +++ b/0013-fix-logs-content-grammar-and-format.patch @@ -0,0 +1,196 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..82b38865bfbb7610c47eea7b9f81fa28229d054c --- /dev/null +++ b/0014-fix-os-agent-add-context-when-returning-error.patch @@ -0,0 +1,144 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..c50afc1d39cfce95f3028d80e632ea55e32a7e13 --- /dev/null +++ b/0015-proxy-Add-unit-tests-and-delete-useless-dependencies.patch @@ -0,0 +1,1011 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..ee93ac8092f5773dfa50325f23111b437bda930c --- /dev/null +++ b/0016-proxy-fix-code-review-issues.patch @@ -0,0 +1,256 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..c5bac38f8760e6a274963eeaf0ee8255fc545848 --- /dev/null +++ b/0018-Bump-tokio-to-1.28.0.patch @@ -0,0 +1,127 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..88fe986c06155db1b3b42d983ba5fea9cee74781 --- /dev/null +++ b/0019-build-update-vendor.patch @@ -0,0 +1,89134 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..add40f0eb4b399a48db8f1de35cef01b9f934117 --- /dev/null +++ b/0020-fix-mutex-locking-in-agent_impl.rs.patch @@ -0,0 +1,84 @@ +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 new file mode 100644 index 0000000000000000000000000000000000000000..1f12606064a49b479e082922e10d1a16787f83bf --- /dev/null +++ b/0021-fix-partition-info-retrieval-in-get_partition_info-f.patch @@ -0,0 +1,38 @@ +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 3edcca5cea75f6d6b02e05ac342b1d939360d8ac..50ba0c05edc9c3fec68272942a5d55d74655fd16 100644 --- a/KubeOS.spec +++ b/KubeOS.spec @@ -1,21 +1,37 @@ # Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved. Name: KubeOS -Version: 1.0.2 -Release: 8 +Version: 1.0.5 +Release: 4 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-Write-a-tool-to-support-KubeOS-deployment-on-physica.patch -Patch2: 0002-KubeOS-fix-the-kbimg.sh-exception-and-pxe-installati.patch -Patch3: 0003-KubeOS-fixed-the-issue-of-VMs-images-and-add-check-o.patch -Patch4: 0004-KubeOS-add-the-clearing-of-space-before-the-upgrade-.patch -Patch5: 0005-KubeOS-add-the-configuration-of-etc-resolv.conf-and-.patch -Patch6: 0006-KubeOS-remove-grub2-legacy-install-add-error-handlin.patch -Patch7: 0007-KubeOS-fix-usage-does-not-print-when-an-error-occurs.patch +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 + BuildRoot: %{_tmppath}/%{name}-%{version}-build -BuildRequires: make +BuildRequires: make rust cargo openssl-devel BuildRequires: golang >= 1.13 + %description This is an O&M platform used to update the whole OS as an entirety, it should be running in kubernetes environment. @@ -35,14 +51,24 @@ The scripts package includes scripts which could build the os image and binaries %{nil} %build +mkdir ./KubeOS-Rust/.cargo +cat << EOF >> ./KubeOS-Rust/.cargo/config + +[source.crates-io] +replace-with = "vendored-sources" + +[source.vendored-sources] +directory = "vendor" +EOF + make %install install -d %{buildroot}%{_bindir} #install binary install -d -m 0740 %{buildroot}/opt/kubeOS/bin -install -p -m 0500 ./bin/os-agent %{buildroot}/opt/kubeOS/bin -install -p -m 0500 ./bin/proxy %{buildroot}/opt/kubeOS/bin +install -p -m 0500 ./bin/rust/release/os-agent %{buildroot}/opt/kubeOS/bin +install -p -m 0500 ./bin/rust/release/proxy %{buildroot}/opt/kubeOS/bin install -p -m 0500 ./bin/operator %{buildroot}/opt/kubeOS/bin #install artifacts @@ -77,8 +103,8 @@ install -p -m 0600 ./files/os-agent.service %{buildroot}/opt/kubeOS/files install -p -m 0600 ./files/os-release %{buildroot}/opt/kubeOS/files %files -%attr(0500,root,root) /opt/kubeOS/bin/os-agent %defattr(-,root,root,0500) +%attr(0500,root,root) /opt/kubeOS/bin/os-agent %attr(0600,root,root) /opt/kubeOS/files/boot-efi.mount %attr(0600,root,root) /opt/kubeOS/files/etc.mount %attr(0600,root,root) /opt/kubeOS/files/persist.mount @@ -108,11 +134,64 @@ install -p -m 0600 ./files/os-release %{buildroot}/opt/kubeOS/files %attr(0500,root,root) /opt/kubeOS/scripts/00bootup/module-setup.sh %attr(0500,root,root) /opt/kubeOS/scripts/00bootup/mount.sh - %clean rm -rfv %{buildroot} %changelog +* Fri Feb 23 2024 Yuhang Wei - 1.0.5-4 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:fix code check + +* Mon Feb 05 2024 Yuhang Wei - 1.0.5-3 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:bump tokio to 1.28.0 + +* Mon Jan 29 2024 Yuhang Wei - 1.0.5-2 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:sync code from source master branch + +* Wed Jan 10 2024 Yuhang Wei - 1.0.5-1 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:update version to 1.0.5.1 + +* Tue Sep 05 2023 Yuhang Wei - 1.0.4-4 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:fix proxy requeue and update image label + +* Thu Aug 24 2023 Yuhang Wei - 1.0.4-3 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:sync code from source master branch + +* Mon Aug 07 2023 liyuanrong - 1.0.4-2 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:fix the hostshell cannot obtain the lib + +* Wed Aug 02 2023 liyuanrong - 1.0.4-1 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:update version to 1.0.4.1 + +* Thu Dec 08 2022 liyuanrong - 1.0.2-9 +- Type:requirement +- CVE:NA +- SUG:restart +- DESC:sync code from source, support containerd upgrade,settings and admin-container + * Thu Dec 08 2022 liyuanrong - 1.0.2-8 - Type:requirement - CVE:NA @@ -179,7 +258,7 @@ rm -rfv %{buildroot} - SUG:restart - DESC:fix bugs of checks in generate.sh and change module path -* Fri Oct 30 2021 liyuanrong - 1.0.1-2 +* Sat Oct 30 2021 liyuanrong - 1.0.1-2 - Type:requirement - CVE:NA - SUG:restart diff --git a/v1.0.2.tar.gz b/v1.0.2.tar.gz deleted file mode 100644 index 941b5670b3d71931ec3b151323432bdefed68684..0000000000000000000000000000000000000000 Binary files a/v1.0.2.tar.gz and /dev/null differ diff --git a/v1.0.5.tar.gz b/v1.0.5.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6c7ae5f02eafba231e4dbfe69eea0f70082c22da Binary files /dev/null and b/v1.0.5.tar.gz differ