From 1c169a8a26fe58ebb5d8a761d4d59cbbe3af2668 Mon Sep 17 00:00:00 2001 From: zhangshaoning Date: Mon, 17 Feb 2025 14:41:18 +0800 Subject: [PATCH] Add sw_64 support --- 0001-add-sw_64-support-on-nispor.patch | 5037 ++++++++++++++++++++++++ nispor.spec | 8 +- 2 files changed, 5044 insertions(+), 1 deletion(-) create mode 100644 0001-add-sw_64-support-on-nispor.patch diff --git a/0001-add-sw_64-support-on-nispor.patch b/0001-add-sw_64-support-on-nispor.patch new file mode 100644 index 0000000..7221f6b --- /dev/null +++ b/0001-add-sw_64-support-on-nispor.patch @@ -0,0 +1,5037 @@ +From dcade584c8f94a4265c946a63e6ae25727a9976d Mon Sep 17 00:00:00 2001 +From: Super User +Date: Fri, 3 Jan 2025 15:44:49 +0800 +Subject: [PATCH] add sw_64 support on nispor + +--- + vendor/libc/.cargo-checksum.json | 2 +- + vendor/libc/.cargo-checksum.json.uncheck | 1 + + vendor/libc/Cargo.toml | 2 +- + vendor/libc/src/fuchsia/mod.rs | 5 - + vendor/libc/src/unix/bsd/apple/mod.rs | 812 +++++++++++- + .../src/unix/bsd/freebsdlike/dragonfly/mod.rs | 59 +- + .../bsd/freebsdlike/freebsd/freebsd11/mod.rs | 1 + + .../bsd/freebsdlike/freebsd/freebsd12/mod.rs | 9 + + .../freebsdlike/freebsd/freebsd12/x86_64.rs | 5 + + .../bsd/freebsdlike/freebsd/freebsd13/mod.rs | 8 + + .../freebsdlike/freebsd/freebsd13/x86_64.rs | 5 + + .../src/unix/bsd/freebsdlike/freebsd/mod.rs | 52 +- + vendor/libc/src/unix/bsd/freebsdlike/mod.rs | 14 +- + .../src/unix/bsd/netbsdlike/netbsd/aarch64.rs | 81 ++ + .../src/unix/bsd/netbsdlike/netbsd/mod.rs | 39 + + .../unix/bsd/netbsdlike/openbsd/aarch64.rs | 14 + + .../src/unix/bsd/netbsdlike/openbsd/mod.rs | 6 + + vendor/libc/src/unix/haiku/mod.rs | 30 + + vendor/libc/src/unix/haiku/native.rs | 24 + + vendor/libc/src/unix/haiku/x86_64.rs | 264 ++++ + .../libc/src/unix/linux_like/android/mod.rs | 11 + + .../libc/src/unix/linux_like/linux/align.rs | 2 + + .../linux_like/linux/gnu/b32/riscv32/mod.rs | 1 + + .../src/unix/linux_like/linux/gnu/b64/mod.rs | 19 + + .../linux_like/linux/gnu/b64/riscv64/mod.rs | 1 + + .../unix/linux_like/linux/gnu/b64/s390x.rs | 1 + + .../src/unix/linux_like/linux/gnu/b64/sw64.rs | 1096 +++++++++++++++++ + .../libc/src/unix/linux_like/linux/gnu/mod.rs | 83 +- + vendor/libc/src/unix/linux_like/linux/mod.rs | 114 +- + .../src/unix/linux_like/linux/musl/mod.rs | 35 - + .../src/unix/linux_like/linux/no_align.rs | 2 + + .../unix/linux_like/linux/uclibc/arm/mod.rs | 34 +- + .../linux/uclibc/mips/mips32/mod.rs | 1 + + .../unix/linux_like/linux/uclibc/mips/mod.rs | 45 - + .../src/unix/linux_like/linux/uclibc/mod.rs | 143 +++ + .../linux_like/linux/uclibc/x86_64/l4re.rs | 5 + + vendor/libc/src/unix/linux_like/mod.rs | 78 +- + vendor/libc/src/unix/newlib/mod.rs | 3 + + vendor/libc/src/unix/newlib/xtensa/mod.rs | 93 ++ + vendor/libc/src/unix/redox/mod.rs | 2 + + vendor/libc/src/unix/solarish/illumos.rs | 4 + + vendor/libc/src/unix/solarish/mod.rs | 119 +- + vendor/libc/src/unix/solarish/x86_64.rs | 129 ++ + vendor/libc/src/vxworks/mod.rs | 0 + vendor/libc/src/windows/mod.rs | 4 + + .../libc/src/windows/{msvc.rs => msvc/mod.rs} | 16 + + vendor/libc/src/windows/msvc/x86_64.rs | 140 +++ + 47 files changed, 3442 insertions(+), 172 deletions(-) + create mode 100644 vendor/libc/.cargo-checksum.json.uncheck + create mode 100644 vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd12/x86_64.rs + create mode 100644 vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/x86_64.rs + create mode 100644 vendor/libc/src/unix/haiku/x86_64.rs + create mode 100644 vendor/libc/src/unix/linux_like/linux/gnu/b64/sw64.rs + create mode 100644 vendor/libc/src/unix/newlib/xtensa/mod.rs + create mode 100644 vendor/libc/src/unix/solarish/x86_64.rs + mode change 100755 => 100644 vendor/libc/src/vxworks/mod.rs + rename vendor/libc/src/windows/{msvc.rs => msvc/mod.rs} (57%) + create mode 100644 vendor/libc/src/windows/msvc/x86_64.rs + +diff --git a/vendor/libc/.cargo-checksum.json b/vendor/libc/.cargo-checksum.json +index 655df25..096ce52 100644 +--- a/vendor/libc/.cargo-checksum.json ++++ b/vendor/libc/.cargo-checksum.json +@@ -1 +1 @@ +-{"files":{"CONTRIBUTING.md":"752eea5a703d11b485c6b5f195f51bd2c79aa5159b619ce09555c779e1fb586b","Cargo.toml":"151a09f8f25db066c8256ba2c8498cfd9e2205a988ebaf9a1e6e485f8c4b0e2d","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"a8d47ff51ca256f56a8932dba07660672dbfe3004257ca8de708aac1415937a1","README.md":"8228847944f1332882fbb00275b6f30e4a8aad08a13569c25d52cac012cc2a47","build.rs":"8e0e8d33cc9e7c25cde75c2b502420f943266a681024169f94084774b422681d","rustfmt.toml":"eaa2ea84fc1ba0359b77680804903e07bb38d257ab11986b95b158e460f787b2","src/fixed_width_ints.rs":"34c60f12ec5eeb90f13ec3b954427532111c2446e69617616a97aefc1086a9f1","src/fuchsia/aarch64.rs":"378776a9e40766154a54c94c2a7b4675b5c302a38e6e42da99e67bfbaee60e56","src/fuchsia/align.rs":"ae1cf8f011a99737eabeb14ffff768e60f13b13363d7646744dbb0f443dab3d6","src/fuchsia/mod.rs":"66fe805867933dc875e87fa5371458913aee596d80562a6873de234bbc61294d","src/fuchsia/no_align.rs":"303f3f1b255e0088b5715094353cf00476131d8e94e6aebb3f469557771c8b8a","src/fuchsia/x86_64.rs":"93a3632b5cf67d2a6bcb7dc0a558605252d5fe689e0f38d8aa2ec5852255ac87","src/hermit/aarch64.rs":"86048676e335944c37a63d0083d0f368ae10ceccefeed9debb3bbe08777fc682","src/hermit/mod.rs":"d3bfce41e4463d4be8020a2d063c9bfa8b665f45f1cc6cbf3163f5d01e7cb21f","src/hermit/x86_64.rs":"ab832b7524e5fb15c49ff7431165ab1a37dc4667ae0b58e8306f4c539bfa110c","src/lib.rs":"d4f7452c0fe720f3a961b918b74ec86d19cef33e6b4aac08efbbad6f6d818e09","src/macros.rs":"7844312c233a6889fa15395fe3106f6a8f6229211104a92f33ea3c9536eef763","src/psp.rs":"dd31aabd46171d474ec5828372e28588935120e7355c90c105360d8fa9264c1c","src/sgx.rs":"16a95cdefc81c5ee00d8353a60db363c4cc3e0f75abcd5d0144723f2a306ed1b","src/switch.rs":"9da3dd39b3de45a7928789926e8572d00e1e11a39e6f7289a1349aadce90edba","src/unix/align.rs":"2cdc7c826ef7ae61f5171c5ae8c445a743d86f1a7f2d9d7e4ceeec56d6874f65","src/unix/bsd/apple/b32/align.rs":"ec833a747866fe19ca2d9b4d3c9ff0385faba5edf4bd0d15fa68884c40b0e26c","src/unix/bsd/apple/b32/mod.rs":"6a4ce300da0d2b0db04b18548286603ffe4b47d679a41cf60f1902895894aa1f","src/unix/bsd/apple/b64/aarch64/align.rs":"f0c321265dd7671f16106b84951ac7dd77ed2e65c6623cbf2d29e76531984770","src/unix/bsd/apple/b64/aarch64/mod.rs":"46d5d061c7a74cbc09cbdfb3bee9a600867bf4e04c0e4d0ca6c817e6033b32e1","src/unix/bsd/apple/b64/align.rs":"ec833a747866fe19ca2d9b4d3c9ff0385faba5edf4bd0d15fa68884c40b0e26c","src/unix/bsd/apple/b64/mod.rs":"f5e278a1af7fb358891d1c9be4eb7e815aaca0c5cb738d0c3604ba2208a856f7","src/unix/bsd/apple/b64/x86_64/align.rs":"ec833a747866fe19ca2d9b4d3c9ff0385faba5edf4bd0d15fa68884c40b0e26c","src/unix/bsd/apple/b64/x86_64/mod.rs":"cc6878dd130c3f255418e4da74992ae9ba6a3cdb0530772de76c518077d3b12a","src/unix/bsd/apple/mod.rs":"eeffdf3542657410eefdb8ad3b02584a323fd9d70495106a1d284b3c89f2e93a","src/unix/bsd/freebsdlike/dragonfly/errno.rs":"8295b8bb0dfd38d2cdb4d9192cdeeb534cc6c3b208170e64615fa3e0edb3e578","src/unix/bsd/freebsdlike/dragonfly/mod.rs":"d94fae70582ac058f9c492f7385c86a5e5815f6f3e1667bf001a556840886cb4","src/unix/bsd/freebsdlike/freebsd/aarch64.rs":"2a215bd6136b8617aacedf9be738ccee94da9d29b418e9a78101d6291c182352","src/unix/bsd/freebsdlike/freebsd/arm.rs":"59d6a670eea562fb87686e243e0a84603d29a2028a3d4b3f99ccc01bd04d2f47","src/unix/bsd/freebsdlike/freebsd/freebsd11/b64.rs":"9808d152c1196aa647f1b0f0cf84dac8c930da7d7f897a44975545e3d9d17681","src/unix/bsd/freebsdlike/freebsd/freebsd11/mod.rs":"6523af60c0e4937ad374003c1653e9e721f5b6f11572c747732f76522d07d034","src/unix/bsd/freebsdlike/freebsd/freebsd12/b64.rs":"61cbe45f8499bedb168106b686d4f8239472f25c7553b069eec2afe197ff2df6","src/unix/bsd/freebsdlike/freebsd/freebsd12/mod.rs":"4de82eed7fc33fc5f3962e3af3f4b17c82f6b2a9916442bfca4e00e3f2f5a492","src/unix/bsd/freebsdlike/freebsd/freebsd13/b64.rs":"61cbe45f8499bedb168106b686d4f8239472f25c7553b069eec2afe197ff2df6","src/unix/bsd/freebsdlike/freebsd/freebsd13/mod.rs":"b77316c3503be031af6536743ecf69c444c4e74f7c2e41ce4fc8de69835aefd1","src/unix/bsd/freebsdlike/freebsd/mod.rs":"433349d5328359004f1624547918ac817d9c9268023c51bc6dc7834c7e73a3d9","src/unix/bsd/freebsdlike/freebsd/powerpc.rs":"9ca3f82f88974e6db5569f2d76a5a3749b248a31747a6c0da5820492bdfeca42","src/unix/bsd/freebsdlike/freebsd/powerpc64.rs":"2dae3ecc87eac3b11657aa98915def55fc4b5c0de11fe26aae23329a54628a9a","src/unix/bsd/freebsdlike/freebsd/x86.rs":"c5005e3249eb7c93cfbac72a9e9272320d80ce7983da990ceb05a447f59a02c5","src/unix/bsd/freebsdlike/freebsd/x86_64/align.rs":"0e1f69a88fca1c32874b1daf5db3d446fefbe518dca497f096cc9168c39dde70","src/unix/bsd/freebsdlike/freebsd/x86_64/mod.rs":"c3a0111252e201c172b99e7d9cbee4cf088d3dd47995110e819f04276bccd198","src/unix/bsd/freebsdlike/mod.rs":"7b1bfbd0253aa14e9acdd448d0303b84f283a70a0c4ba546f445d44d3ad011ef","src/unix/bsd/mod.rs":"2fed08973739d7f6a7412b204724af64b1a915c712689c250cf9a08263ba05ff","src/unix/bsd/netbsdlike/mod.rs":"4e9da54e541773c7ad4cca9dade1df00f28f2fdac3f8df5957f4c74b7e082344","src/unix/bsd/netbsdlike/netbsd/aarch64.rs":"b38fc046f9a40fea28bd26328b96629f4d5d63d7524936bd6af1865d401a8716","src/unix/bsd/netbsdlike/netbsd/arm.rs":"58cdbb70b0d6f536551f0f3bb3725d2d75c4690db12c26c034e7d6ec4a924452","src/unix/bsd/netbsdlike/netbsd/mod.rs":"78091375c1c6dcdd03d3a1b35337b5c8bc74af500e294bc5ec91d4b73bf982d9","src/unix/bsd/netbsdlike/netbsd/powerpc.rs":"ee7ff5d89d0ed22f531237b5059aa669df93a3b5c489fa641465ace8d405bf41","src/unix/bsd/netbsdlike/netbsd/sparc64.rs":"9489f4b3e4566f43bb12dfb92238960613dac7f6a45cc13068a8d152b902d7d9","src/unix/bsd/netbsdlike/netbsd/x86.rs":"20692320e36bfe028d1a34d16fe12ca77aa909cb02bda167376f98f1a09aefe7","src/unix/bsd/netbsdlike/netbsd/x86_64.rs":"1afe5ef46b14397cdd68664b5b232e4f5b035b6db1d4cf411c899d51ebca9f30","src/unix/bsd/netbsdlike/openbsd/aarch64.rs":"1dd5449dd1fd3d51e30ffdeeaece91d0aaf05c710e0ac699fecc5461cfa2c28e","src/unix/bsd/netbsdlike/openbsd/mod.rs":"ac6fff797511b00659849242b997de4d9f948698b5677de928375fc84d2ac1f3","src/unix/bsd/netbsdlike/openbsd/sparc64.rs":"d04fd287afbaa2c5df9d48c94e8374a532a3ba491b424ddf018270c7312f4085","src/unix/bsd/netbsdlike/openbsd/x86.rs":"6f7f5c4fde2a2259eb547890cbd86570cea04ef85347d7569e94e679448bec87","src/unix/bsd/netbsdlike/openbsd/x86_64.rs":"d31db31630289c85af3339dbe357998a21ca584cbae31607448fe2cf7675a4e1","src/unix/haiku/b32.rs":"69ae47fc52c6880e85416b4744500d5655c9ec6131cb737f3b649fceaadce15a","src/unix/haiku/b64.rs":"73e64db09275a8da8d50a13cce2cfa2b136036ddf3a930d2939f337fc995900b","src/unix/haiku/mod.rs":"916e15a760e973b3ad3830ecfab435b557d05942116e33cb80b15bcba02e39f0","src/unix/haiku/native.rs":"b3c35dba8c07e3347de58a44750690e16dc137adbae8bc030a3a658dd1f3c871","src/unix/hermit/aarch64.rs":"86048676e335944c37a63d0083d0f368ae10ceccefeed9debb3bbe08777fc682","src/unix/hermit/mod.rs":"859814f5df89e28fd4b345db399d181e11e7ed413841b6ff703a1fcbdbf013ae","src/unix/hermit/x86_64.rs":"ab832b7524e5fb15c49ff7431165ab1a37dc4667ae0b58e8306f4c539bfa110c","src/unix/linux_like/android/b32/arm.rs":"433c1530f602cc5ed26610c58055dde0c4ceea5e00150063b24ddc60768332a4","src/unix/linux_like/android/b32/mod.rs":"d971b98530a96f5892f98e1edc3133cf278d1b3939d77ab0a27a6323e0961715","src/unix/linux_like/android/b32/x86/align.rs":"812914e4241df82e32b12375ca3374615dc3a4bdd4cf31f0423c5815320c0dab","src/unix/linux_like/android/b32/x86/mod.rs":"8388bd3a0fcb5636bf965eee6dc95ae6860b85a2b555b387c868aa4d4e01ec89","src/unix/linux_like/android/b64/aarch64/align.rs":"2179c3b1608fa4bf68840482bfc2b2fa3ee2faf6fcae3770f9e505cddca35c7b","src/unix/linux_like/android/b64/aarch64/mod.rs":"8fe667d2b14abc5ac8aad32e16c3da24350471d8156eaea9ab4989f73dd9f9fc","src/unix/linux_like/android/b64/mod.rs":"d7bbbadafdb2cb2ff8e9cde3d89a03b9facaabb6b2d45705225d3ece1c5cce37","src/unix/linux_like/android/b64/x86_64/align.rs":"7169d07a9fd4716f7512719aec9fda5d8bed306dc0720ffc1b21696c9951e3c6","src/unix/linux_like/android/b64/x86_64/mod.rs":"06b22dc184e85a988ab969c75cadc52b9878faeab0eb9d21215878c95fe07c19","src/unix/linux_like/android/mod.rs":"7d42d84cb547012d19034221c174208766f2dcf62d08724f6b453b2a075d5cff","src/unix/linux_like/emscripten/align.rs":"86c95cbed7a7161b1f23ee06843e7b0e2340ad92b2cb86fe2a8ef3e0e8c36216","src/unix/linux_like/emscripten/mod.rs":"6ef97140ca6fb24125fdd0aacb986ef785aa21993229660d7f703f8875ebfe49","src/unix/linux_like/emscripten/no_align.rs":"0128e4aa721a9902754828b61b5ec7d8a86619983ed1e0544a85d35b1051fad6","src/unix/linux_like/linux/align.rs":"213e70ebed2703e14a9cf17666b21ecbf180b7bff7fa22fdbb36dbbd52df326d","src/unix/linux_like/linux/arch/generic/mod.rs":"ff1fe8fad4ea15d9bec3db25efcfcb4939190c5189f86cfa4d05825aa8c10956","src/unix/linux_like/linux/arch/mips/mod.rs":"e4a980b002105aaa057eb6568e1e2c6168ade5c00e13a31ef67e316ddffdb900","src/unix/linux_like/linux/arch/mod.rs":"466a29622e47c6c7f1500682b2eb17f5566dd81b322cd6348f0fdd355cec593a","src/unix/linux_like/linux/arch/powerpc/mod.rs":"1789eb5b41f75c29239795124a4a7cdcf7c8d213b88cf581b2f5bda08d7cf15b","src/unix/linux_like/linux/arch/sparc/mod.rs":"ded708124ee610267d011dee31fb02d1ec697c334aa822776ec95a7ddf6fc541","src/unix/linux_like/linux/gnu/align.rs":"e4a3c27fe20a57b8d612c34cb05bc70646edb5cec7251957315afa53a7b9f936","src/unix/linux_like/linux/gnu/b32/arm/align.rs":"3fed009dc9af3cc81be7087da9d2d7d1f39845e4497e290259c5cdbae25f039d","src/unix/linux_like/linux/gnu/b32/arm/mod.rs":"07adf9f4b96854062db518aaf08521fde0ad4a21a5c049efccba437bd97b2b5a","src/unix/linux_like/linux/gnu/b32/mips/align.rs":"429fb5e005cb7143602d430098b6ebfb7d360685b194f333dfd587472ae954ee","src/unix/linux_like/linux/gnu/b32/mips/mod.rs":"1cb5c0c9df3af2bbe131a91593583259fac9118931744c8435e197a394eb0462","src/unix/linux_like/linux/gnu/b32/mod.rs":"794dbcbae7dae8fd6b0b814573243197ceb532b56ef0772ad86b4b401478fcd9","src/unix/linux_like/linux/gnu/b32/powerpc.rs":"0cd7348badb9c4f8a0db31a2503b30c456a2bfcc7a0e5919762b1e12f912c5ad","src/unix/linux_like/linux/gnu/b32/riscv32/mod.rs":"9c628cd97806181dc4d34b072f63fe1eb42f08108712002e0628ffe27f2fa93f","src/unix/linux_like/linux/gnu/b32/sparc/align.rs":"21adbed27df73e2d1ed934aaf733a643003d7baf2bde9c48ea440895bcca6d41","src/unix/linux_like/linux/gnu/b32/sparc/mod.rs":"1bcec269a8416ccc48a384ca5765eaaa23f30f39f32311f50008ef4eeadafb2f","src/unix/linux_like/linux/gnu/b32/x86/align.rs":"e4bafdc4a519a7922a81b37a62bbfd1177a2f620890eef8f1fbc47162e9eb413","src/unix/linux_like/linux/gnu/b32/x86/mod.rs":"5317dbf2323577b89370bbee3894882b89d8333176db4f7b271ddc2f036ef43c","src/unix/linux_like/linux/gnu/b64/aarch64/align.rs":"2179c3b1608fa4bf68840482bfc2b2fa3ee2faf6fcae3770f9e505cddca35c7b","src/unix/linux_like/linux/gnu/b64/aarch64/ilp32.rs":"21a21503ef2e095f4371044915d4bfb07a8578011cb5c713cd9f45947b0b5730","src/unix/linux_like/linux/gnu/b64/aarch64/lp64.rs":"e78c3cd197f44832338b414d1a9bc0d194f44c74db77bd7bf830c1fff62b2690","src/unix/linux_like/linux/gnu/b64/aarch64/mod.rs":"c3730792dabcc166d8fd22929ef2633d49bc626875382dfcd401e8e125fb7a84","src/unix/linux_like/linux/gnu/b64/mips64/align.rs":"7169d07a9fd4716f7512719aec9fda5d8bed306dc0720ffc1b21696c9951e3c6","src/unix/linux_like/linux/gnu/b64/mips64/mod.rs":"68bcb71bbfccb4e8648948e494366d94767ce96f36daab9c1329375cdd32a459","src/unix/linux_like/linux/gnu/b64/mod.rs":"6336065423c26b59681fd2ce77f1117ea36af13e163fdadaefd108bd8191e8c8","src/unix/linux_like/linux/gnu/b64/powerpc64/align.rs":"e29c4868bbecfa4a6cd8a2ad06193f3bbc78a468cc1dc9df83f002f1268130d9","src/unix/linux_like/linux/gnu/b64/powerpc64/mod.rs":"dbb8905e363ed4a2dfb984554ad9b6389d27f6a2d599ec2d80e38a6c7551a019","src/unix/linux_like/linux/gnu/b64/riscv64/mod.rs":"18edaa89c9746125863ff53182e0ef32cb1e1612e1ed9a2672558a9de85440e9","src/unix/linux_like/linux/gnu/b64/s390x.rs":"d9bb4e524e70d6fef49e0f77d89a92f478fd95d9a1aea32f4dc845275a7465d4","src/unix/linux_like/linux/gnu/b64/sparc64/align.rs":"e29c4868bbecfa4a6cd8a2ad06193f3bbc78a468cc1dc9df83f002f1268130d9","src/unix/linux_like/linux/gnu/b64/sparc64/mod.rs":"26fda11bdce99372c2c246e60866b56d98beb9fb49a2f6b69347ecfd03d18255","src/unix/linux_like/linux/gnu/b64/x86_64/align.rs":"7169d07a9fd4716f7512719aec9fda5d8bed306dc0720ffc1b21696c9951e3c6","src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs":"5a5ce7c5c92f60d8900dce63d363a38f3126aaf5be981710e172bec96ef95ac6","src/unix/linux_like/linux/gnu/b64/x86_64/not_x32.rs":"f775ac2b754f90b63053fe22afe1d19d306b5404995568d6805baa9249fb617f","src/unix/linux_like/linux/gnu/b64/x86_64/x32.rs":"4ba1b58468f55254717366f50fdfd3e4114fde6dc442a56681926c4d7e5b6b0d","src/unix/linux_like/linux/gnu/mod.rs":"8cae88fb171344dd2ce21835691476ea1cf21dd7d6b4c81aaa10de72fb2a7d34","src/unix/linux_like/linux/gnu/no_align.rs":"9cd223135de75315840ff9c3fd5441ba1cb632b96b5c85a76f8316c86653db25","src/unix/linux_like/linux/mod.rs":"4924fdce70f2d1dcf3f024f64fbdab679264c20fa99bbe42b5f17e31f258f660","src/unix/linux_like/linux/musl/b32/arm/align.rs":"3e8ac052c1043764776b54c93ba4260e061df998631737a897d9d47d54f7b80c","src/unix/linux_like/linux/musl/b32/arm/mod.rs":"6255abe2ee04986832d12b7b2190589580f2a43e9bfb285b32b5747227f62727","src/unix/linux_like/linux/musl/b32/hexagon.rs":"a8811791809672be8338e6e27d1c4fcf383c2f26585be8bf9ab2923b219de032","src/unix/linux_like/linux/musl/b32/mips/align.rs":"429fb5e005cb7143602d430098b6ebfb7d360685b194f333dfd587472ae954ee","src/unix/linux_like/linux/musl/b32/mips/mod.rs":"b9e9ff42363ebbb884ddf6445129ec4164471df45846874fc08f5f458e659254","src/unix/linux_like/linux/musl/b32/mod.rs":"8ede3985e6243882814ce91e8ce543e7edbafc0cee5932816072b6f14207a671","src/unix/linux_like/linux/musl/b32/powerpc.rs":"4592dc5f1f2fe888dfef85fa862d42d168e73a2c6f4fc052b58287d0f4d4ffcd","src/unix/linux_like/linux/musl/b32/x86/align.rs":"08e77fbd7435d7dec2ff56932433bece3f02e47ce810f89004a275a86d39cbe1","src/unix/linux_like/linux/musl/b32/x86/mod.rs":"a19a8decfab185af3cebd34aae4b15082e7552be573904b8c1a3f0c0e493ef34","src/unix/linux_like/linux/musl/b64/aarch64/align.rs":"798a9229d70ce235394f2dd625f6c4c1e10519a94382dc5b091952b638ae2928","src/unix/linux_like/linux/musl/b64/aarch64/mod.rs":"a73035c6d9b776f13b839008e15c04c2c53455571efd06664affcb047e457112","src/unix/linux_like/linux/musl/b64/mips64.rs":"2744895451f3a777fbe54f7f2695be53310b965fd62084c9b7e9121c7fe28346","src/unix/linux_like/linux/musl/b64/mod.rs":"d18abc0aeba2e26342bf3416a4dba0836db2bb0ee013b0a39629475cf8640289","src/unix/linux_like/linux/musl/b64/powerpc64.rs":"e5a55525b42493923956d668f978fb45e22d51deea00ce5edbfddf76ff19c741","src/unix/linux_like/linux/musl/b64/s390x.rs":"03dfec6794d93cb31a7c52b2d53a0973755168f91f8fa437cc5dbd54882c8ee7","src/unix/linux_like/linux/musl/b64/x86_64/align.rs":"7169d07a9fd4716f7512719aec9fda5d8bed306dc0720ffc1b21696c9951e3c6","src/unix/linux_like/linux/musl/b64/x86_64/mod.rs":"0dd168f5a6881f32e5239fb312b23cf137b800d0ff323286a92c8a2c382b5456","src/unix/linux_like/linux/musl/mod.rs":"81690cfec80ae3de9dc7e3d31b251de46863a87b534e038a56fa0bedc0986889","src/unix/linux_like/linux/no_align.rs":"5ed04c53bf9d27da9b4d65ba7625c6ac53330162683d1b3df98950caafa3507b","src/unix/linux_like/linux/uclibc/align.rs":"9ed16138d8e439bd90930845a65eafa7ebd67366e6bf633936d44014f6e4c959","src/unix/linux_like/linux/uclibc/arm/align.rs":"e4a3c27fe20a57b8d612c34cb05bc70646edb5cec7251957315afa53a7b9f936","src/unix/linux_like/linux/uclibc/arm/mod.rs":"9b691eeec0a9bf7b2abb87e09062d2c148d18e11c96ecad0edd0b74d1d0509fd","src/unix/linux_like/linux/uclibc/arm/no_align.rs":"9cd223135de75315840ff9c3fd5441ba1cb632b96b5c85a76f8316c86653db25","src/unix/linux_like/linux/uclibc/mips/mips32/align.rs":"e4a3c27fe20a57b8d612c34cb05bc70646edb5cec7251957315afa53a7b9f936","src/unix/linux_like/linux/uclibc/mips/mips32/mod.rs":"18753a99b820d69e062e3ba22a63fa86577b6dcc42f740479c7be1a4c658e1be","src/unix/linux_like/linux/uclibc/mips/mips32/no_align.rs":"9cd223135de75315840ff9c3fd5441ba1cb632b96b5c85a76f8316c86653db25","src/unix/linux_like/linux/uclibc/mips/mips64/align.rs":"a7bdcb18a37a2d91e64d5fad83ea3edc78f5412adb28f77ab077dbb26dd08b2d","src/unix/linux_like/linux/uclibc/mips/mips64/mod.rs":"e3085ba56cfbc528d7c3c55065880603238c333b6047ef51c58177508a487fcd","src/unix/linux_like/linux/uclibc/mips/mips64/no_align.rs":"4a18e3875698c85229599225ac3401a2a40da87e77b2ad4ef47c6fcd5a24ed30","src/unix/linux_like/linux/uclibc/mips/mod.rs":"656fbf5157ab6d06fc365a8353b138818ad5b8429ea5628ff35a3972c63a1a7c","src/unix/linux_like/linux/uclibc/mod.rs":"6885187dc15e9239981ad36ac5bdc8559ae4c55775c8e304ae1a2093568d93f2","src/unix/linux_like/linux/uclibc/no_align.rs":"3f28637046524618adaa1012e26cb7ffe94b9396e6b518cccdc69d59f274d709","src/unix/linux_like/linux/uclibc/x86_64/l4re.rs":"bb31053d6403091e11f95ac2203982f279f8b984a19adf30796878c45fdd8c25","src/unix/linux_like/linux/uclibc/x86_64/mod.rs":"02e21c0550a423a3f6db0a0af6a0f37cf5937feb2562a490e0ad0e09a8d9fc77","src/unix/linux_like/linux/uclibc/x86_64/other.rs":"42c3f71e58cabba373f6a55a623f3c31b85049eb64824c09c2b082b3b2d6a0a8","src/unix/linux_like/mod.rs":"9f6eadebed153e31777482932dae2f3fd3471d5b5465099f98f1e2a9429922fe","src/unix/mod.rs":"6b2b57833e37cd3231944696c8216eb587a2a68069346150cf321153eaf04d03","src/unix/newlib/aarch64/mod.rs":"bb269c1468a9676442554600e87417079a787fe6220dfc23b3109639259e8710","src/unix/newlib/align.rs":"28aaf87fafbc6b312622719d472d8cf65f9e5467d15339df5f73e66d8502b28a","src/unix/newlib/arm/mod.rs":"c71be856bfd7f576b2db28af9f680211cbe6c1cac7d537bbc8020b39591af07c","src/unix/newlib/espidf/mod.rs":"c198cb4beccdab483be61c102da74dc51ac80f766797e33021f3110394ed5a3d","src/unix/newlib/mod.rs":"07c282da3fedf04d061c70ab918b561ba44e5d67670e0b04664505afc9c5979f","src/unix/newlib/no_align.rs":"e0743b2179495a9514bc3a4d1781e492878c4ec834ee0085d0891dd1712e82fb","src/unix/newlib/powerpc/mod.rs":"2d0f7af28b47f7a2a6c210ebd1c1f33ed8eac62e56b5af2b856de2ad3fdc5187","src/unix/no_align.rs":"c06e95373b9088266e0b14bba0954eef95f93fb2b01d951855e382d22de78e53","src/unix/redox/mod.rs":"251ade5cbe9d648ba7186f58dfe7d4fd8e08be1ab9d0d51bba13e0bf3a0207d0","src/unix/solarish/compat.rs":"b07a5bfac925eb012003a459ba6bddbd3bfa9c44b3394da2ac5a602e54beae9c","src/unix/solarish/illumos.rs":"be7cf5334fc8f2c6bc1b856288e53af7f90a92bd64793eb19b60b660383e508c","src/unix/solarish/mod.rs":"e326528365803b1085050b5d14705c02db25ff0c241facbaa8929d7a3f417b59","src/unix/solarish/solaris.rs":"65b005453aefa9b9d4fc860fe77cfec80d8c97a51342b15daf55fc3e808bb384","src/vxworks/aarch64.rs":"98f0afdc511cd02557e506c21fed6737585490a1dce7a9d4941d08c437762b99","src/vxworks/arm.rs":"acb7968ce99fe3f4abdf39d98f8133d21a4fba435b8ef7084777cb181d788e88","src/vxworks/mod.rs":"aea3da66f2140f2a82dfc9c58f6e6531d2dd9c15ea696e0f95a0d4a2a187b5b6","src/vxworks/powerpc.rs":"acb7968ce99fe3f4abdf39d98f8133d21a4fba435b8ef7084777cb181d788e88","src/vxworks/powerpc64.rs":"98f0afdc511cd02557e506c21fed6737585490a1dce7a9d4941d08c437762b99","src/vxworks/x86.rs":"552f007f38317620b23889cb7c49d1d115841252439060122f52f434fbc6e5ba","src/vxworks/x86_64.rs":"018d92be3ad628a129eff9f2f5dfbc0883d8b8e5f2fa917b900a7f98ed6b514a","src/wasi.rs":"2c945bce3ddd26bf20ff03fb4192c9c3f625f1308a479c5cb4bd4510a892629a","src/windows/gnu/align.rs":"b2c13ec1b9f3b39a75c452c80c951dff9d0215e31d77e883b4502afb31794647","src/windows/gnu/mod.rs":"3c8c7edb7cdf5d0c44af936db2a94869585c69dfabeef30571b4f4e38375767a","src/windows/mod.rs":"cf605ceefc10481aaf6274a205b2899abeb7c043bd384ff766dcb301318dfa2a","src/windows/msvc.rs":"ea6d87a6a9cd668261b1c043e7c36cf599e80b5d09f6e4502e85daa4797c7927","tests/const_fn.rs":"cb75a1f0864f926aebe79118fc34d51a0d1ade2c20a394e7774c7e545f21f1f4"},"package":"3cb00336871be5ed2c8ed44b60ae9959dc5b9f08539422ed43f09e34ecaeba21"} +\ No newline at end of file ++{"files":{ },"package":"dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"} +\ No newline at end of file +diff --git a/vendor/libc/.cargo-checksum.json.uncheck b/vendor/libc/.cargo-checksum.json.uncheck +new file mode 100644 +index 0000000..2d1b6b5 +--- /dev/null ++++ b/vendor/libc/.cargo-checksum.json.uncheck +@@ -0,0 +1 @@ ++{"files":{},"package":"dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"} +\ No newline at end of file +diff --git a/vendor/libc/Cargo.toml b/vendor/libc/Cargo.toml +index 55c2529..0a49396 100644 +--- a/vendor/libc/Cargo.toml ++++ b/vendor/libc/Cargo.toml +@@ -11,7 +11,7 @@ + + [package] + name = "libc" +-version = "0.2.101" ++version = "0.2.103" + authors = ["The Rust Project Developers"] + build = "build.rs" + exclude = ["/ci/*", "/.github/*", "/.cirrus.yml", "/triagebot.toml"] +diff --git a/vendor/libc/src/fuchsia/mod.rs b/vendor/libc/src/fuchsia/mod.rs +index 2377604..7b94f64 100644 +--- a/vendor/libc/src/fuchsia/mod.rs ++++ b/vendor/libc/src/fuchsia/mod.rs +@@ -89,8 +89,6 @@ pub type rlim_t = ::c_ulonglong; + pub type c_long = i64; + pub type c_ulong = u64; + +-pub type zx_status_t = i32; +- + // FIXME: why are these uninhabited types? that seems... wrong? + // Presumably these should be `()` or an `extern type` (when that stabilizes). + #[cfg_attr(feature = "extra_traits", derive(Debug))] +@@ -4231,9 +4229,6 @@ extern "C" { + >, + data: *mut ::c_void, + ) -> ::c_int; +- +- pub fn zx_cprng_draw(buffer: *mut ::c_void, buffer_size: ::size_t); +- pub fn zx_cprng_add_entropy(buffer: *const ::c_void, buffer_size: ::size_t) -> ::zx_status_t; + } + + cfg_if! { +diff --git a/vendor/libc/src/unix/bsd/apple/mod.rs b/vendor/libc/src/unix/bsd/apple/mod.rs +index 6839ed3..4c38ded 100644 +--- a/vendor/libc/src/unix/bsd/apple/mod.rs ++++ b/vendor/libc/src/unix/bsd/apple/mod.rs +@@ -30,6 +30,13 @@ pub type natural_t = u32; + pub type mach_msg_type_number_t = natural_t; + pub type kern_return_t = ::c_int; + pub type uuid_t = [u8; 16]; ++pub type task_info_t = *mut integer_t; ++pub type host_info_t = *mut integer_t; ++pub type task_flavor_t = natural_t; ++pub type rusage_info_t = *mut ::c_void; ++pub type vm_offset_t = ::uintptr_t; ++pub type vm_size_t = ::uintptr_t; ++pub type vm_address_t = vm_offset_t; + + pub type posix_spawnattr_t = *mut ::c_void; + pub type posix_spawn_file_actions_t = *mut ::c_void; +@@ -40,6 +47,9 @@ pub type sae_associd_t = u32; + pub type sae_connid_t = u32; + + pub type mach_port_t = ::c_uint; ++pub type host_t = ::c_uint; ++pub type host_flavor_t = integer_t; ++pub type host_info64_t = *mut integer_t; + pub type processor_flavor_t = ::c_int; + pub type thread_flavor_t = natural_t; + pub type thread_inspect_t = mach_port_t; +@@ -67,6 +77,11 @@ pub type processor_set_load_info_t = *mut processor_set_load_info; + pub type processor_info_t = *mut integer_t; + pub type processor_info_array_t = *mut integer_t; + ++pub type mach_task_basic_info_data_t = mach_task_basic_info; ++pub type mach_task_basic_info_t = *mut mach_task_basic_info; ++pub type task_thread_times_info_data_t = task_thread_times_info; ++pub type task_thread_times_info_t = *mut task_thread_times_info; ++ + pub type thread_info_t = *mut integer_t; + pub type thread_basic_info_t = *mut thread_basic_info; + pub type thread_basic_info_data_t = thread_basic_info; +@@ -97,12 +112,18 @@ pub type thread_latency_qos_policy_t = *mut thread_latency_qos_policy; + pub type thread_throughput_qos_policy_data_t = thread_throughput_qos_policy; + pub type thread_throughput_qos_policy_t = *mut thread_throughput_qos_policy; + ++pub type vm_statistics_t = *mut vm_statistics; ++pub type vm_statistics_data_t = vm_statistics; ++pub type vm_statistics64_t = *mut vm_statistics64; ++pub type vm_statistics64_data_t = vm_statistics64; ++ ++pub type sysdir_search_path_enumeration_state = ::c_uint; ++ + pub type CCStatus = i32; + pub type CCCryptorStatus = i32; + pub type CCRNGStatus = ::CCCryptorStatus; + + deprecated_mach! { +- pub type vm_size_t = ::uintptr_t; + pub type mach_timebase_info_data_t = mach_timebase_info; + } + +@@ -132,6 +153,57 @@ impl ::Clone for qos_class_t { + } + } + ++#[cfg_attr(feature = "extra_traits", derive(Debug))] ++#[repr(u32)] ++pub enum sysdir_search_path_directory_t { ++ SYSDIR_DIRECTORY_APPLICATION = 1, ++ SYSDIR_DIRECTORY_DEMO_APPLICATION = 2, ++ SYSDIR_DIRECTORY_DEVELOPER_APPLICATION = 3, ++ SYSDIR_DIRECTORY_ADMIN_APPLICATION = 4, ++ SYSDIR_DIRECTORY_LIBRARY = 5, ++ SYSDIR_DIRECTORY_DEVELOPER = 6, ++ SYSDIR_DIRECTORY_USER = 7, ++ SYSDIR_DIRECTORY_DOCUMENTATION = 8, ++ SYSDIR_DIRECTORY_DOCUMENT = 9, ++ SYSDIR_DIRECTORY_CORESERVICE = 10, ++ SYSDIR_DIRECTORY_AUTOSAVED_INFORMATION = 11, ++ SYSDIR_DIRECTORY_DESKTOP = 12, ++ SYSDIR_DIRECTORY_CACHES = 13, ++ SYSDIR_DIRECTORY_APPLICATION_SUPPORT = 14, ++ SYSDIR_DIRECTORY_DOWNLOADS = 15, ++ SYSDIR_DIRECTORY_INPUT_METHODS = 16, ++ SYSDIR_DIRECTORY_MOVIES = 17, ++ SYSDIR_DIRECTORY_MUSIC = 18, ++ SYSDIR_DIRECTORY_PICTURES = 19, ++ SYSDIR_DIRECTORY_PRINTER_DESCRIPTION = 20, ++ SYSDIR_DIRECTORY_SHARED_PUBLIC = 21, ++ SYSDIR_DIRECTORY_PREFERENCE_PANES = 22, ++ SYSDIR_DIRECTORY_ALL_APPLICATIONS = 100, ++ SYSDIR_DIRECTORY_ALL_LIBRARIES = 101, ++} ++impl ::Copy for sysdir_search_path_directory_t {} ++impl ::Clone for sysdir_search_path_directory_t { ++ fn clone(&self) -> sysdir_search_path_directory_t { ++ *self ++ } ++} ++ ++#[cfg_attr(feature = "extra_traits", derive(Debug))] ++#[repr(u32)] ++pub enum sysdir_search_path_domain_mask_t { ++ SYSDIR_DOMAIN_MASK_USER = (1 << 0), ++ SYSDIR_DOMAIN_MASK_LOCAL = (1 << 1), ++ SYSDIR_DOMAIN_MASK_NETWORK = (1 << 2), ++ SYSDIR_DOMAIN_MASK_SYSTEM = (1 << 3), ++ SYSDIR_DOMAIN_MASK_ALL = 0x0ffff, ++} ++impl ::Copy for sysdir_search_path_domain_mask_t {} ++impl ::Clone for sysdir_search_path_domain_mask_t { ++ fn clone(&self) -> sysdir_search_path_domain_mask_t { ++ *self ++ } ++} ++ + s! { + pub struct ip_mreq { + pub imr_multiaddr: in_addr, +@@ -721,6 +793,155 @@ s! { + pub pvi_cdir: vnode_info_path, + pub pvi_rdir: vnode_info_path, + } ++ ++ pub struct vm_statistics { ++ pub free_count: natural_t, ++ pub active_count: natural_t, ++ pub inactive_count: natural_t, ++ pub wire_count: natural_t, ++ pub zero_fill_count: natural_t, ++ pub reactivations: natural_t, ++ pub pageins: natural_t, ++ pub pageouts: natural_t, ++ pub faults: natural_t, ++ pub cow_faults: natural_t, ++ pub lookups: natural_t, ++ pub hits: natural_t, ++ pub purgeable_count: natural_t, ++ pub purges: natural_t, ++ pub speculative_count: natural_t, ++ } ++ ++ pub struct task_thread_times_info { ++ pub user_time: time_value_t, ++ pub system_time: time_value_t, ++ } ++ ++ pub struct rusage_info_v0 { ++ pub ri_uuid: [u8; 16], ++ pub ri_user_time: u64, ++ pub ri_system_time: u64, ++ pub ri_pkg_idle_wkups: u64, ++ pub ri_interrupt_wkups: u64, ++ pub ri_pageins: u64, ++ pub ri_wired_size: u64, ++ pub ri_resident_size: u64, ++ pub ri_phys_footprint: u64, ++ pub ri_proc_start_abstime: u64, ++ pub ri_proc_exit_abstime: u64, ++ } ++ ++ pub struct rusage_info_v1 { ++ pub ri_uuid: [u8; 16], ++ pub ri_user_time: u64, ++ pub ri_system_time: u64, ++ pub ri_pkg_idle_wkups: u64, ++ pub ri_interrupt_wkups: u64, ++ pub ri_pageins: u64, ++ pub ri_wired_size: u64, ++ pub ri_resident_size: u64, ++ pub ri_phys_footprint: u64, ++ pub ri_proc_start_abstime: u64, ++ pub ri_proc_exit_abstime: u64, ++ pub ri_child_user_time: u64, ++ pub ri_child_system_time: u64, ++ pub ri_child_pkg_idle_wkups: u64, ++ pub ri_child_interrupt_wkups: u64, ++ pub ri_child_pageins: u64, ++ pub ri_child_elapsed_abstime: u64, ++ } ++ ++ pub struct rusage_info_v2 { ++ pub ri_uuid: [u8; 16], ++ pub ri_user_time: u64, ++ pub ri_system_time: u64, ++ pub ri_pkg_idle_wkups: u64, ++ pub ri_interrupt_wkups: u64, ++ pub ri_pageins: u64, ++ pub ri_wired_size: u64, ++ pub ri_resident_size: u64, ++ pub ri_phys_footprint: u64, ++ pub ri_proc_start_abstime: u64, ++ pub ri_proc_exit_abstime: u64, ++ pub ri_child_user_time: u64, ++ pub ri_child_system_time: u64, ++ pub ri_child_pkg_idle_wkups: u64, ++ pub ri_child_interrupt_wkups: u64, ++ pub ri_child_pageins: u64, ++ pub ri_child_elapsed_abstime: u64, ++ pub ri_diskio_bytesread: u64, ++ pub ri_diskio_byteswritten: u64, ++ } ++ ++ pub struct rusage_info_v3 { ++ pub ri_uuid: [u8; 16], ++ pub ri_user_time: u64, ++ pub ri_system_time: u64, ++ pub ri_pkg_idle_wkups: u64, ++ pub ri_interrupt_wkups: u64, ++ pub ri_pageins: u64, ++ pub ri_wired_size: u64, ++ pub ri_resident_size: u64, ++ pub ri_phys_footprint: u64, ++ pub ri_proc_start_abstime: u64, ++ pub ri_proc_exit_abstime: u64, ++ pub ri_child_user_time: u64, ++ pub ri_child_system_time: u64, ++ pub ri_child_pkg_idle_wkups: u64, ++ pub ri_child_interrupt_wkups: u64, ++ pub ri_child_pageins: u64, ++ pub ri_child_elapsed_abstime: u64, ++ pub ri_diskio_bytesread: u64, ++ pub ri_diskio_byteswritten: u64, ++ pub ri_cpu_time_qos_default: u64, ++ pub ri_cpu_time_qos_maintenance: u64, ++ pub ri_cpu_time_qos_background: u64, ++ pub ri_cpu_time_qos_utility: u64, ++ pub ri_cpu_time_qos_legacy: u64, ++ pub ri_cpu_time_qos_user_initiated: u64, ++ pub ri_cpu_time_qos_user_interactive: u64, ++ pub ri_billed_system_time: u64, ++ pub ri_serviced_system_time: u64, ++ } ++ ++ pub struct rusage_info_v4 { ++ pub ri_uuid: [u8; 16], ++ pub ri_user_time: u64, ++ pub ri_system_time: u64, ++ pub ri_pkg_idle_wkups: u64, ++ pub ri_interrupt_wkups: u64, ++ pub ri_pageins: u64, ++ pub ri_wired_size: u64, ++ pub ri_resident_size: u64, ++ pub ri_phys_footprint: u64, ++ pub ri_proc_start_abstime: u64, ++ pub ri_proc_exit_abstime: u64, ++ pub ri_child_user_time: u64, ++ pub ri_child_system_time: u64, ++ pub ri_child_pkg_idle_wkups: u64, ++ pub ri_child_interrupt_wkups: u64, ++ pub ri_child_pageins: u64, ++ pub ri_child_elapsed_abstime: u64, ++ pub ri_diskio_bytesread: u64, ++ pub ri_diskio_byteswritten: u64, ++ pub ri_cpu_time_qos_default: u64, ++ pub ri_cpu_time_qos_maintenance: u64, ++ pub ri_cpu_time_qos_background: u64, ++ pub ri_cpu_time_qos_utility: u64, ++ pub ri_cpu_time_qos_legacy: u64, ++ pub ri_cpu_time_qos_user_initiated: u64, ++ pub ri_cpu_time_qos_user_interactive: u64, ++ pub ri_billed_system_time: u64, ++ pub ri_serviced_system_time: u64, ++ pub ri_logical_writes: u64, ++ pub ri_lifetime_max_phys_footprint: u64, ++ pub ri_instructions: u64, ++ pub ri_cycles: u64, ++ pub ri_billed_energy: u64, ++ pub ri_serviced_energy: u64, ++ pub ri_interval_max_phys_footprint: u64, ++ pub ri_runnable_time: u64, ++ } + } + + s_no_extra_traits! { +@@ -904,6 +1125,92 @@ s_no_extra_traits! { + pub pth_maxpriority: i32, + pub pth_name: [::c_char; MAXTHREADNAMESIZE], + } ++ ++ #[cfg_attr(libc_packedN, repr(packed(4)))] ++ pub struct if_data64 { ++ pub ifi_type: ::c_uchar, ++ pub ifi_typelen: ::c_uchar, ++ pub ifi_physical: ::c_uchar, ++ pub ifi_addrlen: ::c_uchar, ++ pub ifi_hdrlen: ::c_uchar, ++ pub ifi_recvquota: ::c_uchar, ++ pub ifi_xmitquota: ::c_uchar, ++ pub ifi_unused1: ::c_uchar, ++ pub ifi_mtu: u32, ++ pub ifi_metric: u32, ++ pub ifi_baudrate: u64, ++ pub ifi_ipackets: u64, ++ pub ifi_ierrors: u64, ++ pub ifi_opackets: u64, ++ pub ifi_oerrors: u64, ++ pub ifi_collisions: u64, ++ pub ifi_ibytes: u64, ++ pub ifi_obytes: u64, ++ pub ifi_imcasts: u64, ++ pub ifi_omcasts: u64, ++ pub ifi_iqdrops: u64, ++ pub ifi_noproto: u64, ++ pub ifi_recvtiming: u32, ++ pub ifi_xmittiming: u32, ++ #[cfg(any(target_arch = "arm", target_arch = "x86"))] ++ pub ifi_lastchange: ::timeval, ++ #[cfg(not(any(target_arch = "arm", target_arch = "x86")))] ++ pub ifi_lastchange: timeval32, ++ } ++ ++ #[cfg_attr(libc_packedN, repr(packed(4)))] ++ pub struct if_msghdr2 { ++ pub ifm_msglen: ::c_ushort, ++ pub ifm_version: ::c_uchar, ++ pub ifm_type: ::c_uchar, ++ pub ifm_addrs: ::c_int, ++ pub ifm_flags: ::c_int, ++ pub ifm_index: ::c_ushort, ++ pub ifm_snd_len: ::c_int, ++ pub ifm_snd_maxlen: ::c_int, ++ pub ifm_snd_drops: ::c_int, ++ pub ifm_timer: ::c_int, ++ pub ifm_data: if_data64, ++ } ++ ++ #[cfg_attr(libc_packedN, repr(packed(8)))] ++ pub struct vm_statistics64 { ++ pub free_count: natural_t, ++ pub active_count: natural_t, ++ pub inactive_count: natural_t, ++ pub wire_count: natural_t, ++ pub zero_fill_count: u64, ++ pub reactivations: u64, ++ pub pageins: u64, ++ pub pageouts: u64, ++ pub faults: u64, ++ pub cow_faults: u64, ++ pub lookups: u64, ++ pub hits: u64, ++ pub purges: u64, ++ pub purgeable_count: natural_t, ++ pub speculative_count: natural_t, ++ pub decompressions: u64, ++ pub compressions: u64, ++ pub swapins: u64, ++ pub swapouts: u64, ++ pub compressor_page_count: natural_t, ++ pub throttled_count: natural_t, ++ pub external_page_count: natural_t, ++ pub internal_page_count: natural_t, ++ pub total_uncompressed_pages_in_compressor: u64, ++ } ++ ++ #[cfg_attr(libc_packedN, repr(packed(4)))] ++ pub struct mach_task_basic_info { ++ pub virtual_size: mach_vm_size_t, ++ pub resident_size: mach_vm_size_t, ++ pub resident_size_max: mach_vm_size_t, ++ pub user_time: time_value_t, ++ pub system_time: time_value_t, ++ pub policy: ::policy_t, ++ pub suspend_count: integer_t, ++ } + } + + impl siginfo_t { +@@ -1754,6 +2061,406 @@ cfg_if! { + self.dispatch_qaddr.hash(state); + } + } ++ impl PartialEq for if_data64 { ++ fn eq(&self, other: &if_data64) -> bool { ++ self.ifi_type == other.ifi_type && ++ self.ifi_typelen == other.ifi_typelen && ++ self.ifi_physical == other.ifi_physical && ++ self.ifi_addrlen == other.ifi_addrlen && ++ self.ifi_hdrlen == other.ifi_hdrlen && ++ self.ifi_recvquota == other.ifi_recvquota && ++ self.ifi_xmitquota == other.ifi_xmitquota && ++ self.ifi_unused1 == other.ifi_unused1 && ++ self.ifi_mtu == other.ifi_mtu && ++ self.ifi_metric == other.ifi_metric && ++ self.ifi_baudrate == other.ifi_baudrate && ++ self.ifi_ipackets == other.ifi_ipackets && ++ self.ifi_ierrors == other.ifi_ierrors && ++ self.ifi_opackets == other.ifi_opackets && ++ self.ifi_oerrors == other.ifi_oerrors && ++ self.ifi_collisions == other.ifi_collisions && ++ self.ifi_ibytes == other.ifi_ibytes && ++ self.ifi_obytes == other.ifi_obytes && ++ self.ifi_imcasts == other.ifi_imcasts && ++ self.ifi_omcasts == other.ifi_omcasts && ++ self.ifi_iqdrops == other.ifi_iqdrops && ++ self.ifi_noproto == other.ifi_noproto && ++ self.ifi_recvtiming == other.ifi_recvtiming && ++ self.ifi_xmittiming == other.ifi_xmittiming && ++ self.ifi_lastchange == other.ifi_lastchange ++ } ++ } ++ impl Eq for if_data64 {} ++ impl ::fmt::Debug for if_data64 { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ let ifi_type = self.ifi_type; ++ let ifi_typelen = self.ifi_typelen; ++ let ifi_physical = self.ifi_physical; ++ let ifi_addrlen = self.ifi_addrlen; ++ let ifi_hdrlen = self.ifi_hdrlen; ++ let ifi_recvquota = self.ifi_recvquota; ++ let ifi_xmitquota = self.ifi_xmitquota; ++ let ifi_unused1 = self.ifi_unused1; ++ let ifi_mtu = self.ifi_mtu; ++ let ifi_metric = self.ifi_metric; ++ let ifi_baudrate = self.ifi_baudrate; ++ let ifi_ipackets = self.ifi_ipackets; ++ let ifi_ierrors = self.ifi_ierrors; ++ let ifi_opackets = self.ifi_opackets; ++ let ifi_oerrors = self.ifi_oerrors; ++ let ifi_collisions = self.ifi_collisions; ++ let ifi_ibytes = self.ifi_ibytes; ++ let ifi_obytes = self.ifi_obytes; ++ let ifi_imcasts = self.ifi_imcasts; ++ let ifi_omcasts = self.ifi_omcasts; ++ let ifi_iqdrops = self.ifi_iqdrops; ++ let ifi_noproto = self.ifi_noproto; ++ let ifi_recvtiming = self.ifi_recvtiming; ++ let ifi_xmittiming = self.ifi_xmittiming; ++ let ifi_lastchange = self.ifi_lastchange; ++ f.debug_struct("if_data64") ++ .field("ifi_type", &ifi_type) ++ .field("ifi_typelen", &ifi_typelen) ++ .field("ifi_physical", &ifi_physical) ++ .field("ifi_addrlen", &ifi_addrlen) ++ .field("ifi_hdrlen", &ifi_hdrlen) ++ .field("ifi_recvquota", &ifi_recvquota) ++ .field("ifi_xmitquota", &ifi_xmitquota) ++ .field("ifi_unused1", &ifi_unused1) ++ .field("ifi_mtu", &ifi_mtu) ++ .field("ifi_metric", &ifi_metric) ++ .field("ifi_baudrate", &ifi_baudrate) ++ .field("ifi_ipackets", &ifi_ipackets) ++ .field("ifi_ierrors", &ifi_ierrors) ++ .field("ifi_opackets", &ifi_opackets) ++ .field("ifi_oerrors", &ifi_oerrors) ++ .field("ifi_collisions", &ifi_collisions) ++ .field("ifi_ibytes", &ifi_ibytes) ++ .field("ifi_obytes", &ifi_obytes) ++ .field("ifi_imcasts", &ifi_imcasts) ++ .field("ifi_omcasts", &ifi_omcasts) ++ .field("ifi_iqdrops", &ifi_iqdrops) ++ .field("ifi_noproto", &ifi_noproto) ++ .field("ifi_recvtiming", &ifi_recvtiming) ++ .field("ifi_xmittiming", &ifi_xmittiming) ++ .field("ifi_lastchange", &ifi_lastchange) ++ .finish() ++ } ++ } ++ impl ::hash::Hash for if_data64 { ++ fn hash(&self, state: &mut H) { ++ let ifi_type = self.ifi_type; ++ let ifi_typelen = self.ifi_typelen; ++ let ifi_physical = self.ifi_physical; ++ let ifi_addrlen = self.ifi_addrlen; ++ let ifi_hdrlen = self.ifi_hdrlen; ++ let ifi_recvquota = self.ifi_recvquota; ++ let ifi_xmitquota = self.ifi_xmitquota; ++ let ifi_unused1 = self.ifi_unused1; ++ let ifi_mtu = self.ifi_mtu; ++ let ifi_metric = self.ifi_metric; ++ let ifi_baudrate = self.ifi_baudrate; ++ let ifi_ipackets = self.ifi_ipackets; ++ let ifi_ierrors = self.ifi_ierrors; ++ let ifi_opackets = self.ifi_opackets; ++ let ifi_oerrors = self.ifi_oerrors; ++ let ifi_collisions = self.ifi_collisions; ++ let ifi_ibytes = self.ifi_ibytes; ++ let ifi_obytes = self.ifi_obytes; ++ let ifi_imcasts = self.ifi_imcasts; ++ let ifi_omcasts = self.ifi_omcasts; ++ let ifi_iqdrops = self.ifi_iqdrops; ++ let ifi_noproto = self.ifi_noproto; ++ let ifi_recvtiming = self.ifi_recvtiming; ++ let ifi_xmittiming = self.ifi_xmittiming; ++ let ifi_lastchange = self.ifi_lastchange; ++ ifi_type.hash(state); ++ ifi_typelen.hash(state); ++ ifi_physical.hash(state); ++ ifi_addrlen.hash(state); ++ ifi_hdrlen.hash(state); ++ ifi_recvquota.hash(state); ++ ifi_xmitquota.hash(state); ++ ifi_unused1.hash(state); ++ ifi_mtu.hash(state); ++ ifi_metric.hash(state); ++ ifi_baudrate.hash(state); ++ ifi_ipackets.hash(state); ++ ifi_ierrors.hash(state); ++ ifi_opackets.hash(state); ++ ifi_oerrors.hash(state); ++ ifi_collisions.hash(state); ++ ifi_ibytes.hash(state); ++ ifi_obytes.hash(state); ++ ifi_imcasts.hash(state); ++ ifi_omcasts.hash(state); ++ ifi_iqdrops.hash(state); ++ ifi_noproto.hash(state); ++ ifi_recvtiming.hash(state); ++ ifi_xmittiming.hash(state); ++ ifi_lastchange.hash(state); ++ } ++ } ++ impl PartialEq for if_msghdr2 { ++ fn eq(&self, other: &if_msghdr2) -> bool { ++ self.ifm_msglen == other.ifm_msglen && ++ self.ifm_version == other.ifm_version && ++ self.ifm_type == other.ifm_type && ++ self.ifm_addrs == other.ifm_addrs && ++ self.ifm_flags == other.ifm_flags && ++ self.ifm_index == other.ifm_index && ++ self.ifm_snd_len == other.ifm_snd_len && ++ self.ifm_snd_maxlen == other.ifm_snd_maxlen && ++ self.ifm_snd_drops == other.ifm_snd_drops && ++ self.ifm_timer == other.ifm_timer && ++ self.ifm_data == other.ifm_data ++ } ++ } ++ impl Eq for if_msghdr2 {} ++ impl ::fmt::Debug for if_msghdr2 { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ let ifm_msglen = self.ifm_msglen; ++ let ifm_version = self.ifm_version; ++ let ifm_type = self.ifm_type; ++ let ifm_addrs = self.ifm_addrs; ++ let ifm_flags = self.ifm_flags; ++ let ifm_index = self.ifm_index; ++ let ifm_snd_len = self.ifm_snd_len; ++ let ifm_snd_maxlen = self.ifm_snd_maxlen; ++ let ifm_snd_drops = self.ifm_snd_drops; ++ let ifm_timer = self.ifm_timer; ++ let ifm_data = self.ifm_data; ++ f.debug_struct("if_msghdr2") ++ .field("ifm_msglen", &ifm_msglen) ++ .field("ifm_version", &ifm_version) ++ .field("ifm_type", &ifm_type) ++ .field("ifm_addrs", &ifm_addrs) ++ .field("ifm_flags", &ifm_flags) ++ .field("ifm_index", &ifm_index) ++ .field("ifm_snd_len", &ifm_snd_len) ++ .field("ifm_snd_maxlen", &ifm_snd_maxlen) ++ .field("ifm_snd_drops", &ifm_snd_drops) ++ .field("ifm_timer", &ifm_timer) ++ .field("ifm_data", &ifm_data) ++ .finish() ++ } ++ } ++ impl ::hash::Hash for if_msghdr2 { ++ fn hash(&self, state: &mut H) { ++ let ifm_msglen = self.ifm_msglen; ++ let ifm_version = self.ifm_version; ++ let ifm_type = self.ifm_type; ++ let ifm_addrs = self.ifm_addrs; ++ let ifm_flags = self.ifm_flags; ++ let ifm_index = self.ifm_index; ++ let ifm_snd_len = self.ifm_snd_len; ++ let ifm_snd_maxlen = self.ifm_snd_maxlen; ++ let ifm_snd_drops = self.ifm_snd_drops; ++ let ifm_timer = self.ifm_timer; ++ let ifm_data = self.ifm_data; ++ ifm_msglen.hash(state); ++ ifm_version.hash(state); ++ ifm_type.hash(state); ++ ifm_addrs.hash(state); ++ ifm_flags.hash(state); ++ ifm_index.hash(state); ++ ifm_snd_len.hash(state); ++ ifm_snd_maxlen.hash(state); ++ ifm_snd_drops.hash(state); ++ ifm_timer.hash(state); ++ ifm_data.hash(state); ++ } ++ } ++ impl PartialEq for vm_statistics64 { ++ fn eq(&self, other: &vm_statistics64) -> bool { ++ // Otherwise rustfmt crashes... ++ let total_uncompressed = self.total_uncompressed_pages_in_compressor; ++ self.free_count == other.free_count && ++ self.active_count == other.active_count && ++ self.inactive_count == other.inactive_count && ++ self.wire_count == other.wire_count && ++ self.zero_fill_count == other.zero_fill_count && ++ self.reactivations == other.reactivations && ++ self.pageins == other.pageins && ++ self.pageouts == other.pageouts && ++ self.faults == other.faults && ++ self.cow_faults == other.cow_faults && ++ self.lookups == other.lookups && ++ self.hits == other.hits && ++ self.purges == other.purges && ++ self.purgeable_count == other.purgeable_count && ++ self.speculative_count == other.speculative_count && ++ self.decompressions == other.decompressions && ++ self.compressions == other.compressions && ++ self.swapins == other.swapins && ++ self.swapouts == other.swapouts && ++ self.compressor_page_count == other.compressor_page_count && ++ self.throttled_count == other.throttled_count && ++ self.external_page_count == other.external_page_count && ++ self.internal_page_count == other.internal_page_count && ++ total_uncompressed == other.total_uncompressed_pages_in_compressor ++ } ++ } ++ impl Eq for vm_statistics64 {} ++ impl ::fmt::Debug for vm_statistics64 { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ let free_count = self.free_count; ++ let active_count = self.active_count; ++ let inactive_count = self.inactive_count; ++ let wire_count = self.wire_count; ++ let zero_fill_count = self.zero_fill_count; ++ let reactivations = self.reactivations; ++ let pageins = self.pageins; ++ let pageouts = self.pageouts; ++ let faults = self.faults; ++ let cow_faults = self.cow_faults; ++ let lookups = self.lookups; ++ let hits = self.hits; ++ let purges = self.purges; ++ let purgeable_count = self.purgeable_count; ++ let speculative_count = self.speculative_count; ++ let decompressions = self.decompressions; ++ let compressions = self.compressions; ++ let swapins = self.swapins; ++ let swapouts = self.swapouts; ++ let compressor_page_count = self.compressor_page_count; ++ let throttled_count = self.throttled_count; ++ let external_page_count = self.external_page_count; ++ let internal_page_count = self.internal_page_count; ++ // Otherwise rustfmt crashes... ++ let total_uncompressed = self.total_uncompressed_pages_in_compressor; ++ f.debug_struct("vm_statistics64") ++ .field("free_count", &free_count) ++ .field("active_count", &active_count) ++ .field("inactive_count", &inactive_count) ++ .field("wire_count", &wire_count) ++ .field("zero_fill_count", &zero_fill_count) ++ .field("reactivations", &reactivations) ++ .field("pageins", &pageins) ++ .field("pageouts", &pageouts) ++ .field("faults", &faults) ++ .field("cow_faults", &cow_faults) ++ .field("lookups", &lookups) ++ .field("hits", &hits) ++ .field("purges", &purges) ++ .field("purgeable_count", &purgeable_count) ++ .field("speculative_count", &speculative_count) ++ .field("decompressions", &decompressions) ++ .field("compressions", &compressions) ++ .field("swapins", &swapins) ++ .field("swapouts", &swapouts) ++ .field("compressor_page_count", &compressor_page_count) ++ .field("throttled_count", &throttled_count) ++ .field("external_page_count", &external_page_count) ++ .field("internal_page_count", &internal_page_count) ++ .field("total_uncompressed_pages_in_compressor", &total_uncompressed) ++ .finish() ++ } ++ } ++ impl ::hash::Hash for vm_statistics64 { ++ fn hash(&self, state: &mut H) { ++ let free_count = self.free_count; ++ let active_count = self.active_count; ++ let inactive_count = self.inactive_count; ++ let wire_count = self.wire_count; ++ let zero_fill_count = self.zero_fill_count; ++ let reactivations = self.reactivations; ++ let pageins = self.pageins; ++ let pageouts = self.pageouts; ++ let faults = self.faults; ++ let cow_faults = self.cow_faults; ++ let lookups = self.lookups; ++ let hits = self.hits; ++ let purges = self.purges; ++ let purgeable_count = self.purgeable_count; ++ let speculative_count = self.speculative_count; ++ let decompressions = self.decompressions; ++ let compressions = self.compressions; ++ let swapins = self.swapins; ++ let swapouts = self.swapouts; ++ let compressor_page_count = self.compressor_page_count; ++ let throttled_count = self.throttled_count; ++ let external_page_count = self.external_page_count; ++ let internal_page_count = self.internal_page_count; ++ // Otherwise rustfmt crashes... ++ let total_uncompressed = self.total_uncompressed_pages_in_compressor; ++ free_count.hash(state); ++ active_count.hash(state); ++ inactive_count.hash(state); ++ wire_count.hash(state); ++ zero_fill_count.hash(state); ++ reactivations.hash(state); ++ pageins.hash(state); ++ pageouts.hash(state); ++ faults.hash(state); ++ cow_faults.hash(state); ++ lookups.hash(state); ++ hits.hash(state); ++ purges.hash(state); ++ purgeable_count.hash(state); ++ speculative_count.hash(state); ++ decompressions.hash(state); ++ compressions.hash(state); ++ swapins.hash(state); ++ swapouts.hash(state); ++ compressor_page_count.hash(state); ++ throttled_count.hash(state); ++ external_page_count.hash(state); ++ internal_page_count.hash(state); ++ total_uncompressed.hash(state); ++ } ++ } ++ ++ impl PartialEq for mach_task_basic_info { ++ fn eq(&self, other: &mach_task_basic_info) -> bool { ++ self.virtual_size == other.virtual_size ++ && self.resident_size == other.resident_size ++ && self.resident_size_max == other.resident_size_max ++ && self.user_time == other.user_time ++ && self.system_time == other.system_time ++ && self.policy == other.policy ++ && self.suspend_count == other.suspend_count ++ } ++ } ++ impl Eq for mach_task_basic_info {} ++ impl ::fmt::Debug for mach_task_basic_info { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ let virtual_size = self.virtual_size; ++ let resident_size = self.resident_size; ++ let resident_size_max = self.resident_size_max; ++ let user_time = self.user_time; ++ let system_time = self.system_time; ++ let policy = self.policy; ++ let suspend_count = self.suspend_count; ++ f.debug_struct("mach_task_basic_info") ++ .field("virtual_size", &virtual_size) ++ .field("resident_size", &resident_size) ++ .field("resident_size_max", &resident_size_max) ++ .field("user_time", &user_time) ++ .field("system_time", &system_time) ++ .field("policy", &policy) ++ .field("suspend_count", &suspend_count) ++ .finish() ++ } ++ } ++ impl ::hash::Hash for mach_task_basic_info { ++ fn hash(&self, state: &mut H) { ++ let virtual_size = self.virtual_size; ++ let resident_size = self.resident_size; ++ let resident_size_max = self.resident_size_max; ++ let user_time = self.user_time; ++ let system_time = self.system_time; ++ let policy = self.policy; ++ let suspend_count = self.suspend_count; ++ virtual_size.hash(state); ++ resident_size.hash(state); ++ resident_size_max.hash(state); ++ user_time.hash(state); ++ system_time.hash(state); ++ policy.hash(state); ++ suspend_count.hash(state); ++ } ++ } + } + } + +@@ -3021,6 +3728,10 @@ pub const FD_SETSIZE: usize = 1024; + + pub const ST_NOSUID: ::c_ulong = 2; + ++pub const SCHED_OTHER: ::c_int = 1; ++pub const SCHED_FIFO: ::c_int = 4; ++pub const SCHED_RR: ::c_int = 2; ++ + pub const EVFILT_READ: i16 = -1; + pub const EVFILT_WRITE: i16 = -2; + pub const EVFILT_AIO: i16 = -3; +@@ -3795,6 +4506,40 @@ pub const kCCCallSequenceError: i32 = -4309; + pub const kCCKeySizeError: i32 = -4310; + pub const kCCInvalidKey: i32 = -4311; + ++// mach/host_info.h ++pub const HOST_LOAD_INFO: i32 = 1; ++pub const HOST_VM_INFO: i32 = 2; ++pub const HOST_CPU_LOAD_INFO: i32 = 3; ++pub const HOST_VM_INFO64: i32 = 4; ++pub const HOST_EXTMOD_INFO64: i32 = 5; ++pub const HOST_EXPIRED_TASK_INFO: i32 = 6; ++ ++// mach/vm_statistics.h ++pub const VM_PAGE_QUERY_PAGE_PRESENT: i32 = 0x1; ++pub const VM_PAGE_QUERY_PAGE_FICTITIOUS: i32 = 0x2; ++pub const VM_PAGE_QUERY_PAGE_REF: i32 = 0x4; ++pub const VM_PAGE_QUERY_PAGE_DIRTY: i32 = 0x8; ++pub const VM_PAGE_QUERY_PAGE_PAGED_OUT: i32 = 0x10; ++pub const VM_PAGE_QUERY_PAGE_COPIED: i32 = 0x20; ++pub const VM_PAGE_QUERY_PAGE_SPECULATIVE: i32 = 0x40; ++pub const VM_PAGE_QUERY_PAGE_EXTERNAL: i32 = 0x80; ++pub const VM_PAGE_QUERY_PAGE_CS_VALIDATED: i32 = 0x100; ++pub const VM_PAGE_QUERY_PAGE_CS_TAINTED: i32 = 0x200; ++pub const VM_PAGE_QUERY_PAGE_CS_NX: i32 = 0x400; ++ ++// mach/task_info.h ++pub const TASK_THREAD_TIMES_INFO: u32 = 3; ++pub const HOST_CPU_LOAD_INFO_COUNT: u32 = 4; ++pub const MACH_TASK_BASIC_INFO: u32 = 20; ++ ++pub const MACH_PORT_NULL: i32 = 0; ++ ++pub const RUSAGE_INFO_V0: ::c_int = 0; ++pub const RUSAGE_INFO_V1: ::c_int = 1; ++pub const RUSAGE_INFO_V2: ::c_int = 2; ++pub const RUSAGE_INFO_V3: ::c_int = 3; ++pub const RUSAGE_INFO_V4: ::c_int = 4; ++ + cfg_if! { + if #[cfg(libc_const_extern_fn)] { + const fn __DARWIN_ALIGN32(p: usize) -> usize { +@@ -3836,6 +4581,15 @@ cfg_if! { + pub const THREAD_EXTENDED_INFO_COUNT: mach_msg_type_number_t = + (::mem::size_of::() / ::mem::size_of::()) + as mach_msg_type_number_t; ++ ++ pub const TASK_THREAD_TIMES_INFO_COUNT: u32 = ++ (::mem::size_of::() ++ / ::mem::size_of::()) as u32; ++ pub const MACH_TASK_BASIC_INFO_COUNT: u32 = (::mem::size_of::() ++ / ::mem::size_of::()) as u32; ++ pub const HOST_VM_INFO64_COUNT: mach_msg_type_number_t = ++ (::mem::size_of::() / ::mem::size_of::()) ++ as mach_msg_type_number_t; + } else { + fn __DARWIN_ALIGN32(p: usize) -> usize { + let __DARWIN_ALIGNBYTES32: usize = ::mem::size_of::() - 1; +@@ -3851,6 +4605,9 @@ cfg_if! { + pub const THREAD_BASIC_INFO_COUNT: mach_msg_type_number_t = 10; + pub const THREAD_IDENTIFIER_INFO_COUNT: mach_msg_type_number_t = 6; + pub const THREAD_EXTENDED_INFO_COUNT: mach_msg_type_number_t = 28; ++ pub const TASK_THREAD_TIMES_INFO_COUNT: u32 = 4; ++ pub const MACH_TASK_BASIC_INFO_COUNT: u32 = 12; ++ pub const HOST_VM_INFO64_COUNT: mach_msg_type_number_t = 38; + } + } + +@@ -4454,6 +5211,7 @@ extern "C" { + ) -> ::c_int; + pub fn proc_kmsgbuf(buffer: *mut ::c_void, buffersize: u32) -> ::c_int; + pub fn proc_libversion(major: *mut ::c_int, mintor: *mut ::c_int) -> ::c_int; ++ pub fn proc_pid_rusage(pid: ::c_int, flavor: ::c_int, buffer: *mut rusage_info_t) -> ::c_int; + /// # Notes + /// + /// `id` is of type [`uuid_t`]. +@@ -4480,6 +5238,58 @@ extern "C" { + max_protection: ::vm_prot_t, + inheritance: ::vm_inherit_t, + ) -> ::kern_return_t; ++ ++ pub fn vm_deallocate( ++ target_task: vm_map_t, ++ address: vm_address_t, ++ size: vm_size_t, ++ ) -> ::kern_return_t; ++ ++ pub fn host_statistics64( ++ host_priv: host_t, ++ flavor: host_flavor_t, ++ host_info64_out: host_info64_t, ++ host_info64_outCnt: *mut mach_msg_type_number_t, ++ ) -> ::kern_return_t; ++ pub fn host_processor_info( ++ host: host_t, ++ flavor: processor_flavor_t, ++ out_processor_count: *mut natural_t, ++ out_processor_info: *mut processor_info_array_t, ++ out_processor_infoCnt: *mut mach_msg_type_number_t, ++ ) -> ::kern_return_t; ++ ++ pub static mut mach_task_self_: mach_port_t; ++ pub fn task_for_pid(host: mach_port_t, pid: ::pid_t, task: *mut mach_port_t) ++ -> ::kern_return_t; ++ pub fn task_info( ++ host: mach_port_t, ++ flavor: task_flavor_t, ++ task_info_out: task_info_t, ++ task_info_count: *mut mach_msg_type_number_t, ++ ) -> ::kern_return_t; ++ pub fn host_statistics( ++ host_priv: host_t, ++ flavor: host_flavor_t, ++ host_info_out: host_info_t, ++ host_info_outCnt: *mut mach_msg_type_number_t, ++ ) -> ::kern_return_t; ++ ++ // sysdir.h ++ pub fn sysdir_start_search_path_enumeration( ++ dir: sysdir_search_path_directory_t, ++ domainMask: sysdir_search_path_domain_mask_t, ++ ) -> ::sysdir_search_path_enumeration_state; ++ pub fn sysdir_get_next_search_path_enumeration( ++ state: ::sysdir_search_path_enumeration_state, ++ path: *mut ::c_char, ++ ) -> ::sysdir_search_path_enumeration_state; ++ ++ pub static vm_page_size: vm_size_t; ++} ++ ++pub unsafe fn mach_task_self() -> mach_port_t { ++ mach_task_self_ + } + + cfg_if! { +diff --git a/vendor/libc/src/unix/bsd/freebsdlike/dragonfly/mod.rs b/vendor/libc/src/unix/bsd/freebsdlike/dragonfly/mod.rs +index ecc9662..4b99038 100644 +--- a/vendor/libc/src/unix/bsd/freebsdlike/dragonfly/mod.rs ++++ b/vendor/libc/src/unix/bsd/freebsdlike/dragonfly/mod.rs +@@ -584,8 +584,9 @@ cfg_if! { + self.mc_ss == other.mc_ss && + self.mc_len == other.mc_len && + self.mc_fpformat == other.mc_fpformat && +- self.mc_ownedfp == other.mc_ownedfp +- // FIXME: self.mc_fpregs == other.mc_fpregs ++ self.mc_ownedfp == other.mc_ownedfp && ++ self.mc_fpregs.iter().zip(other.mc_fpregs.iter()). ++ all(|(a, b)| a == b) + } + } + impl Eq for mcontext_t {} +@@ -621,10 +622,46 @@ cfg_if! { + .field("mc_len", &self.mc_len) + .field("mc_fpformat", &self.mc_fpformat) + .field("mc_ownedfp", &self.mc_ownedfp) +- // FIXME: .field("mc_fpregs", &self.mc_fpregs) ++ .field("mc_fpregs", &self.mc_fpregs) + .finish() + } + } ++ impl ::hash::Hash for mcontext_t { ++ fn hash(&self, state: &mut H) { ++ self.mc_onstack.hash(state); ++ self.mc_rdi.hash(state); ++ self.mc_rsi.hash(state); ++ self.mc_rdx.hash(state); ++ self.mc_rcx.hash(state); ++ self.mc_r8.hash(state); ++ self.mc_r9.hash(state); ++ self.mc_rax.hash(state); ++ self.mc_rbx.hash(state); ++ self.mc_rbp.hash(state); ++ self.mc_r10.hash(state); ++ self.mc_r11.hash(state); ++ self.mc_r10.hash(state); ++ self.mc_r11.hash(state); ++ self.mc_r12.hash(state); ++ self.mc_r13.hash(state); ++ self.mc_r14.hash(state); ++ self.mc_r15.hash(state); ++ self.mc_xflags.hash(state); ++ self.mc_trapno.hash(state); ++ self.mc_addr.hash(state); ++ self.mc_flags.hash(state); ++ self.mc_err.hash(state); ++ self.mc_rip.hash(state); ++ self.mc_cs.hash(state); ++ self.mc_rflags.hash(state); ++ self.mc_rsp.hash(state); ++ self.mc_ss.hash(state); ++ self.mc_len.hash(state); ++ self.mc_fpformat.hash(state); ++ self.mc_ownedfp.hash(state); ++ self.mc_fpregs.hash(state); ++ } ++ } + impl PartialEq for ucontext_t { + fn eq(&self, other: &ucontext_t) -> bool { + self.uc_sigmask == other.uc_sigmask +@@ -648,6 +685,16 @@ cfg_if! { + .finish() + } + } ++ impl ::hash::Hash for ucontext_t { ++ fn hash(&self, state: &mut H) { ++ self.uc_sigmask.hash(state); ++ self.uc_mcontext.hash(state); ++ self.uc_link.hash(state); ++ self.uc_stack.hash(state); ++ self.uc_cofunc.hash(state); ++ self.uc_arg.hash(state); ++ } ++ } + } + } + +@@ -1288,7 +1335,7 @@ f! { + () + } + +- pub fn CPU_ISSET(cpu: usize, cpuset: &mut cpu_set_t) -> bool { ++ pub fn CPU_ISSET(cpu: usize, cpuset: &cpu_set_t) -> bool { + let (idx, offset) = ((cpu >> 6) & 3, cpu & 63); + 0 != cpuset.ary[idx] & (1 << offset) + } +@@ -1343,6 +1390,7 @@ extern "C" { + pub fn sched_getaffinity(pid: ::pid_t, cpusetsize: ::size_t, mask: *mut cpu_set_t) -> ::c_int; + pub fn sched_setaffinity(pid: ::pid_t, cpusetsize: ::size_t, mask: *const cpu_set_t) + -> ::c_int; ++ pub fn sched_getcpu() -> ::c_int; + pub fn setproctitle(fmt: *const ::c_char, ...); + + pub fn shmget(key: ::key_t, size: ::size_t, shmflg: ::c_int) -> ::c_int; +@@ -1377,6 +1425,9 @@ extern "C" { + nitems: ::c_int, + sevp: *mut sigevent, + ) -> ::c_int; ++ ++ pub fn reallocf(ptr: *mut ::c_void, size: ::size_t) -> *mut ::c_void; ++ pub fn freezero(ptr: *mut ::c_void, size: ::size_t); + } + + cfg_if! { +diff --git a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd11/mod.rs b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd11/mod.rs +index a0b5105..863de94 100644 +--- a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd11/mod.rs ++++ b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd11/mod.rs +@@ -191,6 +191,7 @@ cfg_if! { + + pub const ELAST: ::c_int = 96; + pub const RAND_MAX: ::c_int = 0x7fff_fffd; ++pub const KI_NSPARE_PTR: usize = 6; + + extern "C" { + // Return type ::c_int was removed in FreeBSD 12 +diff --git a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd12/mod.rs b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd12/mod.rs +index 601f33d..05cadd1 100644 +--- a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd12/mod.rs ++++ b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd12/mod.rs +@@ -205,6 +205,8 @@ pub const RAND_MAX: ::c_int = 0x7fff_fffd; + pub const PROC_ASLR_CTL: ::c_int = 13; + pub const PROC_ASLR_STATUS: ::c_int = 14; + ++pub const PROC_PROCCTL_MD_MIN: ::c_int = 0x10000000; ++ + pub const SO_DOMAIN: ::c_int = 0x1019; + + pub const EINTEGRITY: ::c_int = 97; +@@ -244,3 +246,10 @@ cfg_if! { + pub use self::b64::*; + } + } ++ ++cfg_if! { ++ if #[cfg(target_arch = "x86_64")] { ++ mod x86_64; ++ pub use self::x86_64::*; ++ } ++} +diff --git a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd12/x86_64.rs b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd12/x86_64.rs +new file mode 100644 +index 0000000..7bf2534 +--- /dev/null ++++ b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd12/x86_64.rs +@@ -0,0 +1,5 @@ ++pub const PROC_KPTI_CTL: ::c_int = ::PROC_PROCCTL_MD_MIN; ++pub const PROC_KPTI_CTL_ENABLE_ON_EXEC: ::c_int = 1; ++pub const PROC_KPTI_CTL_DISABLE_ON_EXEC: ::c_int = 2; ++pub const PROC_KPTI_STATUS: ::c_int = ::PROC_PROCCTL_MD_MIN + 1; ++pub const PROC_KPTI_STATUS_ACTIVE: ::c_int = 0x80000000; +diff --git a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/mod.rs b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/mod.rs +index 65c377d..93ef2a2 100644 +--- a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/mod.rs ++++ b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/mod.rs +@@ -223,6 +223,7 @@ pub const PROC_ASLR_CTL: ::c_int = 13; + pub const PROC_ASLR_STATUS: ::c_int = 14; + pub const PROC_PROTMAX_CTL: ::c_int = 15; + pub const PROC_PROTMAX_STATUS: ::c_int = 16; ++pub const PROC_PROCCTL_MD_MIN: ::c_int = 0x10000000; + + pub const LOCAL_CREDS_PERSISTENT: ::c_int = 3; + pub const SCM_CREDS2: ::c_int = 0x08; +@@ -275,3 +276,10 @@ cfg_if! { + pub use self::b64::*; + } + } ++ ++cfg_if! { ++ if #[cfg(target_arch = "x86_64")] { ++ mod x86_64; ++ pub use self::x86_64::*; ++ } ++} +diff --git a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/x86_64.rs b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/x86_64.rs +new file mode 100644 +index 0000000..7bf2534 +--- /dev/null ++++ b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/x86_64.rs +@@ -0,0 +1,5 @@ ++pub const PROC_KPTI_CTL: ::c_int = ::PROC_PROCCTL_MD_MIN; ++pub const PROC_KPTI_CTL_ENABLE_ON_EXEC: ::c_int = 1; ++pub const PROC_KPTI_CTL_DISABLE_ON_EXEC: ::c_int = 2; ++pub const PROC_KPTI_STATUS: ::c_int = ::PROC_PROCCTL_MD_MIN + 1; ++pub const PROC_KPTI_STATUS_ACTIVE: ::c_int = 0x80000000; +diff --git a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/mod.rs b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/mod.rs +index 99a7f2d..cc22a01 100644 +--- a/vendor/libc/src/unix/bsd/freebsdlike/freebsd/mod.rs ++++ b/vendor/libc/src/unix/bsd/freebsdlike/freebsd/mod.rs +@@ -5,6 +5,7 @@ pub type lwpid_t = i32; + pub type blksize_t = i32; + pub type clockid_t = ::c_int; + pub type sem_t = _sem; ++pub type timer_t = *mut __c_anonymous__timer; + + pub type fsblkcnt_t = u64; + pub type fsfilcnt_t = u64; +@@ -24,6 +25,8 @@ pub type pthread_spinlock_t = *mut __c_anonymous_pthread_spinlock; + pub type pthread_barrierattr_t = *mut __c_anonymous_pthread_barrierattr; + pub type pthread_barrier_t = *mut __c_anonymous_pthread_barrier; + ++pub type uuid_t = ::uuid; ++ + s! { + pub struct aiocb { + pub aio_fildes: ::c_int, +@@ -152,6 +155,15 @@ s! { + c_spare: [u32; 1], + } + ++ pub struct uuid { ++ pub time_low: u32, ++ pub time_mid: u16, ++ pub time_hi_and_version: u16, ++ pub clock_seq_hi_and_reserved: u8, ++ pub clock_seq_low: u8, ++ pub node: [u8; _UUID_NODE_LEN], ++ } ++ + pub struct __c_anonymous_pthread_spinlock { + s_clock: umutex, + } +@@ -238,6 +250,15 @@ s! { + envv: *mut ::c_void, + core: ::uintptr_t, + } ++ ++ pub struct itimerspec { ++ pub it_interval: ::timespec, ++ pub it_value: ::timespec, ++ } ++ ++ pub struct __c_anonymous__timer { ++ _priv: [::c_int; 3], ++ } + } + + s_no_extra_traits! { +@@ -624,6 +645,7 @@ pub const Q_SETQUOTA: ::c_int = 0x800; + + pub const MAP_GUARD: ::c_int = 0x00002000; + pub const MAP_EXCL: ::c_int = 0x00004000; ++pub const MAP_PREFAULT_READ: ::c_int = 0x00040000; + pub const MAP_ALIGNED_SUPER: ::c_int = 1 << 24; + + pub const POSIX_FADV_NORMAL: ::c_int = 0; +@@ -1382,6 +1404,8 @@ pub const _PC_ACL_NFS4: ::c_int = 64; + + pub const _SC_CPUSET_SIZE: ::c_int = 122; + ++pub const _UUID_NODE_LEN: usize = 6; ++ + // Flags which can be passed to pdfork(2) + pub const PD_DAEMON: ::c_int = 0x00000001; + pub const PD_CLOEXEC: ::c_int = 0x00000002; +@@ -1527,7 +1551,7 @@ f! { + () + } + +- pub fn CPU_ISSET(cpu: usize, cpuset: &mut cpuset_t) -> bool { ++ pub fn CPU_ISSET(cpu: usize, cpuset: &cpuset_t) -> bool { + let bitset_bits = ::mem::size_of::<::c_long>(); + let (idx, offset) = (cpu / bitset_bits, cpu % bitset_bits); + 0 != cpuset.__bits[idx] & (1 << offset) +@@ -1765,6 +1789,8 @@ extern "C" { + newfd: ::c_int, + ) -> ::c_int; + ++ pub fn uuidgen(store: *mut uuid, count: ::c_int) -> ::c_int; ++ + pub fn pthread_getthreadid_np() -> ::c_int; + pub fn pthread_getaffinity_np( + td: ::pthread_t, +@@ -1910,6 +1936,16 @@ extern "C" { + pub fn kld_load(name: *const ::c_char) -> ::c_int; + + pub fn kinfo_getvmmap(pid: ::pid_t, cntp: *mut ::c_int) -> *mut kinfo_vmentry; ++ ++ pub fn hexdump(ptr: *const ::c_void, length: ::c_int, hdr: *const ::c_char, flags: ::c_int); ++ pub fn humanize_number( ++ buf: *mut ::c_char, ++ len: ::size_t, ++ number: i64, ++ suffix: *const ::c_char, ++ scale: ::c_int, ++ flags: ::c_int, ++ ) -> ::c_int; + } + + #[link(name = "procstat")] +@@ -1937,6 +1973,20 @@ extern "C" { + pub fn procstat_close(procstat: *mut procstat); + } + ++#[link(name = "rt")] ++extern "C" { ++ pub fn timer_create(clock_id: clockid_t, evp: *mut sigevent, timerid: *mut timer_t) -> ::c_int; ++ pub fn timer_delete(timerid: timer_t) -> ::c_int; ++ pub fn timer_getoverrun(timerid: timer_t) -> ::c_int; ++ pub fn timer_gettime(timerid: timer_t, value: *mut itimerspec) -> ::c_int; ++ pub fn timer_settime( ++ timerid: timer_t, ++ flags: ::c_int, ++ value: *const itimerspec, ++ ovalue: *mut itimerspec, ++ ) -> ::c_int; ++} ++ + cfg_if! { + if #[cfg(freebsd13)] { + mod freebsd13; +diff --git a/vendor/libc/src/unix/bsd/freebsdlike/mod.rs b/vendor/libc/src/unix/bsd/freebsdlike/mod.rs +index f749039..da38f1a 100644 +--- a/vendor/libc/src/unix/bsd/freebsdlike/mod.rs ++++ b/vendor/libc/src/unix/bsd/freebsdlike/mod.rs +@@ -986,10 +986,16 @@ pub const LOCK_UN: ::c_int = 8; + + pub const MAP_COPY: ::c_int = 0x0002; + #[doc(hidden)] +-#[deprecated(since = "0.2.54", note = "Removed in FreeBSD 11")] ++#[deprecated( ++ since = "0.2.54", ++ note = "Removed in FreeBSD 11, unused in DragonFlyBSD" ++)] + pub const MAP_RENAME: ::c_int = 0x0020; + #[doc(hidden)] +-#[deprecated(since = "0.2.54", note = "Removed in FreeBSD 11")] ++#[deprecated( ++ since = "0.2.54", ++ note = "Removed in FreeBSD 11, unused in DragonFlyBSD" ++)] + pub const MAP_NORESERVE: ::c_int = 0x0040; + pub const MAP_HASSEMAPHORE: ::c_int = 0x0200; + pub const MAP_STACK: ::c_int = 0x0400; +@@ -1424,6 +1430,8 @@ extern "C" { + pub fn clock_settime(clk_id: ::clockid_t, tp: *const ::timespec) -> ::c_int; + pub fn clock_getcpuclockid(pid: ::pid_t, clk_id: *mut ::clockid_t) -> ::c_int; + ++ pub fn pthread_getcpuclockid(thread: ::pthread_t, clk_id: *mut ::clockid_t) -> ::c_int; ++ + pub fn dirfd(dirp: *mut ::DIR) -> ::c_int; + pub fn duplocale(base: ::locale_t) -> ::locale_t; + pub fn endutxent(); +@@ -1557,8 +1565,10 @@ extern "C" { + ) -> ::c_int; + pub fn pthread_barrier_destroy(barrier: *mut pthread_barrier_t) -> ::c_int; + pub fn pthread_barrier_wait(barrier: *mut pthread_barrier_t) -> ::c_int; ++ pub fn pthread_get_name_np(tid: ::pthread_t, name: *mut ::c_char, len: ::size_t); + pub fn pthread_set_name_np(tid: ::pthread_t, name: *const ::c_char); + pub fn ptrace(request: ::c_int, pid: ::pid_t, addr: *mut ::c_char, data: ::c_int) -> ::c_int; ++ pub fn utrace(addr: *const ::c_void, len: ::size_t) -> ::c_int; + pub fn pututxline(ut: *const utmpx) -> *mut utmpx; + pub fn pwritev(fd: ::c_int, iov: *const ::iovec, iovcnt: ::c_int, offset: ::off_t) + -> ::ssize_t; +diff --git a/vendor/libc/src/unix/bsd/netbsdlike/netbsd/aarch64.rs b/vendor/libc/src/unix/bsd/netbsdlike/netbsd/aarch64.rs +index 58c4cf7..7b895f6 100644 +--- a/vendor/libc/src/unix/bsd/netbsdlike/netbsd/aarch64.rs ++++ b/vendor/libc/src/unix/bsd/netbsdlike/netbsd/aarch64.rs +@@ -3,8 +3,89 @@ use PT_FIRSTMACH; + pub type c_long = i64; + pub type c_ulong = u64; + pub type c_char = u8; ++pub type greg_t = u64; + pub type __cpu_simple_lock_nv_t = ::c_uchar; + ++s! { ++ pub struct __fregset { ++ #[cfg(libc_union)] ++ pub __qregs: [__c_anonymous__freg; 32], ++ pub __fpcr: u32, ++ pub __fpsr: u32, ++ } ++ ++ pub struct mcontext_t { ++ pub __gregs: [::greg_t; 32], ++ pub __fregs: __fregset, ++ __spare: [::greg_t; 8], ++ } ++ ++ pub struct ucontext_t { ++ pub uc_flags: ::c_uint, ++ pub uc_link: *mut ucontext_t, ++ pub uc_sigmask: ::sigset_t, ++ pub uc_stack: ::stack_t, ++ pub uc_mcontext: mcontext_t, ++ } ++} ++ ++s_no_extra_traits! { ++ #[cfg(libc_union)] ++ #[repr(align(16))] ++ pub union __c_anonymous__freg { ++ pub __b8: [u8; 16], ++ pub __h16: [u16; 8], ++ pub __s32: [u32; 4], ++ pub __d64: [u64; 2], ++ pub __q128: [u128; 1], ++ } ++} ++ ++cfg_if! { ++ if #[cfg(feature = "extra_traits")] { ++ #[cfg(libc_union)] ++ impl PartialEq for __c_anonymous__freg { ++ fn eq(&self, other: &__c_anonymous__freg) -> bool { ++ unsafe { ++ self.__b8 == other.__b8 ++ || self.__h16 == other.__h16 ++ || self.__s32 == other.__s32 ++ || self.__d64 == other.__d64 ++ || self.__q128 == other.__q128 ++ } ++ } ++ } ++ #[cfg(libc_union)] ++ impl Eq for __c_anonymous__freg {} ++ #[cfg(libc_union)] ++ impl ::fmt::Debug for __c_anonymous__freg { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ unsafe { ++ f.debug_struct("__c_anonymous__freg") ++ .field("__b8", &self.__b8) ++ .field("__h16", &self.__h16) ++ .field("__s32", &self.__s32) ++ .field("__d64", &self.__d64) ++ .field("__q128", &self.__q128) ++ .finish() ++ } ++ } ++ } ++ #[cfg(libc_union)] ++ impl ::hash::Hash for __c_anonymous__freg { ++ fn hash(&self, state: &mut H) { ++ unsafe { ++ self.__b8.hash(state); ++ self.__h16.hash(state); ++ self.__s32.hash(state); ++ self.__d64.hash(state); ++ self.__q128.hash(state); ++ } ++ } ++ } ++ } ++} ++ + // should be pub(crate), but that requires Rust 1.18.0 + cfg_if! { + if #[cfg(libc_const_size_of)] { +diff --git a/vendor/libc/src/unix/bsd/netbsdlike/netbsd/mod.rs b/vendor/libc/src/unix/bsd/netbsdlike/netbsd/mod.rs +index 474698a..2fa9d85 100644 +--- a/vendor/libc/src/unix/bsd/netbsdlike/netbsd/mod.rs ++++ b/vendor/libc/src/unix/bsd/netbsdlike/netbsd/mod.rs +@@ -13,6 +13,7 @@ pub type shmatt_t = ::c_uint; + pub type cpuid_t = u64; + pub type cpuset_t = _cpuset; + pub type pthread_spin_t = ::c_uchar; ++pub type timer_t = ::c_int; + + // elf.h + +@@ -120,6 +121,11 @@ s! { + pub mq_curmsgs: ::c_long, + } + ++ pub struct itimerspec { ++ pub it_interval: ::timespec, ++ pub it_value: ::timespec, ++ } ++ + pub struct sigset_t { + __bits: [u32; 4], + } +@@ -1296,6 +1302,7 @@ pub const MAP_RENAME: ::c_int = 0x20; + pub const MAP_NORESERVE: ::c_int = 0x40; + pub const MAP_HASSEMAPHORE: ::c_int = 0x200; + pub const MAP_WIRED: ::c_int = 0x800; ++pub const MAP_STACK: ::c_int = 0x2000; + // mremap flag + pub const MAP_REMAPDUP: ::c_int = 0x004; + +@@ -2146,6 +2153,8 @@ extern "C" { + ) -> ::c_int; + pub fn mq_unlink(name: *const ::c_char) -> ::c_int; + pub fn ptrace(request: ::c_int, pid: ::pid_t, addr: *mut ::c_void, data: ::c_int) -> ::c_int; ++ pub fn utrace(label: *const ::c_char, addr: *mut ::c_void, len: ::size_t) -> ::c_int; ++ pub fn pthread_getname_np(t: ::pthread_t, name: *mut ::c_char, len: ::size_t) -> ::c_int; + pub fn pthread_setname_np( + t: ::pthread_t, + name: *const ::c_char, +@@ -2254,6 +2263,21 @@ extern "C" { + ) -> ::size_t; + pub fn iconv_close(cd: iconv_t) -> ::c_int; + ++ pub fn timer_create( ++ clockid: ::clockid_t, ++ sevp: *mut ::sigevent, ++ timerid: *mut ::timer_t, ++ ) -> ::c_int; ++ pub fn timer_delete(timerid: ::timer_t) -> ::c_int; ++ pub fn timer_getoverrun(timerid: ::timer_t) -> ::c_int; ++ pub fn timer_gettime(timerid: ::timer_t, curr_value: *mut ::itimerspec) -> ::c_int; ++ pub fn timer_settime( ++ timerid: ::timer_t, ++ flags: ::c_int, ++ new_value: *const ::itimerspec, ++ old_value: *mut ::itimerspec, ++ ) -> ::c_int; ++ + // Added in `NetBSD` 7.0 + pub fn explicit_memset(b: *mut ::c_void, c: ::c_int, len: ::size_t); + pub fn consttime_memequal(a: *const ::c_void, b: *const ::c_void, len: ::size_t) -> ::c_int; +@@ -2275,6 +2299,14 @@ extern "C" { + policy: ::c_int, + param: *const ::sched_param, + ) -> ::c_int; ++ ++ #[link_name = "__pollts50"] ++ pub fn pollts( ++ fds: *mut ::pollfd, ++ nfds: ::nfds_t, ++ ts: *const ::timespec, ++ sigmask: *const ::sigset_t, ++ ) -> ::c_int; + } + + #[link(name = "util")] +@@ -2387,6 +2419,13 @@ extern "C" { + tpe: ::c_int, + ); + ++ pub fn string_to_flags( ++ string_p: *mut *mut ::c_char, ++ setp: *mut ::c_ulong, ++ clrp: *mut ::c_ulong, ++ ) -> ::c_int; ++ pub fn flags_to_string(flags: ::c_ulong, def: *const ::c_char) -> ::c_int; ++ + pub fn kinfo_getvmmap(pid: ::pid_t, cntp: *mut ::size_t) -> *mut kinfo_vmentry; + } + +diff --git a/vendor/libc/src/unix/bsd/netbsdlike/openbsd/aarch64.rs b/vendor/libc/src/unix/bsd/netbsdlike/openbsd/aarch64.rs +index 99350ec..2bc82e4 100644 +--- a/vendor/libc/src/unix/bsd/netbsdlike/openbsd/aarch64.rs ++++ b/vendor/libc/src/unix/bsd/netbsdlike/openbsd/aarch64.rs +@@ -1,6 +1,20 @@ + pub type c_long = i64; + pub type c_ulong = u64; + pub type c_char = u8; ++pub type ucontext_t = sigcontext; ++ ++s! { ++ pub struct sigcontext { ++ __sc_unused: ::c_int, ++ pub sc_mask: ::c_int, ++ pub sc_sp: ::c_ulong, ++ pub sc_lr: ::c_ulong, ++ pub sc_elr: ::c_ulong, ++ pub sc_spsr: ::c_ulong, ++ pub sc_x: [::c_ulong; 30], ++ pub sc_cookie: ::c_long, ++ } ++} + + // should be pub(crate), but that requires Rust 1.18.0 + cfg_if! { +diff --git a/vendor/libc/src/unix/bsd/netbsdlike/openbsd/mod.rs b/vendor/libc/src/unix/bsd/netbsdlike/openbsd/mod.rs +index b22c037..535d7b1 100644 +--- a/vendor/libc/src/unix/bsd/netbsdlike/openbsd/mod.rs ++++ b/vendor/libc/src/unix/bsd/netbsdlike/openbsd/mod.rs +@@ -1546,6 +1546,7 @@ extern "C" { + stacksize: *mut ::size_t, + ) -> ::c_int; + pub fn pthread_main_np() -> ::c_int; ++ pub fn pthread_get_name_np(tid: ::pthread_t, name: *mut ::c_char, len: ::size_t); + pub fn pthread_set_name_np(tid: ::pthread_t, name: *const ::c_char); + pub fn pthread_stackseg_np(thread: ::pthread_t, sinfo: *mut ::stack_t) -> ::c_int; + +@@ -1561,6 +1562,7 @@ extern "C" { + pub fn setresgid(rgid: ::gid_t, egid: ::gid_t, sgid: ::gid_t) -> ::c_int; + pub fn setresuid(ruid: ::uid_t, euid: ::uid_t, suid: ::uid_t) -> ::c_int; + pub fn ptrace(request: ::c_int, pid: ::pid_t, addr: caddr_t, data: ::c_int) -> ::c_int; ++ pub fn utrace(label: *const ::c_char, addr: *const ::c_void, len: ::size_t) -> ::c_int; + pub fn memmem( + haystack: *const ::c_void, + haystacklen: ::size_t, +@@ -1587,6 +1589,10 @@ extern "C" { + pub fn explicit_bzero(s: *mut ::c_void, len: ::size_t); + + pub fn setproctitle(fmt: *const ::c_char, ...); ++ ++ pub fn freezero(ptr: *mut ::c_void, size: ::size_t); ++ pub fn malloc_conceal(size: ::size_t) -> *mut ::c_void; ++ pub fn calloc_conceal(nmemb: ::size_t, size: ::size_t) -> *mut ::c_void; + } + + cfg_if! { +diff --git a/vendor/libc/src/unix/haiku/mod.rs b/vendor/libc/src/unix/haiku/mod.rs +index 09c9509..ee2af39 100644 +--- a/vendor/libc/src/unix/haiku/mod.rs ++++ b/vendor/libc/src/unix/haiku/mod.rs +@@ -321,6 +321,18 @@ s! { + pub uid: ::uid_t, + pub gid: ::gid_t, + } ++ ++ pub struct sockaddr_dl { ++ pub sdl_len: u8, ++ pub sdl_family: u8, ++ pub sdl_e_type: u16, ++ pub sdl_index: u32, ++ pub sdl_type: u8, ++ pub sdl_nlen: u8, ++ pub sdl_alen: u8, ++ pub sdl_slen: u8, ++ pub sdl_data: [u8; 46], ++ } + } + + s_no_extra_traits! { +@@ -549,6 +561,7 @@ pub const RLIMIT_FSIZE: ::c_int = 3; + pub const RLIMIT_NOFILE: ::c_int = 4; + pub const RLIMIT_STACK: ::c_int = 5; + pub const RLIMIT_AS: ::c_int = 6; ++pub const RLIM_INFINITY: ::c_ulong = 0xffffffff; + // Haiku specific + pub const RLIMIT_NOVMON: ::c_int = 7; + pub const RLIM_NLIMITS: ::c_int = 8; +@@ -1421,6 +1434,8 @@ extern "C" { + attr: *mut pthread_condattr_t, + clock_id: ::clockid_t, + ) -> ::c_int; ++ pub fn valloc(numBytes: ::size_t) -> *mut ::c_void; ++ pub fn malloc_usable_size(ptr: *mut ::c_void) -> ::size_t; + pub fn memalign(align: ::size_t, size: ::size_t) -> *mut ::c_void; + pub fn setgroups(ngroups: ::c_int, ptr: *const ::gid_t) -> ::c_int; + pub fn ioctl(fd: ::c_int, request: ::c_ulong, ...) -> ::c_int; +@@ -1560,5 +1575,20 @@ cfg_if! { + } + } + ++cfg_if! { ++ if #[cfg(target_arch = "x86")] { ++ // TODO ++ // mod x86; ++ // pub use self::x86::*; ++ } else if #[cfg(target_arch = "x86_64")] { ++ mod x86_64; ++ pub use self::x86_64::*; ++ } else if #[cfg(target_arch = "aarch64")] { ++ // TODO ++ // mod aarch64; ++ // pub use self::aarch64::*; ++ } ++} ++ + mod native; + pub use self::native::*; +diff --git a/vendor/libc/src/unix/haiku/native.rs b/vendor/libc/src/unix/haiku/native.rs +index 6fa2acc..765dc4e 100644 +--- a/vendor/libc/src/unix/haiku/native.rs ++++ b/vendor/libc/src/unix/haiku/native.rs +@@ -63,6 +63,23 @@ e! { + } + + // kernel/scheduler.h ++ ++ pub enum be_task_flags { ++ B_DEFAULT_MEDIA_PRIORITY = 0x000, ++ B_OFFLINE_PROCESSING = 0x001, ++ B_STATUS_RENDERING = 0x002, ++ B_USER_INPUT_HANDLING = 0x004, ++ B_LIVE_VIDEO_MANIPULATION = 0x008, ++ B_VIDEO_PLAYBACK = 0x010, ++ B_VIDEO_RECORDING = 0x020, ++ B_LIVE_AUDIO_MANIPULATION = 0x040, ++ B_AUDIO_PLAYBACK = 0x080, ++ B_AUDIO_RECORDING = 0x100, ++ B_LIVE_3D_RENDERING = 0x200, ++ B_NUMBER_CRUNCHING = 0x400, ++ B_MIDI_PROCESSING = 0x800, ++ } ++ + pub enum schduler_mode { + SCHEDULER_MODE_LOW_LATENCY, + SCHEDULER_MODE_POWER_SAVING, +@@ -861,6 +878,13 @@ extern "C" { + + pub fn rename_thread(thread: thread_id, newName: *const ::c_char) -> status_t; + pub fn set_thread_priority(thread: thread_id, newPriority: i32) -> status_t; ++ pub fn suggest_thread_priority( ++ task_flags: be_task_flags, ++ period: i32, ++ jitter: ::bigtime_t, ++ length: ::bigtime_t, ++ ) -> i32; ++ pub fn estimate_max_scheduling_latency(th: ::thread_id) -> ::bigtime_t; + pub fn exit_thread(status: status_t); + pub fn wait_for_thread(thread: thread_id, returnValue: *mut status_t) -> status_t; + pub fn on_exit_thread(callback: extern "C" fn(*mut ::c_void), data: *mut ::c_void) -> status_t; +diff --git a/vendor/libc/src/unix/haiku/x86_64.rs b/vendor/libc/src/unix/haiku/x86_64.rs +new file mode 100644 +index 0000000..1b0462f +--- /dev/null ++++ b/vendor/libc/src/unix/haiku/x86_64.rs +@@ -0,0 +1,264 @@ ++s_no_extra_traits! { ++ pub struct fpu_state { ++ pub control: ::c_ushort, ++ pub status: ::c_ushort, ++ pub tag: ::c_ushort, ++ pub opcode: ::c_ushort, ++ pub rip: ::c_ulong, ++ pub rdp: ::c_ulong, ++ pub mxcsr: ::c_uint, ++ pub mscsr_mask: ::c_uint, ++ pub _fpreg: [[::c_uchar; 8]; 16], ++ pub _xmm: [[::c_uchar; 16]; 16], ++ pub _reserved_416_511: [::c_uchar; 96], ++ } ++ ++ pub struct xstate_hdr { ++ pub bv: ::c_ulong, ++ pub xcomp_bv: ::c_ulong, ++ pub _reserved: [::c_uchar; 48], ++ } ++ ++ pub struct savefpu { ++ pub fp_fxsave: fpu_state, ++ pub fp_xstate: xstate_hdr, ++ pub _fp_ymm: [[::c_uchar; 16]; 16], ++ } ++ ++ pub struct mcontext_t { ++ pub rax: ::c_ulong, ++ pub rbx: ::c_ulong, ++ pub rcx: ::c_ulong, ++ pub rdx: ::c_ulong, ++ pub rdi: ::c_ulong, ++ pub rsi: ::c_ulong, ++ pub rbp: ::c_ulong, ++ pub r8: ::c_ulong, ++ pub r9: ::c_ulong, ++ pub r10: ::c_ulong, ++ pub r11: ::c_ulong, ++ pub r12: ::c_ulong, ++ pub r13: ::c_ulong, ++ pub r14: ::c_ulong, ++ pub r15: ::c_ulong, ++ pub rsp: ::c_ulong, ++ pub rip: ::c_ulong, ++ pub rflags: ::c_ulong, ++ pub fpu: savefpu, ++ } ++ ++ pub struct ucontext_t { ++ pub uc_link: *mut ucontext_t, ++ pub uc_sigmask: ::sigset_t, ++ pub uc_stack: ::stack_t, ++ pub uc_mcontext: mcontext_t, ++ } ++} ++ ++cfg_if! { ++ if #[cfg(feature = "extra_traits")] { ++ impl PartialEq for fpu_state { ++ fn eq(&self, other: &fpu_state) -> bool { ++ self.control == other.control ++ && self.status == other.status ++ && self.tag == other.tag ++ && self.opcode == other.opcode ++ && self.rip == other.rip ++ && self.rdp == other.rdp ++ && self.mxcsr == other.mxcsr ++ && self.mscsr_mask == other.mscsr_mask ++ && self._fpreg.iter().zip(other._fpreg.iter()).all(|(a, b)| a == b) ++ && self._xmm.iter().zip(other._xmm.iter()).all(|(a, b)| a == b) ++ && self._reserved_416_511. ++ iter(). ++ zip(other._reserved_416_511.iter()). ++ all(|(a, b)| a == b) ++ } ++ } ++ impl Eq for fpu_state {} ++ impl ::fmt::Debug for fpu_state { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ f.debug_struct("fpu_state") ++ .field("control", &self.control) ++ .field("status", &self.status) ++ .field("tag", &self.tag) ++ .field("opcode", &self.opcode) ++ .field("rip", &self.rip) ++ .field("rdp", &self.rdp) ++ .field("mxcsr", &self.mxcsr) ++ .field("mscsr_mask", &self.mscsr_mask) ++ // FIXME: .field("_fpreg", &self._fpreg) ++ // FIXME: .field("_xmm", &self._xmm) ++ // FIXME: .field("_reserved_416_511", &self._reserved_416_511) ++ .finish() ++ } ++ } ++ impl ::hash::Hash for fpu_state { ++ fn hash(&self, state: &mut H) { ++ self.control.hash(state); ++ self.status.hash(state); ++ self.tag.hash(state); ++ self.opcode.hash(state); ++ self.rip.hash(state); ++ self.rdp.hash(state); ++ self.mxcsr.hash(state); ++ self.mscsr_mask.hash(state); ++ self._fpreg.hash(state); ++ self._xmm.hash(state); ++ self._reserved_416_511.hash(state); ++ } ++ } ++ ++ impl PartialEq for xstate_hdr { ++ fn eq(&self, other: &xstate_hdr) -> bool { ++ self.bv == other.bv ++ && self.xcomp_bv == other.xcomp_bv ++ && self._reserved.iter().zip(other._reserved.iter()).all(|(a, b)| a == b) ++ } ++ } ++ impl Eq for xstate_hdr {} ++ impl ::fmt::Debug for xstate_hdr { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ f.debug_struct("xstate_hdr") ++ .field("bv", &self.bv) ++ .field("xcomp_bv", &self.xcomp_bv) ++ // FIXME: .field("_reserved", &field._reserved) ++ .finish() ++ } ++ } ++ impl ::hash::Hash for xstate_hdr { ++ fn hash(&self, state: &mut H) { ++ self.bv.hash(state); ++ self.xcomp_bv.hash(state); ++ self._reserved.hash(state); ++ } ++ } ++ ++ impl PartialEq for savefpu { ++ fn eq(&self, other: &savefpu) -> bool { ++ self.fp_fxsave == other.fp_fxsave ++ && self.fp_xstate == other.fp_xstate ++ && self._fp_ymm.iter().zip(other._fp_ymm.iter()).all(|(a, b)| a == b) ++ } ++ } ++ impl Eq for savefpu {} ++ impl ::fmt::Debug for savefpu { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ f.debug_struct("savefpu") ++ .field("fp_fxsave", &self.fp_fxsave) ++ .field("fp_xstate", &self.fp_xstate) ++ // FIXME: .field("_fp_ymm", &field._fp_ymm) ++ .finish() ++ } ++ } ++ impl ::hash::Hash for savefpu { ++ fn hash(&self, state: &mut H) { ++ self.fp_fxsave.hash(state); ++ self.fp_xstate.hash(state); ++ self._fp_ymm.hash(state); ++ } ++ } ++ ++ impl PartialEq for mcontext_t { ++ fn eq(&self, other: &mcontext_t) -> bool { ++ self.rax == other.rax ++ && self.rbx == other.rbx ++ && self.rbx == other.rbx ++ && self.rcx == other.rcx ++ && self.rdx == other.rdx ++ && self.rdi == other.rdi ++ && self.rsi == other.rsi ++ && self.r8 == other.r8 ++ && self.r9 == other.r9 ++ && self.r10 == other.r10 ++ && self.r11 == other.r11 ++ && self.r12 == other.r12 ++ && self.r13 == other.r13 ++ && self.r14 == other.r14 ++ && self.r15 == other.r15 ++ && self.rsp == other.rsp ++ && self.rip == other.rip ++ && self.rflags == other.rflags ++ && self.fpu == other.fpu ++ } ++ } ++ impl Eq for mcontext_t {} ++ impl ::fmt::Debug for mcontext_t { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ f.debug_struct("mcontext_t") ++ .field("rax", &self.rax) ++ .field("rbx", &self.rbx) ++ .field("rcx", &self.rcx) ++ .field("rdx", &self.rdx) ++ .field("rdi", &self.rdi) ++ .field("rsi", &self.rsi) ++ .field("rbp", &self.rbp) ++ .field("r8", &self.r8) ++ .field("r9", &self.r9) ++ .field("r10", &self.r10) ++ .field("r11", &self.r11) ++ .field("r12", &self.r12) ++ .field("r13", &self.r13) ++ .field("r14", &self.r14) ++ .field("r15", &self.r15) ++ .field("rsp", &self.rsp) ++ .field("rip", &self.rip) ++ .field("rflags", &self.rflags) ++ .field("fpu", &self.fpu) ++ .finish() ++ ++ } ++ } ++ impl ::hash::Hash for mcontext_t { ++ fn hash(&self, state: &mut H) { ++ self.rax.hash(state); ++ self.rbx.hash(state); ++ self.rcx.hash(state); ++ self.rdx.hash(state); ++ self.rdi.hash(state); ++ self.rsi.hash(state); ++ self.rbp.hash(state); ++ self.r8.hash(state); ++ self.r9.hash(state); ++ self.r10.hash(state); ++ self.r11.hash(state); ++ self.r12.hash(state); ++ self.r13.hash(state); ++ self.r14.hash(state); ++ self.r15.hash(state); ++ self.rsp.hash(state); ++ self.rip.hash(state); ++ self.rflags.hash(state); ++ self.fpu.hash(state); ++ } ++ } ++ ++ impl PartialEq for ucontext_t { ++ fn eq(&self, other: &ucontext_t) -> bool { ++ self.uc_link == other.uc_link ++ && self.uc_sigmask == other.uc_sigmask ++ && self.uc_stack == other.uc_stack ++ && self.uc_mcontext == other.uc_mcontext ++ } ++ } ++ impl Eq for ucontext_t {} ++ impl ::fmt::Debug for ucontext_t { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ f.debug_struct("ucontext_t") ++ .field("uc_link", &self.uc_link) ++ .field("uc_sigmask", &self.uc_sigmask) ++ .field("uc_stack", &self.uc_stack) ++ .field("uc_mcontext", &self.uc_mcontext) ++ .finish() ++ } ++ } ++ impl ::hash::Hash for ucontext_t { ++ fn hash(&self, state: &mut H) { ++ self.uc_link.hash(state); ++ self.uc_sigmask.hash(state); ++ self.uc_stack.hash(state); ++ self.uc_mcontext.hash(state); ++ } ++ } ++ } ++} +diff --git a/vendor/libc/src/unix/linux_like/android/mod.rs b/vendor/libc/src/unix/linux_like/android/mod.rs +index 04801fd..5e6fae7 100644 +--- a/vendor/libc/src/unix/linux_like/android/mod.rs ++++ b/vendor/libc/src/unix/linux_like/android/mod.rs +@@ -2424,6 +2424,8 @@ pub const SCHED_BATCH: ::c_int = 3; + pub const SCHED_IDLE: ::c_int = 5; + pub const SCHED_DEADLINE: ::c_int = 6; + ++pub const SCHED_RESET_ON_FORK: ::c_int = 0x40000000; ++ + // bits/seek_constants.h + pub const SEEK_DATA: ::c_int = 3; + pub const SEEK_HOLE: ::c_int = 4; +@@ -2438,6 +2440,10 @@ pub const PF_VSOCK: ::c_int = AF_VSOCK; + pub const PROP_VALUE_MAX: ::c_int = 92; + pub const PROP_NAME_MAX: ::c_int = 32; + ++// sys/prctl.h ++pub const PR_SET_VMA: ::c_int = 0x53564d41; ++pub const PR_SET_VMA_ANON_NAME: ::c_int = 0; ++ + f! { + pub fn CMSG_NXTHDR(mhdr: *const msghdr, + cmsg: *const cmsghdr) -> *mut cmsghdr { +@@ -2570,6 +2576,9 @@ extern "C" { + pub fn __sched_cpucount(setsize: ::size_t, set: *const cpu_set_t) -> ::c_int; + pub fn sched_getcpu() -> ::c_int; + pub fn mallinfo() -> ::mallinfo; ++ // available from API 23 ++ pub fn malloc_info(options: ::c_int, stream: *mut ::FILE) -> ::c_int; ++ + pub fn malloc_usable_size(ptr: *const ::c_void) -> ::size_t; + + pub fn utmpname(name: *const ::c_char) -> ::c_int; +@@ -2914,6 +2923,8 @@ extern "C" { + pub fn arc4random_buf(__buf: *mut ::c_void, __n: ::size_t); + + pub fn reallocarray(ptr: *mut ::c_void, nmemb: ::size_t, size: ::size_t) -> *mut ::c_void; ++ ++ pub fn pthread_getcpuclockid(thread: ::pthread_t, clk_id: *mut ::clockid_t) -> ::c_int; + } + + cfg_if! { +diff --git a/vendor/libc/src/unix/linux_like/linux/align.rs b/vendor/libc/src/unix/linux_like/linux/align.rs +index 11f5504..b932e8d 100644 +--- a/vendor/libc/src/unix/linux_like/linux/align.rs ++++ b/vendor/libc/src/unix/linux_like/linux/align.rs +@@ -5,6 +5,7 @@ macro_rules! expand_align { + target_arch = "x86_64", + target_arch = "powerpc64", + target_arch = "mips64", ++ target_arch = "sw64", // GUYC20210602 + target_arch = "s390x", + target_arch = "sparc64", + target_arch = "aarch64", +@@ -15,6 +16,7 @@ macro_rules! expand_align { + target_arch = "x86_64", + target_arch = "powerpc64", + target_arch = "mips64", ++ target_arch = "sw64", // GUYC20210602 + target_arch = "s390x", + target_arch = "sparc64", + target_arch = "aarch64", +diff --git a/vendor/libc/src/unix/linux_like/linux/gnu/b32/riscv32/mod.rs b/vendor/libc/src/unix/linux_like/linux/gnu/b32/riscv32/mod.rs +index 96ee5a3..09061f3 100644 +--- a/vendor/libc/src/unix/linux_like/linux/gnu/b32/riscv32/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/gnu/b32/riscv32/mod.rs +@@ -221,6 +221,7 @@ pub const O_SYNC: ::c_int = 1052672; + pub const O_RSYNC: ::c_int = 1052672; + pub const O_DSYNC: ::c_int = 4096; + pub const O_FSYNC: ::c_int = 1052672; ++pub const MADV_SOFT_OFFLINE: ::c_int = 101; + pub const MAP_GROWSDOWN: ::c_int = 256; + pub const EDEADLK: ::c_int = 35; + pub const ENAMETOOLONG: ::c_int = 36; +diff --git a/vendor/libc/src/unix/linux_like/linux/gnu/b64/mod.rs b/vendor/libc/src/unix/linux_like/linux/gnu/b64/mod.rs +index db82f26..9a2cf52 100644 +--- a/vendor/libc/src/unix/linux_like/linux/gnu/b64/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/gnu/b64/mod.rs +@@ -2,11 +2,23 @@ + + pub type ino_t = u64; + pub type off_t = i64; ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub type blkcnt_t = u32; ++#[cfg(not(target_arch = "sw64"))] + pub type blkcnt_t = i64; + pub type shmatt_t = u64; + pub type msgqnum_t = u64; + pub type msglen_t = u64; ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub type fsblkcnt_t = i32; ++#[cfg(not(target_arch = "sw64"))] + pub type fsblkcnt_t = u64; ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub type fsfilcnt_t = u32; ++#[cfg(not(target_arch = "sw64"))] + pub type fsfilcnt_t = u64; + pub type rlim_t = u64; + #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] +@@ -20,6 +32,10 @@ cfg_if! { + pub type time_t = i32; + pub type __fsword_t = i32; + } else { ++ // GUYC20210602 ++ #[cfg(target_arch = "sw64")] ++ pub type __fsword_t = i32; ++ #[cfg(not(target_arch = "sw64"))] + pub type __fsword_t = i64; + pub type clock_t = i64; + pub type time_t = i64; +@@ -107,6 +123,9 @@ cfg_if! { + } else if #[cfg(any(target_arch = "mips64"))] { + mod mips64; + pub use self::mips64::*; ++ } else if #[cfg(any(target_arch = "sw64"))] { // GUYC20210602 ++ mod sw64; ++ pub use self::sw64::*; + } else if #[cfg(any(target_arch = "s390x"))] { + mod s390x; + pub use self::s390x::*; +diff --git a/vendor/libc/src/unix/linux_like/linux/gnu/b64/riscv64/mod.rs b/vendor/libc/src/unix/linux_like/linux/gnu/b64/riscv64/mod.rs +index c656189..982277d 100644 +--- a/vendor/libc/src/unix/linux_like/linux/gnu/b64/riscv64/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/gnu/b64/riscv64/mod.rs +@@ -226,6 +226,7 @@ pub const O_FSYNC: ::c_int = 1052672; + pub const O_NOATIME: ::c_int = 262144; + pub const O_PATH: ::c_int = 2097152; + pub const O_TMPFILE: ::c_int = 4259840; ++pub const MADV_SOFT_OFFLINE: ::c_int = 101; + pub const MAP_GROWSDOWN: ::c_int = 256; + pub const EDEADLK: ::c_int = 35; + pub const ENAMETOOLONG: ::c_int = 36; +diff --git a/vendor/libc/src/unix/linux_like/linux/gnu/b64/s390x.rs b/vendor/libc/src/unix/linux_like/linux/gnu/b64/s390x.rs +index 7685a34..833997a 100644 +--- a/vendor/libc/src/unix/linux_like/linux/gnu/b64/s390x.rs ++++ b/vendor/libc/src/unix/linux_like/linux/gnu/b64/s390x.rs +@@ -385,6 +385,7 @@ pub const MAP_POPULATE: ::c_int = 0x08000; + pub const MAP_NONBLOCK: ::c_int = 0x010000; + pub const MAP_STACK: ::c_int = 0x020000; + pub const MAP_HUGETLB: ::c_int = 0x040000; ++pub const MAP_SYNC: ::c_int = 0x080000; + + pub const EDEADLOCK: ::c_int = 35; + pub const ENAMETOOLONG: ::c_int = 36; +diff --git a/vendor/libc/src/unix/linux_like/linux/gnu/b64/sw64.rs b/vendor/libc/src/unix/linux_like/linux/gnu/b64/sw64.rs +new file mode 100644 +index 0000000..67dc5ba +--- /dev/null ++++ b/vendor/libc/src/unix/linux_like/linux/gnu/b64/sw64.rs +@@ -0,0 +1,1096 @@ ++//! SW64-specific definitions for 64-bit linux-like values ++ ++use pthread_mutex_t; ++ ++pub type blksize_t = u32; ++pub type c_char = i8; ++pub type c_long = i64; ++pub type c_ulong = u64; ++pub type nlink_t = u32; ++pub type suseconds_t = i64; ++pub type wchar_t = i32; ++pub type __u64 = ::c_ulong; ++ ++s! { ++ pub struct stat { ++ pub st_dev: ::dev_t, ++ pub st_ino: ::ino64_t, ++ pub st_rdev: ::dev_t, ++ pub st_size: ::off_t, ++ pub st_blocks: ::blkcnt_t, ++ __pad1: ::c_int, ++ ++ pub st_mode: ::mode_t, ++ pub st_uid: ::uid_t, ++ pub st_gid: ::gid_t, ++ pub st_blksize: ::blksize_t, ++ pub st_nlink: ::nlink_t, ++ __pad2: ::c_int, ++ pub st_atime: ::time_t, ++ pub st_atime_nsec: ::c_long, ++ pub st_mtime: ::time_t, ++ pub st_mtime_nsec: ::c_long, ++ pub st_ctime: ::time_t, ++ pub st_ctime_nsec: ::c_long, ++ __glibc_reserved: [::c_long; 3], ++ } ++ ++ pub struct stat64 { ++ pub st_dev: ::dev_t, ++ pub st_ino: ::ino64_t, ++ pub st_rdev: ::dev_t, ++ pub st_size: ::off64_t, ++ pub st_blocks: ::blkcnt64_t, ++ ++ pub st_mode: ::mode_t, ++ pub st_uid: ::uid_t, ++ pub st_gid: ::gid_t, ++ pub st_blksize: ::blksize_t, ++ pub st_nlink: ::nlink_t, ++ __pad0: ::c_int, ++ ++ pub st_atime: ::time_t, ++ pub st_atime_nsec: ::c_long, ++ pub st_mtime: ::time_t, ++ pub st_mtime_nsec: ::c_long, ++ pub st_ctime: ::time_t, ++ pub st_ctime_nsec: ::c_long, ++ __unused: [::c_long; 3], ++ } ++ ++ pub struct statfs64 { ++ pub f_type: ::c_long, ++ pub f_bsize: ::c_long, ++ pub f_blocks: ::c_long, ++ pub f_bfree: ::c_long, ++ pub f_bavail: ::c_long, ++ pub f_files: ::c_ulong, ++ pub f_ffree: ::c_ulong, ++ pub f_fsid: ::fsid_t, ++ pub f_namelen: ::c_long, ++ pub f_frsize: ::c_long, ++ pub f_flags: ::c_long, ++ pub f_spare: [::c_long; 4], ++ } ++ ++ pub struct statvfs { ++ pub f_bsize: ::c_ulong, ++ pub f_frsize: ::c_ulong, ++ pub f_blocks: ::fsblkcnt_t, ++ pub f_bfree: ::fsblkcnt_t, ++ pub f_bavail: ::fsblkcnt_t, ++ pub f_files: ::fsfilcnt_t, ++ pub f_ffree: ::fsfilcnt_t, ++ pub f_favail: ::fsfilcnt_t, ++ pub f_fsid: ::c_ulong, ++ pub f_flag: ::c_ulong, ++ pub f_namemax: ::c_ulong, ++ __f_spare: [::c_int; 6], ++ } ++ ++ pub struct statvfs64 { ++ pub f_bsize: ::c_ulong, ++ pub f_frsize: ::c_ulong, ++ pub f_blocks: ::c_long, ++ pub f_bfree: ::c_long, ++ pub f_bavail: ::c_long, ++ pub f_files: ::c_ulong, ++ pub f_ffree: ::c_ulong, ++ pub f_favail: ::c_ulong, ++ pub f_fsid: ::c_ulong, ++ pub f_flag: ::c_ulong, ++ pub f_namemax: ::c_ulong, ++ __f_spare: [::c_int; 6], ++ } ++ ++ pub struct pthread_attr_t { ++ __size: [::c_ulong; 7] ++ } ++ ++ // GUYC20201103 add sigaction stack_t siginfo_t ++ ++ pub struct sigaction { ++ pub sa_sigaction: ::sighandler_t, ++ pub sa_mask: ::sigset_t, ++ pub sa_flags: ::c_int, ++ } ++ ++ pub struct stack_t { ++ pub ss_sp: *mut ::c_void, ++ pub ss_flags: ::c_int, ++ pub ss_size: ::size_t ++ } ++ ++ pub struct siginfo_t { ++ pub si_signo: ::c_int, ++ pub si_errno: ::c_int, ++ pub si_code: ::c_int, ++ pub _pad: [::c_int; 29], ++ _align: [usize; 0], ++ } ++ ++ // GUYC20201103 add flock ++ ++ pub struct flock { ++ pub l_type: ::c_short, ++ pub l_whence: ::c_short, ++ pub l_start: ::off_t, ++ pub l_len: ::off_t, ++ pub l_pid: ::pid_t, ++ } ++ ++ pub struct ipc_perm { ++ pub __key: ::key_t, ++ pub uid: ::uid_t, ++ pub gid: ::gid_t, ++ pub cuid: ::uid_t, ++ pub cgid: ::gid_t, ++ pub mode: ::c_uint, ++ pub __seq: ::c_ushort, ++ __pad1: ::c_ushort, ++ __unused1: ::c_ulong, ++ __unused2: ::c_ulong ++ } ++ ++ pub struct shmid_ds { ++ pub shm_perm: ::ipc_perm, ++ pub shm_segsz: ::size_t, ++ pub shm_atime: ::time_t, ++ pub shm_dtime: ::time_t, ++ pub shm_ctime: ::time_t, ++ pub shm_cpid: ::pid_t, ++ pub shm_lpid: ::pid_t, ++ pub shm_nattch: ::shmatt_t, ++ __unused4: ::c_ulong, ++ __unused5: ::c_ulong ++ } ++ ++ // GUYC20210303 copy from 1.34.2 libc/src/unix/notbsd/linux/other/mod.rs ++ pub struct statfs { ++ pub f_type: ::c_long, ++ pub f_bsize: ::c_long, ++ pub f_blocks: ::c_long, ++ pub f_bfree: ::c_long, ++ pub f_bavail: ::c_long, ++ ++ pub f_files: ::c_long, ++ pub f_ffree: ::c_long, ++ pub f_fsid: ::fsid_t, ++ ++ pub f_namelen: ::c_long, ++ pub f_frsize: ::c_long, ++ pub f_flags: ::c_long, ++ f_spare: [::c_long; 4], ++ } ++} ++ ++pub const __SIZEOF_PTHREAD_CONDATTR_T: usize = 4; ++pub const __SIZEOF_PTHREAD_MUTEXATTR_T: usize = 4; ++pub const __SIZEOF_PTHREAD_MUTEX_T: usize = 40; ++pub const __SIZEOF_PTHREAD_RWLOCK_T: usize = 56; ++ ++align_const! { ++ pub const PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP: ::pthread_mutex_t = ++ pthread_mutex_t { ++ size: [ ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ ], ++ }; ++ pub const PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP: ::pthread_mutex_t = ++ pthread_mutex_t { ++ size: [ ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ ], ++ }; ++ pub const PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP: ::pthread_mutex_t = ++ pthread_mutex_t { ++ size: [ ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ ], ++ }; ++} ++ ++pub const TIOCGSOFTCAR: ::c_ulong = 0x5419; ++pub const TIOCSSOFTCAR: ::c_ulong = 0x541A; ++ ++pub const RLIMIT_NOFILE: ::c_int = 6; ++pub const RLIMIT_NPROC: ::c_int = 8; ++ ++pub const O_APPEND: ::c_int = 0o00010; ++pub const O_CREAT: ::c_int = 0o01000; ++pub const O_EXCL: ::c_int = 0o04000; ++pub const O_NOCTTY: ::c_int = 0o010000; ++pub const O_DIRECT: ::c_int = 0o02000000; ++pub const O_DIRECTORY: ::c_int = 0o0100000; ++pub const O_NOFOLLOW: ::c_int = 0o0200000; ++pub const O_NONBLOCK: ::c_int = 0o00004; ++pub const O_CLOEXEC: ::c_int = 0o010000000; ++ ++ ++pub const O_DSYNC: ::c_int = 0o040000; ++pub const O_SYNC: ::c_int = 0o020000000 |O_DSYNC; ++pub const O_RSYNC: ::c_int = O_SYNC; // TODO ++pub const O_FSYNC: ::c_int = O_SYNC; // TODO ++ ++pub const O_NOATIME: ::c_int = 0o04000000; ++pub const O_PATH: ::c_int = 0o040000000; ++pub const O_TMPFILE: ::c_int = 0o0100100000; ++ ++pub const MAP_GROWSDOWN: ::c_int = 0x01000; ++ ++pub const EDEADLK: ::c_int = 11; ++pub const ENAMETOOLONG: ::c_int = 63; ++pub const ENOLCK: ::c_int = 77; ++pub const ENOSYS: ::c_int = 78; ++pub const ENOTEMPTY: ::c_int = 66; ++pub const ELOOP: ::c_int = 62; ++ ++pub const ENOMSG: ::c_int = 80; ++pub const EIDRM: ::c_int = 81; ++pub const ECHRNG: ::c_int = 88; ++pub const EL2NSYNC: ::c_int = 89; ++pub const EL3HLT: ::c_int = 90; ++pub const EL3RST: ::c_int = 91; ++pub const ELNRNG: ::c_int = 93; ++pub const EUNATCH: ::c_int = 94; ++pub const ENOCSI: ::c_int = 95; ++pub const EL2HLT: ::c_int = 96; ++pub const EBADE: ::c_int = 97; ++pub const EBADR: ::c_int = 98; ++pub const EXFULL: ::c_int = 99; ++pub const ENOANO: ::c_int = 100; ++pub const EBADRQC: ::c_int = 101; ++pub const EBADSLT: ::c_int = 102; ++pub const EMULTIHOP: ::c_int = 110; ++pub const EOVERFLOW: ::c_int = 112; ++pub const ENOTUNIQ: ::c_int = 113; ++pub const EBADFD: ::c_int = 114; ++pub const EBADMSG: ::c_int = 84; ++ ++ ++pub const EREMCHG: ::c_int = 115; ++pub const ELIBACC: ::c_int = 122; ++pub const ELIBBAD: ::c_int = 123; ++pub const ELIBSCN: ::c_int = 124; ++pub const ELIBMAX: ::c_int = 125; ++pub const ELIBEXEC: ::c_int = 126; ++pub const EILSEQ: ::c_int = 116; ++ ++pub const ERESTART: ::c_int = 127; ++pub const ESTRPIPE: ::c_int = 128; ++pub const EUSERS: ::c_int = 68; ++pub const ENOTSOCK: ::c_int = 38; ++pub const EDESTADDRREQ: ::c_int = 39; ++pub const EMSGSIZE: ::c_int = 40; ++pub const EPROTOTYPE: ::c_int = 41; ++pub const ENOPROTOOPT: ::c_int = 42; ++pub const EPROTONOSUPPORT: ::c_int = 43; ++pub const ESOCKTNOSUPPORT: ::c_int = 44; ++pub const EOPNOTSUPP: ::c_int = 45; ++pub const EPFNOSUPPORT: ::c_int = 46; ++pub const EAFNOSUPPORT: ::c_int = 47; ++pub const EADDRINUSE: ::c_int = 48; ++pub const EADDRNOTAVAIL: ::c_int = 49; ++pub const ENETDOWN: ::c_int = 50; ++pub const ENETUNREACH: ::c_int = 51; ++pub const ENETRESET: ::c_int = 52; ++pub const ECONNABORTED: ::c_int = 53; ++pub const ECONNRESET: ::c_int = 54; ++pub const ENOBUFS: ::c_int = 55; ++pub const EISCONN: ::c_int = 56; ++pub const ENOTCONN: ::c_int = 57; ++pub const ESHUTDOWN: ::c_int = 58; ++pub const ETOOMANYREFS: ::c_int = 59; ++pub const ETIMEDOUT: ::c_int = 60; ++pub const ECONNREFUSED: ::c_int = 61; ++pub const EHOSTDOWN: ::c_int = 64; ++pub const EHOSTUNREACH: ::c_int = 65; ++pub const EALREADY: ::c_int = 37; ++pub const EINPROGRESS: ::c_int = 36; ++pub const ESTALE: ::c_int = 70; ++pub const EDQUOT: ::c_int = 69; ++ ++pub const ENOMEDIUM: ::c_int = 129; ++pub const EMEDIUMTYPE: ::c_int = 130; ++pub const ECANCELED: ::c_int = 131; ++pub const ENOKEY: ::c_int = 132; ++pub const EKEYEXPIRED: ::c_int = 133; ++pub const EKEYREVOKED: ::c_int = 134; ++pub const EKEYREJECTED: ::c_int = 135; ++pub const EOWNERDEAD: ::c_int = 136; ++pub const ENOTRECOVERABLE: ::c_int = 137; ++pub const EHWPOISON: ::c_int = 139; ++pub const ERFKILL: ::c_int = 138; ++ ++pub const SOL_SOCKET: ::c_int = 0xffff; ++pub const SO_REUSEADDR: ::c_int = 0x0004; ++pub const SO_TYPE: ::c_int = 0x1008; ++pub const SO_ERROR: ::c_int = 0x1007; ++pub const SO_DONTROUTE: ::c_int = 0x0010; ++pub const SO_BROADCAST: ::c_int = 0x0020; ++pub const SO_SNDBUF: ::c_int = 0x1001; ++pub const SO_RCVBUF: ::c_int = 0x1002; ++pub const SO_SNDBUFFORCE: ::c_int = 0x100a; ++pub const SO_RCVBUFFORCE: ::c_int = 0x100b; ++pub const SO_KEEPALIVE: ::c_int = 0x0008; ++pub const SO_OOBINLINE: ::c_int = 0x0100; ++pub const SO_NO_CHECK: ::c_int = 11; ++pub const SO_PRIORITY: ::c_int = 12; ++ ++pub const SO_LINGER: ::c_int = 0x0080; ++pub const SO_BSDCOMPAT: ::c_int = 14; ++pub const SO_REUSEPORT: ::c_int = 0x0200; ++pub const SO_PASSCRED: ::c_int = 17; ++pub const SO_PEERCRED: ::c_int = 18; ++pub const SO_RCVLOWAT: ::c_int = 0x1010; ++pub const SO_SNDLOWAT: ::c_int = 0x1011; ++pub const SO_RCVTIMEO: ::c_int = 0x1012; ++pub const SO_SNDTIMEO: ::c_int = 0x1013; ++ ++pub const SO_SECURITY_AUTHENTICATION: ::c_int = 19; ++pub const SO_SECURITY_ENCRYPTION_TRANSPORT: ::c_int = 20; ++pub const SO_SECURITY_ENCRYPTION_NETWORK: ::c_int = 21; ++pub const SO_BINDTODEVICE: ::c_int = 25; ++pub const SO_ATTACH_FILTER: ::c_int = 26; ++pub const SO_DETACH_FILTER: ::c_int = 27; ++pub const SO_GET_FILTER: ::c_int = SO_ATTACH_FILTER; ++pub const SO_PEERNAME: ::c_int = 28; ++pub const SO_TIMESTAMP: ::c_int = 29; ++pub const SO_ACCEPTCONN: ::c_int = 0x1014; ++ ++pub const SO_PEERSEC: ::c_int = 30; ++pub const SO_PASSSEC: ::c_int = 34; ++pub const SO_TIMESTAMPNS: ::c_int = 35; ++pub const SCM_TIMESTAMPNS: ::c_int = SO_TIMESTAMPNS; ++pub const SO_MARK: ::c_int = 36; ++pub const SO_PROTOCOL: ::c_int = 0x1028; ++pub const SO_DOMAIN: ::c_int = 0x1029; ++pub const SO_RXQ_OVFL: ::c_int = 40; ++pub const SO_WIFI_STATUS: ::c_int = 41; ++pub const SCM_WIFI_STATUS: ::c_int = SO_WIFI_STATUS; ++pub const SO_PEEK_OFF: ::c_int = 42; ++pub const SO_NOFCS: ::c_int = 43; ++pub const SO_LOCK_FILTER: ::c_int = 44; ++pub const SO_SELECT_ERR_QUEUE: ::c_int = 45; ++pub const SO_BUSY_POLL: ::c_int = 46; ++pub const SO_MAX_PACING_RATE: ::c_int = 47; ++pub const SO_BPF_EXTENSIONS: ::c_int = 48; ++pub const SO_INCOMING_CPU: ::c_int = 49; ++pub const SO_ATTACH_BPF: ::c_int = 50; ++pub const SO_DETACH_BPF: ::c_int = SO_DETACH_FILTER; ++pub const SA_ONSTACK: ::c_int = 0x00000001; ++pub const SA_SIGINFO: ::c_int = 0x00000040; ++pub const SA_NOCLDWAIT: ::c_int = 0x00000020; ++ ++pub const SIGCHLD: ::c_int = 20; ++pub const SIGBUS: ::c_int = 10; ++pub const SIGUSR1: ::c_int = 30; ++pub const SIGUSR2: ::c_int = 31; ++pub const SIGCONT: ::c_int = 19; ++pub const SIGSTOP: ::c_int = 17; ++pub const SIGTSTP: ::c_int = 18; ++pub const SIGURG: ::c_int = 16; ++pub const SIGIO: ::c_int = 23; ++pub const SIGSYS: ::c_int = 12; ++pub const SIGINFO: ::c_int = 29; ++//pub const SIGSTKFLT: ::c_int = 16; ++pub const SIGUNUSED: ::c_int = 31; ++pub const SIGPOLL: ::c_int = SIGIO; ++pub const SIGPWR: ::c_int = SIGINFO; ++pub const SIG_SETMASK: ::c_int = 3; ++pub const SIG_BLOCK: ::c_int = 1; ++pub const SIG_UNBLOCK: ::c_int = 2; ++ ++pub const POLLWRNORM: ::c_short = 0x0100; // TODO ++pub const POLLWRBAND: ::c_short = 0x0200; ++pub const O_ASYNC: ::c_int = 0o020000; ++pub const O_NDELAY: ::c_int = 0o00004; ++pub const PTRACE_DETACH: ::c_uint = 17; ++pub const EFD_NONBLOCK: ::c_int = 0o000000004; ++ ++pub const F_GETLK: ::c_int = 7; ++pub const F_GETOWN: ::c_int = 6; ++pub const F_SETOWN: ::c_int = 5; ++pub const F_SETLK: ::c_int = 8; ++pub const F_SETLKW: ::c_int = 9; ++pub const F_RDLCK: ::c_int = 1; ++pub const F_WRLCK: ::c_int = 2; ++pub const F_UNLCK: ::c_int = 8; ++ ++pub const SFD_NONBLOCK: ::c_int = 0o000000004; ++pub const TIOCEXCL: ::c_ulong = 0x540C; ++pub const TIOCNXCL: ::c_ulong = 0x540D; ++pub const TIOCSCTTY: ::c_ulong = 0x540E; ++pub const TIOCSTI: ::c_ulong = 0x5412; ++pub const TIOCMGET: ::c_ulong = 0x5415; ++pub const TIOCMBIS: ::c_ulong = 0x5416; ++pub const TIOCMBIC: ::c_ulong = 0x5417; ++pub const TIOCMSET: ::c_ulong = 0x5418; ++pub const TIOCCONS: ::c_ulong = 0x541D; ++ ++pub const SFD_CLOEXEC: ::c_int = 0o010000000; ++ ++pub const NCCS: usize = 32; ++pub const O_TRUNC: ::c_int = 0o02000; ++pub const EBFONT: ::c_int = 104; ++pub const ENOSTR: ::c_int = 87; ++pub const ENODATA: ::c_int = 86; ++pub const ETIME: ::c_int = 83; ++pub const ENOSR: ::c_int = 82; ++pub const ENONET: ::c_int = 105; ++pub const ENOPKG: ::c_int = 92; ++pub const EREMOTE: ::c_int = 71; ++pub const EREMOTEIO: ::c_int = 121; ++pub const ENOLINK: ::c_int = 106; ++pub const EADV: ::c_int = 107; ++pub const ESRMNT: ::c_int = 108; ++pub const ECOMM: ::c_int = 109; ++pub const EPROTO: ::c_int = 85; ++pub const EDOTDOT: ::c_int = 111; ++pub const SA_NODEFER: ::c_int = 0x00000008; ++pub const SA_NOMASK: ::c_int = SA_NODEFER; ++pub const SA_RESETHAND: ::c_int = 0x00000010; ++pub const SA_ONESHOT: ::c_int = SA_RESETHAND; ++pub const SA_RESTART: ::c_int = 0x00000002; ++pub const SA_NOCLDSTOP: ::c_int = 0x00000004; ++ ++pub const EPOLL_CLOEXEC: ::c_int = 0o010000000; // TODO ++pub const EFD_CLOEXEC: ::c_int = 0o010000000; // TODO ++ ++pub const MAP_LOCKED: ::c_int = 0x08000; ++pub const MAP_NORESERVE: ::c_int = 0x10000; ++ ++pub const EDEADLOCK: ::c_int = EDEADLK; ++ ++pub const FIOCLEX: ::c_ulong = 0x20006601; ++pub const FIONBIO: ::c_ulong = 0x8004667e; ++ ++pub const MCL_CURRENT: ::c_int = 8192; ++pub const MCL_FUTURE: ::c_int = 16384; ++ ++pub const SIGSTKSZ: ::size_t = 16384; ++pub const MINSIGSTKSZ: ::size_t = 4096; ++pub const CBAUD: ::tcflag_t = 0o0000037; ++pub const CBAUDEX: ::tcflag_t = 0o0000000; ++pub const TAB1: ::c_int = 0o00002000; ++pub const TAB2: ::c_int = 0o00004000; ++pub const TAB3: ::c_int = 0o00006000; ++pub const CR1: ::c_int = 0o00010000; ++pub const CR2: ::c_int = 0o00020000; ++pub const CR3: ::c_int = 0o00030000; ++pub const FF1: ::c_int = 0o00040000; ++pub const BS1: ::c_int = 0o00100000; ++pub const VT1: ::c_int = 0o00200000; ++ ++pub const VWERASE: usize = 4; ++pub const VREPRINT: usize = 6; ++pub const VSUSP: usize = 10; ++pub const VSTART: usize = 12; ++pub const VSTOP: usize = 13; ++pub const VDISCARD: usize = 15; ++pub const VTIME: usize = 17; ++pub const IXON: ::tcflag_t = 0o0001000; ++pub const IXOFF: ::tcflag_t = 0o0002000; ++pub const ONLCR: ::tcflag_t = 0o0000002; ++pub const CSIZE: ::tcflag_t = 0o00001400; ++pub const CS6: ::tcflag_t = 0o00000400; ++pub const CS7: ::tcflag_t = 0o00001000; ++pub const CS8: ::tcflag_t = 0o00001400; ++pub const CSTOPB: ::tcflag_t = 0o00002000; ++pub const CREAD: ::tcflag_t = 0o00004000; ++pub const PARENB: ::tcflag_t = 0o00010000; ++pub const PARODD: ::tcflag_t = 0o00020000; ++ ++pub const HUPCL: ::tcflag_t = 0o00040000; ++pub const CLOCAL: ::tcflag_t = 0o00100000; ++pub const ECHOKE: ::tcflag_t = 0x00000001; ++pub const ECHOE: ::tcflag_t = 0x00000002; ++pub const ECHOK: ::tcflag_t = 0x00000004; ++pub const ECHONL: ::tcflag_t = 0x00000010; ++pub const ECHOPRT: ::tcflag_t = 0x00000020; ++pub const ECHOCTL: ::tcflag_t = 0x00000040; ++pub const ISIG: ::tcflag_t = 0x00000080; ++pub const ICANON: ::tcflag_t = 0x00000100; ++pub const PENDIN: ::tcflag_t = 0x20000000; ++pub const NOFLSH: ::tcflag_t = 0x80000000; ++//pub const CIBAUD: ::tcflag_t = 0o07600000; ++pub const VSWTC: usize = 7; ++pub const OLCUC: ::tcflag_t = 0o0000004; ++pub const NLDLY: ::tcflag_t = 0o00001400; ++pub const CRDLY: ::tcflag_t = 0o00030000; ++pub const TABDLY: ::tcflag_t = 0o00006000; ++pub const BSDLY: ::tcflag_t = 0o00100000; ++pub const FFDLY: ::tcflag_t = 0o00040000; ++pub const VTDLY: ::tcflag_t = 0o00200000; ++pub const XTABS: ::tcflag_t = 0o00006000; ++ ++pub const B0: ::speed_t = 0o0000000; ++pub const B50: ::speed_t = 0o0000001; ++pub const B75: ::speed_t = 0o0000002; ++pub const B110: ::speed_t = 0o0000003; ++pub const B134: ::speed_t = 0o0000004; ++pub const B150: ::speed_t = 0o0000005; ++pub const B200: ::speed_t = 0o0000006; ++pub const B300: ::speed_t = 0o0000007; ++pub const B600: ::speed_t = 0o0000010; ++pub const B1200: ::speed_t = 0o0000011; ++pub const B1800: ::speed_t = 0o0000012; ++pub const B2400: ::speed_t = 0o0000013; ++pub const B4800: ::speed_t = 0o0000014; ++pub const B9600: ::speed_t = 0o0000015; ++pub const B19200: ::speed_t = 0o0000016; ++pub const B38400: ::speed_t = 0o0000017; ++pub const EXTA: ::speed_t = B19200; ++pub const EXTB: ::speed_t = B38400; ++//pub const BOTHER: ::speed_t = 0o00037; ++pub const B57600: ::speed_t = 0o00020; ++pub const B115200: ::speed_t = 0o00021; ++pub const B230400: ::speed_t = 0o00022; ++pub const B460800: ::speed_t = 0o00023; ++pub const B500000: ::speed_t = 0o00024; ++pub const B576000: ::speed_t = 0o00025; ++pub const B921600: ::speed_t = 0o00026; ++pub const B1000000: ::speed_t = 0o00027; ++pub const B1152000: ::speed_t = 0o00030; ++pub const B1500000: ::speed_t = 0o00031; ++pub const B2000000: ::speed_t = 0o00032; ++pub const B2500000: ::speed_t = 0o00033; ++pub const B3000000: ::speed_t = 0o00034; ++pub const B3500000: ::speed_t = 0o00035; ++pub const B4000000: ::speed_t = 0o00036; ++ ++pub const VEOL: usize = 1; ++pub const VEOL2: usize = 2; ++//pub const _VEOL: usize = 5; ++//pub const _VEOL2: usize = 6; ++pub const VMIN: usize = 16; ++//pub const _VMIN: usize = 4; ++pub const IEXTEN: ::tcflag_t = 0x00000400; ++pub const TOSTOP: ::tcflag_t = 0x00400000; ++pub const FLUSHO: ::tcflag_t = 0x00800000; ++//pub const EXTPROC: ::tcflag_t = 0x10000000; ++pub const TCGETS: ::c_ulong = 0x402c7413; ++//pub const TCGETS2: ::c_ulong = 0x401a542a; ++pub const TCSETS: ::c_ulong = 0x802c7414; ++pub const TCSETSW: ::c_ulong = 0x802c7415; ++//pub const TCSETSW2: ::c_ulong = 0x801a542c; ++pub const TCSETSF: ::c_ulong = 0x802c7416; ++//pub const TCSETSF2: ::c_ulong = 0x801a542d; ++pub const TCGETA: ::c_ulong = 0x40127417; ++pub const TCSETA: ::c_ulong = 0x80127418; ++pub const TCSETAW: ::c_ulong = 0x80127419; ++pub const TCSETAF: ::c_ulong = 0x8012741c; ++pub const TCSBRK: ::c_ulong = 0x2000741d; ++pub const TCSBRKP: ::c_ulong = 0x5425; ++pub const FIONREAD: ::c_ulong = 0x4004667f; ++pub const TCXONC: ::c_ulong = 0x2000741e; ++pub const TCFLSH: ::c_ulong = 0x2000741f; ++pub const TIOCINQ: ::c_ulong = FIONREAD; ++ ++pub const TIOCGPGRP: ::c_ulong = 0x40047477; ++pub const TIOCSPGRP: ::c_ulong = 0x80047476; ++pub const TIOCOUTQ: ::c_ulong = 0x40047473; ++pub const TIOCGWINSZ: ::c_ulong = 0x40087468; ++pub const TIOCSWINSZ: ::c_ulong = 0x80087467; ++ ++// GUYC20201112 add RLIMIT_RSS ~ TIOCM_DSR ++pub const RLIMIT_RSS: ::c_int = 5; ++pub const RLIMIT_AS: ::c_int = 7; ++pub const RLIMIT_MEMLOCK: ::c_int = 9; ++pub const MAP_ANON: ::c_int = 0x0010; ++pub const MAP_ANONYMOUS: ::c_int = 0x0010; ++pub const MAP_DENYWRITE: ::c_int = 0x2000; ++pub const MAP_EXECUTABLE: ::c_int = 0x04000; ++pub const MAP_POPULATE: ::c_int = 0x20000; ++pub const MAP_NONBLOCK: ::c_int = 0x40000; ++pub const MAP_STACK: ::c_int = 0x80000; ++pub const EUCLEAN: ::c_int = 117; ++pub const ENOTNAM: ::c_int = 118; ++pub const ENAVAIL: ::c_int = 119; ++pub const EISNAM: ::c_int = 120; ++pub const SOCK_STREAM: ::c_int = 1; ++pub const SOCK_DGRAM: ::c_int = 2; ++pub const SIGTTIN: ::c_int = 21; ++pub const SIGTTOU: ::c_int = 22; ++pub const SIGXCPU: ::c_int = 24; ++pub const SIGXFSZ: ::c_int = 25; ++pub const SIGVTALRM: ::c_int = 26; ++pub const SIGPROF: ::c_int = 27; ++pub const SIGWINCH: ::c_int = 28; ++pub const POSIX_FADV_DONTNEED: ::c_int = 4; ++pub const POSIX_FADV_NOREUSE: ::c_int = 5; ++pub const VEOF: usize = 0; ++pub const MAP_HUGETLB: ::c_int = 0x100000; ++pub const TCSANOW: ::c_int = 0; ++pub const TCSADRAIN: ::c_int = 1; ++pub const TCSAFLUSH: ::c_int = 2; ++pub const TIOCLINUX: ::c_ulong = 0x541C; ++pub const TIOCGSERIAL: ::c_ulong = 0x541E; ++pub const RTLD_DEEPBIND: ::c_int = 0x8; ++pub const RTLD_GLOBAL: ::c_int = 0x100; ++pub const RTLD_NOLOAD: ::c_int = 0x4; ++pub const TIOCM_ST: ::c_int = 0x008; ++pub const TIOCM_SR: ::c_int = 0x010; ++pub const TIOCM_CTS: ::c_int = 0x020; ++pub const TIOCM_CAR: ::c_int = 0x040; ++pub const TIOCM_RNG: ::c_int = 0x080; ++pub const TIOCM_DSR: ::c_int = 0x100; ++ ++pub const SYS_osf_syscall: ::c_long = 0; ++pub const SYS_exit: ::c_long = 1; ++pub const SYS_fork: ::c_long = 2; ++pub const SYS_read: ::c_long = 3; ++pub const SYS_write: ::c_long = 4; ++pub const SYS_osf_old_open: ::c_long = 5; ++pub const SYS_close: ::c_long = 6; ++pub const SYS_osf_wait4: ::c_long = 7; ++pub const SYS_osf_old_creat: ::c_long = 8; ++pub const SYS_link: ::c_long = 9; ++pub const SYS_unlink: ::c_long = 10; ++pub const SYS_osf_execve: ::c_long = 11; ++pub const SYS_chdir: ::c_long = 12; ++pub const SYS_fchdir: ::c_long = 13; ++pub const SYS_mknod: ::c_long = 14; ++pub const SYS_chmod: ::c_long = 15; ++pub const SYS_chown: ::c_long = 16; ++pub const SYS_brk: ::c_long = 17; ++pub const SYS_osf_getfsstat: ::c_long = 18; ++pub const SYS_lseek: ::c_long = 19; ++pub const SYS_getxpid: ::c_long = 20; ++pub const SYS_osf_mount: ::c_long = 21; ++pub const SYS_umount: ::c_long = 22; ++pub const SYS_setuid: ::c_long = 23; ++pub const SYS_getxuid: ::c_long = 24; ++pub const SYS_exec_with_loader: ::c_long = 25; ++pub const SYS_ptrace: ::c_long = 26; ++pub const SYS_osf_nrecvmsg: ::c_long = 27; ++pub const SYS_osf_nsendmsg: ::c_long = 28; ++pub const SYS_osf_nrecvfrom: ::c_long = 29; ++pub const SYS_osf_naccept: ::c_long = 30; ++pub const SYS_osf_ngetpeername: ::c_long = 31; ++pub const SYS_osf_ngetsockname: ::c_long = 32; ++pub const SYS_access: ::c_long = 33; ++pub const SYS_osf_chflags: ::c_long = 34; ++pub const SYS_osf_fchflags: ::c_long = 35; ++pub const SYS_sync: ::c_long = 36; ++pub const SYS_kill: ::c_long = 37; ++pub const SYS_osf_old_stat: ::c_long = 38; ++pub const SYS_setpgid: ::c_long = 39; ++pub const SYS_osf_old_lstat: ::c_long = 40; ++pub const SYS_dup: ::c_long = 41; ++pub const SYS_pipe: ::c_long = 42; ++pub const SYS_osf_set_program_attributes: ::c_long = 43; ++pub const SYS_osf_profil: ::c_long = 44; ++pub const SYS_open: ::c_long = 45; ++pub const SYS_osf_old_sigaction: ::c_long = 46; ++pub const SYS_getxgid: ::c_long = 47; ++pub const SYS_osf_sigprocmask: ::c_long = 48; ++pub const SYS_osf_getlogin: ::c_long = 49; ++pub const SYS_osf_setlogin: ::c_long = 50; ++pub const SYS_acct: ::c_long = 51; ++pub const SYS_sigpending: ::c_long = 52; ++pub const SYS_ioctl: ::c_long = 54; ++pub const SYS_osf_reboot: ::c_long = 55; ++pub const SYS_osf_revoke: ::c_long = 56; ++pub const SYS_symlink: ::c_long = 57; ++pub const SYS_readlink: ::c_long = 58; ++pub const SYS_execve: ::c_long = 59; ++pub const SYS_umask: ::c_long = 60; ++pub const SYS_chroot: ::c_long = 61; ++pub const SYS_osf_old_fstat: ::c_long = 62; ++pub const SYS_getpgrp: ::c_long = 63; ++pub const SYS_getpagesize: ::c_long = 64; ++pub const SYS_osf_mremap: ::c_long = 65; ++pub const SYS_vfork: ::c_long = 66; ++pub const SYS_stat: ::c_long = 67; ++pub const SYS_lstat: ::c_long = 68; ++pub const SYS_osf_sbrk: ::c_long = 69; ++pub const SYS_osf_sstk: ::c_long = 70; ++pub const SYS_mmap: ::c_long = 71; ++pub const SYS_osf_old_vadvise: ::c_long = 72; ++pub const SYS_munmap: ::c_long = 73; ++pub const SYS_mprotect: ::c_long = 74; ++pub const SYS_madvise: ::c_long = 75; ++pub const SYS_vhangup: ::c_long = 76; ++pub const SYS_osf_kmodcall: ::c_long = 77; ++pub const SYS_osf_mincore: ::c_long = 78; ++pub const SYS_getgroups: ::c_long = 79; ++pub const SYS_setgroups: ::c_long = 80; ++pub const SYS_osf_old_getpgrp: ::c_long = 81; ++pub const SYS_setpgrp: ::c_long = 82; ++pub const SYS_osf_setitimer: ::c_long = 83; ++pub const SYS_osf_old_wait: ::c_long = 84; ++pub const SYS_osf_table: ::c_long = 85; ++pub const SYS_osf_getitimer: ::c_long = 86; ++pub const SYS_gethostname: ::c_long = 87; ++pub const SYS_sethostname: ::c_long = 88; ++pub const SYS_getdtablesize: ::c_long = 89; ++pub const SYS_dup2: ::c_long = 90; ++pub const SYS_fstat: ::c_long = 91; ++pub const SYS_fcntl: ::c_long = 92; ++pub const SYS_osf_select: ::c_long = 93; ++pub const SYS_poll: ::c_long = 94; ++pub const SYS_fsync: ::c_long = 95; ++pub const SYS_setpriority: ::c_long = 96; ++pub const SYS_socket: ::c_long = 97; ++pub const SYS_connect: ::c_long = 98; ++pub const SYS_accept: ::c_long = 99; ++pub const SYS_getpriority: ::c_long = 100; ++pub const SYS_send: ::c_long = 101; ++pub const SYS_recv: ::c_long = 102; ++pub const SYS_sigreturn: ::c_long = 103; ++pub const SYS_bind: ::c_long = 104; ++pub const SYS_setsockopt: ::c_long = 105; ++pub const SYS_listen: ::c_long = 106; ++pub const SYS_osf_plock: ::c_long = 107; ++pub const SYS_osf_old_sigvec: ::c_long = 108; ++pub const SYS_osf_old_sigblock: ::c_long = 109; ++pub const SYS_osf_old_sigsetmask: ::c_long = 110; ++pub const SYS_sigsuspend: ::c_long = 111; ++pub const SYS_osf_sigstack: ::c_long = 112; ++pub const SYS_recvmsg: ::c_long = 113; ++pub const SYS_sendmsg: ::c_long = 114; ++pub const SYS_osf_old_vtrace: ::c_long = 115; ++pub const SYS_osf_gettimeofday: ::c_long = 116; ++pub const SYS_osf_getrusage: ::c_long = 117; ++pub const SYS_getsockopt: ::c_long = 118; ++pub const SYS_readv: ::c_long = 120; ++pub const SYS_writev: ::c_long = 121; ++pub const SYS_osf_settimeofday: ::c_long = 122; ++pub const SYS_fchown: ::c_long = 123; ++pub const SYS_fchmod: ::c_long = 124; ++pub const SYS_recvfrom: ::c_long = 125; ++pub const SYS_setreuid: ::c_long = 126; ++pub const SYS_setregid: ::c_long = 127; ++pub const SYS_rename: ::c_long = 128; ++pub const SYS_truncate: ::c_long = 129; ++pub const SYS_ftruncate: ::c_long = 130; ++pub const SYS_flock: ::c_long = 131; ++pub const SYS_setgid: ::c_long = 132; ++pub const SYS_sendto: ::c_long = 133; ++pub const SYS_shutdown: ::c_long = 134; ++pub const SYS_socketpair: ::c_long = 135; ++pub const SYS_mkdir: ::c_long = 136; ++pub const SYS_rmdir: ::c_long = 137; ++pub const SYS_osf_utimes: ::c_long = 138; ++pub const SYS_osf_old_sigreturn: ::c_long = 139; ++pub const SYS_osf_adjtime: ::c_long = 140; ++pub const SYS_getpeername: ::c_long = 141; ++pub const SYS_osf_gethostid: ::c_long = 142; ++pub const SYS_osf_sethostid: ::c_long = 143; ++pub const SYS_getrlimit: ::c_long = 144; ++pub const SYS_setrlimit: ::c_long = 145; ++pub const SYS_osf_old_killpg: ::c_long = 146; ++pub const SYS_setsid: ::c_long = 147; ++pub const SYS_quotactl: ::c_long = 148; ++pub const SYS_osf_oldquota: ::c_long = 149; ++pub const SYS_getsockname: ::c_long = 150; ++pub const SYS_osf_pid_block: ::c_long = 153; ++pub const SYS_osf_pid_unblock: ::c_long = 154; ++pub const SYS_sigaction: ::c_long = 156; ++pub const SYS_osf_sigwaitprim: ::c_long = 157; ++pub const SYS_osf_nfssvc: ::c_long = 158; ++pub const SYS_osf_getdirentries: ::c_long = 159; ++pub const SYS_osf_statfs: ::c_long = 160; ++pub const SYS_osf_fstatfs: ::c_long = 161; ++pub const SYS_osf_asynch_daemon: ::c_long = 163; ++pub const SYS_osf_getfh: ::c_long = 164; ++pub const SYS_osf_getdomainname: ::c_long = 165; ++pub const SYS_setdomainname: ::c_long = 166; ++pub const SYS_osf_exportfs: ::c_long = 169; ++pub const SYS_osf_alt_plock: ::c_long = 181; ++pub const SYS_osf_getmnt: ::c_long = 184; ++pub const SYS_osf_alt_sigpending: ::c_long = 187; ++pub const SYS_osf_alt_setsid: ::c_long = 188; ++pub const SYS_osf_swapon: ::c_long = 199; ++pub const SYS_msgctl: ::c_long = 200; ++pub const SYS_msgget: ::c_long = 201; ++pub const SYS_msgrcv: ::c_long = 202; ++pub const SYS_msgsnd: ::c_long = 203; ++pub const SYS_semctl: ::c_long = 204; ++pub const SYS_semget: ::c_long = 205; ++pub const SYS_semop: ::c_long = 206; ++pub const SYS_osf_utsname: ::c_long = 207; ++pub const SYS_lchown: ::c_long = 208; ++pub const SYS_osf_shmat: ::c_long = 209; ++pub const SYS_shmctl: ::c_long = 210; ++pub const SYS_shmdt: ::c_long = 211; ++pub const SYS_shmget: ::c_long = 212; ++pub const SYS_osf_mvalid: ::c_long = 213; ++pub const SYS_osf_getaddressconf: ::c_long = 214; ++pub const SYS_osf_msleep: ::c_long = 215; ++pub const SYS_osf_mwakeup: ::c_long = 216; ++pub const SYS_msync: ::c_long = 217; ++pub const SYS_osf_signal: ::c_long = 218; ++pub const SYS_osf_utc_gettime: ::c_long = 219; ++pub const SYS_osf_utc_adjtime: ::c_long = 220; ++pub const SYS_osf_security: ::c_long = 222; ++pub const SYS_osf_kloadcall: ::c_long = 223; ++pub const SYS_osf_stat: ::c_long = 224; ++pub const SYS_osf_lstat: ::c_long = 225; ++pub const SYS_osf_fstat: ::c_long = 226; ++pub const SYS_osf_statfs64: ::c_long = 227; ++pub const SYS_osf_fstatfs64: ::c_long = 228; ++pub const SYS_getpgid: ::c_long = 233; ++pub const SYS_getsid: ::c_long = 234; ++pub const SYS_sigaltstack: ::c_long = 235; ++pub const SYS_osf_waitid: ::c_long = 236; ++pub const SYS_osf_priocntlset: ::c_long = 237; ++pub const SYS_osf_sigsendset: ::c_long = 238; ++pub const SYS_osf_set_speculative: ::c_long = 239; ++pub const SYS_osf_msfs_syscall: ::c_long = 240; ++pub const SYS_osf_sysinfo: ::c_long = 241; ++pub const SYS_osf_uadmin: ::c_long = 242; ++pub const SYS_osf_fuser: ::c_long = 243; ++pub const SYS_osf_proplist_syscall: ::c_long = 244; ++pub const SYS_osf_ntp_adjtime: ::c_long = 245; ++pub const SYS_osf_ntp_gettime: ::c_long = 246; ++pub const SYS_osf_pathconf: ::c_long = 247; ++pub const SYS_osf_fpathconf: ::c_long = 248; ++pub const SYS_osf_uswitch: ::c_long = 250; ++pub const SYS_osf_usleep_thread: ::c_long = 251; ++pub const SYS_osf_audcntl: ::c_long = 252; ++pub const SYS_osf_audgen: ::c_long = 253; ++pub const SYS_sysfs: ::c_long = 254; ++pub const SYS_osf_subsys_info: ::c_long = 255; ++pub const SYS_osf_getsysinfo: ::c_long = 256; ++pub const SYS_osf_setsysinfo: ::c_long = 257; ++pub const SYS_osf_afs_syscall: ::c_long = 258; ++pub const SYS_osf_swapctl: ::c_long = 259; ++pub const SYS_osf_memcntl: ::c_long = 260; ++pub const SYS_osf_fdatasync: ::c_long = 261; ++pub const SYS_bdflush: ::c_long = 300; ++pub const SYS_sethae: ::c_long = 301; ++pub const SYS_mount: ::c_long = 302; ++pub const SYS_old_adjtimex: ::c_long = 303; ++pub const SYS_swapoff: ::c_long = 304; ++pub const SYS_getdents: ::c_long = 305; ++pub const SYS_create_module: ::c_long = 306; ++pub const SYS_init_module: ::c_long = 307; ++pub const SYS_delete_module: ::c_long = 308; ++pub const SYS_get_kernel_syms: ::c_long = 309; ++pub const SYS_syslog: ::c_long = 310; ++pub const SYS_reboot: ::c_long = 311; ++pub const SYS_clone: ::c_long = 312; ++pub const SYS_uselib: ::c_long = 313; ++pub const SYS_mlock: ::c_long = 314; ++pub const SYS_munlock: ::c_long = 315; ++pub const SYS_mlockall: ::c_long = 316; ++pub const SYS_munlockall: ::c_long = 317; ++pub const SYS_sysinfo: ::c_long = 318; ++pub const SYS__sysctl: ::c_long = 319; ++pub const SYS_oldumount: ::c_long = 321; ++pub const SYS_swapon: ::c_long = 322; ++pub const SYS_times: ::c_long = 323; ++pub const SYS_personality: ::c_long = 324; ++pub const SYS_setfsuid: ::c_long = 325; ++pub const SYS_setfsgid: ::c_long = 326; ++pub const SYS_ustat: ::c_long = 327; ++pub const SYS_statfs: ::c_long = 328; ++pub const SYS_fstatfs: ::c_long = 329; ++pub const SYS_sched_setparam: ::c_long = 330; ++pub const SYS_sched_getparam: ::c_long = 331; ++pub const SYS_sched_setscheduler: ::c_long = 332; ++pub const SYS_sched_getscheduler: ::c_long = 333; ++pub const SYS_sched_yield: ::c_long = 334; ++pub const SYS_sched_get_priority_max: ::c_long = 335; ++pub const SYS_sched_get_priority_min: ::c_long = 336; ++pub const SYS_sched_rr_get_interval: ::c_long = 337; ++pub const SYS_afs_syscall: ::c_long = 338; ++pub const SYS_uname: ::c_long = 339; ++pub const SYS_nanosleep: ::c_long = 340; ++pub const SYS_mremap: ::c_long = 341; ++pub const SYS_nfsservctl: ::c_long = 342; ++pub const SYS_setresuid: ::c_long = 343; ++pub const SYS_getresuid: ::c_long = 344; ++pub const SYS_pciconfig_read: ::c_long = 345; ++pub const SYS_pciconfig_write: ::c_long = 346; ++pub const SYS_query_module: ::c_long = 347; ++pub const SYS_prctl: ::c_long = 348; ++pub const SYS_pread64: ::c_long = 349; ++pub const SYS_pwrite64: ::c_long = 350; ++pub const SYS_rt_sigreturn: ::c_long = 351; ++pub const SYS_rt_sigaction: ::c_long = 352; ++pub const SYS_rt_sigprocmask: ::c_long = 353; ++pub const SYS_rt_sigpending: ::c_long = 354; ++pub const SYS_rt_sigtimedwait: ::c_long = 355; ++pub const SYS_rt_sigqueueinfo: ::c_long = 356; ++pub const SYS_rt_sigsuspend: ::c_long = 357; ++pub const SYS_select: ::c_long = 358; ++pub const SYS_gettimeofday: ::c_long = 359; ++pub const SYS_settimeofday: ::c_long = 360; ++pub const SYS_getitimer: ::c_long = 361; ++pub const SYS_setitimer: ::c_long = 362; ++pub const SYS_utimes: ::c_long = 363; ++pub const SYS_getrusage: ::c_long = 364; ++pub const SYS_wait4: ::c_long = 365; ++pub const SYS_adjtimex: ::c_long = 366; ++pub const SYS_getcwd: ::c_long = 367; ++pub const SYS_capget: ::c_long = 368; ++pub const SYS_capset: ::c_long = 369; ++pub const SYS_sendfile: ::c_long = 370; ++pub const SYS_setresgid: ::c_long = 371; ++pub const SYS_getresgid: ::c_long = 372; ++pub const SYS_dipc: ::c_long = 373; ++pub const SYS_pivot_root: ::c_long = 374; ++pub const SYS_mincore: ::c_long = 375; ++pub const SYS_pciconfig_iobase: ::c_long = 376; ++pub const SYS_getdents64: ::c_long = 377; ++pub const SYS_gettid: ::c_long = 378; ++pub const SYS_readahead: ::c_long = 379; ++pub const SYS_tkill: ::c_long = 381; ++pub const SYS_setxattr: ::c_long = 382; ++pub const SYS_lsetxattr: ::c_long = 383; ++pub const SYS_fsetxattr: ::c_long = 384; ++pub const SYS_getxattr: ::c_long = 385; ++pub const SYS_lgetxattr: ::c_long = 386; ++pub const SYS_fgetxattr: ::c_long = 387; ++pub const SYS_listxattr: ::c_long = 388; ++pub const SYS_llistxattr: ::c_long = 389; ++pub const SYS_flistxattr: ::c_long = 390; ++pub const SYS_removexattr: ::c_long = 391; ++pub const SYS_lremovexattr: ::c_long = 392; ++pub const SYS_fremovexattr: ::c_long = 393; ++pub const SYS_futex: ::c_long = 394; ++pub const SYS_sched_setaffinity: ::c_long = 395; ++pub const SYS_sched_getaffinity: ::c_long = 396; ++pub const SYS_tuxcall: ::c_long = 397; ++pub const SYS_io_setup: ::c_long = 398; ++pub const SYS_io_destroy: ::c_long = 399; ++pub const SYS_io_getevents: ::c_long = 400; ++pub const SYS_io_submit: ::c_long = 401; ++pub const SYS_io_cancel: ::c_long = 402; ++pub const SYS_exit_group: ::c_long = 405; ++pub const SYS_lookup_dcookie: ::c_long = 406; ++pub const SYS_epoll_create: ::c_long = 407; ++pub const SYS_epoll_ctl: ::c_long = 408; ++pub const SYS_epoll_wait: ::c_long = 409; ++pub const SYS_sys_epoll_create: ::c_long = 407; ++pub const SYS_sys_epoll_ctl: ::c_long = 408; ++pub const SYS_sys_epoll_wait: ::c_long = 409; ++pub const SYS_remap_file_pages: ::c_long = 410; ++pub const SYS_set_tid_address: ::c_long = 411; ++pub const SYS_restart_syscall: ::c_long = 412; ++pub const SYS_fadvise64: ::c_long = 413; ++pub const SYS_timer_create: ::c_long = 414; ++pub const SYS_timer_settime: ::c_long = 415; ++pub const SYS_timer_gettime: ::c_long = 416; ++pub const SYS_timer_getoverrun: ::c_long = 417; ++pub const SYS_timer_delete: ::c_long = 418; ++pub const SYS_clock_settime: ::c_long = 419; ++pub const SYS_clock_gettime: ::c_long = 420; ++pub const SYS_clock_getres: ::c_long = 421; ++pub const SYS_clock_nanosleep: ::c_long = 422; ++pub const SYS_semtimedop: ::c_long = 423; ++pub const SYS_tgkill: ::c_long = 424; ++pub const SYS_stat64: ::c_long = 425; ++pub const SYS_lstat64: ::c_long = 426; ++pub const SYS_fstat64: ::c_long = 427; ++pub const SYS_vserver: ::c_long = 428; ++pub const SYS_mbind: ::c_long = 429; ++pub const SYS_get_mempolicy: ::c_long = 430; ++pub const SYS_set_mempolicy: ::c_long = 431; ++pub const SYS_mq_open: ::c_long = 432; ++pub const SYS_mq_unlink: ::c_long = 433; ++pub const SYS_mq_timedsend: ::c_long = 434; ++pub const SYS_mq_timedreceive: ::c_long = 435; ++pub const SYS_mq_notify: ::c_long = 436; ++pub const SYS_mq_getsetattr: ::c_long = 437; ++pub const SYS_waitid: ::c_long = 438; ++pub const SYS_add_key: ::c_long = 439; ++pub const SYS_request_key: ::c_long = 440; ++pub const SYS_keyctl: ::c_long = 441; ++pub const SYS_ioprio_set: ::c_long = 442; ++pub const SYS_ioprio_get: ::c_long = 443; ++pub const SYS_inotify_init: ::c_long = 444; ++pub const SYS_inotify_add_watch: ::c_long = 445; ++pub const SYS_inotify_rm_watch: ::c_long = 446; ++pub const SYS_fdatasync: ::c_long = 447; ++pub const SYS_kexec_load: ::c_long = 448; ++pub const SYS_migrate_pages: ::c_long = 449; ++pub const SYS_openat: ::c_long = 450; ++pub const SYS_mkdirat: ::c_long = 451; ++pub const SYS_mknodat: ::c_long = 452; ++pub const SYS_fchownat: ::c_long = 453; ++pub const SYS_futimesat: ::c_long = 454; ++pub const SYS_fstatat64: ::c_long = 455; ++pub const SYS_unlinkat: ::c_long = 456; ++pub const SYS_renameat: ::c_long = 457; ++pub const SYS_linkat: ::c_long = 458; ++pub const SYS_symlinkat: ::c_long = 459; ++pub const SYS_readlinkat: ::c_long = 460; ++pub const SYS_fchmodat: ::c_long = 461; ++pub const SYS_faccessat: ::c_long = 462; ++pub const SYS_pselect6: ::c_long = 463; ++pub const SYS_ppoll: ::c_long = 464; ++pub const SYS_unshare: ::c_long = 465; ++pub const SYS_set_robust_list: ::c_long = 466; ++pub const SYS_get_robust_list: ::c_long = 467; ++pub const SYS_splice: ::c_long = 468; ++pub const SYS_sync_file_range: ::c_long = 469; ++pub const SYS_tee: ::c_long = 470; ++pub const SYS_vmsplice: ::c_long = 471; ++pub const SYS_move_pages: ::c_long = 472; ++pub const SYS_getcpu: ::c_long = 473; ++pub const SYS_epoll_pwait: ::c_long = 474; ++pub const SYS_utimensat: ::c_long = 475; ++pub const SYS_signalfd: ::c_long = 476; ++pub const SYS_timerfd: ::c_long = 477; ++pub const SYS_eventfd: ::c_long = 478; ++pub const SYS_recvmmsg: ::c_long = 479; ++pub const SYS_fallocate: ::c_long = 480; ++pub const SYS_timerfd_create: ::c_long = 481; ++pub const SYS_timerfd_settime: ::c_long = 482; ++pub const SYS_timerfd_gettime: ::c_long = 483; ++pub const SYS_signalfd4: ::c_long = 484; ++pub const SYS_eventfd2: ::c_long = 485; ++pub const SYS_epoll_create1: ::c_long = 486; ++pub const SYS_dup3: ::c_long = 487; ++pub const SYS_pipe2: ::c_long = 488; ++pub const SYS_inotify_init1: ::c_long = 489; ++pub const SYS_preadv: ::c_long = 490; ++pub const SYS_pwritev: ::c_long = 491; ++pub const SYS_rt_tgsigqueueinfo: ::c_long = 492; ++pub const SYS_perf_event_open: ::c_long = 493; ++pub const SYS_fanotify_init: ::c_long = 494; ++pub const SYS_fanotify_mark: ::c_long = 495; ++pub const SYS_prlimit64: ::c_long = 496; ++pub const SYS_name_to_handle_at: ::c_long = 497; ++pub const SYS_open_by_handle_at: ::c_long = 498; ++pub const SYS_clock_adjtime: ::c_long = 499; ++pub const SYS_syncfs: ::c_long = 500; ++pub const SYS_setns: ::c_long = 501; ++pub const SYS_accept4: ::c_long = 502; ++pub const SYS_sendmmsg: ::c_long = 503; ++pub const SYS_process_vm_readv: ::c_long = 504; ++pub const SYS_process_vm_writev: ::c_long = 505; ++pub const SYS_kcmp: ::c_long = 506; ++pub const SYS_finit_module: ::c_long = 507; ++pub const SYS_sched_setattr: ::c_long = 508; ++pub const SYS_sched_getattr: ::c_long = 509; ++pub const SYS_renameat2: ::c_long = 510; ++pub const SYS_getrandom: ::c_long = 511; ++pub const SYS_memfd_create: ::c_long = 512; ++pub const SYS_execveat: ::c_long = 513; ++pub const SYS_seccomp: ::c_long = 514; ++pub const SYS_copy_file_range: ::c_long = 515; ++pub const SYS_preadv2: ::c_long = 516; ++pub const SYS_pwritev2: ::c_long = 517; ++pub const SYS_statx: ::c_long = 518; ++pub const SYS_clone3: ::c_long = 519; // CHENHB20220214 ++ ++ ++#[link(name = "util")] ++extern "C" { ++ pub fn sysctl( ++ name: *mut ::c_int, ++ namelen: ::c_int, ++ oldp: *mut ::c_void, ++ oldlenp: *mut ::size_t, ++ newp: *mut ::c_void, ++ newlen: ::size_t, ++ ) -> ::c_int; ++} +diff --git a/vendor/libc/src/unix/linux_like/linux/gnu/mod.rs b/vendor/libc/src/unix/linux_like/linux/gnu/mod.rs +index ed917cc..faa9739 100644 +--- a/vendor/libc/src/unix/linux_like/linux/gnu/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/gnu/mod.rs +@@ -99,7 +99,15 @@ s! { + pub c_oflag: ::tcflag_t, + pub c_cflag: ::tcflag_t, + pub c_lflag: ::tcflag_t, ++ // GUYC20210602 ++ #[cfg(target_arch = "sw64")] ++ pub c_cc: [::cc_t; 32], ++ #[cfg(not(target_arch = "sw64"))] + pub c_line: ::cc_t, ++ // GUYC20210602 ++ #[cfg(target_arch = "sw64")] ++ pub c_line: ::cc_t, ++ #[cfg(not(target_arch = "sw64"))] + pub c_cc: [::cc_t; ::NCCS], + #[cfg(not(any( + target_arch = "sparc", +@@ -141,19 +149,6 @@ s! { + pub keepcost: ::size_t, + } + +- pub struct nlmsghdr { +- pub nlmsg_len: u32, +- pub nlmsg_type: u16, +- pub nlmsg_flags: u16, +- pub nlmsg_seq: u32, +- pub nlmsg_pid: u32, +- } +- +- pub struct nlmsgerr { +- pub error: ::c_int, +- pub msg: nlmsghdr, +- } +- + pub struct nl_pktinfo { + pub group: u32, + } +@@ -174,11 +169,6 @@ s! { + pub nm_gid: u32, + } + +- pub struct nlattr { +- pub nla_len: u16, +- pub nla_type: u16, +- } +- + pub struct rtentry { + pub rt_pad1: ::c_ulong, + pub rt_dst: ::sockaddr, +@@ -429,22 +419,26 @@ s_no_extra_traits! { + + #[cfg(any(target_arch = "aarch64", + target_arch = "s390x", ++ target_arch = "sw64", // GUYC20210602 + all(target_pointer_width = "32", + not(target_arch = "x86_64"))))] + pub ut_session: ::c_long, + #[cfg(any(target_arch = "aarch64", + target_arch = "s390x", ++ target_arch = "sw64", // GUYC20210602 + all(target_pointer_width = "32", + not(target_arch = "x86_64"))))] + pub ut_tv: ::timeval, + + #[cfg(not(any(target_arch = "aarch64", + target_arch = "s390x", ++ target_arch = "sw64", // GUYC20210602 + all(target_pointer_width = "32", + not(target_arch = "x86_64")))))] + pub ut_session: i32, + #[cfg(not(any(target_arch = "aarch64", + target_arch = "s390x", ++ target_arch = "sw64", // GUYC20210602 + all(target_pointer_width = "32", + not(target_arch = "x86_64")))))] + pub ut_tv: __timeval, +@@ -604,6 +598,10 @@ pub const RTLD_DI_PROFILEOUT: ::c_int = 8; + pub const RTLD_DI_TLS_MODID: ::c_int = 9; + pub const RTLD_DI_TLS_DATA: ::c_int = 10; + ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub const SOCK_NONBLOCK: ::c_int = 0x40000000; ++#[cfg(not(target_arch = "sw64"))] + pub const SOCK_NONBLOCK: ::c_int = O_NONBLOCK; + + pub const SOL_RXRPC: ::c_int = 272; +@@ -613,6 +611,8 @@ pub const SOL_RDS: ::c_int = 276; + pub const SOL_IUCV: ::c_int = 277; + pub const SOL_CAIF: ::c_int = 278; + pub const SOL_NFC: ::c_int = 280; ++// GUYC20210602 ++#[cfg(not(target_arch = "sw64"))] + pub const SOL_XDP: ::c_int = 283; + + pub const MSG_TRYHARD: ::c_int = 4; +@@ -690,8 +690,12 @@ pub const SIGEV_THREAD_ID: ::c_int = 4; + pub const BUFSIZ: ::c_uint = 8192; + pub const TMP_MAX: ::c_uint = 238328; + pub const FOPEN_MAX: ::c_uint = 16; +-pub const FILENAME_MAX: ::c_uint = 4096; ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub const POSIX_MADV_DONTNEED: ::c_int = 6; ++#[cfg(not(target_arch = "sw64"))] + pub const POSIX_MADV_DONTNEED: ::c_int = 4; ++pub const FILENAME_MAX: ::c_uint = 4096; + pub const _SC_EQUIV_CLASS_MAX: ::c_int = 41; + pub const _SC_CHARCLASS_NAME_MAX: ::c_int = 45; + pub const _SC_PII: ::c_int = 53; +@@ -974,6 +978,25 @@ pub const TIOCM_RTS: ::c_int = 0x004; + pub const TIOCM_CD: ::c_int = TIOCM_CAR; + pub const TIOCM_RI: ::c_int = TIOCM_RNG; + ++// elf.h ++pub const NT_PRSTATUS: ::c_int = 1; ++pub const NT_PRFPREG: ::c_int = 2; ++pub const NT_FPREGSET: ::c_int = 2; ++pub const NT_PRPSINFO: ::c_int = 3; ++pub const NT_PRXREG: ::c_int = 4; ++pub const NT_TASKSTRUCT: ::c_int = 4; ++pub const NT_PLATFORM: ::c_int = 5; ++pub const NT_AUXV: ::c_int = 6; ++pub const NT_GWINDOWS: ::c_int = 7; ++pub const NT_ASRS: ::c_int = 8; ++pub const NT_PSTATUS: ::c_int = 10; ++pub const NT_PSINFO: ::c_int = 13; ++pub const NT_PRCRED: ::c_int = 14; ++pub const NT_UTSNAME: ::c_int = 15; ++pub const NT_LWPSTATUS: ::c_int = 16; ++pub const NT_LWPSINFO: ::c_int = 17; ++pub const NT_PRFPXREG: ::c_int = 20; ++ + // linux/keyctl.h + pub const KEYCTL_DH_COMPUTE: u32 = 23; + pub const KEYCTL_PKEY_QUERY: u32 = 24; +@@ -1119,6 +1142,8 @@ cfg_if! { + target_arch = "sparc64" + ))] { + pub const PTHREAD_STACK_MIN: ::size_t = 0x6000; ++ } else if #[cfg(target_arch = "sw64")] { // GUYC20210602 ++ pub const PTHREAD_STACK_MIN: ::size_t = 0x6000; + } else { + pub const PTHREAD_STACK_MIN: ::size_t = 131072; + } +@@ -1210,13 +1235,6 @@ extern "C" { + statxbuf: *mut statx, + ) -> ::c_int; + pub fn getrandom(buf: *mut ::c_void, buflen: ::size_t, flags: ::c_uint) -> ::ssize_t; +- +- pub fn memmem( +- haystack: *const ::c_void, +- haystacklen: ::size_t, +- needle: *const ::c_void, +- needlelen: ::size_t, +- ) -> *mut ::c_void; + pub fn getauxval(type_: ::c_ulong) -> ::c_ulong; + + pub fn adjtimex(buf: *mut timex) -> ::c_int; +@@ -1305,16 +1323,6 @@ extern "C" { + ) -> ::c_int; + pub fn getpriority(which: ::__priority_which_t, who: ::id_t) -> ::c_int; + pub fn setpriority(which: ::__priority_which_t, who: ::id_t, prio: ::c_int) -> ::c_int; +- pub fn pthread_getaffinity_np( +- thread: ::pthread_t, +- cpusetsize: ::size_t, +- cpuset: *mut ::cpu_set_t, +- ) -> ::c_int; +- pub fn pthread_setaffinity_np( +- thread: ::pthread_t, +- cpusetsize: ::size_t, +- cpuset: *const ::cpu_set_t, +- ) -> ::c_int; + pub fn pthread_rwlockattr_getkind_np( + attr: *const ::pthread_rwlockattr_t, + val: *mut ::c_int, +@@ -1323,9 +1331,9 @@ extern "C" { + attr: *mut ::pthread_rwlockattr_t, + val: ::c_int, + ) -> ::c_int; +- pub fn sched_getcpu() -> ::c_int; + pub fn mallinfo() -> ::mallinfo; + pub fn mallinfo2() -> ::mallinfo2; ++ pub fn malloc_info(options: ::c_int, stream: *mut ::FILE) -> ::c_int; + pub fn malloc_usable_size(ptr: *mut ::c_void) -> ::size_t; + pub fn getpwent_r( + pwd: *mut ::passwd, +@@ -1369,6 +1377,7 @@ cfg_if! { + target_arch = "aarch64", + target_arch = "powerpc64", + target_arch = "mips64", ++ target_arch = "sw64", // GUYC20210602 + target_arch = "s390x", + target_arch = "sparc64", + target_arch = "riscv64"))] { +diff --git a/vendor/libc/src/unix/linux_like/linux/mod.rs b/vendor/libc/src/unix/linux_like/linux/mod.rs +index 3e57966..7d002b1 100644 +--- a/vendor/libc/src/unix/linux_like/linux/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/mod.rs +@@ -6,6 +6,10 @@ pub type socklen_t = u32; + pub type mode_t = u32; + pub type ino64_t = u64; + pub type off64_t = i64; ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub type blkcnt64_t = u64; ++#[cfg(not(target_arch = "sw64"))] + pub type blkcnt64_t = i64; + pub type rlim64_t = u64; + pub type mqd_t = ::c_int; +@@ -563,6 +567,24 @@ s! { + pub instruction_pointer: ::__u64, + pub args: [::__u64; 6], + } ++ ++ pub struct nlmsghdr { ++ pub nlmsg_len: u32, ++ pub nlmsg_type: u16, ++ pub nlmsg_flags: u16, ++ pub nlmsg_seq: u32, ++ pub nlmsg_pid: u32, ++ } ++ ++ pub struct nlmsgerr { ++ pub error: ::c_int, ++ pub msg: nlmsghdr, ++ } ++ ++ pub struct nlattr { ++ pub nla_len: u16, ++ pub nla_type: u16, ++ } + } + + s_no_extra_traits! { +@@ -652,6 +674,19 @@ s_no_extra_traits! { + } + } + ++cfg_if! { ++ if #[cfg(not(all(target_env = "musl", target_arch = "mips")))] { ++ s_no_extra_traits! { ++ // linux/net_tstamp.h ++ #[allow(missing_debug_implementations)] ++ pub struct sock_txtime { ++ pub clockid: ::clockid_t, ++ pub flags: ::__u32, ++ } ++ } ++ } ++} ++ + cfg_if! { + if #[cfg(libc_union)] { + s_no_extra_traits! { +@@ -1299,6 +1334,7 @@ pub const POSIX_MADV_NORMAL: ::c_int = 0; + pub const POSIX_MADV_RANDOM: ::c_int = 1; + pub const POSIX_MADV_SEQUENTIAL: ::c_int = 2; + pub const POSIX_MADV_WILLNEED: ::c_int = 3; ++pub const POSIX_SPAWN_USEVFORK: ::c_int = 64; + + pub const S_IEXEC: mode_t = 64; + pub const S_IWRITE: mode_t = 128; +@@ -1460,6 +1496,8 @@ pub const PTHREAD_MUTEX_NORMAL: ::c_int = 0; + pub const PTHREAD_MUTEX_RECURSIVE: ::c_int = 1; + pub const PTHREAD_MUTEX_ERRORCHECK: ::c_int = 2; + pub const PTHREAD_MUTEX_DEFAULT: ::c_int = PTHREAD_MUTEX_NORMAL; ++pub const PTHREAD_MUTEX_STALLED: ::c_int = 0; ++pub const PTHREAD_MUTEX_ROBUST: ::c_int = 1; + pub const PTHREAD_PROCESS_PRIVATE: ::c_int = 0; + pub const PTHREAD_PROCESS_SHARED: ::c_int = 1; + pub const __SIZEOF_PTHREAD_COND_T: usize = 48; +@@ -1476,6 +1514,8 @@ pub const SCHED_IDLE: ::c_int = 5; + + pub const SCHED_RESET_ON_FORK: ::c_int = 0x40000000; + ++pub const CLONE_PIDFD: ::c_int = 0x1000; ++ + // netinet/in.h + // NOTE: These are in addition to the constants defined in src/unix/mod.rs + +@@ -1488,6 +1528,17 @@ pub const IPPROTO_MPTCP: ::c_int = 262; + See #1896 for more info." + )] + pub const IPPROTO_MAX: ::c_int = 256; ++// GUYC20210602 ++#[cfg(not(target_arch = "sw64"))] ++pub const AF_XDP: ::c_int = 44; ++pub const PF_IB: ::c_int = AF_IB; ++pub const PF_MPLS: ::c_int = AF_MPLS; ++pub const PF_NFC: ::c_int = AF_NFC; ++pub const PF_VSOCK: ::c_int = AF_VSOCK; ++// GUYC20210602 ++#[cfg(not(target_arch = "sw64"))] ++pub const PF_XDP: ::c_int = AF_XDP; ++ + + // System V IPC + pub const IPC_PRIVATE: ::key_t = 0; +@@ -1598,6 +1649,7 @@ cfg_if! { + + pub const MREMAP_MAYMOVE: ::c_int = 1; + pub const MREMAP_FIXED: ::c_int = 2; ++pub const MREMAP_DONTUNMAP: ::c_int = 4; + + pub const PR_SET_PDEATHSIG: ::c_int = 1; + pub const PR_GET_PDEATHSIG: ::c_int = 2; +@@ -1789,6 +1841,10 @@ pub const MFD_CLOEXEC: ::c_uint = 0x0001; + pub const MFD_ALLOW_SEALING: ::c_uint = 0x0002; + pub const MFD_HUGETLB: ::c_uint = 0x0004; + ++// linux/close_range.h ++pub const CLOSE_RANGE_UNSHARE: ::c_uint = 1 << 1; ++pub const CLOSE_RANGE_CLOEXEC: ::c_uint = 1 << 2; ++ + // these are used in the p_type field of Elf32_Phdr and Elf64_Phdr, which has + // the type Elf32Word and Elf64Word respectively. Luckily, both of those are u32 + // so we can use that type here to avoid having to cast. +@@ -2361,6 +2417,8 @@ pub const NETLINK_TX_RING: ::c_int = 7; + pub const NETLINK_LISTEN_ALL_NSID: ::c_int = 8; + pub const NETLINK_LIST_MEMBERSHIPS: ::c_int = 9; + pub const NETLINK_CAP_ACK: ::c_int = 10; ++pub const NETLINK_EXT_ACK: ::c_int = 11; ++pub const NETLINK_GET_STRICT_CHK: ::c_int = 12; + + pub const NLA_F_NESTED: ::c_int = 1 << 15; + pub const NLA_F_NET_BYTEORDER: ::c_int = 1 << 14; +@@ -2509,6 +2567,12 @@ pub const SOF_TIMESTAMPING_RX_SOFTWARE: ::c_uint = 1 << 3; + pub const SOF_TIMESTAMPING_SOFTWARE: ::c_uint = 1 << 4; + pub const SOF_TIMESTAMPING_SYS_HARDWARE: ::c_uint = 1 << 5; + pub const SOF_TIMESTAMPING_RAW_HARDWARE: ::c_uint = 1 << 6; ++cfg_if! { ++ if #[cfg(not(all(target_env = "musl", target_arch = "mips")))] { ++ pub const SOF_TXTIME_DEADLINE_MODE: u32 = 1 << 0; ++ pub const SOF_TXTIME_REPORT_ERRORS: u32 = 1 << 1; ++ } ++} + + // linux/if_alg.h + pub const ALG_SET_KEY: ::c_int = 1; +@@ -2530,6 +2594,10 @@ pub const UDP_NO_CHECK6_RX: ::c_int = 102; + pub const MAP_SHARED_VALIDATE: ::c_int = 0x3; + + // include/uapi/asm-generic/mman-common.h ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub const MAP_FIXED_NOREPLACE: ::c_int = 0x200000; ++#[cfg(not(target_arch = "sw64"))] + pub const MAP_FIXED_NOREPLACE: ::c_int = 0x100000; + + // uapi/linux/vm_sockets.h +@@ -2970,6 +3038,10 @@ pub const E2BIG: ::c_int = 7; + pub const ENOEXEC: ::c_int = 8; + pub const EBADF: ::c_int = 9; + pub const ECHILD: ::c_int = 10; ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub const EAGAIN: ::c_int = 35; ++#[cfg(not(target_arch = "sw64"))] + pub const EAGAIN: ::c_int = 11; + pub const ENOMEM: ::c_int = 12; + pub const EACCES: ::c_int = 13; +@@ -3036,10 +3108,14 @@ pub const SOL_CAN_BASE: ::c_int = 100; + pub const CAN_INV_FILTER: canid_t = 0x20000000; + pub const CAN_RAW_FILTER_MAX: ::c_int = 512; + +-#[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))] +-pub const POLLRDHUP: ::c_int = 0x2000; +-#[cfg(any(target_arch = "sparc", target_arch = "sparc64"))] +-pub const POLLRDHUP: ::c_int = 0x800; ++// linux/can/raw.h ++pub const SOL_CAN_RAW: ::c_int = SOL_CAN_BASE + CAN_RAW; ++pub const CAN_RAW_FILTER: ::c_int = 1; ++pub const CAN_RAW_ERR_FILTER: ::c_int = 2; ++pub const CAN_RAW_LOOPBACK: ::c_int = 3; ++pub const CAN_RAW_RECV_OWN_MSGS: ::c_int = 4; ++pub const CAN_RAW_FD_FRAMES: ::c_int = 5; ++pub const CAN_RAW_JOIN_FILTERS: ::c_int = 6; + + f! { + pub fn NLA_ALIGN(len: ::c_int) -> ::c_int { +@@ -3429,6 +3505,16 @@ extern "C" { + len: *mut ::socklen_t, + flg: ::c_int, + ) -> ::c_int; ++ pub fn pthread_getaffinity_np( ++ thread: ::pthread_t, ++ cpusetsize: ::size_t, ++ cpuset: *mut ::cpu_set_t, ++ ) -> ::c_int; ++ pub fn pthread_setaffinity_np( ++ thread: ::pthread_t, ++ cpusetsize: ::size_t, ++ cpuset: *const ::cpu_set_t, ++ ) -> ::c_int; + pub fn pthread_setschedprio(native: ::pthread_t, priority: ::c_int) -> ::c_int; + pub fn reboot(how_to: ::c_int) -> ::c_int; + pub fn setfsgid(gid: ::gid_t) -> ::c_int; +@@ -3559,6 +3645,7 @@ extern "C" { + timeout: *const ::timespec, + sigmask: *const sigset_t, + ) -> ::c_int; ++ pub fn pthread_mutex_consistent(mutex: *mut pthread_mutex_t) -> ::c_int; + pub fn pthread_mutex_timedlock( + lock: *mut pthread_mutex_t, + abstime: *const ::timespec, +@@ -3674,6 +3761,14 @@ extern "C" { + attr: *const pthread_mutexattr_t, + pshared: *mut ::c_int, + ) -> ::c_int; ++ pub fn pthread_mutexattr_getrobust( ++ attr: *const pthread_mutexattr_t, ++ robustness: *mut ::c_int, ++ ) -> ::c_int; ++ pub fn pthread_mutexattr_setrobust( ++ attr: *mut pthread_mutexattr_t, ++ robustness: ::c_int, ++ ) -> ::c_int; + pub fn popen(command: *const c_char, mode: *const c_char) -> *mut ::FILE; + pub fn faccessat( + dirfd: ::c_int, +@@ -3839,6 +3934,17 @@ extern "C" { + ) -> ::c_int; + + pub fn gethostid() -> ::c_long; ++ ++ pub fn pthread_getcpuclockid(thread: ::pthread_t, clk_id: *mut ::clockid_t) -> ::c_int; ++ pub fn memmem( ++ haystack: *const ::c_void, ++ haystacklen: ::size_t, ++ needle: *const ::c_void, ++ needlelen: ::size_t, ++ ) -> *mut ::c_void; ++ pub fn sched_getcpu() -> ::c_int; ++ ++ pub fn memfd_create(name: *const ::c_char, flags: ::c_uint) -> ::c_int; + } + + cfg_if! { +diff --git a/vendor/libc/src/unix/linux_like/linux/musl/mod.rs b/vendor/libc/src/unix/linux_like/linux/musl/mod.rs +index 6b2dd89..df596e9 100644 +--- a/vendor/libc/src/unix/linux_like/linux/musl/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/musl/mod.rs +@@ -133,24 +133,6 @@ s! { + __dummy4: [::c_char; 16], + } + +- pub struct nlmsghdr { +- pub nlmsg_len: u32, +- pub nlmsg_type: u16, +- pub nlmsg_flags: u16, +- pub nlmsg_seq: u32, +- pub nlmsg_pid: u32, +- } +- +- pub struct nlmsgerr { +- pub error: ::c_int, +- pub msg: nlmsghdr, +- } +- +- pub struct nlattr { +- pub nla_len: u16, +- pub nla_type: u16, +- } +- + pub struct sigaction { + pub sa_sigaction: ::sighandler_t, + pub sa_mask: ::sigset_t, +@@ -757,23 +739,6 @@ extern "C" { + pub fn ptrace(request: ::c_int, ...) -> ::c_long; + pub fn getpriority(which: ::c_int, who: ::id_t) -> ::c_int; + pub fn setpriority(which: ::c_int, who: ::id_t, prio: ::c_int) -> ::c_int; +- pub fn pthread_getaffinity_np( +- thread: ::pthread_t, +- cpusetsize: ::size_t, +- cpuset: *mut ::cpu_set_t, +- ) -> ::c_int; +- pub fn pthread_setaffinity_np( +- thread: ::pthread_t, +- cpusetsize: ::size_t, +- cpuset: *const ::cpu_set_t, +- ) -> ::c_int; +- pub fn sched_getcpu() -> ::c_int; +- pub fn memmem( +- haystack: *const ::c_void, +- haystacklen: ::size_t, +- needle: *const ::c_void, +- needlelen: ::size_t, +- ) -> *mut ::c_void; + // Musl targets need the `mask` argument of `fanotify_mark` be specified + // `::c_ulonglong` instead of `u64` or there will be a type mismatch between + // `long long unsigned int` and the expected `uint64_t`. +diff --git a/vendor/libc/src/unix/linux_like/linux/no_align.rs b/vendor/libc/src/unix/linux_like/linux/no_align.rs +index de64be5..a2c08de 100644 +--- a/vendor/libc/src/unix/linux_like/linux/no_align.rs ++++ b/vendor/libc/src/unix/linux_like/linux/no_align.rs +@@ -5,6 +5,7 @@ macro_rules! expand_align { + #[cfg(any(target_arch = "x86_64", + target_arch = "powerpc64", + target_arch = "mips64", ++ target_arch = "sw64", // GUYC20210602 + target_arch = "s390x", + target_arch = "sparc64", + target_arch = "riscv64", +@@ -15,6 +16,7 @@ macro_rules! expand_align { + #[cfg(not(any(target_arch = "x86_64", + target_arch = "powerpc64", + target_arch = "mips64", ++ target_arch = "sw64", // GUYC20210602 + target_arch = "s390x", + target_arch = "sparc64", + target_arch = "riscv64", +diff --git a/vendor/libc/src/unix/linux_like/linux/uclibc/arm/mod.rs b/vendor/libc/src/unix/linux_like/linux/uclibc/arm/mod.rs +index dc6518c..ccc005d 100644 +--- a/vendor/libc/src/unix/linux_like/linux/uclibc/arm/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/uclibc/arm/mod.rs +@@ -61,8 +61,8 @@ s! { + pub st_mtime_nsec: ::c_long, + pub st_ctime: ::time_t, + pub st_ctime_nsec: ::c_long, +- pub __uclibc_unused4: ::c_ulong, +- pub __uclibc_unused5: ::c_ulong, ++ pub __unused4: ::c_ulong, ++ pub __unused5: ::c_ulong, + } + + pub struct stat64 +@@ -205,41 +205,41 @@ s! { + pub __pad1: ::c_ushort, + pub __seq: ::c_ushort, + pub __pad2: ::c_ushort, +- pub __uclibc_unused1: ::c_ulong, +- pub __uclibc_unused2: ::c_ulong, ++ pub __unused1: ::c_ulong, ++ pub __unused2: ::c_ulong, + } + + pub struct msqid_ds { + pub msg_perm: ::ipc_perm, + pub msg_stime: ::time_t, +- pub __uclibc_unused1: ::c_ulong, ++ pub __unused1: ::c_ulong, + pub msg_rtime: ::time_t, +- pub __uclibc_unused2: ::c_ulong, ++ pub __unused2: ::c_ulong, + pub msg_ctime: ::time_t, +- pub __uclibc_unused3: ::c_ulong, ++ pub __unused3: ::c_ulong, + pub __msg_cbytes: ::c_ulong, + pub msg_qnum: ::msgqnum_t, + pub msg_qbytes: ::msglen_t, + pub msg_lspid: ::pid_t, + pub msg_lrpid: ::pid_t, +- pub __uclibc_unused4: ::c_ulong, +- pub __uclibc_unused5: ::c_ulong, ++ pub __unused4: ::c_ulong, ++ pub __unused5: ::c_ulong, + } + + pub struct shmid_ds { + pub shm_perm: ::ipc_perm, + pub shm_segsz: ::size_t, + pub shm_atime: ::time_t, +- pub __uclibc_unused1: ::c_ulong, ++ pub __unused1: ::c_ulong, + pub shm_dtime: ::time_t, +- pub __uclibc_unused2: ::c_ulong, ++ pub __unused2: ::c_ulong, + pub shm_ctime: ::time_t, +- pub __uclibc_unused3: ::c_ulong, ++ pub __unused3: ::c_ulong, + pub shm_cpid: ::pid_t, + pub shm_lpid: ::pid_t, + pub shm_nattch: ::shmatt_t, +- pub __uclibc_unused4: ::c_ulong, +- pub __uclibc_unused5: ::c_ulong, ++ pub __unused4: ::c_ulong, ++ pub __unused5: ::c_ulong, + } + } + +@@ -469,6 +469,7 @@ pub const PENDIN: ::tcflag_t = 0x4000; + pub const POLLWRBAND: ::c_short = 0x200; + pub const POLLWRNORM: ::c_short = 0x100; + pub const PTHREAD_STACK_MIN: ::size_t = 16384; ++pub const RTLD_GLOBAL: ::c_int = 0x00100; + + // These are typed unsigned to match sigaction + pub const SA_NOCLDSTOP: ::c_ulong = 0x1; +@@ -516,6 +517,8 @@ pub const TABDLY: ::c_int = 0x1800; + pub const TCSADRAIN: ::c_int = 0x1; + pub const TCSAFLUSH: ::c_int = 0x2; + pub const TCSANOW: ::c_int = 0; ++pub const TIOCGWINSZ: ::c_int = 0x5413; ++pub const TIOCSWINSZ: ::c_int = 0x5414; + pub const TOSTOP: ::tcflag_t = 0x100; + pub const VDISCARD: usize = 0xd; + pub const VEOF: usize = 0x4; +@@ -886,6 +889,9 @@ pub const SYS_pwritev2: ::c_long = 393; + pub const SYS_pkey_mprotect: ::c_long = 394; + pub const SYS_pkey_alloc: ::c_long = 395; + pub const SYS_pkey_free: ::c_long = 396; ++pub const SYS_statx: ::c_int = 397; ++pub const SYS_pidfd_open: ::c_long = 434; ++pub const SYS_clone3: ::c_long = 435; + + extern "C" { + pub fn ioctl(fd: ::c_int, request: ::c_ulong, ...) -> ::c_int; +diff --git a/vendor/libc/src/unix/linux_like/linux/uclibc/mips/mips32/mod.rs b/vendor/libc/src/unix/linux_like/linux/uclibc/mips/mips32/mod.rs +index 8edde11..c0fe0ab 100644 +--- a/vendor/libc/src/unix/linux_like/linux/uclibc/mips/mips32/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/uclibc/mips/mips32/mod.rs +@@ -625,6 +625,7 @@ pub const SYS_pwritev2: ::c_long = 4000 + 362; + pub const SYS_pkey_mprotect: ::c_long = 4000 + 363; + pub const SYS_pkey_alloc: ::c_long = 4000 + 364; + pub const SYS_pkey_free: ::c_long = 4000 + 365; ++pub const SYS_clone3: ::c_long = 4000 + 435; + + #[link(name = "util")] + extern "C" { +diff --git a/vendor/libc/src/unix/linux_like/linux/uclibc/mips/mod.rs b/vendor/libc/src/unix/linux_like/linux/uclibc/mips/mod.rs +index 28fa9a2..a724c3e 100644 +--- a/vendor/libc/src/unix/linux_like/linux/uclibc/mips/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/uclibc/mips/mod.rs +@@ -32,22 +32,13 @@ pub const EPOLL_CLOEXEC: ::c_int = 0x80000; + + pub const EFD_CLOEXEC: ::c_int = 0x80000; + +-pub const BUFSIZ: ::c_uint = 4096; + pub const TMP_MAX: ::c_uint = 238328; +-pub const FOPEN_MAX: ::c_uint = 16; +-pub const POSIX_MADV_DONTNEED: ::c_int = 4; + pub const _SC_2_C_VERSION: ::c_int = 96; + pub const O_ACCMODE: ::c_int = 3; + pub const O_DIRECT: ::c_int = 0x8000; + pub const O_DIRECTORY: ::c_int = 0x10000; + pub const O_NOFOLLOW: ::c_int = 0x20000; +-pub const NI_MAXHOST: ::socklen_t = 1025; + +-pub const RLIMIT_NOFILE: ::c_int = 5; +-pub const RLIMIT_AS: ::c_int = 6; +-pub const RLIMIT_RSS: ::c_int = 7; +-pub const RLIMIT_NPROC: ::c_int = 8; +-pub const RLIMIT_MEMLOCK: ::c_int = 9; + pub const RLIMIT_NLIMITS: ::c_int = 15; + pub const RLIM_NLIMITS: ::c_int = RLIMIT_NLIMITS; + +@@ -87,7 +78,6 @@ pub const EXFULL: ::c_int = 52; + pub const ENOANO: ::c_int = 53; + pub const EBADRQC: ::c_int = 54; + pub const EBADSLT: ::c_int = 55; +-pub const EDEADLOCK: ::c_int = 56; + pub const EMULTIHOP: ::c_int = 74; + pub const EOVERFLOW: ::c_int = 79; + pub const ENOTUNIQ: ::c_int = 80; +@@ -189,7 +179,6 @@ pub const SIGTSTP: ::c_int = 24; + pub const SIGURG: ::c_int = 21; + pub const SIGIO: ::c_int = 22; + pub const SIGSYS: ::c_int = 12; +-pub const SIGPOLL: ::c_int = 22; + pub const SIGPWR: ::c_int = 19; + pub const SIG_SETMASK: ::c_int = 3; + pub const SIG_BLOCK: ::c_int = 0x1; +@@ -216,47 +205,15 @@ pub const CPU_SETSIZE: ::c_int = 0x400; + pub const EFD_NONBLOCK: ::c_int = 0x80; + + pub const F_GETLK: ::c_int = 14; +-pub const F_GETOWN: ::c_int = 23; +-pub const F_SETOWN: ::c_int = 24; + pub const F_SETLK: ::c_int = 6; + pub const F_SETLKW: ::c_int = 7; + + pub const SFD_NONBLOCK: ::c_int = 0x80; + +-pub const TCGETS: ::c_ulong = 0x540d; +-pub const TCSETS: ::c_ulong = 0x540e; +-pub const TCSETSW: ::c_ulong = 0x540f; +-pub const TCSETSF: ::c_ulong = 0x5410; +-pub const TCGETA: ::c_ulong = 0x5401; +-pub const TCSETA: ::c_ulong = 0x5402; +-pub const TCSETAW: ::c_ulong = 0x5403; +-pub const TCSETAF: ::c_ulong = 0x5404; +-pub const TCSBRK: ::c_ulong = 0x5405; +-pub const TCXONC: ::c_ulong = 0x5406; +-pub const TCFLSH: ::c_ulong = 0x5407; +-pub const TIOCGSOFTCAR: ::c_ulong = 0x5481; +-pub const TIOCSSOFTCAR: ::c_ulong = 0x5482; +-pub const TIOCINQ: ::c_ulong = 0x467f; +-pub const TIOCLINUX: ::c_ulong = 0x5483; +-pub const TIOCGSERIAL: ::c_ulong = 0x5484; +-pub const TIOCEXCL: ::c_ulong = 0x740d; +-pub const TIOCNXCL: ::c_ulong = 0x740e; +-pub const TIOCSCTTY: ::c_ulong = 0x5480; +-pub const TIOCGPGRP: ::c_ulong = 0x40047477; +-pub const TIOCSPGRP: ::c_ulong = 0x80047476; +-pub const TIOCOUTQ: ::c_ulong = 0x7472; +-pub const TIOCSTI: ::c_ulong = 0x5472; + pub const TIOCGWINSZ: ::c_ulong = 0x40087468; + pub const TIOCSWINSZ: ::c_ulong = 0x80087467; +-pub const TIOCMGET: ::c_ulong = 0x741d; +-pub const TIOCMBIS: ::c_ulong = 0x741b; +-pub const TIOCMBIC: ::c_ulong = 0x741c; +-pub const TIOCMSET: ::c_ulong = 0x741a; +-pub const FIONREAD: ::c_ulong = 0x467f; +-pub const TIOCCONS: ::c_ulong = 0x80047478; + + pub const RTLD_GLOBAL: ::c_int = 0x4; +-pub const RTLD_NOLOAD: ::c_int = 0x8; + + pub const SIGSTKSZ: ::size_t = 8192; + pub const CBAUD: ::tcflag_t = 0o0010017; +@@ -316,8 +273,6 @@ pub const B4800: ::speed_t = 0o000014; + pub const B9600: ::speed_t = 0o000015; + pub const B19200: ::speed_t = 0o000016; + pub const B38400: ::speed_t = 0o000017; +-pub const EXTA: ::speed_t = B19200; +-pub const EXTB: ::speed_t = B38400; + pub const B57600: ::speed_t = 0o010001; + pub const B115200: ::speed_t = 0o010002; + pub const B230400: ::speed_t = 0o010003; +diff --git a/vendor/libc/src/unix/linux_like/linux/uclibc/mod.rs b/vendor/libc/src/unix/linux_like/linux/uclibc/mod.rs +index 396e33d..113303a 100644 +--- a/vendor/libc/src/unix/linux_like/linux/uclibc/mod.rs ++++ b/vendor/libc/src/unix/linux_like/linux/uclibc/mod.rs +@@ -2,6 +2,8 @@ pub type shmatt_t = ::c_ulong; + pub type msgqnum_t = ::c_ulong; + pub type msglen_t = ::c_ulong; + pub type regoff_t = ::c_int; ++pub type __rlimit_resource_t = ::c_uint; ++pub type __priority_which_t = ::c_uint; + + s! { + pub struct statvfs { // Different than GNU! +@@ -34,6 +36,32 @@ s! { + __re_nsub: ::size_t, + __bitfield: u8, + } ++ ++ pub struct rtentry { ++ pub rt_pad1: ::c_ulong, ++ pub rt_dst: ::sockaddr, ++ pub rt_gateway: ::sockaddr, ++ pub rt_genmask: ::sockaddr, ++ pub rt_flags: ::c_ushort, ++ pub rt_pad2: ::c_short, ++ pub rt_pad3: ::c_ulong, ++ pub rt_tos: ::c_uchar, ++ pub rt_class: ::c_uchar, ++ #[cfg(target_pointer_width = "64")] ++ pub rt_pad4: [::c_short; 3usize], ++ #[cfg(not(target_pointer_width = "64"))] ++ pub rt_pad4: ::c_short, ++ pub rt_metric: ::c_short, ++ pub rt_dev: *mut ::c_char, ++ pub rt_mtu: ::c_ulong, ++ pub rt_window: ::c_ulong, ++ pub rt_irtt: ::c_ushort, ++ } ++ ++ pub struct __exit_status { ++ pub e_termination: ::c_short, ++ pub e_exit: ::c_short, ++ } + } + + pub const MCL_CURRENT: ::c_int = 0x0001; +@@ -223,6 +251,108 @@ pub const PRIO_USER: ::c_int = 2; + + pub const ST_RELATIME: ::c_ulong = 4096; + ++pub const AF_NFC: ::c_int = PF_NFC; ++pub const BUFSIZ: ::c_int = 4096; ++pub const EDEADLOCK: ::c_int = EDEADLK; ++pub const EXTA: ::c_uint = B19200; ++pub const EXTB: ::c_uint = B38400; ++pub const EXTPROC: ::c_int = 0200000; ++pub const FAN_MARK_FILESYSTEM: ::c_int = 0x00000100; ++pub const FAN_MARK_INODE: ::c_int = 0x00000000; ++pub const FAN_MARK_MOUNT: ::c_int = 0x10; ++pub const FIONREAD: ::c_int = 0x541B; ++pub const FOPEN_MAX: ::c_int = 16; ++pub const F_GETOWN: ::c_int = 9; ++pub const F_OFD_GETLK: ::c_int = 36; ++pub const F_OFD_SETLK: ::c_int = 37; ++pub const F_OFD_SETLKW: ::c_int = 38; ++pub const F_RDLCK: ::c_int = 0; ++pub const F_SETOWN: ::c_int = 8; ++pub const F_UNLCK: ::c_int = 2; ++pub const F_WRLCK: ::c_int = 1; ++pub const IPV6_MULTICAST_ALL: ::c_int = 29; ++pub const IPV6_ROUTER_ALERT_ISOLATE: ::c_int = 30; ++pub const MAP_HUGE_SHIFT: ::c_int = 26; ++pub const MAP_HUGE_MASK: ::c_int = 0x3f; ++pub const MAP_HUGE_64KB: ::c_int = 16 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_512KB: ::c_int = 19 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_1MB: ::c_int = 20 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_2MB: ::c_int = 21 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_8MB: ::c_int = 23 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_16MB: ::c_int = 24 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_32MB: ::c_int = 25 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_256MB: ::c_int = 28 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_512MB: ::c_int = 29 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_1GB: ::c_int = 30 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_2GB: ::c_int = 31 << MAP_HUGE_SHIFT; ++pub const MAP_HUGE_16GB: ::c_int = 34 << MAP_HUGE_SHIFT; ++pub const MINSIGSTKSZ: ::c_int = 2048; ++pub const MSG_COPY: ::c_int = 040000; ++pub const NI_MAXHOST: ::socklen_t = 1025; ++pub const O_TMPFILE: ::c_int = 020000000 | O_DIRECTORY; ++pub const PACKET_MR_UNICAST: ::c_int = 3; ++pub const PF_NFC: ::c_int = 39; ++pub const PF_VSOCK: ::c_int = 40; ++pub const POSIX_MADV_DONTNEED: ::c_int = 4; ++pub const PTRACE_EVENT_STOP: ::c_int = 128; ++pub const PTRACE_PEEKSIGINFO: ::c_int = 0x4209; ++pub const RLIMIT_AS: ::c_int = 9; ++pub const RLIMIT_MEMLOCK: ::c_int = 8; ++pub const RLIMIT_NLIMITS: ::c_int = 15; ++pub const RLIMIT_NOFILE: ::c_int = 7; ++pub const RLIMIT_NPROC: ::c_int = 6; ++pub const RLIMIT_RSS: ::c_int = 5; ++pub const RLIMIT_RTTIME: ::c_int = 15; ++pub const RTLD_NOLOAD: ::c_int = 0x00004; ++pub const RUSAGE_THREAD: ::c_int = 1; ++pub const SHM_EXEC: ::c_int = 0100000; ++pub const SIGPOLL: ::c_int = SIGIO; ++pub const SOCK_DCCP: ::c_int = 6; ++pub const SOCK_PACKET: ::c_int = 10; ++pub const TCFLSH: ::c_int = 0x540B; ++pub const TCGETA: ::c_int = 0x5405; ++pub const TCGETS: ::c_int = 0x5401; ++pub const TCP_COOKIE_TRANSACTIONS: ::c_int = 15; ++pub const TCSBRK: ::c_int = 0x5409; ++pub const TCSETA: ::c_int = 0x5406; ++pub const TCSETAF: ::c_int = 0x5408; ++pub const TCSETAW: ::c_int = 0x5407; ++pub const TCSETS: ::c_int = 0x5402; ++pub const TCSETSF: ::c_int = 0x5404; ++pub const TCSETSW: ::c_int = 0x5403; ++pub const TCXONC: ::c_int = 0x540A; ++pub const TIOCCONS: ::c_int = 0x541D; ++pub const TIOCEXCL: ::c_int = 0x540C; ++pub const TIOCGPGRP: ::c_int = 0x540F; ++pub const TIOCGSERIAL: ::c_int = 0x541E; ++pub const TIOCGSOFTCAR: ::c_int = 0x5419; ++pub const TIOCINQ: ::c_int = FIONREAD; ++pub const TIOCLINUX: ::c_int = 0x541C; ++pub const TIOCMBIC: ::c_int = 0x5417; ++pub const TIOCMGET: ::c_int = 0x5415; ++pub const TIOCMBIS: ::c_int = 0x5416; ++pub const TIOCMSET: ::c_int = 0x5418; ++pub const TIOCM_CAR: ::c_int = 0x040; ++pub const TIOCM_CD: ::c_int = TIOCM_CAR; ++pub const TIOCM_CTS: ::c_int = 0x020; ++pub const TIOCM_DSR: ::c_int = 0x100; ++pub const TIOCM_DTR: ::c_int = 0x002; ++pub const TIOCM_LE: ::c_int = 0x001; ++pub const TIOCM_RI: ::c_int = TIOCM_RNG; ++pub const TIOCM_RNG: ::c_int = 0x080; ++pub const TIOCM_RTS: ::c_int = 0x004; ++pub const TIOCM_SR: ::c_int = 0x010; ++pub const TIOCM_ST: ::c_int = 0x008; ++pub const TIOCNXCL: ::c_int = 0x540D; ++pub const TIOCOUTQ: ::c_int = 0x5411; ++pub const TIOCSCTTY: ::c_int = 0x540E; ++pub const TIOCSPGRP: ::c_int = 0x5410; ++pub const TIOCSSOFTCAR: ::c_int = 0x541A; ++pub const TIOCSTI: ::c_int = 0x5412; ++pub const UDP_GRO: ::c_int = 104; ++pub const UDP_SEGMENT: ::c_int = 103; ++pub const YESEXPR: ::c_int = ((5) << 8) | (0); ++ + extern "C" { + pub fn gettimeofday(tp: *mut ::timeval, tz: *mut ::timezone) -> ::c_int; + +@@ -289,6 +419,19 @@ extern "C" { + ) -> ::ssize_t; + + pub fn sethostid(hostid: ::c_long) -> ::c_int; ++ pub fn fanotify_mark( ++ fd: ::c_int, ++ flags: ::c_uint, ++ mask: u64, ++ dirfd: ::c_int, ++ path: *const ::c_char, ++ ) -> ::c_int; ++ pub fn getrlimit64(resource: ::__rlimit_resource_t, rlim: *mut ::rlimit64) -> ::c_int; ++ pub fn setrlimit64(resource: ::__rlimit_resource_t, rlim: *const ::rlimit64) -> ::c_int; ++ pub fn getrlimit(resource: ::__rlimit_resource_t, rlim: *mut ::rlimit) -> ::c_int; ++ pub fn setrlimit(resource: ::__rlimit_resource_t, rlim: *const ::rlimit) -> ::c_int; ++ pub fn getpriority(which: ::__priority_which_t, who: ::id_t) -> ::c_int; ++ pub fn setpriority(which: ::__priority_which_t, who: ::id_t, prio: ::c_int) -> ::c_int; + } + + cfg_if! { +diff --git a/vendor/libc/src/unix/linux_like/linux/uclibc/x86_64/l4re.rs b/vendor/libc/src/unix/linux_like/linux/uclibc/x86_64/l4re.rs +index 16ec0ef..c7cbafa 100644 +--- a/vendor/libc/src/unix/linux_like/linux/uclibc/x86_64/l4re.rs ++++ b/vendor/libc/src/unix/linux_like/linux/uclibc/x86_64/l4re.rs +@@ -46,3 +46,8 @@ pub struct pthread_attr_t { + // L4Re requires a min stack size of 64k; that isn't defined in uClibc, but + // somewhere in the core libraries. uClibc wants 16k, but that's not enough. + pub const PTHREAD_STACK_MIN: usize = 65536; ++ ++// Misc other constants required for building. ++pub const SIGIO: ::c_int = 29; ++pub const B19200: ::speed_t = 0o000016; ++pub const B38400: ::speed_t = 0o000017; +diff --git a/vendor/libc/src/unix/linux_like/mod.rs b/vendor/libc/src/unix/linux_like/mod.rs +index a8b0332..b66e3fa 100644 +--- a/vendor/libc/src/unix/linux_like/mod.rs ++++ b/vendor/libc/src/unix/linux_like/mod.rs +@@ -573,14 +573,27 @@ pub const LC_MESSAGES_MASK: ::c_int = 1 << LC_MESSAGES; + pub const MAP_FILE: ::c_int = 0x0000; + pub const MAP_SHARED: ::c_int = 0x0001; + pub const MAP_PRIVATE: ::c_int = 0x0002; ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub const MAP_FIXED: ::c_int = 0x100; ++#[cfg(not(target_arch = "sw64"))] + pub const MAP_FIXED: ::c_int = 0x0010; + + pub const MAP_FAILED: *mut ::c_void = !0 as *mut ::c_void; + + // MS_ flags for msync(2) + pub const MS_ASYNC: ::c_int = 0x0001; +-pub const MS_INVALIDATE: ::c_int = 0x0002; +-pub const MS_SYNC: ::c_int = 0x0004; ++ ++// GUYC20210602 ++cfg_if!{ ++ if #[cfg(target_arch = "sw64")] { ++ pub const MS_INVALIDATE: ::c_int = 0x0004; ++ pub const MS_SYNC: ::c_int = 0x0002; ++ } else { ++ pub const MS_INVALIDATE: ::c_int = 0x0002; ++ pub const MS_SYNC: ::c_int = 0x0004; ++ } ++} + + // MS_ flags for mount(2) + pub const MS_RDONLY: ::c_ulong = 0x01; +@@ -623,6 +636,10 @@ pub const MADV_NORMAL: ::c_int = 0; + pub const MADV_RANDOM: ::c_int = 1; + pub const MADV_SEQUENTIAL: ::c_int = 2; + pub const MADV_WILLNEED: ::c_int = 3; ++// GUYC20210602 ++#[cfg(target_arch = "sw64")] ++pub const MADV_DONTNEED: ::c_int = 6; ++#[cfg(not(target_arch = "sw64"))] + pub const MADV_DONTNEED: ::c_int = 4; + pub const MADV_FREE: ::c_int = 8; + pub const MADV_REMOVE: ::c_int = 9; +@@ -877,6 +894,8 @@ pub const IPPROTO_MH: ::c_int = 135; + pub const IPPROTO_UDPLITE: ::c_int = 136; + /// raw IP packet + pub const IPPROTO_RAW: ::c_int = 255; ++pub const IPPROTO_BEETPH: ::c_int = 94; ++pub const IPPROTO_MPLS: ::c_int = 137; + + pub const MCAST_EXCLUDE: ::c_int = 0; + pub const MCAST_INCLUDE: ::c_int = 1; +@@ -913,6 +932,7 @@ pub const IPV6_JOIN_ANYCAST: ::c_int = 27; + pub const IPV6_LEAVE_ANYCAST: ::c_int = 28; + pub const IPV6_IPSEC_POLICY: ::c_int = 34; + pub const IPV6_XFRM_POLICY: ::c_int = 35; ++pub const IPV6_HDRINCL: ::c_int = 36; + pub const IPV6_RECVPKTINFO: ::c_int = 49; + pub const IPV6_PKTINFO: ::c_int = 50; + pub const IPV6_RECVHOPLIMIT: ::c_int = 51; +@@ -948,6 +968,8 @@ pub const IPV6_PMTUDISC_DONT: ::c_int = 0; + pub const IPV6_PMTUDISC_WANT: ::c_int = 1; + pub const IPV6_PMTUDISC_DO: ::c_int = 2; + pub const IPV6_PMTUDISC_PROBE: ::c_int = 3; ++pub const IPV6_PMTUDISC_INTERFACE: ::c_int = 4; ++pub const IPV6_PMTUDISC_OMIT: ::c_int = 5; + + pub const TCP_NODELAY: ::c_int = 1; + pub const TCP_MAXSEG: ::c_int = 2; +@@ -1023,13 +1045,17 @@ pub const FD_SETSIZE: usize = 1024; + pub const EPOLLIN: ::c_int = 0x1; + pub const EPOLLPRI: ::c_int = 0x2; + pub const EPOLLOUT: ::c_int = 0x4; ++pub const EPOLLERR: ::c_int = 0x8; ++pub const EPOLLHUP: ::c_int = 0x10; + pub const EPOLLRDNORM: ::c_int = 0x40; + pub const EPOLLRDBAND: ::c_int = 0x80; + pub const EPOLLWRNORM: ::c_int = 0x100; + pub const EPOLLWRBAND: ::c_int = 0x200; + pub const EPOLLMSG: ::c_int = 0x400; +-pub const EPOLLERR: ::c_int = 0x8; +-pub const EPOLLHUP: ::c_int = 0x10; ++pub const EPOLLRDHUP: ::c_int = 0x2000; ++pub const EPOLLEXCLUSIVE: ::c_int = 0x10000000; ++pub const EPOLLWAKEUP: ::c_int = 0x20000000; ++pub const EPOLLONESHOT: ::c_int = 0x40000000; + pub const EPOLLET: ::c_int = 0x80000000; + + pub const EPOLL_CTL_ADD: ::c_int = 1; +@@ -1075,11 +1101,22 @@ pub const CR0: ::tcflag_t = 0x00000000; + pub const FF0: ::tcflag_t = 0x00000000; + pub const BS0: ::tcflag_t = 0x00000000; + pub const VT0: ::tcflag_t = 0x00000000; +-pub const VERASE: usize = 2; +-pub const VKILL: usize = 3; +-pub const VINTR: usize = 0; +-pub const VQUIT: usize = 1; +-pub const VLNEXT: usize = 15; ++// GUYC20210602 ++cfg_if! { ++ if #[cfg(target_arch = "sw64")] { ++ pub const VERASE: usize = 3; ++ pub const VKILL: usize = 5; ++ pub const VINTR: usize = 8; ++ pub const VQUIT: usize = 9; ++ pub const VLNEXT: usize = 14; ++ } else { ++ pub const VERASE: usize = 2; ++ pub const VKILL: usize = 3; ++ pub const VINTR: usize = 0; ++ pub const VQUIT: usize = 1; ++ pub const VLNEXT: usize = 15; ++ } ++} + pub const IGNBRK: ::tcflag_t = 0x00000001; + pub const BRKINT: ::tcflag_t = 0x00000002; + pub const IGNPAR: ::tcflag_t = 0x00000004; +@@ -1117,6 +1154,7 @@ pub const CLONE_CHILD_CLEARTID: ::c_int = 0x200000; + pub const CLONE_DETACHED: ::c_int = 0x400000; + pub const CLONE_UNTRACED: ::c_int = 0x800000; + pub const CLONE_CHILD_SETTID: ::c_int = 0x01000000; ++pub const CLONE_NEWCGROUP: ::c_int = 0x02000000; + pub const CLONE_NEWUTS: ::c_int = 0x04000000; + pub const CLONE_NEWIPC: ::c_int = 0x08000000; + pub const CLONE_NEWUSER: ::c_int = 0x10000000; +@@ -1132,11 +1170,15 @@ pub const WCONTINUED: ::c_int = 0x00000008; + pub const WNOWAIT: ::c_int = 0x01000000; + + // Options for personality(2). ++pub const ADDR_NO_RANDOMIZE: ::c_int = 0x0040000; + pub const MMAP_PAGE_ZERO: ::c_int = 0x0100000; ++pub const ADDR_COMPAT_LAYOUT: ::c_int = 0x0200000; ++pub const READ_IMPLIES_EXEC: ::c_int = 0x0400000; + pub const ADDR_LIMIT_32BIT: ::c_int = 0x0800000; + pub const SHORT_INODE: ::c_int = 0x1000000; + pub const WHOLE_SECONDS: ::c_int = 0x2000000; + pub const STICKY_TIMEOUTS: ::c_int = 0x4000000; ++pub const ADDR_LIMIT_3GB: ::c_int = 0x8000000; + + // Options set using PTRACE_SETOPTIONS. + pub const PTRACE_O_TRACESYSGOOD: ::c_int = 0x00000001; +@@ -1147,6 +1189,8 @@ pub const PTRACE_O_TRACEEXEC: ::c_int = 0x00000010; + pub const PTRACE_O_TRACEVFORKDONE: ::c_int = 0x00000020; + pub const PTRACE_O_TRACEEXIT: ::c_int = 0x00000040; + pub const PTRACE_O_TRACESECCOMP: ::c_int = 0x00000080; ++pub const PTRACE_O_SUSPEND_SECCOMP: ::c_int = 0x00200000; ++pub const PTRACE_O_EXITKILL: ::c_int = 0x00100000; + + // Wait extended result codes for the above trace options. + pub const PTRACE_EVENT_FORK: ::c_int = 1; +@@ -1221,6 +1265,10 @@ pub const POLLHUP: ::c_short = 0x10; + pub const POLLNVAL: ::c_short = 0x20; + pub const POLLRDNORM: ::c_short = 0x040; + pub const POLLRDBAND: ::c_short = 0x080; ++#[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))] ++pub const POLLRDHUP: ::c_short = 0x2000; ++#[cfg(any(target_arch = "sparc", target_arch = "sparc64"))] ++pub const POLLRDHUP: ::c_short = 0x800; + + pub const IPTOS_LOWDELAY: u8 = 0x10; + pub const IPTOS_THROUGHPUT: u8 = 0x08; +@@ -1346,18 +1394,6 @@ pub const ARPHRD_NONE: u16 = 0xFFFE; + + cfg_if! { + if #[cfg(not(target_env = "uclibc"))] { +- pub const IPPROTO_BEETPH: ::c_int = 94; +- pub const IPPROTO_MPLS: ::c_int = 137; +- pub const IPV6_HDRINCL: ::c_int = 36; +- pub const IPV6_PMTUDISC_INTERFACE: ::c_int = 4; +- pub const IPV6_PMTUDISC_OMIT: ::c_int = 5; +- pub const CLONE_NEWCGROUP: ::c_int = 0x02000000; +- pub const ADDR_NO_RANDOMIZE: ::c_int = 0x0040000; +- pub const ADDR_COMPAT_LAYOUT: ::c_int = 0x0200000; +- pub const READ_IMPLIES_EXEC: ::c_int = 0x0400000; +- pub const ADDR_LIMIT_3GB: ::c_int = 0x8000000; +- pub const PTRACE_O_EXITKILL: ::c_int = 0x00100000; +- pub const PTRACE_O_SUSPEND_SECCOMP: ::c_int = 0x00200000; + pub const PTRACE_O_MASK: ::c_int = 0x003000ff; + } + } +diff --git a/vendor/libc/src/unix/newlib/mod.rs b/vendor/libc/src/unix/newlib/mod.rs +index 4a35356..3a7cfa4 100644 +--- a/vendor/libc/src/unix/newlib/mod.rs ++++ b/vendor/libc/src/unix/newlib/mod.rs +@@ -611,10 +611,12 @@ extern "C" { + target_arch = "powerpc", + target_vendor = "nintendo" + )))] ++ #[cfg_attr(target_os = "espidf", link_name = "lwip_bind")] + pub fn bind(fd: ::c_int, addr: *const sockaddr, len: socklen_t) -> ::c_int; + pub fn clock_settime(clock_id: ::clockid_t, tp: *const ::timespec) -> ::c_int; + pub fn clock_gettime(clock_id: ::clockid_t, tp: *mut ::timespec) -> ::c_int; + pub fn clock_getres(clock_id: ::clockid_t, res: *mut ::timespec) -> ::c_int; ++ #[cfg_attr(target_os = "espidf", link_name = "lwip_close")] + pub fn closesocket(sockfd: ::c_int) -> ::c_int; + pub fn ioctl(fd: ::c_int, request: ::c_ulong, ...) -> ::c_int; + #[cfg(not(all( +@@ -622,6 +624,7 @@ extern "C" { + target_arch = "powerpc", + target_vendor = "nintendo" + )))] ++ #[cfg_attr(target_os = "espidf", link_name = "lwip_recvfrom")] + pub fn recvfrom( + fd: ::c_int, + buf: *mut ::c_void, +diff --git a/vendor/libc/src/unix/newlib/xtensa/mod.rs b/vendor/libc/src/unix/newlib/xtensa/mod.rs +new file mode 100644 +index 0000000..f520f7a +--- /dev/null ++++ b/vendor/libc/src/unix/newlib/xtensa/mod.rs +@@ -0,0 +1,93 @@ ++pub type clock_t = ::c_ulong; ++pub type c_char = i8; ++pub type wchar_t = u32; ++ ++pub type c_long = i32; ++pub type c_ulong = u32; ++ ++s! { ++ pub struct cmsghdr { ++ pub cmsg_len: ::socklen_t, ++ pub cmsg_level: ::c_int, ++ pub cmsg_type: ::c_int, ++ } ++ ++ pub struct msghdr { ++ pub msg_name: *mut ::c_void, ++ pub msg_namelen: ::socklen_t, ++ pub msg_iov: *mut ::iovec, ++ pub msg_iovlen: ::c_int, ++ pub msg_control: *mut ::c_void, ++ pub msg_controllen: ::socklen_t, ++ pub msg_flags: ::c_int, ++ } ++ ++ pub struct sockaddr_un { ++ pub sun_family: ::sa_family_t, ++ pub sun_path: [::c_char; 108], ++ } ++ ++ pub struct sockaddr { ++ pub sa_len: u8, ++ pub sa_family: ::sa_family_t, ++ pub sa_data: [::c_char; 14], ++ } ++ ++ pub struct sockaddr_in6 { ++ pub sin6_len: u8, ++ pub sin6_family: ::sa_family_t, ++ pub sin6_port: ::in_port_t, ++ pub sin6_flowinfo: u32, ++ pub sin6_addr: ::in6_addr, ++ pub sin6_scope_id: u32, ++ } ++ ++ pub struct sockaddr_in { ++ pub sin_len: u8, ++ pub sin_family: ::sa_family_t, ++ pub sin_port: ::in_port_t, ++ pub sin_addr: ::in_addr, ++ pub sin_zero: [::c_char; 8], ++ } ++ ++ pub struct sockaddr_storage { ++ pub s2_len: u8, ++ pub ss_family: ::sa_family_t, ++ pub s2_data1: [::c_char; 2], ++ pub s2_data2: [u32; 3], ++ pub s2_data3: [u32; 3], ++ } ++} ++ ++pub const AF_UNIX: ::c_int = 1; ++pub const AF_INET6: ::c_int = 10; ++ ++pub const FIONBIO: ::c_ulong = 2147772030; ++ ++pub const POLLIN: ::c_short = 1 << 0; ++pub const POLLRDNORM: ::c_short = 1 << 1; ++pub const POLLRDBAND: ::c_short = 1 << 2; ++pub const POLLPRI: ::c_short = POLLRDBAND; ++pub const POLLOUT: ::c_short = 1 << 3; ++pub const POLLWRNORM: ::c_short = POLLOUT; ++pub const POLLWRBAND: ::c_short = 1 << 4; ++pub const POLLERR: ::c_short = 1 << 5; ++pub const POLLHUP: ::c_short = 1 << 6; ++ ++pub const SOL_SOCKET: ::c_int = 0xfff; ++ ++pub const MSG_OOB: ::c_int = 0x04; ++pub const MSG_PEEK: ::c_int = 0x01; ++pub const MSG_DONTWAIT: ::c_int = 0x08; ++pub const MSG_DONTROUTE: ::c_int = 0x4; ++pub const MSG_WAITALL: ::c_int = 0x02; ++pub const MSG_MORE: ::c_int = 0x10; ++pub const MSG_NOSIGNAL: ::c_int = 0x20; ++ ++extern "C" { ++ pub fn sendmsg(s: ::c_int, msg: *const ::msghdr, flags: ::c_int) -> ::ssize_t; ++ pub fn recvmsg(s: ::c_int, msg: *mut ::msghdr, flags: ::c_int) -> ::ssize_t; ++ ++ pub fn writev(s: ::c_int, iov: *const ::iovec, iovcnt: ::c_int) -> ::c_int; ++ pub fn readv(fd: ::c_int, iov: *const ::iovec, iovcnt: ::c_int) -> ::ssize_t; ++} +diff --git a/vendor/libc/src/unix/redox/mod.rs b/vendor/libc/src/unix/redox/mod.rs +index 747d98c..f2a2d62 100644 +--- a/vendor/libc/src/unix/redox/mod.rs ++++ b/vendor/libc/src/unix/redox/mod.rs +@@ -819,6 +819,8 @@ pub const __WCLONE: ::c_int = 0x8000_0000; + // time.h + pub const CLOCK_REALTIME: ::c_int = 1; + pub const CLOCK_MONOTONIC: ::c_int = 4; ++pub const CLOCK_PROCESS_CPUTIME_ID: ::clockid_t = 2; ++pub const CLOCKS_PER_SEC: ::clock_t = 1_000_000; + + // unistd.h + // POSIX.1 { +diff --git a/vendor/libc/src/unix/solarish/illumos.rs b/vendor/libc/src/unix/solarish/illumos.rs +index c495019..5a8b083 100644 +--- a/vendor/libc/src/unix/solarish/illumos.rs ++++ b/vendor/libc/src/unix/solarish/illumos.rs +@@ -45,4 +45,8 @@ extern "C" { + opset: *mut ::psetid_t, + ) -> ::c_int; + pub fn pset_getloadavg(pset: ::psetid_t, load: *mut ::c_double, num: ::c_int) -> ::c_int; ++ ++ pub fn preadv(fd: ::c_int, iov: *const ::iovec, iovcnt: ::c_int, offset: ::off_t) -> ::ssize_t; ++ pub fn pwritev(fd: ::c_int, iov: *const ::iovec, iovcnt: ::c_int, offset: ::off_t) ++ -> ::ssize_t; + } +diff --git a/vendor/libc/src/unix/solarish/mod.rs b/vendor/libc/src/unix/solarish/mod.rs +index a34b9cc..d1de315 100644 +--- a/vendor/libc/src/unix/solarish/mod.rs ++++ b/vendor/libc/src/unix/solarish/mod.rs +@@ -35,6 +35,7 @@ pub type socklen_t = ::c_uint; + pub type sa_family_t = u16; + pub type pthread_t = ::c_uint; + pub type pthread_key_t = ::c_uint; ++pub type thread_t = ::c_uint; + pub type blksize_t = ::c_int; + pub type nl_item = ::c_int; + pub type mqd_t = *mut ::c_void; +@@ -266,6 +267,13 @@ s! { + pub f_fstr: [::c_char; 32] + } + ++ pub struct sendfilevec_t { ++ pub sfv_fd: ::c_int, ++ pub sfv_flag: ::c_uint, ++ pub sfv_off: ::off_t, ++ pub sfv_len: ::size_t, ++ } ++ + pub struct sched_param { + pub sched_priority: ::c_int, + sched_pad: [::c_int; 8] +@@ -417,7 +425,6 @@ s! { + pub maxerror: i32, + pub esterror: i32, + } +- + } + + s_no_extra_traits! { +@@ -502,6 +509,18 @@ s_no_extra_traits! { + pub sigev_notify_attributes: *const ::pthread_attr_t, + __sigev_pad2: ::c_int, + } ++ ++ #[cfg(libc_union)] ++ pub union pad128_t { ++ pub _q: ::c_double, ++ pub _l: [i32; 4], ++ } ++ ++ #[cfg(libc_union)] ++ pub union upad128_t { ++ pub _q: ::c_double, ++ pub _l: [u32; 4], ++ } + } + + cfg_if! { +@@ -827,6 +846,68 @@ cfg_if! { + } + } + ++ #[cfg(libc_union)] ++ impl PartialEq for pad128_t { ++ fn eq(&self, other: &pad128_t) -> bool { ++ unsafe { ++ self._q == other._q || ++ self._l == other._l ++ } ++ } ++ } ++ #[cfg(libc_union)] ++ impl Eq for pad128_t {} ++ #[cfg(libc_union)] ++ impl ::fmt::Debug for pad128_t { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ unsafe { ++ f.debug_struct("pad128_t") ++ .field("_q", &{self._q}) ++ .field("_l", &{self._l}) ++ .finish() ++ } ++ } ++ } ++ #[cfg(libc_union)] ++ impl ::hash::Hash for pad128_t { ++ fn hash(&self, state: &mut H) { ++ unsafe { ++ state.write_i64(self._q as i64); ++ self._l.hash(state); ++ } ++ } ++ } ++ #[cfg(libc_union)] ++ impl PartialEq for upad128_t { ++ fn eq(&self, other: &upad128_t) -> bool { ++ unsafe { ++ self._q == other._q || ++ self._l == other._l ++ } ++ } ++ } ++ #[cfg(libc_union)] ++ impl Eq for upad128_t {} ++ #[cfg(libc_union)] ++ impl ::fmt::Debug for upad128_t { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ unsafe { ++ f.debug_struct("upad128_t") ++ .field("_q", &{self._q}) ++ .field("_l", &{self._l}) ++ .finish() ++ } ++ } ++ } ++ #[cfg(libc_union)] ++ impl ::hash::Hash for upad128_t { ++ fn hash(&self, state: &mut H) { ++ unsafe { ++ state.write_i64(self._q as i64); ++ self._l.hash(state); ++ } ++ } ++ } + } + } + +@@ -1117,6 +1198,11 @@ pub const P_CTID: idtype_t = 13; + pub const P_CPUID: idtype_t = 14; + pub const P_PSETID: idtype_t = 15; + ++pub const PBIND_NONE: ::processorid_t = -1; ++pub const PBIND_QUERY: ::processorid_t = -2; ++pub const PBIND_HARD: ::processorid_t = -3; ++pub const PBIND_SOFT: ::processorid_t = -4; ++ + pub const PS_NONE: ::c_int = -1; + pub const PS_QUERY: ::c_int = -2; + pub const PS_MYID: ::c_int = -3; +@@ -2113,6 +2199,15 @@ pub const SCHED_IA: ::c_int = 4; + pub const SCHED_FSS: ::c_int = 5; + pub const SCHED_FX: ::c_int = 6; + ++// sys/priv.h ++pub const PRIV_DEBUG: ::c_uint = 0x0001; ++pub const PRIV_AWARE: ::c_uint = 0x0002; ++pub const PRIV_AWARE_INHERIT: ::c_uint = 0x0004; ++pub const __PROC_PROTECT: ::c_uint = 0x0008; ++pub const NET_MAC_AWARE: ::c_uint = 0x0010; ++pub const NET_MAC_AWARE_INHERIT: ::c_uint = 0x0020; ++pub const PRIV_AWARE_RESET: ::c_uint = 0x0040; ++ + // As per sys/socket.h, header alignment must be 8 bytes on SPARC + // and 4 bytes everywhere else: + #[cfg(target_arch = "sparc64")] +@@ -2337,6 +2432,8 @@ extern "C" { + lock: *mut pthread_mutex_t, + abstime: *const ::timespec, + ) -> ::c_int; ++ pub fn pthread_getname_np(tid: ::pthread_t, name: *mut ::c_char, len: ::size_t) -> ::c_int; ++ pub fn pthread_setname_np(tid: ::pthread_t, name: *const ::c_char) -> ::c_int; + pub fn waitid(idtype: idtype_t, id: id_t, infop: *mut ::siginfo_t, options: ::c_int) + -> ::c_int; + +@@ -2514,6 +2611,7 @@ extern "C" { + buflen: ::size_t, + result: *mut *mut ::group, + ) -> ::c_int; ++ pub fn thr_self() -> ::thread_t; + pub fn pthread_sigmask(how: ::c_int, set: *const sigset_t, oldset: *mut sigset_t) -> ::c_int; + pub fn sem_open(name: *const ::c_char, oflag: ::c_int, ...) -> *mut sem_t; + pub fn getgrnam(name: *const ::c_char) -> *mut ::group; +@@ -2678,6 +2776,18 @@ extern "C" { + + pub fn gethostid() -> ::c_long; + pub fn sethostid(hostid: ::c_long) -> ::c_int; ++ ++ pub fn getpflags(flags: ::c_uint) -> ::c_uint; ++ pub fn setpflags(flags: ::c_uint, value: ::c_uint) -> ::c_int; ++ ++ pub fn sendfile(out_fd: ::c_int, in_fd: ::c_int, off: *mut ::off_t, len: ::size_t) ++ -> ::ssize_t; ++ pub fn sendfilev( ++ fildes: ::c_int, ++ vec: *const sendfilevec_t, ++ sfvcnt: ::c_int, ++ xferred: *mut ::size_t, ++ ) -> ::ssize_t; + } + + mod compat; +@@ -2694,3 +2804,10 @@ cfg_if! { + // Unknown target_os + } + } ++ ++cfg_if! { ++ if #[cfg(target_arch = "x86_64")] { ++ mod x86_64; ++ pub use self::x86_64::*; ++ } ++} +diff --git a/vendor/libc/src/unix/solarish/x86_64.rs b/vendor/libc/src/unix/solarish/x86_64.rs +new file mode 100644 +index 0000000..a7107b0 +--- /dev/null ++++ b/vendor/libc/src/unix/solarish/x86_64.rs +@@ -0,0 +1,129 @@ ++pub type greg_t = ::c_long; ++ ++s! { ++ pub struct __c_anonymous_fpchip_state { ++ pub cw: u16, ++ pub sw: u16, ++ pub fctw: u8, ++ pub __fx_rsvd: u8, ++ pub fop: u16, ++ pub rip: u64, ++ pub rdp: u64, ++ pub mxcsr: u32, ++ pub mxcsr_mask: u32, ++ pub st: [::upad128_t; 8], ++ pub xmm: [::upad128_t; 16], ++ pub __fx_ign: [::upad128_t; 6], ++ pub status: u32, ++ pub xstatus: u32, ++ } ++} ++ ++s_no_extra_traits! { ++ #[cfg(libc_union)] ++ pub union __c_anonymous_fp_reg_set { ++ pub fpchip_state: __c_anonymous_fpchip_state, ++ pub f_fpregs: [[u32; 13]; 10], ++ } ++ ++ pub struct fpregset_t { ++ pub fp_reg_set: __c_anonymous_fp_reg_set, ++ } ++ ++ pub struct mcontext_t { ++ pub gregs: [::greg_t; 28], ++ pub fpgregs: fpregset_t, ++ } ++ ++ pub struct ucontext_t { ++ pub uc_flags: ::c_ulong, ++ pub uc_link: *mut ucontext_t, ++ pub uc_sigmask: ::sigset_t, ++ pub uc_stack: ::stack_t, ++ pub uc_mcontext: mcontext_t, ++ pub uc_filler: [::c_long; 5], ++ } ++} ++ ++cfg_if! { ++ if #[cfg(feature = "extra_traits")] { ++ #[cfg(libc_union)] ++ impl PartialEq for __c_anonymous_fp_reg_set { ++ fn eq(&self, other: &__c_anonymous_fp_reg_set) -> bool { ++ unsafe { ++ self.fpchip_state == other.fpchip_state || ++ self. ++ f_fpregs. ++ iter(). ++ zip(other.f_fpregs.iter()). ++ all(|(a, b)| a == b) ++ } ++ } ++ } ++ #[cfg(libc_union)] ++ impl Eq for __c_anonymous_fp_reg_set {} ++ #[cfg(libc_union)] ++ impl ::fmt::Debug for __c_anonymous_fp_reg_set { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ unsafe { ++ f.debug_struct("__c_anonymous_fp_reg_set") ++ .field("fpchip_state", &{self.fpchip_state}) ++ .field("f_fpregs", &{self.f_fpregs}) ++ .finish() ++ } ++ } ++ } ++ impl PartialEq for fpregset_t { ++ fn eq(&self, other: &fpregset_t) -> bool { ++ self.fp_reg_set == other.fp_reg_set ++ } ++ } ++ impl Eq for fpregset_t {} ++ impl ::fmt::Debug for fpregset_t { ++ fn fmt(&self, f:&mut ::fmt::Formatter) -> ::fmt::Result { ++ f.debug_struct("fpregset_t") ++ .field("fp_reg_set", &self.fp_reg_set) ++ .finish() ++ } ++ } ++ impl PartialEq for mcontext_t { ++ fn eq(&self, other: &mcontext_t) -> bool { ++ self.gregs == other.gregs && ++ self.fpgregs == other.fpgregs ++ } ++ } ++ impl Eq for mcontext_t {} ++ impl ::fmt::Debug for mcontext_t { ++ fn fmt(&self, f:&mut ::fmt::Formatter) -> ::fmt::Result { ++ f.debug_struct("mcontext_t") ++ .field("gregs", &self.gregs) ++ .field("fpgregs", &self.fpgregs) ++ .finish() ++ } ++ } ++ impl PartialEq for ucontext_t { ++ fn eq(&self, other: &ucontext_t) -> bool { ++ self.uc_flags == other.uc_flags ++ && self.uc_link == other.uc_link ++ && self.uc_sigmask == other.uc_sigmask ++ && self.uc_stack == other.uc_stack ++ && self.uc_mcontext == other.uc_mcontext ++ && self.uc_filler == other.uc_filler ++ } ++ } ++ impl Eq for ucontext_t {} ++ impl ::fmt::Debug for ucontext_t { ++ fn fmt(&self, f:&mut ::fmt::Formatter) -> ::fmt::Result { ++ f.debug_struct("ucontext_t") ++ .field("uc_flags", &self.uc_flags) ++ .field("uc_link", &self.uc_link) ++ .field("uc_sigmask", &self.uc_sigmask) ++ .field("uc_stack", &self.uc_stack) ++ .field("uc_mcontext", &self.uc_mcontext) ++ .field("uc_filler", &self.uc_filler) ++ .finish() ++ } ++ } ++ ++ } ++} +diff --git a/vendor/libc/src/vxworks/mod.rs b/vendor/libc/src/vxworks/mod.rs +old mode 100755 +new mode 100644 +diff --git a/vendor/libc/src/windows/mod.rs b/vendor/libc/src/windows/mod.rs +index 71af46a..8ecff3c 100644 +--- a/vendor/libc/src/windows/mod.rs ++++ b/vendor/libc/src/windows/mod.rs +@@ -27,6 +27,8 @@ pub type wchar_t = u16; + + pub type clock_t = i32; + ++pub type errno_t = ::c_int; ++ + cfg_if! { + if #[cfg(all(target_arch = "x86", target_env = "gnu"))] { + pub type time_t = i32; +@@ -372,6 +374,8 @@ extern "C" { + + #[link_name = "_gmtime64_s"] + pub fn gmtime_s(destTime: *mut tm, srcTime: *const time_t) -> ::c_int; ++ #[link_name = "_localtime64_s"] ++ pub fn localtime_s(tmDest: *mut tm, sourceTime: *const time_t) -> ::errno_t; + #[link_name = "_time64"] + pub fn time(destTime: *mut time_t) -> time_t; + #[link_name = "_chmod"] +diff --git a/vendor/libc/src/windows/msvc.rs b/vendor/libc/src/windows/msvc/mod.rs +similarity index 57% +rename from vendor/libc/src/windows/msvc.rs +rename to vendor/libc/src/windows/msvc/mod.rs +index b4c98a8..8cdb5bb 100644 +--- a/vendor/libc/src/windows/msvc.rs ++++ b/vendor/libc/src/windows/msvc/mod.rs +@@ -10,4 +10,20 @@ extern "C" { + pub fn stricmp(s1: *const ::c_char, s2: *const ::c_char) -> ::c_int; + #[link_name = "_strnicmp"] + pub fn strnicmp(s1: *const ::c_char, s2: *const ::c_char, n: ::size_t) -> ::c_int; ++ #[link_name = "_memccpy"] ++ pub fn memccpy( ++ dest: *mut ::c_void, ++ src: *const ::c_void, ++ c: ::c_int, ++ count: ::size_t, ++ ) -> *mut ::c_void; ++} ++ ++cfg_if! { ++ if #[cfg(target_arch = "x86_64")] { ++ mod x86_64; ++ pub use self::x86_64::*; ++ } else { ++ // Unknown target_arch ++ } + } +diff --git a/vendor/libc/src/windows/msvc/x86_64.rs b/vendor/libc/src/windows/msvc/x86_64.rs +new file mode 100644 +index 0000000..249e590 +--- /dev/null ++++ b/vendor/libc/src/windows/msvc/x86_64.rs +@@ -0,0 +1,140 @@ ++pub type XMM_SAVE_AREA32 = XSAVE_FORMAT; ++ ++s_no_extra_traits! { ++ #[repr(align(16))] ++ pub union __c_anonymous_CONTEXT_FP { ++ pub FltSave: ::XMM_SAVE_AREA32, ++ pub Xmm: __c_anonymous_CONTEXT_XMM, ++ } ++} ++ ++cfg_if! { ++ if #[cfg(feature = "extra_traits")] { ++ impl PartialEq for __c_anonymous_CONTEXT_FP { ++ fn eq(&self, other: &__c_anonymous_CONTEXT_FP) -> bool { ++ unsafe { ++ self.FltSave == other.FltSave || ++ self.Xmm == other.Xmm ++ } ++ } ++ } ++ impl Eq for __c_anonymous_CONTEXT_FP {} ++ impl ::fmt::Debug for __c_anonymous_CONTEXT_FP { ++ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { ++ unsafe { ++ f.debug_struct("__c_anonymous_CONTEXT_FP") ++ .field("FltSave", &self.FltSave) ++ .finish() ++ } ++ } ++ } ++ impl ::hash::Hash for __c_anonymous_CONTEXT_FP { ++ fn hash(&self, state: &mut H) { ++ unsafe { ++ self.FltSave.hash(state); ++ self.Xmm.hash(state); ++ } ++ } ++ } ++ } ++} ++ ++s! { ++ #[repr(align(16))] ++ pub struct M128A { ++ pub Low: ::c_ulonglong, ++ pub High: ::c_longlong, ++ } ++ ++ #[repr(align(16))] ++ pub struct XSAVE_FORMAT { ++ pub ControlWord: ::c_ushort, ++ pub StatusWord: ::c_ushort, ++ pub TagWord: ::c_uchar, ++ _Reserved1: ::c_uchar, ++ pub ErrorOpcode: ::c_ushort, ++ pub ErrorOffset: ::c_ulong, ++ pub ErrorSelector: ::c_ushort, ++ _Reserved2: ::c_ushort, ++ pub DataOffset: ::c_ulong, ++ pub DataSelector: ::c_ushort, ++ _Reserved3: ::c_ushort, ++ pub MxCsr: ::c_ulong, ++ pub MxCsr_Mask: ::c_ulong, ++ pub FloatRegisters: [M128A; 8], ++ pub XmmRegisters: [M128A; 16], ++ _Reserved4: [::c_uchar; 96], ++ } ++ ++ #[repr(align(16))] ++ pub struct __c_anonymous_CONTEXT_XMM { ++ pub Header: [M128A; 2], ++ pub Legacy: [M128A; 8], ++ pub Xmm0: M128A, ++ pub Xmm1: M128A, ++ pub Xmm2: M128A, ++ pub Xmm3: M128A, ++ pub Xmm4: M128A, ++ pub Xmm5: M128A, ++ pub Xmm6: M128A, ++ pub Xmm7: M128A, ++ pub Xmm8: M128A, ++ pub Xmm9: M128A, ++ pub Xmm10: M128A, ++ pub Xmm11: M128A, ++ pub Xmm12: M128A, ++ pub Xmm13: M128A, ++ pub Xmm14: M128A, ++ pub Xmm15: M128A, ++ } ++ ++ #[repr(align(16))] ++ pub struct CONTEXT { ++ pub P1Home: u64, ++ pub P2Home: u64, ++ pub P3Home: u64, ++ pub P4Home: u64, ++ pub P5Home: u64, ++ pub P6Home: u64, ++ pub ContextFlags: ::c_ulong, ++ pub MxCsr: ::c_ulong, ++ pub SegCs: ::c_ushort, ++ pub SegDs: ::c_ushort, ++ pub SegEs: ::c_ushort, ++ pub SegFs: ::c_ushort, ++ pub SegGs: ::c_ushort, ++ pub SegSs: ::c_ushort, ++ pub EFlags: ::c_ulong, ++ pub Dr0: u64, ++ pub Dr1: u64, ++ pub Dr2: u64, ++ pub Dr3: u64, ++ pub Dr6: u64, ++ pub Dr7: u64, ++ pub Rax: u64, ++ pub Rcx: u64, ++ pub Rdx: u64, ++ pub Rbx: u64, ++ pub Rsp: u64, ++ pub Rbp: u64, ++ pub Rsi: u64, ++ pub Rdi: u64, ++ pub R8: u64, ++ pub R9: u64, ++ pub R10: u64, ++ pub R11: u64, ++ pub R12: u64, ++ pub R13: u64, ++ pub R14: u64, ++ pub R15: u64, ++ pub Rip: u64, ++ pub Fp: __c_anonymous_CONTEXT_FP, ++ pub VectorRegister: [M128A; 26], ++ pub VectorControl: u64, ++ pub DebugControl: u64, ++ pub LastBranchToRip: u64, ++ pub LastBranchFromRip: u64, ++ pub LastExceptionToRip: u64, ++ pub LastExceptionFromRip: u64, ++ } ++} +-- +2.43.0 + diff --git a/nispor.spec b/nispor.spec index 4439090..acab481 100644 --- a/nispor.spec +++ b/nispor.spec @@ -2,12 +2,15 @@ %global __cargo_skip_build 0 Name: nispor Version: 1.0.1 -Release: 4 +Release: 5 Summary: Unified interface for Linux network state querying License: ASL 2.0 URL: https://github.com/nispor/nispor Source: https://github.com/nispor/nispor/archive/v%{version}.tar.gz#/%{name}-%{version}.tar.gz Patch0: Enable-debug-symbols.patch +%ifarch sw_64 +Patch1: 0001-add-sw_64-support-on-nispor.patch +%endif ExclusiveArch: aarch64 x86_64 riscv64 loongarch64 BuildRequires: make pkg-config python3-devel rust-packaging systemd-devel openEuler-rpm-config @@ -100,6 +103,9 @@ rm -rf %{buildroot}%{cargo_registry}/%{name}-%{version}/ %{_libdir}/pkgconfig/nispor.pc %changelog +* Mon Feb 17 2025 zhangshaoning - 1.0.1-5 +- Add sw_64 support + * Wed Apr 17 2024 yanjianqing - 1.0.1-4 - Enable debug symbols -- Gitee