summaryrefslogtreecommitdiffstats
path: root/vendor/sysinfo
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/sysinfo')
-rw-r--r--vendor/sysinfo/.cargo-checksum.json2
-rw-r--r--vendor/sysinfo/CHANGELOG.md90
-rw-r--r--vendor/sysinfo/Cargo.lock129
-rw-r--r--vendor/sysinfo/Cargo.toml13
-rw-r--r--vendor/sysinfo/README.md54
-rw-r--r--vendor/sysinfo/build.rs19
-rw-r--r--vendor/sysinfo/examples/simple.rs41
-rw-r--r--vendor/sysinfo/src/apple/app_store/process.rs2
-rw-r--r--vendor/sysinfo/src/apple/cpu.rs4
-rw-r--r--vendor/sysinfo/src/apple/disk.rs351
-rw-r--r--vendor/sysinfo/src/apple/ffi.rs32
-rw-r--r--vendor/sysinfo/src/apple/macos/component/arm.rs179
-rw-r--r--vendor/sysinfo/src/apple/macos/component/mod.rs13
-rw-r--r--vendor/sysinfo/src/apple/macos/component/x86.rs (renamed from vendor/sysinfo/src/apple/macos/component.rs)145
-rw-r--r--vendor/sysinfo/src/apple/macos/disk.rs281
-rw-r--r--vendor/sysinfo/src/apple/macos/ffi.rs295
-rw-r--r--vendor/sysinfo/src/apple/macos/mod.rs3
-rw-r--r--vendor/sysinfo/src/apple/macos/process.rs511
-rw-r--r--vendor/sysinfo/src/apple/macos/utils.rs30
-rw-r--r--vendor/sysinfo/src/apple/mod.rs1
-rw-r--r--vendor/sysinfo/src/apple/network.rs1
-rw-r--r--vendor/sysinfo/src/apple/system.rs176
-rw-r--r--vendor/sysinfo/src/apple/utils.rs34
-rw-r--r--vendor/sysinfo/src/c_interface.rs2
-rw-r--r--vendor/sysinfo/src/common.rs6
-rw-r--r--vendor/sysinfo/src/debug.rs2
-rw-r--r--vendor/sysinfo/src/freebsd/component.rs4
-rw-r--r--vendor/sysinfo/src/freebsd/process.rs57
-rw-r--r--vendor/sysinfo/src/freebsd/system.rs53
-rw-r--r--vendor/sysinfo/src/freebsd/utils.rs6
-rw-r--r--vendor/sysinfo/src/lib.rs50
-rw-r--r--vendor/sysinfo/src/linux/component.rs405
-rw-r--r--vendor/sysinfo/src/linux/cpu.rs208
-rw-r--r--vendor/sysinfo/src/linux/disk.rs22
-rw-r--r--vendor/sysinfo/src/linux/network.rs2
-rw-r--r--vendor/sysinfo/src/linux/process.rs439
-rw-r--r--vendor/sysinfo/src/linux/system.rs268
-rw-r--r--vendor/sysinfo/src/linux/utils.rs130
-rw-r--r--vendor/sysinfo/src/traits.rs164
-rw-r--r--vendor/sysinfo/src/unknown/process.rs2
-rw-r--r--vendor/sysinfo/src/unknown/system.rs11
-rw-r--r--vendor/sysinfo/src/utils.rs18
-rw-r--r--vendor/sysinfo/src/windows/disk.rs36
-rw-r--r--vendor/sysinfo/src/windows/macros.rs16
-rw-r--r--vendor/sysinfo/src/windows/mod.rs2
-rw-r--r--vendor/sysinfo/src/windows/process.rs94
-rw-r--r--vendor/sysinfo/src/windows/system.rs147
-rw-r--r--vendor/sysinfo/tests/code_checkers/docs.rs15
-rw-r--r--vendor/sysinfo/tests/code_checkers/headers.rs2
-rw-r--r--vendor/sysinfo/tests/code_checkers/mod.rs1
-rw-r--r--vendor/sysinfo/tests/code_checkers/utils.rs2
-rw-r--r--vendor/sysinfo/tests/process.rs90
52 files changed, 3072 insertions, 1588 deletions
diff --git a/vendor/sysinfo/.cargo-checksum.json b/vendor/sysinfo/.cargo-checksum.json
index f63622edd..b6ddd19f3 100644
--- a/vendor/sysinfo/.cargo-checksum.json
+++ b/vendor/sysinfo/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"ADDING_NEW_PLATFORMS.md":"43f54e5bd825d402cad4197e215c3a5fdeea81a39bec83505695557494953ae4","CHANGELOG.md":"b3cb8ef81a456fe82a5e100c6f32352c98c38ff241ec396f6fc24fc16e7a1c38","Cargo.lock":"578e29553d502c56627871c2ec35c8cf582293492d450f1489acecc331c913b8","Cargo.toml":"031737d9165c31f629742ffdeeb045b988cc1b9c497ced2adb62272a37dab021","LICENSE":"1f14f9ce70a5fdedab449bb32cd7d3f20e6e9d18c2a2b74221fc203db8684d43","Makefile":"c997ed3d89a46b42e79fc5f73c67fa9f21419779442b98dfb7d51fe4a49e31a2","README.md":"970de8c6c22ecd6e5dd5ecf6c1884c63b925b6c4aee884e20a8e0bdd2049315f","benches/basic.rs":"994cc27b68f62ccd1df54f85bbffd0a8af887bc43efead7ff02b0e85cc2137ea","build.rs":"84e31c7534feb4b795f904a188b547d3789aba855245e1ddad9477dac7e8e67f","examples/simple.c":"cb18ac15e7303c5b465a28d116fa1f17e2d3478c501ab323a3d609bdaa866bd2","examples/simple.rs":"ec5590ae463b90248837398e9a0ab4ca70da41de4103c9a323ccc45a6104caeb","md_doc/component.md":"98d4bd1493c3812e5b56203b6a5533359816fa8650b8dbf6fb2fe42e38473238","md_doc/cpu.md":"9bb6f7b7dade0b8acf078438bd8697d7807bb03d89c3c14c16cbaefcda2d02a7","md_doc/disk.md":"a7f63b95f8eed225484b34d8656ae7ec9dd7c619e2801d5f822f14a68bed6aba","md_doc/network_data.md":"a91aef3810f680cc3426379971d08babde03bb00c636b7c9fa9253bf32aabd4d","md_doc/networks.md":"ec192e4a13cdbb0d6af59c1b67076d09f34b42527412fdf244a40252f8fb9a40","md_doc/pid.md":"077dd679a758e317ef0cf911d6d0299ddfe4d6fa642a18460661d6da97eb5fde","md_doc/process.md":"b354fad715566d0b1922dc7eb408dfaecc3dc34c02850b7e62d709c737a8464f","md_doc/system.md":"2ee835f40091174f143cb734490c2dd3aab16a29594d42031d3d9ee7ed75e371","src/apple/app_store/component.rs":"c64f2b554f0f03bb001c58b109b0f48bfb63a3371dfc45116bae6f1d4ffea528","src/apple/app_store/mod.rs":"4558616af6978f9db2cab0704fada3404cb2346e462a51b09c355ad0bf5209b2","src/apple/app_store/process.rs":"42e6c65b373a7735c5ae286970e15d9bb7aa0318ab8e7d7c7322133a6d875ce1","src/apple/component.rs":"2811bf6f53776c00903ab023de18098ed63eaa914016e2c17f37697b634768b1","src/apple/cpu.rs":"c17f8308523c437e2804c54e70f61724bfc1e9b7981bb4d95b8797f0444604c7","src/apple/disk.rs":"5f6cb04381d0363dea44e69c73f1762eafe1dd82818e758ef8ef5b99ef6fae25","src/apple/ffi.rs":"02d0539bb2d52f030b41debb7e51ca82425ef6918cbb7bcb6582801cfdd00f07","src/apple/ios.rs":"7c9ac153d7a49af1cf0e5a37754ba388813a80fb77619fca510505e4e4e278c0","src/apple/macos/component.rs":"b8d3077e4dea2b78446a45afd7700ec2acff016521409350e3239b5497d3c2b3","src/apple/macos/disk.rs":"181adb8039ab2631bb20a7df2b85a810a32b6631defea7bbefaa4161960e2f73","src/apple/macos/ffi.rs":"a5e1a39f86318997d88367cc875ad9dff8d33aa679a540d054a393a0d636c16c","src/apple/macos/mod.rs":"f09a9c108b1001edf2d4c6d629207e039e17e87a19f70e953687b6f0d58cfffc","src/apple/macos/process.rs":"f523df2af59758d686be6116fd9a2f31b926d676f7218a55b1cf88b33352335e","src/apple/macos/system.rs":"131186910327a2287307501993a8d0ac2d771e9ae2ac924c153786d3256bd62a","src/apple/mod.rs":"3b2878ce65629cf2e444f26194e68e275aaffb8f2f9e1acd12c07bdc6e5d728f","src/apple/network.rs":"e2ca43e55794c2d443b7d7a29947c23d0256974390f4c674d9a3228c0e7f9937","src/apple/process.rs":"d9c10439f7ed98825bc439976c71010260da78640155a11a5532ded87a1946e9","src/apple/system.rs":"526147196133dcae57cfc3c3e52d0ec30d5c1f5bfd91f99f9af4ba14dce8df24","src/apple/users.rs":"610bf4dbe028fdb65e67235f779a11a888353a95d2862faf5fb794f065ad4e87","src/apple/utils.rs":"5e09cb3f66134eece80daf4c92fe15ee8e521c7638c459dd2a939126eafb35d6","src/c_interface.rs":"f4cbde5278b89b51dbc5ed3a8c2db6212e4359f2d006c81ec28ab03aa7bf80d7","src/common.rs":"4b2cfa51ede2f3d29d876d54803b1305b66a1a36405dd4255fdb8ce6c8f92931","src/debug.rs":"12b228176bbcef5e230588ad1e7c3a97aa0b5600cdb11fe5b5ac7792cd275bf5","src/freebsd/component.rs":"e52c0d18708fad9a5f0e3165e1546265ca5c3e36788684cd6a676c83e978f5dc","src/freebsd/cpu.rs":"173068c665d6b9ab2b9bee4c8a7ba9b260919613336fcce7897832ff1b2ee6af","src/freebsd/disk.rs":"e159b29beb7972633a10f051cc7becd42f34a91393cfbeb42d7c11955e5807fc","src/freebsd/mod.rs":"fdccfd037a3e9ac339ec803cf671904ef9ea3a902df205765dc30f234c2b6b56","src/freebsd/network.rs":"f980a7bedb9397b2fd11ba9e9196756023dc7e6848e88c7172af6b363186799c","src/freebsd/process.rs":"fcf0486ce0e197afc0635532f1c027576a3722e5b61f6d6da5d9a3547c7f2fa6","src/freebsd/system.rs":"fb14c127511e43f9a2640a27e7431897a69e0f2aef8460ea863743c50adf98b1","src/freebsd/utils.rs":"dda0af05935c770abfb23c5613bc42b85153349b60c613460201426d7780e3b1","src/lib.rs":"4a62daee69f50db0e37fbdf1c0a4bcd604ae283d58fed3288f1d78ee204447c5","src/linux/component.rs":"a47296b790458e84f0782d68433a49b713195a124bc3146267d159e10f017b14","src/linux/cpu.rs":"cfa0c510ae6bd9cd6dff0be4e03f9c3bc4222aeb056e7fcbe7da93c36dda8d86","src/linux/disk.rs":"e93a7c595166fe4942c11fff8e2b9d8f0c2121e3f9d31ba4bbe10ba203da1edb","src/linux/mod.rs":"3060ebbaf1a0b0f6ae8a380af6e7c304190f4c5384e70bfe3523e898a6af98f7","src/linux/network.rs":"1a00319da44e447cbd61ea9c2ba31cfe3cb15c20b114f9d657a4880a91b5e8cf","src/linux/process.rs":"42779fc3bfe8b3905c533c10285ebc550e3ed42c614a86d2b40ac8955633fe84","src/linux/system.rs":"a27e34b86fad4b6f5fa696c6458fe3a0d3b73dbe7e539f7bf1b3485429544288","src/linux/utils.rs":"4557401d2e78fd45e48ec54db85594d5217a44f67c95ef8b6ea70d02685ee7b3","src/macros.rs":"0c5d348d32efe019568596268d4b5eed44288554bfad54d3c9e9ab29d74706f6","src/sysinfo.h":"2d0a581507f809163d0f7eb2de2b2b23adadc480c94894ec0a790c18cdf5a5b2","src/system.rs":"1f750c5912ce8ccfbe1052281ef4e6aaa0765108e6d2d979a286fa74e2571277","src/traits.rs":"b229b7019b6266c0bd74fd5572fdb0f2ba6632df481c4824bf5df64e9a1bb579","src/unknown/component.rs":"0c6c36533bffed04de4719c7b664c5f0af99f81a4284923475d48c1248d960ab","src/unknown/cpu.rs":"bd4ff7e3d1ab2da6830e5bbc635187323d67a7062b973034d57b439d0555f9b3","src/unknown/disk.rs":"8c2d2b1bfd55bd67040910b726387f9dded4dc10a1e1b27c5a6f88182d73d4dd","src/unknown/mod.rs":"0f6b02841a32d51aeb6a58fd228fb7b2dbbd6b32679c3033b8a33e6a58e35c16","src/unknown/network.rs":"f1ab8998756a4a4607ad17a0596dea0957b752ea0511556f11c5a3575339477d","src/unknown/process.rs":"b3471ba1dad3777286637eb09053db94271426f1ae6ca63eceec24dc62c29436","src/unknown/system.rs":"dd708651413bd2a2376b619c6ad12205e10b3ddb1bec5e943b3840fa9eab55e3","src/users.rs":"2b0a629c41bd7873a0c11c3cc639aa5215d8801f2a0db1e45575c0169d29804e","src/utils.rs":"a1e69518048225c96d3839f3d0fa9cfd0c2e2f14d10f485c87bf6813c77a2c81","src/windows/component.rs":"e4deb1db32c954ed8d165ff234230d72ad63d6cb210b776cf660dd11200ca23f","src/windows/cpu.rs":"9acd73b7a23c6ae36be4dc4a2b7f6bb10a4b2f9d5589764da1ea8dbfccd9f17b","src/windows/disk.rs":"ab0f380bfc8501a80619b44c5cef8bc857dfcc7361ce62b95cb66b9d2b246769","src/windows/macros.rs":"971f4e8b708f6c694486122fb03beb13be1ba30e39ff1b03f59c5a9ac74d3590","src/windows/mod.rs":"48775c2691c3445b74abd79d74f25ec1ac45becd33e1f5a4a931255f4773838f","src/windows/network.rs":"d53eff35b6d153d138082dd5043d8a4475e3be6a6b035e29fe79b1b4269dc364","src/windows/process.rs":"032899847c75022705bb79c2229108b4f660d3e7baec7cc992e7261fb2dd166f","src/windows/system.rs":"e4f5ae54778d3d59bb9ab7a49b8f60cc8d86f32aeca79216aede19827c2f04f2","src/windows/tools.rs":"93d375c78843bea9911a4f9dc3c536682269059a1fa03e7d242c59dcdd28b672","src/windows/users.rs":"315d891a94de89b50cb24dbe1d3be7dd636185bafa8dd8d625714fc04a1f17d2","src/windows/utils.rs":"4ae34f6ae6da63df7f2762800d1b6f3eba5ba3d0a7838c9220d0a25b73aa38cb","tests/code_checkers/docs.rs":"f7ea3978dc87116ee140db18ef10b8ff16e93a62148862662f43084e5e5f8800","tests/code_checkers/headers.rs":"1c8364311c274c74168997712f441d7740b4ef6d9e2b0f86b0b6cc37b89362c4","tests/code_checkers/mod.rs":"dc8434143d099b8fd3f1eca348b2e842c4a8d0f976555f9a17a7bdb87ed37b10","tests/code_checkers/signals.rs":"72e9a0315a793dce0ed87083380a6bd998ffc70d71c8e4c2782f81d30c29dc9d","tests/code_checkers/utils.rs":"75d4301a8582605633140af7d4a4ce1dc79766c6e2acf7843e7d26796a20694c","tests/cpu.rs":"342ab66e912732d5b0edcd4b4c770546290909a56ca62b84338d560054e7baab","tests/disk_list.rs":"fe586252caa1f65c617744ce754718f1ecc1632644282dec2d98fdd058dfd098","tests/extras.rs":"adce56aa1d9ddcd33d19900e07a3e23df8800a8d55cc2d11c348daf5065aa2ff","tests/network.rs":"71975421c17a594813f0a70f36ea5262979f5e85dafc391efecbef62cd249975","tests/process.rs":"af9782a6f433e57e6aff51613e56b96adbe4a809a79b906b867ca0bfbccb56f4","tests/send_sync.rs":"c247878d496823abcef531d312acdcc9759fe334641fffe00398e7a65d7caff9","tests/uptime.rs":"9f01e9c747b51587c3e609c98e621494491850016e4e3705faf142627e77ecb8"},"package":"9a2809487b962344ca55d9aea565f9ffbcb6929780802217acc82561f6746770"} \ No newline at end of file
+{"files":{"ADDING_NEW_PLATFORMS.md":"43f54e5bd825d402cad4197e215c3a5fdeea81a39bec83505695557494953ae4","CHANGELOG.md":"1e0192d6d8427582507fcbecf84094717103ebcdd76414961eda42698ec83174","Cargo.lock":"cb71bc6523035a64eec65b923cc1f531ddde9b6e3b3c89e45e2a5c4e60183c1d","Cargo.toml":"71de8d3afb51b04d1186e0bc356fbfd80415ed639e9b56b8d5191f6e71628f83","LICENSE":"1f14f9ce70a5fdedab449bb32cd7d3f20e6e9d18c2a2b74221fc203db8684d43","Makefile":"c997ed3d89a46b42e79fc5f73c67fa9f21419779442b98dfb7d51fe4a49e31a2","README.md":"b60bb99658f3ad9347922a8d9851427009b8a068ddd15946d05bf4d2bd6d9090","benches/basic.rs":"994cc27b68f62ccd1df54f85bbffd0a8af887bc43efead7ff02b0e85cc2137ea","examples/simple.c":"cb18ac15e7303c5b465a28d116fa1f17e2d3478c501ab323a3d609bdaa866bd2","examples/simple.rs":"ffb83a3fb7e5cf4497cf5ae92a80d1cfd22c57964009583f4186d002afc177dd","md_doc/component.md":"98d4bd1493c3812e5b56203b6a5533359816fa8650b8dbf6fb2fe42e38473238","md_doc/cpu.md":"9bb6f7b7dade0b8acf078438bd8697d7807bb03d89c3c14c16cbaefcda2d02a7","md_doc/disk.md":"a7f63b95f8eed225484b34d8656ae7ec9dd7c619e2801d5f822f14a68bed6aba","md_doc/network_data.md":"a91aef3810f680cc3426379971d08babde03bb00c636b7c9fa9253bf32aabd4d","md_doc/networks.md":"ec192e4a13cdbb0d6af59c1b67076d09f34b42527412fdf244a40252f8fb9a40","md_doc/pid.md":"077dd679a758e317ef0cf911d6d0299ddfe4d6fa642a18460661d6da97eb5fde","md_doc/process.md":"b354fad715566d0b1922dc7eb408dfaecc3dc34c02850b7e62d709c737a8464f","md_doc/system.md":"2ee835f40091174f143cb734490c2dd3aab16a29594d42031d3d9ee7ed75e371","src/apple/app_store/component.rs":"c64f2b554f0f03bb001c58b109b0f48bfb63a3371dfc45116bae6f1d4ffea528","src/apple/app_store/mod.rs":"4558616af6978f9db2cab0704fada3404cb2346e462a51b09c355ad0bf5209b2","src/apple/app_store/process.rs":"603c9df6526cea8d3cf81c1c5b72c183109e9117903766fccb3e67669033e4ac","src/apple/component.rs":"2811bf6f53776c00903ab023de18098ed63eaa914016e2c17f37697b634768b1","src/apple/cpu.rs":"1a6d29b42d2e05506efb253845ceba25e42e8750042c90e29a7e047dc24d5b92","src/apple/disk.rs":"1a469917d2029f8842d59d36fe6294f1d7216ccd5fa42366c1004740b7d723a2","src/apple/ffi.rs":"8d19c70830ad91e67704cafc7489933d2bd32f0fe7e5186fe3b09d25e64ddffa","src/apple/ios.rs":"7c9ac153d7a49af1cf0e5a37754ba388813a80fb77619fca510505e4e4e278c0","src/apple/macos/component/arm.rs":"b3a5fb2addbe24503556293c704c4d090ad87ca866d90c3c5312eef79962dcd0","src/apple/macos/component/mod.rs":"0daab53e82a10f013b486b077177f4746c043b3571d23de36bb35c87b1ec9dd9","src/apple/macos/component/x86.rs":"8d7de10f37275301d09b3a8a072b6c5101b61e6142d3c9a93d428753ab229b2a","src/apple/macos/disk.rs":"20bb15824ed8a591b94c138fa1278c583e2d488ac9291a3a365514ab98e5b846","src/apple/macos/ffi.rs":"5449bcc8c8aa3e156f3238b264743805a1a939d6767c5f3a0576cd85083a0876","src/apple/macos/mod.rs":"32e0717737d172c073e479f68042f865b2f69421b6674d60aef880a87667b02b","src/apple/macos/process.rs":"ccee06976403384791ae70dceecdcbe0a6efcbcf539acba3cdaa6320d426ca7a","src/apple/macos/system.rs":"131186910327a2287307501993a8d0ac2d771e9ae2ac924c153786d3256bd62a","src/apple/macos/utils.rs":"c8a3809cce3311b5ac94855444d87495c269fe5ecf1d9cd7c373e40edbb61135","src/apple/mod.rs":"f764ca71f945cfc85592954db6404e9bd025b835f923078f3bdb0f1b0ebf3ea3","src/apple/network.rs":"c1c05f85167c652ae60d9b1e1f668a7aabd8ce6a89c93ef732a1d87540e7236b","src/apple/process.rs":"d9c10439f7ed98825bc439976c71010260da78640155a11a5532ded87a1946e9","src/apple/system.rs":"209423d0602ea71c87d5eeb09e843e3b6a4dbde8576d06c08024104e1ac9f45e","src/apple/users.rs":"610bf4dbe028fdb65e67235f779a11a888353a95d2862faf5fb794f065ad4e87","src/apple/utils.rs":"d4ea7f759b69e8a149246b2e4dab924b22d179d6961eb9d2a3c467d59b22cb1a","src/c_interface.rs":"82806dc47ba4eb19fb70fe4db8ca9bfab01d696b9a1917dcbcec7a58ad6f5a93","src/common.rs":"01fba002141d77172e879fc23dbff812c8993f0b056067a14c3257023d251614","src/debug.rs":"250e09a2a9ff17f9312b713c7f7937a40967ead53bd8722b56a007a110f7afaa","src/freebsd/component.rs":"882e129128bcac6be2e19b35017fa1f993fe97c974a1f73cdc0e02761cf64100","src/freebsd/cpu.rs":"173068c665d6b9ab2b9bee4c8a7ba9b260919613336fcce7897832ff1b2ee6af","src/freebsd/disk.rs":"e159b29beb7972633a10f051cc7becd42f34a91393cfbeb42d7c11955e5807fc","src/freebsd/mod.rs":"fdccfd037a3e9ac339ec803cf671904ef9ea3a902df205765dc30f234c2b6b56","src/freebsd/network.rs":"f980a7bedb9397b2fd11ba9e9196756023dc7e6848e88c7172af6b363186799c","src/freebsd/process.rs":"aea7028d65f24af5e486c937fedb6181374230e795d6718cb3e665ff41865d7c","src/freebsd/system.rs":"47e397525689f6d3591b27fe933e4bb31d62a118bccc5f5dc3367ba0a0143521","src/freebsd/utils.rs":"a4616be6c12a85369eac4840a2dc485ddfd7dc2ef6a02c2e2ef9099749f4ba69","src/lib.rs":"7185cea7d4fa84fe994b262597ae721eaae7e6701d821f746d985e66323f2016","src/linux/component.rs":"8bc34dd380dd4262e8a0835e67b7ae3dd54b68ee2d919a4384f733cc2af09c59","src/linux/cpu.rs":"abed341d370fff574b5c325b99f6fb33701947f59c44589bb01b97d8ce5c00e9","src/linux/disk.rs":"65c07161c88f4531e46645c1cb667ae1c0a1a78de38578120f8c8b37062b9e3f","src/linux/mod.rs":"3060ebbaf1a0b0f6ae8a380af6e7c304190f4c5384e70bfe3523e898a6af98f7","src/linux/network.rs":"1a57d734f5dc61c7985816e963f9a2721fa8c318a384909711dc443dd2bad74e","src/linux/process.rs":"e910c2c3ca58ff488ec06501ca82569103d273576d207592bf3f4dd65edfc56d","src/linux/system.rs":"d0ac2163100f0e051eeb0dff2a4b40ba799cfb3e1d99e4eeb4dfff2cf98b9ea9","src/linux/utils.rs":"e4d01b869e9b4b96dcbf03b92a8cdb53bbcd751d3aea6ad8ce3451ac5b5b1f04","src/macros.rs":"0c5d348d32efe019568596268d4b5eed44288554bfad54d3c9e9ab29d74706f6","src/sysinfo.h":"2d0a581507f809163d0f7eb2de2b2b23adadc480c94894ec0a790c18cdf5a5b2","src/system.rs":"1f750c5912ce8ccfbe1052281ef4e6aaa0765108e6d2d979a286fa74e2571277","src/traits.rs":"21501c06a6002d2335e030cb3f6c57ede424c18e0bce0a3939f460471962f88f","src/unknown/component.rs":"0c6c36533bffed04de4719c7b664c5f0af99f81a4284923475d48c1248d960ab","src/unknown/cpu.rs":"bd4ff7e3d1ab2da6830e5bbc635187323d67a7062b973034d57b439d0555f9b3","src/unknown/disk.rs":"8c2d2b1bfd55bd67040910b726387f9dded4dc10a1e1b27c5a6f88182d73d4dd","src/unknown/mod.rs":"0f6b02841a32d51aeb6a58fd228fb7b2dbbd6b32679c3033b8a33e6a58e35c16","src/unknown/network.rs":"f1ab8998756a4a4607ad17a0596dea0957b752ea0511556f11c5a3575339477d","src/unknown/process.rs":"db462276bfb50ef8f13cf959e20f46fbd4425816318e5715384f83dce68d6187","src/unknown/system.rs":"ad6ec949c0e02ef4d7145435b12854d38d7b601c71ff474e7d1d830d8c5d0771","src/users.rs":"2b0a629c41bd7873a0c11c3cc639aa5215d8801f2a0db1e45575c0169d29804e","src/utils.rs":"37738900055dd3334f36fac9b8f50b3eef2435fbfacc7dbab05bbcdb86199750","src/windows/component.rs":"e4deb1db32c954ed8d165ff234230d72ad63d6cb210b776cf660dd11200ca23f","src/windows/cpu.rs":"9acd73b7a23c6ae36be4dc4a2b7f6bb10a4b2f9d5589764da1ea8dbfccd9f17b","src/windows/disk.rs":"87e7f638576a3f7fc7a792837187cb6b315d7dbf86d79bbbadd04f552da6b64c","src/windows/mod.rs":"8299250e5a013686dba74324361b4a45c65a2e4282da4133b1b97e094732433f","src/windows/network.rs":"d53eff35b6d153d138082dd5043d8a4475e3be6a6b035e29fe79b1b4269dc364","src/windows/process.rs":"5ff561ab05bfb225ddb34b58b136e07a3a844357027300038a32eca2dfa9e9e5","src/windows/system.rs":"e0ec4ed3f82979f16a1bf3cec4b34ca9606ed703f86cb663fdaeb6ef428a9861","src/windows/tools.rs":"93d375c78843bea9911a4f9dc3c536682269059a1fa03e7d242c59dcdd28b672","src/windows/users.rs":"315d891a94de89b50cb24dbe1d3be7dd636185bafa8dd8d625714fc04a1f17d2","src/windows/utils.rs":"4ae34f6ae6da63df7f2762800d1b6f3eba5ba3d0a7838c9220d0a25b73aa38cb","tests/code_checkers/docs.rs":"d9aaaa2b8ce224319c8812fc127ec4d6e355911724d52ee295b4e53859ea383e","tests/code_checkers/headers.rs":"80d82d0290e5e1f50cffb264018dc975fe30927b16d761db5cf9a71292b51750","tests/code_checkers/mod.rs":"171356a68bd2d9c6d5e22c2344df5902276184fa0edd63a6ebf4e5e82fb48ae0","tests/code_checkers/signals.rs":"72e9a0315a793dce0ed87083380a6bd998ffc70d71c8e4c2782f81d30c29dc9d","tests/code_checkers/utils.rs":"8acd064ce01b64905921719c17db12f9444788073c1095335dcb1454097705fa","tests/cpu.rs":"342ab66e912732d5b0edcd4b4c770546290909a56ca62b84338d560054e7baab","tests/disk_list.rs":"fe586252caa1f65c617744ce754718f1ecc1632644282dec2d98fdd058dfd098","tests/extras.rs":"adce56aa1d9ddcd33d19900e07a3e23df8800a8d55cc2d11c348daf5065aa2ff","tests/network.rs":"71975421c17a594813f0a70f36ea5262979f5e85dafc391efecbef62cd249975","tests/process.rs":"63ac38afb22a6c813343afb50f91a4d44f96177dbbec2f7298a422ea41d3b7c5","tests/send_sync.rs":"c247878d496823abcef531d312acdcc9759fe334641fffe00398e7a65d7caff9","tests/uptime.rs":"9f01e9c747b51587c3e609c98e621494491850016e4e3705faf142627e77ecb8"},"package":"c375d5fd899e32847b8566e10598d6e9f1d9b55ec6de3cdf9e7da4bdc51371bc"} \ No newline at end of file
diff --git a/vendor/sysinfo/CHANGELOG.md b/vendor/sysinfo/CHANGELOG.md
index 8a0defd4d..5e3402112 100644
--- a/vendor/sysinfo/CHANGELOG.md
+++ b/vendor/sysinfo/CHANGELOG.md
@@ -1,3 +1,93 @@
+# 0.26.7
+
+ * Apple: Greatly improve disk retrieval (I recommend reading the pull request first comment for more information here: <https://github.com/GuillaumeGomez/sysinfo/pull/855>).
+ * Remove build script.
+
+# 0.26.6
+
+ * Add `Process::wait`.
+ * Add "Good pratice" entry into the crate level documentation and in the README.
+ * Linux: More precise used memory computation.
+
+# 0.26.5
+
+ * Windows: Fix disk information retrieval.
+ * Linux: Improve `Process` document.
+ * Linux: Fix a compilation error if the `apple-sandbox` feature is enabled.
+ * Internal code improvements.
+
+# 0.26.4
+
+ * Add `SystemExt::distribution_id` method.
+ * Update `ntapi` version to `0.4`.
+ * Update minimum supported Rust version (MSRV) to `1.59` for `ntapi` 0.4.
+
+# 0.26.3
+
+ * Update minimum supported Rust version (MSRV) to `1.56` to follow `once_cell` minor update.
+
+# 0.26.2
+
+ * Linux: Fix process information retrieval.
+ * Linux: Get more components temperature.
+ * Linux: Fix disk name retrieval (which in turn fixed disk type retrieval).
+
+# 0.26.1
+
+ * macOS M1: Fix segmentation fault crash.
+
+# 0.26.0
+
+ * Switch memory unit from kilobytes to bytes.
+ * Windows: Fix Windows version display on Windows 11.
+
+# 0.25.3
+
+ * Add macOS M1 CI checks.
+ * macOS M1: Add temperature support.
+ * macOS: Fix leak in disk retrieval.
+
+# 0.25.2
+
+ * Windows: Fix `Process::exe` information retrieval.
+ * All supported platforms: Correctly handle a PID owner change (#809).
+
+# 0.25.1
+
+ * Linux: Fix potential problem on `ProcessExt::exe` in case `/proc/<pid>/exe` cannot be read.
+ * Add `SystemExt::sort_disks_by`.
+
+# 0.25.0
+
+ * Linux: CPU frequency is now retrieved on-demand as expected when `CpuRefreshKind::frequency` is `true`.
+ * `System::refresh_cpu` behaviour changed: it only computes CPU usage and doesn't retrieve CPU frequency.
+
+# 0.24.7
+
+ * Windows: Fix boot time computation.
+ * macOS: Fix available memory computation.
+ * Some documentation fixes.
+
+# 0.24.6
+
+ * macOS: Don't compute CPU usage when elapsed time is 0.
+ * macOS: Fix memory leak when retrieving disks.
+ * C interface: Fix `char` cast when platform is using unsigned `char`s.
+
+# 0.24.5
+
+ * Implement `Hash` trait on `Uid` and `Gid` types.
+ * Remove dependency `once_cell` for targets other than `linux`, `android` and `windows`.
+
+# 0.24.4
+
+ * Windows: Fix `System::refresh_process` when required higher priviledges.
+
+# 0.24.3
+
+ * macOS: Fix `System::refresh_processes` badly handling updates.
+ * FreeBSD: Improve performance of `System::refresh_processes`.
+
# 0.24.2
* Windows: Fix CPU usage computation.
diff --git a/vendor/sysinfo/Cargo.lock b/vendor/sysinfo/Cargo.lock
index 6d06a3fac..1b08f4cd0 100644
--- a/vendor/sysinfo/Cargo.lock
+++ b/vendor/sysinfo/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
[[package]]
name = "autocfg"
-version = "1.0.1"
+version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
[[package]]
name = "bitflags"
@@ -28,9 +28,9 @@ checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
[[package]]
name = "crossbeam-channel"
-version = "0.5.1"
+version = "0.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
+checksum = "5aaa7bd5fb665c6864b5f963dd9097905c54125909c7aa94c9e18507cdbe6c53"
dependencies = [
"cfg-if",
"crossbeam-utils",
@@ -49,10 +49,11 @@ dependencies = [
[[package]]
name = "crossbeam-epoch"
-version = "0.9.5"
+version = "0.9.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
+checksum = "1145cf131a2c6ba0615079ab6a638f7e1973ac9c2634fcbeaaad6114246efe8c"
dependencies = [
+ "autocfg",
"cfg-if",
"crossbeam-utils",
"lazy_static",
@@ -62,9 +63,9 @@ dependencies = [
[[package]]
name = "crossbeam-utils"
-version = "0.8.5"
+version = "0.8.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
+checksum = "0bf124c720b7686e3c2663cf54062ab0f68a88af2fb6a030e87e30bf721fcb38"
dependencies = [
"cfg-if",
"lazy_static",
@@ -77,14 +78,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
[[package]]
-name = "getrandom"
-version = "0.2.3"
+name = "fastrand"
+version = "1.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
dependencies = [
- "cfg-if",
- "libc",
- "wasi",
+ "instant",
]
[[package]]
@@ -97,6 +96,15 @@ dependencies = [
]
[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
name = "lazy_static"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -104,33 +112,33 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]
name = "libc"
-version = "0.2.121"
+version = "0.2.126"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f"
+checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
[[package]]
name = "memoffset"
-version = "0.6.4"
+version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
dependencies = [
"autocfg",
]
[[package]]
name = "ntapi"
-version = "0.3.6"
+version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
+checksum = "bc51db7b362b205941f71232e56c625156eb9a929f8cf74a428fd5bc094a4afc"
dependencies = [
"winapi",
]
[[package]]
name = "num_cpus"
-version = "1.13.0"
+version = "1.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
dependencies = [
"hermit-abi",
"libc",
@@ -138,61 +146,15 @@ dependencies = [
[[package]]
name = "once_cell"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3ca011bd0129ff4ae15cd04c4eef202cadf6c51c21e47aba319b4e0501db741"
-
-[[package]]
-name = "rand"
-version = "0.8.4"
+version = "1.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
- "rand_hc",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
-dependencies = [
- "rand_core",
-]
+checksum = "7709cef83f0c1f58f666e746a08b21e0085f7440fa6a29cc194d68aac97a4225"
[[package]]
name = "rayon"
-version = "1.5.1"
+version = "1.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d"
dependencies = [
"autocfg",
"crossbeam-deque",
@@ -202,22 +164,21 @@ dependencies = [
[[package]]
name = "rayon-core"
-version = "1.9.1"
+version = "1.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
+checksum = "258bcdb5ac6dad48491bb2992db6b7cf74878b0384908af124823d118c99683f"
dependencies = [
"crossbeam-channel",
"crossbeam-deque",
"crossbeam-utils",
- "lazy_static",
"num_cpus",
]
[[package]]
name = "redox_syscall"
-version = "0.2.10"
+version = "0.2.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+checksum = "62f25bc4c7e55e0b0b7a1d43fb893f4fa1361d0abe38b9ce4f323c2adfe6ef42"
dependencies = [
"bitflags",
]
@@ -239,7 +200,7 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
[[package]]
name = "sysinfo"
-version = "0.24.2"
+version = "0.26.7"
dependencies = [
"cfg-if",
"core-foundation-sys",
@@ -253,25 +214,19 @@ dependencies = [
[[package]]
name = "tempfile"
-version = "3.2.0"
+version = "3.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
dependencies = [
"cfg-if",
+ "fastrand",
"libc",
- "rand",
"redox_syscall",
"remove_dir_all",
"winapi",
]
[[package]]
-name = "wasi"
-version = "0.10.2+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
-
-[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/vendor/sysinfo/Cargo.toml b/vendor/sysinfo/Cargo.toml
index 2dac4e344..f8719a4dd 100644
--- a/vendor/sysinfo/Cargo.toml
+++ b/vendor/sysinfo/Cargo.toml
@@ -11,11 +11,10 @@
[package]
edition = "2018"
-rust-version = "1.54"
+rust-version = "1.59"
name = "sysinfo"
-version = "0.24.2"
+version = "0.26.7"
authors = ["Guillaume Gomez <guillaume1.gomez@gmail.com>"]
-build = "build.rs"
exclude = ["/test-unknown"]
description = "Library to get system information such as processes, CPUs, disks, components and networks"
readme = "README.md"
@@ -37,9 +36,6 @@ crate_type = [
[dependencies.cfg-if]
version = "1.0"
-[dependencies.once_cell]
-version = "1.0"
-
[dependencies.rayon]
version = "^1.5.1"
optional = true
@@ -59,11 +55,14 @@ version = "3.2"
[target."cfg(any(target_os = \"macos\", target_os = \"ios\"))".dependencies.core-foundation-sys]
version = "0.8"
+[target."cfg(any(windows, target_os = \"linux\", target_os = \"android\"))".dependencies.once_cell]
+version = "1.0"
+
[target."cfg(not(any(target_os = \"unknown\", target_arch = \"wasm32\")))".dependencies.libc]
version = "^0.2.112"
[target."cfg(windows)".dependencies.ntapi]
-version = "0.3"
+version = "0.4"
[target."cfg(windows)".dependencies.winapi]
version = "0.3.9"
diff --git a/vendor/sysinfo/README.md b/vendor/sysinfo/README.md
index a58fb10e5..e44a731f4 100644
--- a/vendor/sysinfo/README.md
+++ b/vendor/sysinfo/README.md
@@ -2,7 +2,7 @@
`sysinfo` is a crate used to get a system's information.
-## Supported Oses
+## Supported OSes
It currently supports the following OSes (alphabetically sorted):
@@ -18,7 +18,7 @@ You can still use `sysinfo` on non-supported OSes, it'll simply do nothing and a
empty values. You can check in your program directly if an OS is supported by checking the
[`SystemExt::IS_SUPPORTED`] constant.
-The minimum-supported version of `rustc` is **1.54**.
+The minimum-supported version of `rustc` is **1.59**.
## Usage
@@ -64,10 +64,10 @@ for component in sys.components() {
println!("=> system:");
// RAM and swap information:
-println!("total memory: {} KB", sys.total_memory());
-println!("used memory : {} KB", sys.used_memory());
-println!("total swap : {} KB", sys.total_swap());
-println!("used swap : {} KB", sys.used_swap());
+println!("total memory: {} bytes", sys.total_memory());
+println!("used memory : {} bytes", sys.used_memory());
+println!("total swap : {} bytes", sys.total_swap());
+println!("used swap : {} bytes", sys.used_swap());
// Display system information:
println!("System name: {:?}", sys.name());
@@ -82,13 +82,53 @@ println!("NB CPUs: {}", sys.cpus().len());
for (pid, process) in sys.processes() {
println!("[{}] {} {:?}", pid, process.name(), process.disk_usage());
}
+```
+
+Please remember that to have some up-to-date information, you need to call the equivalent
+`refresh` method. For example, for the CPU usage:
+
+```rust,no_run
+use sysinfo::{CpuExt, System, SystemExt};
+let mut sys = System::new();
+
+loop {
+ sys.refresh_cpu(); // Refreshing CPU information.
+ for cpu in sys.cpus() {
+ print!("{}% ", cpu.cpu_usage());
+ }
+ // Sleeping for 500 ms to let time for the system to run for long
+ // enough to have useful information.
+ std::thread::sleep(std::time::Duration::from_millis(500));
+}
```
By default, `sysinfo` uses multiple threads. However, this can increase the memory usage on some
platforms (macOS for example). The behavior can be disabled by setting `default-features = false`
in `Cargo.toml` (which disables the `multithread` cargo feature).
+### Good practice / Performance tips
+
+Most of the time, you don't want all information provided by `sysinfo` but just a subset of it.
+In this case, it's recommended to use `refresh_specifics(...)` methods with only what you need
+to have much better performance.
+
+Another issues frequently encountered: unless you know what you're doing, it's almost all the
+time better to instantiate the `System` struct once and use this one instance through your
+program. The reason is because a lot of information needs a previous measure to be computed
+(the CPU usage for example). Another example why it's much better: in case you want to list
+all running processes, `sysinfo` needs to allocate all memory for the `Process` struct list,
+which takes quite some time on the first run.
+
+If your program needs to use a lot of file descriptors, you'd better use:
+
+```rust,no_run
+sysinfo::set_open_files_limit(0);
+```
+
+as `sysinfo` keeps a number of file descriptors open to have better performance on some
+targets when refreshing processes.
+
### Running on Raspberry Pi
It'll be difficult to build on Raspberry Pi. A good way-around is to cross-build, then send the
@@ -134,7 +174,7 @@ can be used alone to avoid causing policy violations at runtime.
### How it works
I wrote a blog post you can find [here][sysinfo-blog] which explains how `sysinfo` extracts information
-on the diffent systems.
+on the different systems.
[sysinfo-blog]: https://blog.guillaume-gomez.fr/articles/2021-09-06+sysinfo%3A+how+to+extract+systems%27+information
diff --git a/vendor/sysinfo/build.rs b/vendor/sysinfo/build.rs
deleted file mode 100644
index 437300934..000000000
--- a/vendor/sysinfo/build.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-fn main() {
- let is_apple = std::env::var("TARGET")
- .map(|t| t.contains("-apple"))
- .unwrap_or(false);
- let is_ios = std::env::var("CARGO_CFG_TARGET_OS")
- .map(|s| s == "ios")
- .unwrap_or(false);
-
- if is_apple {
- if !is_ios {
- // DiskArbitration is not available on iOS: https://developer.apple.com/documentation/diskarbitration
- println!("cargo:rustc-link-lib=framework=DiskArbitration");
- // IOKit is not available on iOS: https://developer.apple.com/documentation/iokit
- println!("cargo:rustc-link-lib=framework=IOKit");
- }
-
- println!("cargo:rustc-link-lib=framework=Foundation");
- }
-}
diff --git a/vendor/sysinfo/examples/simple.rs b/vendor/sysinfo/examples/simple.rs
index 43115b007..926cbca79 100644
--- a/vendor/sysinfo/examples/simple.rs
+++ b/vendor/sysinfo/examples/simple.rs
@@ -2,6 +2,7 @@
#![crate_type = "bin"]
#![allow(unused_must_use, non_upper_case_globals)]
+#![allow(clippy::manual_range_contains)]
extern crate sysinfo;
@@ -152,7 +153,7 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
let mut nb = 1i32;
for sig in signals {
- writeln!(&mut io::stdout(), "{:2}:{:?}", nb, sig);
+ writeln!(&mut io::stdout(), "{nb:2}:{sig:?}");
nb += 1;
}
}
@@ -172,14 +173,30 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
sys.global_cpu_info().cpu_usage()
);
for proc_ in sys.cpus() {
- writeln!(&mut io::stdout(), "{:?}", proc_);
+ writeln!(&mut io::stdout(), "{proc_:?}");
}
}
"memory" => {
- writeln!(&mut io::stdout(), "total memory: {} KB", sys.total_memory());
- writeln!(&mut io::stdout(), "used memory : {} KB", sys.used_memory());
- writeln!(&mut io::stdout(), "total swap : {} KB", sys.total_swap());
- writeln!(&mut io::stdout(), "used swap : {} KB", sys.used_swap());
+ writeln!(
+ &mut io::stdout(),
+ "total memory: {} KB",
+ sys.total_memory() / 1_000
+ );
+ writeln!(
+ &mut io::stdout(),
+ "used memory : {} KB",
+ sys.used_memory() / 1_000
+ );
+ writeln!(
+ &mut io::stdout(),
+ "total swap : {} KB",
+ sys.total_swap() / 1_000
+ );
+ writeln!(
+ &mut io::stdout(),
+ "used swap : {} KB",
+ sys.used_swap() / 1_000
+ );
}
"quit" | "exit" => return true,
"all" => {
@@ -228,19 +245,19 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
} else if let Ok(pid) = Pid::from_str(tmp[1]) {
match sys.process(pid) {
Some(p) => writeln!(&mut io::stdout(), "{:?}", *p),
- None => writeln!(&mut io::stdout(), "pid \"{:?}\" not found", pid),
+ None => writeln!(&mut io::stdout(), "pid \"{pid:?}\" not found"),
};
} else {
let proc_name = tmp[1];
for proc_ in sys.processes_by_name(proc_name) {
writeln!(&mut io::stdout(), "==== {} ====", proc_.name());
- writeln!(&mut io::stdout(), "{:?}", proc_);
+ writeln!(&mut io::stdout(), "{proc_:?}");
}
}
}
"temperature" => {
for component in sys.components() {
- writeln!(&mut io::stdout(), "{:?}", component);
+ writeln!(&mut io::stdout(), "{component:?}");
}
}
"network" => {
@@ -287,7 +304,7 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
if let Some(res) =
p.kill_with(*signals.get(signal as usize - 1).unwrap())
{
- writeln!(&mut io::stdout(), "kill: {}", res,);
+ writeln!(&mut io::stdout(), "kill: {res}");
} else {
writeln!(
&mut io::stdout(),
@@ -304,7 +321,7 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
}
"disks" => {
for disk in sys.disks() {
- writeln!(&mut io::stdout(), "{:?}", disk);
+ writeln!(&mut io::stdout(), "{disk:?}");
}
}
"users" => {
@@ -346,7 +363,7 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
.next()
{
if sys.refresh_process(pid) {
- writeln!(&mut io::stdout(), "Process `{}` updated successfully", pid);
+ writeln!(&mut io::stdout(), "Process `{pid}` updated successfully");
} else {
writeln!(
&mut io::stdout(),
diff --git a/vendor/sysinfo/src/apple/app_store/process.rs b/vendor/sysinfo/src/apple/app_store/process.rs
index 8c3348ee9..7c43697a6 100644
--- a/vendor/sysinfo/src/apple/app_store/process.rs
+++ b/vendor/sysinfo/src/apple/app_store/process.rs
@@ -79,4 +79,6 @@ impl ProcessExt for Process {
fn group_id(&self) -> Option<Gid> {
None
}
+
+ fn wait(&self) {}
}
diff --git a/vendor/sysinfo/src/apple/cpu.rs b/vendor/sysinfo/src/apple/cpu.rs
index b1068e971..e613bdd2c 100644
--- a/vendor/sysinfo/src/apple/cpu.rs
+++ b/vendor/sysinfo/src/apple/cpu.rs
@@ -317,14 +317,14 @@ mod test {
let cpus = sys.cpus();
assert!(!cpus.is_empty(), "no CPU found");
if let Some(line) = stdout.lines().find(|l| l.contains("machdep.cpu.vendor")) {
- let sysctl_value = line.split(":").skip(1).next().unwrap();
+ let sysctl_value = line.split(':').nth(1).unwrap();
assert_eq!(cpus[0].vendor_id(), sysctl_value.trim());
}
if let Some(line) = stdout
.lines()
.find(|l| l.contains("machdep.cpu.brand_string"))
{
- let sysctl_value = line.split(":").skip(1).next().unwrap();
+ let sysctl_value = line.split(':').nth(1).unwrap();
assert_eq!(cpus[0].brand(), sysctl_value.trim());
}
}
diff --git a/vendor/sysinfo/src/apple/disk.rs b/vendor/sysinfo/src/apple/disk.rs
index 9f0b4a3a3..d866d5bba 100644
--- a/vendor/sysinfo/src/apple/disk.rs
+++ b/vendor/sysinfo/src/apple/disk.rs
@@ -1,15 +1,23 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use crate::utils::to_cpath;
+use crate::sys::{
+ ffi,
+ utils::{self, CFReleaser},
+};
use crate::{DiskExt, DiskType};
-#[cfg(target_os = "macos")]
-pub(crate) use crate::sys::inner::disk::*;
+use core_foundation_sys::array::CFArrayCreate;
+use core_foundation_sys::base::kCFAllocatorDefault;
+use core_foundation_sys::dictionary::{CFDictionaryGetValueIfPresent, CFDictionaryRef};
+use core_foundation_sys::number::{kCFBooleanTrue, CFBooleanRef, CFNumberGetValue};
+use core_foundation_sys::string::{self as cfs, CFStringRef};
-use libc::statfs;
-use std::ffi::{OsStr, OsString};
-use std::mem;
+use libc::c_void;
+
+use std::ffi::{CStr, OsStr, OsString};
+use std::os::unix::ffi::OsStrExt;
use std::path::{Path, PathBuf};
+use std::ptr;
#[doc = include_str!("../../md_doc/disk.md")]
pub struct Disk {
@@ -17,6 +25,7 @@ pub struct Disk {
pub(crate) name: OsString,
pub(crate) file_system: Vec<u8>,
pub(crate) mount_point: PathBuf,
+ volume_url: RetainedCFURL,
pub(crate) total_space: u64,
pub(crate) available_space: u64,
pub(crate) is_removable: bool,
@@ -53,14 +62,334 @@ impl DiskExt for Disk {
fn refresh(&mut self) -> bool {
unsafe {
- let mut stat: statfs = mem::zeroed();
- let mount_point_cpath = to_cpath(&self.mount_point);
- if statfs(mount_point_cpath.as_ptr() as *const i8, &mut stat) == 0 {
- self.available_space = u64::from(stat.f_bsize).saturating_mul(stat.f_bavail);
- true
+ if let Some(requested_properties) = build_requested_properties(&[
+ ffi::kCFURLVolumeAvailableCapacityKey,
+ ffi::kCFURLVolumeAvailableCapacityForImportantUsageKey,
+ ]) {
+ match get_disk_properties(&self.volume_url, &requested_properties) {
+ Some(disk_props) => {
+ self.available_space = get_available_volume_space(&disk_props);
+ true
+ }
+ None => false,
+ }
} else {
+ sysinfo_debug!("failed to create volume key list, skipping refresh");
false
}
}
}
}
+
+pub(super) unsafe fn get_disks() -> Vec<Disk> {
+ let raw_disks = {
+ let count = libc::getfsstat(ptr::null_mut(), 0, libc::MNT_NOWAIT);
+ if count < 1 {
+ return Vec::new();
+ }
+ let bufsize = count * std::mem::size_of::<libc::statfs>() as libc::c_int;
+ let mut disks = Vec::with_capacity(count as _);
+ let count = libc::getfsstat(disks.as_mut_ptr(), bufsize, libc::MNT_NOWAIT);
+
+ if count < 1 {
+ return Vec::new();
+ }
+
+ disks.set_len(count as usize);
+
+ disks
+ };
+
+ // Create a list of properties about the disk that we want to fetch.
+ let requested_properties = match build_requested_properties(&[
+ ffi::kCFURLVolumeIsEjectableKey,
+ ffi::kCFURLVolumeIsRemovableKey,
+ ffi::kCFURLVolumeIsInternalKey,
+ ffi::kCFURLVolumeTotalCapacityKey,
+ ffi::kCFURLVolumeAvailableCapacityForImportantUsageKey,
+ ffi::kCFURLVolumeAvailableCapacityKey,
+ ffi::kCFURLVolumeNameKey,
+ ffi::kCFURLVolumeIsBrowsableKey,
+ ffi::kCFURLVolumeIsLocalKey,
+ ]) {
+ Some(properties) => properties,
+ None => {
+ sysinfo_debug!("failed to create volume key list");
+ return Vec::new();
+ }
+ };
+
+ let mut disks = Vec::with_capacity(raw_disks.len());
+ for c_disk in raw_disks {
+ let volume_url = match CFReleaser::new(
+ core_foundation_sys::url::CFURLCreateFromFileSystemRepresentation(
+ kCFAllocatorDefault,
+ c_disk.f_mntonname.as_ptr() as *const _,
+ c_disk.f_mntonname.len() as _,
+ false as _,
+ ),
+ ) {
+ Some(url) => url,
+ None => {
+ sysinfo_debug!("getfsstat returned incompatible paths");
+ continue;
+ }
+ };
+
+ let prop_dict = match get_disk_properties(&volume_url, &requested_properties) {
+ Some(props) => props,
+ None => continue,
+ };
+
+ // Future note: There is a difference between `kCFURLVolumeIsBrowsableKey` and the
+ // `kCFURLEnumeratorSkipInvisibles` option of `CFURLEnumeratorOptions`. Specifically,
+ // the first one considers the writable `Data`(`/System/Volumes/Data`) partition to be
+ // browsable, while it is classified as "invisible" by CoreFoundation's volume emumerator.
+ let browsable = get_bool_value(
+ prop_dict.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeIsBrowsableKey),
+ )
+ .unwrap_or_default();
+
+ // Do not return invisible "disks". Most of the time, these are APFS snapshots, hidden
+ // system volumes, etc. Browsable is defined to be visible in the system's UI like Finder,
+ // disk utility, system information, etc.
+ //
+ // To avoid seemingly duplicating many disks and creating an inaccurate view of the system's resources,
+ // these are skipped entirely.
+ if !browsable {
+ continue;
+ }
+
+ let local_only = get_bool_value(
+ prop_dict.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeIsLocalKey),
+ )
+ .unwrap_or(true);
+
+ // Skip any drive that is not locally attached to the system.
+ //
+ // This includes items like SMB mounts, and matches the other platform's behavior.
+ if !local_only {
+ continue;
+ }
+
+ let mount_point = PathBuf::from(OsStr::from_bytes(
+ CStr::from_ptr(c_disk.f_mntonname.as_ptr()).to_bytes(),
+ ));
+
+ disks.extend(new_disk(mount_point, volume_url, c_disk, &prop_dict))
+ }
+
+ disks
+}
+
+type RetainedCFArray = CFReleaser<core_foundation_sys::array::__CFArray>;
+type RetainedCFDictionary = CFReleaser<core_foundation_sys::dictionary::__CFDictionary>;
+type RetainedCFURL = CFReleaser<core_foundation_sys::url::__CFURL>;
+
+unsafe fn build_requested_properties(properties: &[CFStringRef]) -> Option<RetainedCFArray> {
+ CFReleaser::new(CFArrayCreate(
+ ptr::null_mut(),
+ properties.as_ptr() as *const *const c_void,
+ properties.len() as _,
+ &core_foundation_sys::array::kCFTypeArrayCallBacks,
+ ))
+}
+
+fn get_disk_properties(
+ volume_url: &RetainedCFURL,
+ requested_properties: &RetainedCFArray,
+) -> Option<RetainedCFDictionary> {
+ CFReleaser::new(unsafe {
+ ffi::CFURLCopyResourcePropertiesForKeys(
+ volume_url.inner(),
+ requested_properties.inner(),
+ ptr::null_mut(),
+ )
+ })
+}
+
+fn get_available_volume_space(disk_props: &RetainedCFDictionary) -> u64 {
+ // We prefer `AvailableCapacityForImportantUsage` over `AvailableCapacity` because
+ // it takes more of the system's properties into account, like the trash, system-managed caches,
+ // etc. It generally also returns higher values too, because of the above, so it's a more accurate
+ // representation of what the system _could_ still use.
+ unsafe {
+ get_int_value(
+ disk_props.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeAvailableCapacityForImportantUsageKey),
+ )
+ .filter(|bytes| *bytes != 0)
+ .or_else(|| {
+ get_int_value(
+ disk_props.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeAvailableCapacityKey),
+ )
+ })
+ }
+ .unwrap_or_default() as u64
+}
+
+pub(super) enum DictKey {
+ Extern(CFStringRef),
+ #[cfg(target_os = "macos")]
+ Defined(&'static str),
+}
+
+unsafe fn get_dict_value<T, F: FnOnce(*const c_void) -> Option<T>>(
+ dict: CFDictionaryRef,
+ key: DictKey,
+ callback: F,
+) -> Option<T> {
+ #[cfg(target_os = "macos")]
+ let _defined;
+ let key = match key {
+ DictKey::Extern(val) => val,
+ #[cfg(target_os = "macos")]
+ DictKey::Defined(val) => {
+ _defined = CFReleaser::new(cfs::CFStringCreateWithBytesNoCopy(
+ kCFAllocatorDefault,
+ val.as_ptr(),
+ val.len() as _,
+ cfs::kCFStringEncodingUTF8,
+ false as _,
+ core_foundation_sys::base::kCFAllocatorNull,
+ ))?;
+
+ _defined.inner()
+ }
+ };
+
+ let mut value = std::ptr::null();
+ if CFDictionaryGetValueIfPresent(dict, key.cast(), &mut value) != 0 {
+ callback(value)
+ } else {
+ None
+ }
+}
+
+pub(super) unsafe fn get_str_value(dict: CFDictionaryRef, key: DictKey) -> Option<String> {
+ get_dict_value(dict, key, |v| {
+ let v = v as cfs::CFStringRef;
+
+ let len_utf16 = cfs::CFStringGetLength(v) as usize;
+ let len_bytes = len_utf16 * 2; // Two bytes per UTF-16 codepoint.
+
+ let v_ptr = cfs::CFStringGetCStringPtr(v, cfs::kCFStringEncodingUTF8);
+ if v_ptr.is_null() {
+ // Fallback on CFStringGetString to read the underlying bytes from the CFString.
+ let mut buf = vec![0; len_bytes];
+ let success = cfs::CFStringGetCString(
+ v,
+ buf.as_mut_ptr(),
+ len_bytes as _,
+ cfs::kCFStringEncodingUTF8,
+ );
+
+ if success != 0 {
+ utils::vec_to_rust(buf)
+ } else {
+ None
+ }
+ } else {
+ utils::cstr_to_rust_with_size(v_ptr, Some(len_bytes))
+ }
+ })
+}
+
+unsafe fn get_bool_value(dict: CFDictionaryRef, key: DictKey) -> Option<bool> {
+ get_dict_value(dict, key, |v| Some(v as CFBooleanRef == kCFBooleanTrue))
+}
+
+unsafe fn get_int_value(dict: CFDictionaryRef, key: DictKey) -> Option<i64> {
+ get_dict_value(dict, key, |v| {
+ let mut val: i64 = 0;
+ if CFNumberGetValue(
+ v.cast(),
+ core_foundation_sys::number::kCFNumberSInt64Type,
+ &mut val as *mut i64 as *mut c_void,
+ ) {
+ Some(val)
+ } else {
+ None
+ }
+ })
+}
+
+unsafe fn new_disk(
+ mount_point: PathBuf,
+ volume_url: RetainedCFURL,
+ c_disk: libc::statfs,
+ disk_props: &RetainedCFDictionary,
+) -> Option<Disk> {
+ // IOKit is not available on any but the most recent (16+) iOS and iPadOS versions.
+ // Due to this, we can't query the medium type. All iOS devices use flash-based storage
+ // so we just assume the disk type is an SSD until Rust has a way to conditionally link to
+ // IOKit in more recent deployment versions.
+ #[cfg(target_os = "macos")]
+ let type_ = crate::sys::inner::disk::get_disk_type(&c_disk).unwrap_or(DiskType::Unknown(-1));
+ #[cfg(not(target_os = "macos"))]
+ let type_ = DiskType::SSD;
+
+ // Note: Since we requested these properties from the system, we don't expect
+ // these property retrievals to fail.
+
+ let name = get_str_value(
+ disk_props.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeNameKey),
+ )
+ .map(OsString::from)?;
+
+ let is_removable = {
+ let ejectable = get_bool_value(
+ disk_props.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeIsEjectableKey),
+ )
+ .unwrap_or_default();
+
+ let removable = get_bool_value(
+ disk_props.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeIsRemovableKey),
+ )
+ .unwrap_or_default();
+
+ let is_removable = ejectable || removable;
+
+ if is_removable {
+ is_removable
+ } else {
+ // If neither `ejectable` or `removable` return `true`, fallback to checking
+ // if the disk is attached to the internal system.
+ let internal = get_bool_value(
+ disk_props.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeIsInternalKey),
+ )
+ .unwrap_or_default();
+
+ !internal
+ }
+ };
+
+ let total_space = get_int_value(
+ disk_props.inner(),
+ DictKey::Extern(ffi::kCFURLVolumeTotalCapacityKey),
+ )? as u64;
+
+ let available_space = get_available_volume_space(disk_props);
+
+ let file_system = IntoIterator::into_iter(c_disk.f_fstypename)
+ .filter_map(|b| if b != 0 { Some(b as u8) } else { None })
+ .collect();
+
+ Some(Disk {
+ type_,
+ name,
+ file_system,
+ mount_point,
+ volume_url,
+ total_space,
+ available_space,
+ is_removable,
+ })
+}
diff --git a/vendor/sysinfo/src/apple/ffi.rs b/vendor/sysinfo/src/apple/ffi.rs
index 7a8248537..72822202f 100644
--- a/vendor/sysinfo/src/apple/ffi.rs
+++ b/vendor/sysinfo/src/apple/ffi.rs
@@ -1,21 +1,31 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use libc::c_void;
+use core_foundation_sys::{
+ array::CFArrayRef, dictionary::CFDictionaryRef, error::CFErrorRef, string::CFStringRef,
+ url::CFURLRef,
+};
// Reexport items defined in either macos or ios ffi module.
pub use crate::sys::inner::ffi::*;
-#[repr(C)]
-pub struct __DADisk(c_void);
-#[repr(C)]
-pub struct __DASession(c_void);
+#[link(name = "CoreFoundation", kind = "framework")]
+extern "C" {
+ pub fn CFURLCopyResourcePropertiesForKeys(
+ url: CFURLRef,
+ keys: CFArrayRef,
+ error: *mut CFErrorRef,
+ ) -> CFDictionaryRef;
-// #[allow(non_camel_case_types)]
-// pub type io_name_t = [u8; 128];
-// #[allow(non_camel_case_types)]
-// pub type io_registry_entry_t = io_object_t;
-
-// pub type IOOptionBits = u32;
+ pub static kCFURLVolumeIsEjectableKey: CFStringRef;
+ pub static kCFURLVolumeIsRemovableKey: CFStringRef;
+ pub static kCFURLVolumeAvailableCapacityKey: CFStringRef;
+ pub static kCFURLVolumeAvailableCapacityForImportantUsageKey: CFStringRef;
+ pub static kCFURLVolumeTotalCapacityKey: CFStringRef;
+ pub static kCFURLVolumeNameKey: CFStringRef;
+ pub static kCFURLVolumeIsLocalKey: CFStringRef;
+ pub static kCFURLVolumeIsInternalKey: CFStringRef;
+ pub static kCFURLVolumeIsBrowsableKey: CFStringRef;
+}
#[cfg_attr(feature = "debug", derive(Eq, Hash, PartialEq))]
#[derive(Clone)]
diff --git a/vendor/sysinfo/src/apple/macos/component/arm.rs b/vendor/sysinfo/src/apple/macos/component/arm.rs
new file mode 100644
index 000000000..328ffebfa
--- /dev/null
+++ b/vendor/sysinfo/src/apple/macos/component/arm.rs
@@ -0,0 +1,179 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+use std::ffi::CStr;
+
+use core_foundation_sys::array::{CFArrayGetCount, CFArrayGetValueAtIndex};
+use core_foundation_sys::base::{kCFAllocatorDefault, CFRetain};
+use core_foundation_sys::string::{
+ kCFStringEncodingUTF8, CFStringCreateWithBytes, CFStringGetCStringPtr,
+};
+
+use crate::apple::inner::ffi::{
+ kHIDPage_AppleVendor, kHIDUsage_AppleVendor_TemperatureSensor, kIOHIDEventTypeTemperature,
+ matching, IOHIDEventFieldBase, IOHIDEventGetFloatValue, IOHIDEventSystemClientCopyServices,
+ IOHIDEventSystemClientCreate, IOHIDEventSystemClientSetMatching, IOHIDServiceClientCopyEvent,
+ IOHIDServiceClientCopyProperty, __IOHIDEventSystemClient, __IOHIDServiceClient,
+ HID_DEVICE_PROPERTY_PRODUCT,
+};
+use crate::sys::utils::CFReleaser;
+use crate::ComponentExt;
+
+pub(crate) struct Components {
+ pub inner: Vec<Component>,
+ client: Option<CFReleaser<__IOHIDEventSystemClient>>,
+}
+
+impl Components {
+ pub(crate) fn new() -> Self {
+ Self {
+ inner: vec![],
+ client: None,
+ }
+ }
+
+ pub(crate) fn refresh(&mut self) {
+ self.inner.clear();
+
+ unsafe {
+ let matches = match CFReleaser::new(matching(
+ kHIDPage_AppleVendor,
+ kHIDUsage_AppleVendor_TemperatureSensor,
+ )) {
+ Some(m) => m,
+ None => return,
+ };
+
+ if self.client.is_none() {
+ let client =
+ match CFReleaser::new(IOHIDEventSystemClientCreate(kCFAllocatorDefault)) {
+ Some(c) => c,
+ None => return,
+ };
+ // Without this call, client is freed during the execution of the program. It must be kept!
+ CFRetain(client.inner() as _);
+ self.client = Some(client);
+ }
+
+ let client = self.client.as_ref().unwrap();
+
+ let _ = IOHIDEventSystemClientSetMatching(client.inner(), matches.inner());
+
+ let services = match CFReleaser::new(IOHIDEventSystemClientCopyServices(client.inner()))
+ {
+ Some(s) => s,
+ None => return,
+ };
+
+ let key_ref = match CFReleaser::new(CFStringCreateWithBytes(
+ kCFAllocatorDefault,
+ HID_DEVICE_PROPERTY_PRODUCT.as_ptr(),
+ HID_DEVICE_PROPERTY_PRODUCT.len() as _,
+ kCFStringEncodingUTF8,
+ false as _,
+ )) {
+ Some(r) => r,
+ None => return,
+ };
+
+ let count = CFArrayGetCount(services.inner());
+
+ for i in 0..count {
+ let service = match CFReleaser::new(
+ CFArrayGetValueAtIndex(services.inner(), i) as *const _
+ ) {
+ Some(s) => s,
+ None => continue,
+ };
+
+ let name = match CFReleaser::new(IOHIDServiceClientCopyProperty(
+ service.inner(),
+ key_ref.inner(),
+ )) {
+ Some(n) => n,
+ None => continue,
+ };
+
+ let name_ptr =
+ CFStringGetCStringPtr(name.inner() as *const _, kCFStringEncodingUTF8);
+ let name_str = CStr::from_ptr(name_ptr).to_string_lossy().to_string();
+
+ let mut component = Component::new(name_str, None, None, service);
+ component.refresh();
+
+ self.inner.push(component);
+ }
+ }
+ }
+}
+
+unsafe impl Send for Components {}
+unsafe impl Sync for Components {}
+
+#[doc = include_str!("../../../../md_doc/component.md")]
+pub struct Component {
+ service: CFReleaser<__IOHIDServiceClient>,
+ temperature: f32,
+ label: String,
+ max: f32,
+ critical: Option<f32>,
+}
+
+impl Component {
+ pub(crate) fn new(
+ label: String,
+ max: Option<f32>,
+ critical: Option<f32>,
+ service: CFReleaser<__IOHIDServiceClient>,
+ ) -> Self {
+ Self {
+ service,
+ label,
+ max: max.unwrap_or(0.),
+ critical,
+ temperature: 0.,
+ }
+ }
+}
+
+unsafe impl Send for Component {}
+unsafe impl Sync for Component {}
+
+impl ComponentExt for Component {
+ fn temperature(&self) -> f32 {
+ self.temperature
+ }
+
+ fn max(&self) -> f32 {
+ self.max
+ }
+
+ fn critical(&self) -> Option<f32> {
+ self.critical
+ }
+
+ fn label(&self) -> &str {
+ &self.label
+ }
+
+ fn refresh(&mut self) {
+ unsafe {
+ let event = match CFReleaser::new(IOHIDServiceClientCopyEvent(
+ self.service.inner() as *const _,
+ kIOHIDEventTypeTemperature,
+ 0,
+ 0,
+ )) {
+ Some(e) => e,
+ None => return,
+ };
+
+ self.temperature = IOHIDEventGetFloatValue(
+ event.inner(),
+ IOHIDEventFieldBase(kIOHIDEventTypeTemperature),
+ ) as _;
+ if self.temperature > self.max {
+ self.max = self.temperature;
+ }
+ }
+ }
+}
diff --git a/vendor/sysinfo/src/apple/macos/component/mod.rs b/vendor/sysinfo/src/apple/macos/component/mod.rs
new file mode 100644
index 000000000..50b359e61
--- /dev/null
+++ b/vendor/sysinfo/src/apple/macos/component/mod.rs
@@ -0,0 +1,13 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+pub(crate) mod x86;
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+pub use self::x86::*;
+
+#[cfg(target_arch = "aarch64")]
+pub(crate) mod arm;
+
+#[cfg(target_arch = "aarch64")]
+pub use self::arm::*;
diff --git a/vendor/sysinfo/src/apple/macos/component.rs b/vendor/sysinfo/src/apple/macos/component/x86.rs
index 384efb950..415f90455 100644
--- a/vendor/sysinfo/src/apple/macos/component.rs
+++ b/vendor/sysinfo/src/apple/macos/component/x86.rs
@@ -1,13 +1,13 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use crate::sys::ffi;
+use crate::sys::{ffi, macos::utils::IOReleaser};
use crate::ComponentExt;
use libc::{c_char, c_int, c_void};
use std::mem;
-pub(crate) const COMPONENTS_TEMPERATURE_IDS: &[(&str, &[i8])] = &[
+const COMPONENTS_TEMPERATURE_IDS: &[(&str, &[i8])] = &[
("PECI CPU", &['T' as i8, 'C' as i8, 'X' as i8, 'C' as i8]), // PECI CPU "TCXC"
("PECI CPU", &['T' as i8, 'C' as i8, 'X' as i8, 'c' as i8]), // PECI CPU "TCXc"
(
@@ -21,33 +21,69 @@ pub(crate) const COMPONENTS_TEMPERATURE_IDS: &[(&str, &[i8])] = &[
pub(crate) struct ComponentFFI {
input_structure: ffi::KeyData_t,
val: ffi::Val_t,
+ /// It is the `System::connection`. We need it to not require an extra argument
+ /// in `ComponentExt::refresh`.
+ connection: ffi::io_connect_t,
}
impl ComponentFFI {
- fn new(key: &[i8], con: ffi::io_connect_t) -> Option<ComponentFFI> {
+ fn new(key: &[i8], connection: ffi::io_connect_t) -> Option<ComponentFFI> {
unsafe {
- get_key_size(con, key)
+ get_key_size(connection, key)
.ok()
.map(|(input_structure, val)| ComponentFFI {
input_structure,
val,
+ connection,
})
}
}
- fn temperature(&self, con: ffi::io_connect_t) -> Option<f32> {
- get_temperature_inner(con, &self.input_structure, &self.val)
+ fn temperature(&self) -> Option<f32> {
+ get_temperature_inner(self.connection, &self.input_structure, &self.val)
+ }
+}
+
+/// Used to get CPU information, not supported on iOS, or inside the default macOS sandbox.
+pub(crate) struct Components {
+ pub inner: Vec<Component>,
+ connection: Option<IoService>,
+}
+
+impl Components {
+ pub(crate) fn new() -> Self {
+ Self {
+ inner: Vec::with_capacity(2),
+ connection: IoService::new_connection(),
+ }
+ }
+
+ pub(crate) fn refresh(&mut self) {
+ if let Some(ref connection) = self.connection {
+ let connection = connection.inner();
+ self.inner.clear();
+ // getting CPU critical temperature
+ let critical_temp =
+ get_temperature(connection, &['T' as i8, 'C' as i8, '0' as i8, 'D' as i8, 0]);
+
+ for (id, v) in COMPONENTS_TEMPERATURE_IDS.iter() {
+ if let Some(c) =
+ Component::new((*id).to_owned(), None, critical_temp, v, connection)
+ {
+ self.inner.push(c);
+ }
+ }
+ }
}
}
-#[doc = include_str!("../../../md_doc/component.md")]
+#[doc = include_str!("../../../../md_doc/component.md")]
pub struct Component {
temperature: f32,
max: f32,
critical: Option<f32>,
label: String,
ffi_part: ComponentFFI,
- connection: ffi::io_connect_t,
}
impl Component {
@@ -60,16 +96,13 @@ impl Component {
connection: ffi::io_connect_t,
) -> Option<Component> {
let ffi_part = ComponentFFI::new(key, connection)?;
- ffi_part
- .temperature(connection)
- .map(|temperature| Component {
- temperature,
- label,
- max: max.unwrap_or(0.0),
- critical,
- ffi_part,
- connection,
- })
+ ffi_part.temperature().map(|temperature| Component {
+ temperature,
+ label,
+ max: max.unwrap_or(temperature),
+ critical,
+ ffi_part,
+ })
}
}
@@ -91,7 +124,7 @@ impl ComponentExt for Component {
}
fn refresh(&mut self) {
- if let Some(temp) = self.ffi_part.temperature(self.connection) {
+ if let Some(temp) = self.ffi_part.temperature() {
self.temperature = temp;
if self.temperature > self.max {
self.max = self.temperature;
@@ -213,9 +246,81 @@ fn get_temperature_inner(
None
}
-pub(crate) fn get_temperature(con: ffi::io_connect_t, key: &[i8]) -> Option<f32> {
+fn get_temperature(con: ffi::io_connect_t, key: &[i8]) -> Option<f32> {
unsafe {
let (input_structure, val) = get_key_size(con, key).ok()?;
get_temperature_inner(con, &input_structure, &val)
}
}
+
+pub(crate) struct IoService(ffi::io_connect_t);
+
+impl IoService {
+ fn new(obj: ffi::io_connect_t) -> Option<Self> {
+ if obj == 0 {
+ None
+ } else {
+ Some(Self(obj))
+ }
+ }
+
+ pub(crate) fn inner(&self) -> ffi::io_connect_t {
+ self.0
+ }
+
+ // code from https://github.com/Chris911/iStats
+ // Not supported on iOS, or in the default macOS
+ pub(crate) fn new_connection() -> Option<Self> {
+ let mut iterator: ffi::io_iterator_t = 0;
+
+ unsafe {
+ let matching_dictionary = ffi::IOServiceMatching(b"AppleSMC\0".as_ptr() as *const i8);
+ let result = ffi::IOServiceGetMatchingServices(
+ ffi::kIOMasterPortDefault,
+ matching_dictionary,
+ &mut iterator,
+ );
+ if result != ffi::KIO_RETURN_SUCCESS {
+ sysinfo_debug!("Error: IOServiceGetMatchingServices() = {}", result);
+ return None;
+ }
+ let iterator = match IOReleaser::new(iterator) {
+ Some(i) => i,
+ None => {
+ sysinfo_debug!("Error: IOServiceGetMatchingServices() succeeded but returned invalid descriptor");
+ return None;
+ }
+ };
+
+ let device = match IOReleaser::new(ffi::IOIteratorNext(iterator.inner())) {
+ Some(d) => d,
+ None => {
+ sysinfo_debug!("Error: no SMC found");
+ return None;
+ }
+ };
+
+ let mut conn = 0;
+ let result = ffi::IOServiceOpen(device.inner(), libc::mach_task_self(), 0, &mut conn);
+ if result != ffi::KIO_RETURN_SUCCESS {
+ sysinfo_debug!("Error: IOServiceOpen() = {}", result);
+ return None;
+ }
+ let conn = IoService::new(conn);
+ if conn.is_none() {
+ sysinfo_debug!(
+ "Error: IOServiceOpen() succeeded but returned invalid descriptor..."
+ );
+ }
+ conn
+ }
+ }
+}
+
+impl Drop for IoService {
+ fn drop(&mut self) {
+ unsafe {
+ ffi::IOServiceClose(self.0);
+ }
+ }
+}
diff --git a/vendor/sysinfo/src/apple/macos/disk.rs b/vendor/sysinfo/src/apple/macos/disk.rs
index 7cc5a83ce..3a4372a2f 100644
--- a/vendor/sysinfo/src/apple/macos/disk.rs
+++ b/vendor/sysinfo/src/apple/macos/disk.rs
@@ -1,199 +1,126 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use crate::sys::{ffi, utils};
-use crate::utils::to_cpath;
-use crate::{Disk, DiskType};
+use crate::sys::ffi;
+use crate::sys::{
+ disk::{get_str_value, DictKey},
+ macos::utils::IOReleaser,
+ utils::CFReleaser,
+};
+use crate::DiskType;
-use core_foundation_sys::base::{kCFAllocatorDefault, kCFAllocatorNull, CFRelease};
-use core_foundation_sys::dictionary::{CFDictionaryGetValueIfPresent, CFDictionaryRef};
-use core_foundation_sys::number::{kCFBooleanTrue, CFBooleanRef};
+use core_foundation_sys::base::{kCFAllocatorDefault, kCFAllocatorNull};
use core_foundation_sys::string as cfs;
-use libc::{c_char, c_int, c_void, statfs};
+use std::ffi::CStr;
-use std::ffi::{OsStr, OsString};
-use std::mem;
-use std::os::unix::ffi::OsStrExt;
-use std::path::PathBuf;
-use std::ptr;
+pub(crate) fn get_disk_type(disk: &libc::statfs) -> Option<DiskType> {
+ let characteristics_string = unsafe {
+ CFReleaser::new(cfs::CFStringCreateWithBytesNoCopy(
+ kCFAllocatorDefault,
+ ffi::kIOPropertyDeviceCharacteristicsKey.as_ptr(),
+ ffi::kIOPropertyDeviceCharacteristicsKey.len() as _,
+ cfs::kCFStringEncodingUTF8,
+ false as _,
+ kCFAllocatorNull,
+ ))?
+ };
-fn to_path(mount_path: &[c_char]) -> Option<PathBuf> {
- let mut tmp = Vec::with_capacity(mount_path.len());
- for &c in mount_path {
- if c == 0 {
- break;
- }
- tmp.push(c as u8);
- }
- if tmp.is_empty() {
- None
- } else {
- let path = OsStr::from_bytes(&tmp);
- Some(PathBuf::from(path))
- }
-}
+ // Removes `/dev/` from the value.
+ let bsd_name = unsafe {
+ CStr::from_ptr(disk.f_mntfromname.as_ptr())
+ .to_bytes()
+ .strip_prefix(b"/dev/")
+ .or_else(|| {
+ sysinfo_debug!("unknown disk mount path format");
+ None
+ })?
+ };
+
+ // We don't need to wrap this in an auto-releaser because the following call to `IOServiceGetMatchingServices`
+ // will take ownership of one retain reference.
+ let matching =
+ unsafe { ffi::IOBSDNameMatching(ffi::kIOMasterPortDefault, 0, bsd_name.as_ptr().cast()) };
-pub(crate) fn get_disks(session: ffi::DASessionRef) -> Vec<Disk> {
- if session.is_null() {
- return Vec::new();
+ if matching.is_null() {
+ return None;
}
- unsafe {
- let count = libc::getfsstat(ptr::null_mut(), 0, libc::MNT_NOWAIT);
- if count < 1 {
- return Vec::new();
- }
- let bufsize = count * mem::size_of::<libc::statfs>() as c_int;
- let mut disks = Vec::with_capacity(count as _);
- let count = libc::getfsstat(disks.as_mut_ptr(), bufsize, libc::MNT_NOWAIT);
- if count < 1 {
- return Vec::new();
- }
- disks.set_len(count as _);
- disks
- .into_iter()
- .filter_map(|c_disk| {
- let mount_point = to_path(&c_disk.f_mntonname)?;
- let disk = ffi::DADiskCreateFromBSDName(
- kCFAllocatorDefault as _,
- session,
- c_disk.f_mntfromname.as_ptr(),
- );
- let dict = ffi::DADiskCopyDescription(disk);
- if dict.is_null() {
- return None;
- }
- // Keeping this around in case one might want the list of the available
- // keys in "dict".
- // core_foundation_sys::base::CFShow(dict as _);
- let name = match get_str_value(dict, b"DAMediaName\0").map(OsString::from) {
- Some(n) => n,
- None => return None,
- };
- let removable = get_bool_value(dict, b"DAMediaRemovable\0").unwrap_or(false);
- let ejectable = get_bool_value(dict, b"DAMediaEjectable\0").unwrap_or(false);
- // This is very hackish but still better than nothing...
- let type_ = if let Some(model) = get_str_value(dict, b"DADeviceModel\0") {
- if model.contains("SSD") {
- DiskType::SSD
- } else {
- // We just assume by default that this is a HDD
- DiskType::HDD
- }
- } else {
- DiskType::Unknown(-1)
- };
- CFRelease(dict as _);
- new_disk(name, mount_point, type_, removable || ejectable)
- })
- .collect::<Vec<_>>()
+ let mut service_iterator: ffi::io_iterator_t = 0;
+
+ if unsafe {
+ ffi::IOServiceGetMatchingServices(
+ ffi::kIOMasterPortDefault,
+ matching.cast(),
+ &mut service_iterator,
+ )
+ } != libc::KERN_SUCCESS
+ {
+ return None;
}
-}
-unsafe fn get_dict_value<T, F: FnOnce(*const c_void) -> Option<T>>(
- dict: CFDictionaryRef,
- key: &[u8],
- callback: F,
-) -> Option<T> {
- let key = ffi::CFStringCreateWithCStringNoCopy(
- ptr::null_mut(),
- key.as_ptr() as *const c_char,
- cfs::kCFStringEncodingUTF8,
- kCFAllocatorNull as _,
- );
- let mut value = std::ptr::null();
- let ret = if CFDictionaryGetValueIfPresent(dict, key as _, &mut value) != 0 {
- callback(value)
- } else {
- None
- };
- CFRelease(key as _);
- ret
-}
+ // Safety: We checked for success, so there is always a valid iterator, even if its empty.
+ let service_iterator = unsafe { IOReleaser::new_unchecked(service_iterator) };
-unsafe fn get_str_value(dict: CFDictionaryRef, key: &[u8]) -> Option<String> {
- get_dict_value(dict, key, |v| {
- let v = v as cfs::CFStringRef;
-
- let len_utf16 = cfs::CFStringGetLength(v);
- let len_bytes = len_utf16 as usize * 2; // Two bytes per UTF-16 codepoint.
-
- let v_ptr = cfs::CFStringGetCStringPtr(v, cfs::kCFStringEncodingUTF8);
- if v_ptr.is_null() {
- // Fallback on CFStringGetString to read the underlying bytes from the CFString.
- let mut buf = vec![0; len_bytes];
- let success = cfs::CFStringGetCString(
- v,
- buf.as_mut_ptr(),
- len_bytes as _,
- cfs::kCFStringEncodingUTF8,
- );
-
- if success != 0 {
- utils::vec_to_rust(buf)
- } else {
- None
+ let mut parent_entry: ffi::io_registry_entry_t = 0;
+
+ while let Some(mut current_service_entry) =
+ IOReleaser::new(unsafe { ffi::IOIteratorNext(service_iterator.inner()) })
+ {
+ // Note: This loop is required in a non-obvious way. Due to device properties existing as a tree
+ // in IOKit, we may need an arbitrary number of calls to `IORegistryEntryCreateCFProperty` in order to find
+ // the values we are looking for. The function may return nothing if we aren't deep enough into the registry
+ // tree, so we need to continue going from child->parent node until its found.
+ loop {
+ if unsafe {
+ ffi::IORegistryEntryGetParentEntry(
+ current_service_entry.inner(),
+ ffi::kIOServicePlane.as_ptr().cast(),
+ &mut parent_entry,
+ )
+ } != libc::KERN_SUCCESS
+ {
+ break;
}
- } else {
- utils::cstr_to_rust_with_size(v_ptr, Some(len_bytes))
- }
- })
-}
-unsafe fn get_bool_value(dict: CFDictionaryRef, key: &[u8]) -> Option<bool> {
- get_dict_value(dict, key, |v| Some(v as CFBooleanRef == kCFBooleanTrue))
-}
+ current_service_entry = match IOReleaser::new(parent_entry) {
+ Some(service) => service,
+ // There were no more parents left
+ None => break,
+ };
-fn new_disk(
- name: OsString,
- mount_point: PathBuf,
- type_: DiskType,
- is_removable: bool,
-) -> Option<Disk> {
- let mount_point_cpath = to_cpath(&mount_point);
- let mut total_space = 0;
- let mut available_space = 0;
- let mut file_system = None;
- unsafe {
- let mut stat: statfs = mem::zeroed();
- if statfs(mount_point_cpath.as_ptr() as *const i8, &mut stat) == 0 {
- // APFS is "special" because its a snapshot-based filesystem, and modern
- // macOS devices take full advantage of this.
- //
- // By default, listing volumes with `statfs` can return both the root-level
- // "data" partition and any snapshots that exist. However, other than some flags and
- // reserved(undocumented) bytes, there is no difference between the OS boot snapshot
- // and the "data" partition.
- //
- // To avoid duplicating the number of disks (and therefore available space, etc), only return
- // a disk (which is really a partition with APFS) if it is the root of the filesystem.
- let is_root = stat.f_flags & libc::MNT_ROOTFS as u32 == 0;
- if !is_root {
- return None;
- }
+ let properties_result = unsafe {
+ CFReleaser::new(ffi::IORegistryEntryCreateCFProperty(
+ current_service_entry.inner(),
+ characteristics_string.inner(),
+ kCFAllocatorDefault,
+ 0,
+ ))
+ };
+
+ if let Some(device_properties) = properties_result {
+ let disk_type = unsafe {
+ super::disk::get_str_value(
+ device_properties.inner(),
+ DictKey::Defined(ffi::kIOPropertyMediumTypeKey),
+ )
+ };
- total_space = u64::from(stat.f_bsize).saturating_mul(stat.f_blocks);
- available_space = u64::from(stat.f_bsize).saturating_mul(stat.f_bavail);
- let mut vec = Vec::with_capacity(stat.f_fstypename.len());
- for x in &stat.f_fstypename {
- if *x == 0 {
- break;
+ if let Some(disk_type) = disk_type.and_then(|medium| match medium.as_str() {
+ _ if medium == ffi::kIOPropertyMediumTypeSolidStateKey => Some(DiskType::SSD),
+ _ if medium == ffi::kIOPropertyMediumTypeRotationalKey => Some(DiskType::HDD),
+ _ => None,
+ }) {
+ return Some(disk_type);
+ } else {
+ // Many external drive vendors do not advertise their device's storage medium.
+ //
+ // In these cases, assuming that there were _any_ properties about them registered, we fallback
+ // to `HDD` when no storage medium is provided by the device instead of `Unknown`.
+ return Some(DiskType::HDD);
}
- vec.push(*x as u8);
}
- file_system = Some(vec);
- }
- if total_space == 0 {
- return None;
}
- Some(Disk {
- type_,
- name,
- file_system: file_system.unwrap_or_else(|| b"<Unknown>".to_vec()),
- mount_point,
- total_space,
- available_space,
- is_removable,
- })
}
+
+ None
}
diff --git a/vendor/sysinfo/src/apple/macos/ffi.rs b/vendor/sysinfo/src/apple/macos/ffi.rs
index f884701d9..0b9c82cfa 100644
--- a/vendor/sysinfo/src/apple/macos/ffi.rs
+++ b/vendor/sysinfo/src/apple/macos/ffi.rs
@@ -1,105 +1,111 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use core_foundation_sys::base::CFAllocatorRef;
-use core_foundation_sys::dictionary::CFMutableDictionaryRef;
-use core_foundation_sys::string::{CFStringEncoding, CFStringRef};
+use core_foundation_sys::base::{mach_port_t, CFAllocatorRef};
+use core_foundation_sys::dictionary::{CFDictionaryRef, CFMutableDictionaryRef};
+use core_foundation_sys::string::CFStringRef;
-use libc::{c_char, c_void};
-#[cfg(not(feature = "apple-sandbox"))]
-use libc::{mach_port_t, size_t};
+use libc::{c_char, kern_return_t};
-pub(crate) use crate::sys::ffi::*;
+// Note: IOKit is only available on MacOS up until very recent iOS versions: https://developer.apple.com/documentation/iokit
-#[cfg(not(feature = "apple-sandbox"))]
-extern "C" {
- // The proc_* PID functions are internal Apple APIs which are not
- // allowed in App store releases as Apple blocks any binary using them.
+#[allow(non_camel_case_types)]
+pub type io_object_t = mach_port_t;
+
+#[allow(non_camel_case_types)]
+pub type io_iterator_t = io_object_t;
+#[allow(non_camel_case_types)]
+pub type io_registry_entry_t = io_object_t;
+#[allow(non_camel_case_types)]
+pub type io_name_t = *const c_char;
- // IOKit is only available on MacOS: https://developer.apple.com/documentation/iokit, and when not running inside
- // of the default macOS sandbox.
- pub fn IOMasterPort(a: i32, b: *mut mach_port_t) -> i32;
+pub type IOOptionBits = u32;
- pub fn IOServiceMatching(a: *const c_char) -> *mut c_void;
+#[allow(non_upper_case_globals)]
+pub const kIOServicePlane: &str = "IOService\0";
+#[allow(non_upper_case_globals)]
+pub const kIOPropertyDeviceCharacteristicsKey: &str = "Device Characteristics";
+#[allow(non_upper_case_globals)]
+pub const kIOPropertyMediumTypeKey: &str = "Medium Type";
+#[allow(non_upper_case_globals)]
+pub const kIOPropertyMediumTypeSolidStateKey: &str = "Solid State";
+#[allow(non_upper_case_globals)]
+pub const kIOPropertyMediumTypeRotationalKey: &str = "Rotational";
+// Note: Obtaining information about disks using IOKIt is allowed inside the default macOS App Sandbox.
+#[link(name = "IOKit", kind = "framework")]
+extern "C" {
pub fn IOServiceGetMatchingServices(
- a: mach_port_t,
- b: *mut c_void,
- c: *mut io_iterator_t,
- ) -> i32;
+ mainPort: mach_port_t,
+ matching: CFMutableDictionaryRef,
+ existing: *mut io_iterator_t,
+ ) -> kern_return_t;
pub fn IOIteratorNext(iterator: io_iterator_t) -> io_object_t;
- pub fn IOObjectRelease(obj: io_object_t) -> i32;
-
- pub fn IOServiceOpen(device: io_object_t, a: u32, t: u32, x: *mut io_connect_t) -> i32;
-
- pub fn IOServiceClose(a: io_connect_t) -> i32;
-
- pub fn IOConnectCallStructMethod(
- connection: mach_port_t,
- selector: u32,
- inputStruct: *const KeyData_t,
- inputStructCnt: size_t,
- outputStruct: *mut KeyData_t,
- outputStructCnt: *mut size_t,
- ) -> i32;
- // pub fn IORegistryEntryCreateCFProperties(
- // entry: io_registry_entry_t,
- // properties: *mut CFMutableDictionaryRef,
- // allocator: CFAllocatorRef,
- // options: IOOptionBits,
- // ) -> kern_return_t;
- // pub fn IORegistryEntryGetName(entry: io_registry_entry_t, name: *mut c_char) -> kern_return_t;
-}
+ pub fn IOObjectRelease(obj: io_object_t) -> kern_return_t;
-extern "C" {
- pub fn CFStringCreateWithCStringNoCopy(
- alloc: *mut c_void,
- cStr: *const c_char,
- encoding: CFStringEncoding,
- contentsDeallocator: *mut c_void,
- ) -> CFStringRef;
-
- // Disk information functions are non-operational on iOS because of the sandboxing
- // restrictions of apps, so they don't can't filesystem information. This results in
- // mountedVolumeURLs and similar returning `nil`. Hence, they are MacOS specific here.
-
- pub fn DASessionCreate(allocator: CFAllocatorRef) -> DASessionRef;
-
- // pub fn DADiskCreateFromVolumePath(
- // allocator: CFAllocatorRef,
- // session: DASessionRef,
- // path: CFURLRef,
- // ) -> DADiskRef;
- pub fn DADiskCreateFromBSDName(
+ pub fn IORegistryEntryCreateCFProperty(
+ entry: io_registry_entry_t,
+ key: CFStringRef,
allocator: CFAllocatorRef,
- session: DASessionRef,
- path: *const c_char,
- ) -> DADiskRef;
- // pub fn DADiskGetBSDName(disk: DADiskRef) -> *const c_char;
-
- pub fn DADiskCopyDescription(disk: DADiskRef) -> CFMutableDictionaryRef;
-}
+ options: IOOptionBits,
+ ) -> CFDictionaryRef;
+ pub fn IORegistryEntryGetParentEntry(
+ entry: io_registry_entry_t,
+ plane: io_name_t,
+ parent: *mut io_registry_entry_t,
+ ) -> kern_return_t;
-pub type DADiskRef = *const __DADisk;
-pub type DASessionRef = *const __DASession;
+ pub fn IOBSDNameMatching(
+ mainPort: mach_port_t,
+ options: u32,
+ bsdName: *const c_char,
+ ) -> CFMutableDictionaryRef;
-// We need to wrap `DASessionRef` to be sure `System` remains Send+Sync.
-pub struct SessionWrap(pub DASessionRef);
-
-unsafe impl Send for SessionWrap {}
-unsafe impl Sync for SessionWrap {}
+ // This is deprecated as of macOS 12.0, but Rust doesn't have a good way to only use the replacement on 12+.
+ pub static kIOMasterPortDefault: mach_port_t;
+}
-#[cfg(not(feature = "apple-sandbox"))]
+#[cfg(all(
+ not(feature = "apple-sandbox"),
+ any(target_arch = "x86", target_arch = "x86_64")
+))]
mod io_service {
- use super::mach_port_t;
+ use super::{io_object_t, mach_port_t};
+ use core_foundation_sys::dictionary::CFMutableDictionaryRef;
+ use libc::{c_char, kern_return_t, size_t, task_t};
#[allow(non_camel_case_types)]
- pub type io_object_t = mach_port_t;
- #[allow(non_camel_case_types)]
pub type io_connect_t = io_object_t;
+
#[allow(non_camel_case_types)]
- pub type io_iterator_t = io_object_t;
+ pub type io_service_t = io_object_t;
+
+ #[allow(non_camel_case_types)]
+ pub type task_port_t = task_t;
+
+ extern "C" {
+ pub fn IOServiceMatching(a: *const c_char) -> CFMutableDictionaryRef;
+
+ pub fn IOServiceOpen(
+ device: io_service_t,
+ owning_task: task_port_t,
+ type_: u32,
+ connect: *mut io_connect_t,
+ ) -> kern_return_t;
+
+ pub fn IOServiceClose(a: io_connect_t) -> kern_return_t;
+
+ #[allow(dead_code)]
+ pub fn IOConnectCallStructMethod(
+ connection: mach_port_t,
+ selector: u32,
+ inputStruct: *const KeyData_t,
+ inputStructCnt: size_t,
+ outputStruct: *mut KeyData_t,
+ outputStructCnt: *mut size_t,
+ ) -> kern_return_t;
+ }
#[cfg_attr(feature = "debug", derive(Debug, Eq, Hash, PartialEq))]
#[repr(C)]
@@ -143,8 +149,13 @@ mod io_service {
pub bytes: [i8; 32], // SMCBytes_t
}
+ #[allow(dead_code)]
pub const KERNEL_INDEX_SMC: i32 = 2;
+
+ #[allow(dead_code)]
pub const SMC_CMD_READ_KEYINFO: u8 = 9;
+
+ #[allow(dead_code)]
pub const SMC_CMD_READ_BYTES: u8 = 5;
pub const KIO_RETURN_SUCCESS: i32 = 0;
@@ -153,4 +164,128 @@ mod io_service {
#[cfg(feature = "apple-sandbox")]
mod io_service {}
+#[cfg(all(
+ not(feature = "apple-sandbox"),
+ any(target_arch = "x86", target_arch = "x86_64")
+))]
+pub use io_service::*;
+
+#[cfg(all(not(feature = "apple-sandbox"), target_arch = "aarch64"))]
+mod io_service {
+ use std::ptr::null;
+
+ use core_foundation_sys::array::CFArrayRef;
+ use core_foundation_sys::base::{CFAllocatorRef, CFRelease};
+ use core_foundation_sys::dictionary::{
+ kCFTypeDictionaryKeyCallBacks, kCFTypeDictionaryValueCallBacks, CFDictionaryCreate,
+ CFDictionaryRef,
+ };
+ use core_foundation_sys::number::{kCFNumberSInt32Type, CFNumberCreate};
+ use core_foundation_sys::string::{CFStringCreateWithCString, CFStringRef};
+
+ #[repr(C)]
+ pub struct __IOHIDServiceClient(libc::c_void);
+
+ pub type IOHIDServiceClientRef = *const __IOHIDServiceClient;
+
+ #[repr(C)]
+ pub struct __IOHIDEventSystemClient(libc::c_void);
+
+ pub type IOHIDEventSystemClientRef = *const __IOHIDEventSystemClient;
+
+ #[repr(C)]
+ pub struct __IOHIDEvent(libc::c_void);
+
+ pub type IOHIDEventRef = *const __IOHIDEvent;
+
+ #[allow(non_upper_case_globals)]
+ pub const kIOHIDEventTypeTemperature: i64 = 15;
+
+ #[inline]
+ #[allow(non_snake_case)]
+ pub fn IOHIDEventFieldBase(event_type: i64) -> i64 {
+ event_type << 16
+ }
+
+ #[cfg(not(feature = "apple-sandbox"))]
+ extern "C" {
+ pub fn IOHIDEventSystemClientCreate(allocator: CFAllocatorRef)
+ -> IOHIDEventSystemClientRef;
+
+ pub fn IOHIDEventSystemClientSetMatching(
+ client: IOHIDEventSystemClientRef,
+ matches: CFDictionaryRef,
+ ) -> i32;
+
+ pub fn IOHIDEventSystemClientCopyServices(client: IOHIDEventSystemClientRef) -> CFArrayRef;
+
+ pub fn IOHIDServiceClientCopyProperty(
+ service: IOHIDServiceClientRef,
+ key: CFStringRef,
+ ) -> CFStringRef;
+
+ pub fn IOHIDServiceClientCopyEvent(
+ service: IOHIDServiceClientRef,
+ v0: i64,
+ v1: i32,
+ v2: i64,
+ ) -> IOHIDEventRef;
+
+ pub fn IOHIDEventGetFloatValue(event: IOHIDEventRef, field: i64) -> f64;
+ }
+
+ pub(crate) const HID_DEVICE_PROPERTY_PRODUCT: &[u8] = b"Product\0";
+
+ pub(crate) const HID_DEVICE_PROPERTY_PRIMARY_USAGE: &[u8] = b"PrimaryUsage\0";
+ pub(crate) const HID_DEVICE_PROPERTY_PRIMARY_USAGE_PAGE: &[u8] = b"PrimaryUsagePage\0";
+
+ #[allow(non_upper_case_globals)]
+ pub(crate) const kHIDPage_AppleVendor: i32 = 0xff00;
+
+ #[allow(non_upper_case_globals)]
+ pub(crate) const kHIDUsage_AppleVendor_TemperatureSensor: i32 = 0x0005;
+
+ pub(crate) fn matching(page: i32, usage: i32) -> CFDictionaryRef {
+ unsafe {
+ let keys = [
+ CFStringCreateWithCString(
+ null() as *const _,
+ HID_DEVICE_PROPERTY_PRIMARY_USAGE_PAGE.as_ptr() as *const _,
+ 0,
+ ),
+ CFStringCreateWithCString(
+ null() as *const _,
+ HID_DEVICE_PROPERTY_PRIMARY_USAGE.as_ptr() as *const _,
+ 0,
+ ),
+ ];
+
+ let nums = [
+ CFNumberCreate(null(), kCFNumberSInt32Type, &page as *const _ as *const _),
+ CFNumberCreate(null(), kCFNumberSInt32Type, &usage as *const _ as *const _),
+ ];
+
+ let dict = CFDictionaryCreate(
+ null(),
+ &keys as *const _ as *const _,
+ &nums as *const _ as *const _,
+ 2,
+ &kCFTypeDictionaryKeyCallBacks,
+ &kCFTypeDictionaryValueCallBacks,
+ );
+
+ for key in keys {
+ CFRelease(key as _);
+ }
+
+ for num in nums {
+ CFRelease(num as _);
+ }
+
+ dict
+ }
+ }
+}
+
+#[cfg(all(not(feature = "apple-sandbox"), target_arch = "aarch64"))]
pub use io_service::*;
diff --git a/vendor/sysinfo/src/apple/macos/mod.rs b/vendor/sysinfo/src/apple/macos/mod.rs
index 172bbfddc..856c5931d 100644
--- a/vendor/sysinfo/src/apple/macos/mod.rs
+++ b/vendor/sysinfo/src/apple/macos/mod.rs
@@ -2,16 +2,19 @@
pub mod disk;
pub mod ffi;
+pub(crate) mod utils;
#[cfg(not(feature = "apple-sandbox"))]
pub mod system;
#[cfg(not(feature = "apple-sandbox"))]
pub mod component;
+
#[cfg(not(feature = "apple-sandbox"))]
pub mod process;
#[cfg(feature = "apple-sandbox")]
pub use crate::sys::app_store::component;
+
#[cfg(feature = "apple-sandbox")]
pub use crate::sys::app_store::process;
diff --git a/vendor/sysinfo/src/apple/macos/process.rs b/vendor/sysinfo/src/apple/macos/process.rs
index f146126cf..fff9c1f71 100644
--- a/vendor/sysinfo/src/apple/macos/process.rs
+++ b/vendor/sysinfo/src/apple/macos/process.rs
@@ -30,7 +30,7 @@ pub struct Process {
old_stime: u64,
start_time: u64,
run_time: u64,
- updated: bool,
+ pub(crate) updated: bool,
cpu_usage: f32,
user_id: Option<Uid>,
group_id: Option<Gid>,
@@ -184,6 +184,20 @@ impl ProcessExt for Process {
fn group_id(&self) -> Option<Gid> {
self.group_id
}
+
+ fn wait(&self) {
+ let mut status = 0;
+ // attempt waiting
+ unsafe {
+ if libc::waitpid(self.pid.0, &mut status, 0) < 0 {
+ // attempt failed (non-child process) so loop until process ends
+ let duration = std::time::Duration::from_millis(10);
+ while kill(self.pid.0, 0) == 0 {
+ std::thread::sleep(duration);
+ }
+ }
+ }
+ }
}
#[allow(deprecated)] // Because of libc::mach_absolute_time.
@@ -202,7 +216,9 @@ pub(crate) fn compute_cpu_usage(
.saturating_add(task_info.pti_total_user);
let total_time_diff = total_current_time.saturating_sub(total_existing_time);
- p.cpu_usage = (total_time_diff as f64 / time_interval * 100.) as f32;
+ if total_time_diff > 0 {
+ p.cpu_usage = (total_time_diff as f64 / time_interval * 100.) as f32;
+ }
} else {
p.cpu_usage = 0.;
}
@@ -236,7 +252,6 @@ pub(crate) fn compute_cpu_usage(
};
}
}
- p.updated = true;
}
/*pub fn set_time(p: &mut Process, utime: u64, stime: u64) {
@@ -247,18 +262,6 @@ pub(crate) fn compute_cpu_usage(
p.updated = true;
}*/
-#[inline]
-pub(crate) fn has_been_updated(p: &mut Process) -> bool {
- let old = p.updated;
- p.updated = false;
- old
-}
-
-#[inline]
-pub(crate) fn force_update(p: &mut Process) {
- p.updated = true;
-}
-
unsafe fn get_task_info(pid: Pid) -> libc::proc_taskinfo {
let mut task_info = mem::zeroed::<libc::proc_taskinfo>();
// If it doesn't work, we just don't have memory information for this process
@@ -274,12 +277,22 @@ unsafe fn get_task_info(pid: Pid) -> libc::proc_taskinfo {
}
#[inline]
-fn check_if_pid_is_alive(pid: Pid) -> bool {
- unsafe { kill(pid.0, 0) == 0 }
- // For the full complete check, it'd need to be (but that seems unneeded):
- // unsafe {
- // *libc::__errno_location() == libc::ESRCH
- // }
+fn check_if_pid_is_alive(pid: Pid, check_if_alive: bool) -> bool {
+ // In case we are iterating all pids we got from `proc_listallpids`, then
+ // there is no point checking if the process is alive since it was returned
+ // from this function.
+ if !check_if_alive {
+ return true;
+ }
+ unsafe {
+ if kill(pid.0, 0) == 0 {
+ return true;
+ }
+ // `kill` failed but it might not be because the process is dead.
+ let errno = libc::__error();
+ // If errno is equal to ESCHR, it means the process is dead.
+ !errno.is_null() && *errno != libc::ESRCH
+ }
}
#[inline]
@@ -293,91 +306,52 @@ fn do_get_env_path(env: &str, root: &mut PathBuf, check: &mut bool) {
}
}
-pub(crate) fn update_process(
- wrap: &Wrap,
+unsafe fn get_bsd_info(pid: Pid) -> Option<libc::proc_bsdinfo> {
+ let mut info = mem::zeroed::<libc::proc_bsdinfo>();
+
+ if libc::proc_pidinfo(
+ pid.0,
+ libc::PROC_PIDTBSDINFO,
+ 0,
+ &mut info as *mut _ as *mut _,
+ mem::size_of::<libc::proc_bsdinfo>() as _,
+ ) != mem::size_of::<libc::proc_bsdinfo>() as _
+ {
+ None
+ } else {
+ Some(info)
+ }
+}
+
+unsafe fn create_new_process(
pid: Pid,
mut size: size_t,
- time_interval: Option<f64>,
now: u64,
refresh_kind: ProcessRefreshKind,
+ info: Option<libc::proc_bsdinfo>,
) -> Result<Option<Process>, ()> {
- let mut proc_args = Vec::with_capacity(size as usize);
-
- unsafe {
- if let Some(ref mut p) = (*wrap.0.get()).get_mut(&pid) {
- if p.memory == 0 {
- // We don't have access to this process' information.
- force_update(p);
- return if check_if_pid_is_alive(pid) {
- Ok(None)
- } else {
- Err(())
- };
- }
- let task_info = get_task_info(pid);
- let mut thread_info = mem::zeroed::<libc::proc_threadinfo>();
- let (user_time, system_time, thread_status) = if libc::proc_pidinfo(
- pid.0,
- libc::PROC_PIDTHREADINFO,
- 0,
- &mut thread_info as *mut libc::proc_threadinfo as *mut c_void,
- mem::size_of::<libc::proc_threadinfo>() as _,
- ) != 0
- {
- (
- thread_info.pth_user_time,
- thread_info.pth_system_time,
- Some(ThreadStatus::from(thread_info.pth_run_state)),
- )
- } else {
- // It very likely means that the process is dead...
- return if check_if_pid_is_alive(pid) {
- Ok(None)
- } else {
- Err(())
- };
- };
- p.status = thread_status;
- if refresh_kind.cpu() {
- compute_cpu_usage(p, task_info, system_time, user_time, time_interval);
- }
-
- p.memory = task_info.pti_resident_size / 1_000;
- p.virtual_memory = task_info.pti_virtual_size / 1_000;
- if refresh_kind.disk_usage() {
- update_proc_disk_activity(p);
- }
- return Ok(None);
- }
-
- let mut vnodepathinfo = mem::zeroed::<libc::proc_vnodepathinfo>();
- let result = libc::proc_pidinfo(
- pid.0,
- libc::PROC_PIDVNODEPATHINFO,
- 0,
- &mut vnodepathinfo as *mut _ as *mut _,
- mem::size_of::<libc::proc_vnodepathinfo>() as _,
- );
- let cwd = if result > 0 {
- let buffer = vnodepathinfo.pvi_cdir.vip_path;
- let buffer = CStr::from_ptr(buffer.as_ptr() as _);
- buffer
- .to_str()
- .map(PathBuf::from)
- .unwrap_or_else(|_| PathBuf::new())
- } else {
- PathBuf::new()
- };
+ let mut vnodepathinfo = mem::zeroed::<libc::proc_vnodepathinfo>();
+ let result = libc::proc_pidinfo(
+ pid.0,
+ libc::PROC_PIDVNODEPATHINFO,
+ 0,
+ &mut vnodepathinfo as *mut _ as *mut _,
+ mem::size_of::<libc::proc_vnodepathinfo>() as _,
+ );
+ let cwd = if result > 0 {
+ let buffer = vnodepathinfo.pvi_cdir.vip_path;
+ let buffer = CStr::from_ptr(buffer.as_ptr() as _);
+ buffer
+ .to_str()
+ .map(PathBuf::from)
+ .unwrap_or_else(|_| PathBuf::new())
+ } else {
+ PathBuf::new()
+ };
- let mut info = mem::zeroed::<libc::proc_bsdinfo>();
- if libc::proc_pidinfo(
- pid.0,
- libc::PROC_PIDTBSDINFO,
- 0,
- &mut info as *mut _ as *mut _,
- mem::size_of::<libc::proc_bsdinfo>() as _,
- ) != mem::size_of::<libc::proc_bsdinfo>() as _
- {
+ let info = match info {
+ Some(info) => info,
+ None => {
let mut buffer: Vec<u8> = Vec::with_capacity(libc::PROC_PIDPATHINFO_MAXSIZE as _);
match libc::proc_pidpath(
pid.0,
@@ -399,158 +373,228 @@ pub(crate) fn update_process(
}
return Err(());
}
- let parent = match info.pbi_ppid as i32 {
- 0 => None,
- p => Some(Pid(p)),
- };
-
- let ptr: *mut u8 = proc_args.as_mut_slice().as_mut_ptr();
- let mut mib = [libc::CTL_KERN, libc::KERN_PROCARGS2, pid.0 as _];
- /*
- * /---------------\ 0x00000000
- * | ::::::::::::: |
- * |---------------| <-- Beginning of data returned by sysctl() is here.
- * | argc |
- * |---------------|
- * | exec_path |
- * |---------------|
- * | 0 |
- * |---------------|
- * | arg[0] |
- * |---------------|
- * | 0 |
- * |---------------|
- * | arg[n] |
- * |---------------|
- * | 0 |
- * |---------------|
- * | env[0] |
- * |---------------|
- * | 0 |
- * |---------------|
- * | env[n] |
- * |---------------|
- * | ::::::::::::: |
- * |---------------| <-- Top of stack.
- * : :
- * : :
- * \---------------/ 0xffffffff
- */
- if libc::sysctl(
- mib.as_mut_ptr(),
- mib.len() as _,
- ptr as *mut c_void,
- &mut size,
- std::ptr::null_mut(),
- 0,
- ) == -1
- {
- return Err(()); // not enough rights I assume?
- }
- let mut n_args: c_int = 0;
- libc::memcpy(
- (&mut n_args) as *mut c_int as *mut c_void,
- ptr as *const c_void,
- mem::size_of::<c_int>(),
- );
+ };
+ let parent = match info.pbi_ppid as i32 {
+ 0 => None,
+ p => Some(Pid(p)),
+ };
+
+ let mut proc_args = Vec::with_capacity(size as _);
+ let ptr: *mut u8 = proc_args.as_mut_slice().as_mut_ptr();
+ let mut mib = [libc::CTL_KERN, libc::KERN_PROCARGS2, pid.0 as _];
+ /*
+ * /---------------\ 0x00000000
+ * | ::::::::::::: |
+ * |---------------| <-- Beginning of data returned by sysctl() is here.
+ * | argc |
+ * |---------------|
+ * | exec_path |
+ * |---------------|
+ * | 0 |
+ * |---------------|
+ * | arg[0] |
+ * |---------------|
+ * | 0 |
+ * |---------------|
+ * | arg[n] |
+ * |---------------|
+ * | 0 |
+ * |---------------|
+ * | env[0] |
+ * |---------------|
+ * | 0 |
+ * |---------------|
+ * | env[n] |
+ * |---------------|
+ * | ::::::::::::: |
+ * |---------------| <-- Top of stack.
+ * : :
+ * : :
+ * \---------------/ 0xffffffff
+ */
+ if libc::sysctl(
+ mib.as_mut_ptr(),
+ mib.len() as _,
+ ptr as *mut c_void,
+ &mut size,
+ std::ptr::null_mut(),
+ 0,
+ ) == -1
+ {
+ return Err(()); // not enough rights I assume?
+ }
+ let mut n_args: c_int = 0;
+ libc::memcpy(
+ (&mut n_args) as *mut c_int as *mut c_void,
+ ptr as *const c_void,
+ mem::size_of::<c_int>(),
+ );
- let mut cp = ptr.add(mem::size_of::<c_int>());
- let mut start = cp;
+ let mut cp = ptr.add(mem::size_of::<c_int>());
+ let mut start = cp;
- let start_time = info.pbi_start_tvsec;
- let run_time = now.saturating_sub(start_time);
+ let start_time = info.pbi_start_tvsec;
+ let run_time = now.saturating_sub(start_time);
- let mut p = if cp < ptr.add(size) {
- while cp < ptr.add(size) && *cp != 0 {
- cp = cp.offset(1);
- }
- let exe = Path::new(get_unchecked_str(cp, start).as_str()).to_path_buf();
- let name = exe
- .file_name()
- .and_then(|x| x.to_str())
- .unwrap_or("")
- .to_owned();
- while cp < ptr.add(size) && *cp == 0 {
- cp = cp.offset(1);
+ let mut p = if cp < ptr.add(size) {
+ while cp < ptr.add(size) && *cp != 0 {
+ cp = cp.offset(1);
+ }
+ let exe = Path::new(get_unchecked_str(cp, start).as_str()).to_path_buf();
+ let name = exe
+ .file_name()
+ .and_then(|x| x.to_str())
+ .unwrap_or("")
+ .to_owned();
+ while cp < ptr.add(size) && *cp == 0 {
+ cp = cp.offset(1);
+ }
+ start = cp;
+ let mut c = 0;
+ let mut cmd = Vec::with_capacity(n_args as usize);
+ while c < n_args && cp < ptr.add(size) {
+ if *cp == 0 {
+ c += 1;
+ cmd.push(get_unchecked_str(cp, start));
+ start = cp.offset(1);
}
- start = cp;
- let mut c = 0;
- let mut cmd = Vec::with_capacity(n_args as usize);
- while c < n_args && cp < ptr.add(size) {
+ cp = cp.offset(1);
+ }
+
+ #[inline]
+ unsafe fn get_environ<F: Fn(&str, &mut PathBuf, &mut bool)>(
+ ptr: *mut u8,
+ mut cp: *mut u8,
+ size: size_t,
+ mut root: PathBuf,
+ callback: F,
+ ) -> (Vec<String>, PathBuf) {
+ let mut environ = Vec::with_capacity(10);
+ let mut start = cp;
+ let mut check = true;
+ while cp < ptr.add(size) {
if *cp == 0 {
- c += 1;
- cmd.push(get_unchecked_str(cp, start));
+ if cp == start {
+ break;
+ }
+ let e = get_unchecked_str(cp, start);
+ callback(&e, &mut root, &mut check);
+ environ.push(e);
start = cp.offset(1);
}
cp = cp.offset(1);
}
+ (environ, root)
+ }
- #[inline]
- unsafe fn get_environ<F: Fn(&str, &mut PathBuf, &mut bool)>(
- ptr: *mut u8,
- mut cp: *mut u8,
- size: size_t,
- mut root: PathBuf,
- callback: F,
- ) -> (Vec<String>, PathBuf) {
- let mut environ = Vec::with_capacity(10);
- let mut start = cp;
- let mut check = true;
- while cp < ptr.add(size) {
- if *cp == 0 {
- if cp == start {
- break;
- }
- let e = get_unchecked_str(cp, start);
- callback(&e, &mut root, &mut check);
- environ.push(e);
- start = cp.offset(1);
- }
- cp = cp.offset(1);
- }
- (environ, root)
+ let (environ, root) = if exe.is_absolute() {
+ if let Some(parent_path) = exe.parent() {
+ get_environ(
+ ptr,
+ cp,
+ size,
+ parent_path.to_path_buf(),
+ do_not_get_env_path,
+ )
+ } else {
+ get_environ(ptr, cp, size, PathBuf::new(), do_get_env_path)
}
+ } else {
+ get_environ(ptr, cp, size, PathBuf::new(), do_get_env_path)
+ };
+ let mut p = Process::new(pid, parent, start_time, run_time);
+
+ p.exe = exe;
+ p.name = name;
+ p.cwd = cwd;
+ p.cmd = parse_command_line(&cmd);
+ p.environ = environ;
+ p.root = root;
+ p
+ } else {
+ Process::new(pid, parent, start_time, run_time)
+ };
+
+ let task_info = get_task_info(pid);
+
+ p.memory = task_info.pti_resident_size;
+ p.virtual_memory = task_info.pti_virtual_size;
- let (environ, root) = if exe.is_absolute() {
- if let Some(parent_path) = exe.parent() {
- get_environ(
- ptr,
- cp,
- size,
- parent_path.to_path_buf(),
- do_not_get_env_path,
- )
+ p.user_id = Some(Uid(info.pbi_uid));
+ p.group_id = Some(Gid(info.pbi_gid));
+ p.process_status = ProcessStatus::from(info.pbi_status);
+ if refresh_kind.disk_usage() {
+ update_proc_disk_activity(&mut p);
+ }
+ Ok(Some(p))
+}
+
+pub(crate) fn update_process(
+ wrap: &Wrap,
+ pid: Pid,
+ size: size_t,
+ time_interval: Option<f64>,
+ now: u64,
+ refresh_kind: ProcessRefreshKind,
+ check_if_alive: bool,
+) -> Result<Option<Process>, ()> {
+ unsafe {
+ if let Some(ref mut p) = (*wrap.0.get()).get_mut(&pid) {
+ if p.memory == 0 {
+ // We don't have access to this process' information.
+ return if check_if_pid_is_alive(pid, check_if_alive) {
+ p.updated = true;
+ Ok(None)
} else {
- get_environ(ptr, cp, size, PathBuf::new(), do_get_env_path)
+ Err(())
+ };
+ }
+ if let Some(info) = get_bsd_info(pid) {
+ if info.pbi_start_tvsec != p.start_time {
+ // We don't it to be removed, just replaced.
+ p.updated = true;
+ // The owner of this PID changed.
+ return create_new_process(pid, size, now, refresh_kind, Some(info));
}
+ }
+ let task_info = get_task_info(pid);
+ let mut thread_info = mem::zeroed::<libc::proc_threadinfo>();
+ let (user_time, system_time, thread_status) = if libc::proc_pidinfo(
+ pid.0,
+ libc::PROC_PIDTHREADINFO,
+ 0,
+ &mut thread_info as *mut libc::proc_threadinfo as *mut c_void,
+ mem::size_of::<libc::proc_threadinfo>() as _,
+ ) != 0
+ {
+ (
+ thread_info.pth_user_time,
+ thread_info.pth_system_time,
+ Some(ThreadStatus::from(thread_info.pth_run_state)),
+ )
} else {
- get_environ(ptr, cp, size, PathBuf::new(), do_get_env_path)
+ // It very likely means that the process is dead...
+ if check_if_pid_is_alive(pid, check_if_alive) {
+ (0, 0, Some(ThreadStatus::Running))
+ } else {
+ return Err(());
+ }
};
- let mut p = Process::new(pid, parent, start_time, run_time);
-
- p.exe = exe;
- p.name = name;
- p.cwd = cwd;
- p.cmd = parse_command_line(&cmd);
- p.environ = environ;
- p.root = root;
- p
- } else {
- Process::new(pid, parent, start_time, run_time)
- };
-
- let task_info = get_task_info(pid);
+ p.status = thread_status;
- p.memory = task_info.pti_resident_size / 1_000;
- p.virtual_memory = task_info.pti_virtual_size / 1_000;
+ if refresh_kind.cpu() {
+ compute_cpu_usage(p, task_info, system_time, user_time, time_interval);
+ }
- p.user_id = Some(Uid(info.pbi_uid));
- p.group_id = Some(Gid(info.pbi_gid));
- p.process_status = ProcessStatus::from(info.pbi_status);
- if refresh_kind.disk_usage() {
- update_proc_disk_activity(&mut p);
+ p.memory = task_info.pti_resident_size;
+ p.virtual_memory = task_info.pti_virtual_size;
+ if refresh_kind.disk_usage() {
+ update_proc_disk_activity(p);
+ }
+ p.updated = true;
+ return Ok(None);
}
- Ok(Some(p))
+ create_new_process(pid, size, now, refresh_kind, get_bsd_info(pid))
}
}
@@ -577,6 +621,7 @@ fn update_proc_disk_activity(p: &mut Process) {
}
}
+#[allow(unknown_lints)]
#[allow(clippy::uninit_vec)]
pub(crate) fn get_proc_list() -> Option<Vec<Pid>> {
unsafe {
diff --git a/vendor/sysinfo/src/apple/macos/utils.rs b/vendor/sysinfo/src/apple/macos/utils.rs
new file mode 100644
index 000000000..ff870db55
--- /dev/null
+++ b/vendor/sysinfo/src/apple/macos/utils.rs
@@ -0,0 +1,30 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+use std::num::NonZeroU32;
+
+type IoObject = NonZeroU32;
+
+pub(crate) struct IOReleaser(IoObject);
+
+impl IOReleaser {
+ pub(crate) fn new(obj: u32) -> Option<Self> {
+ IoObject::new(obj).map(Self)
+ }
+
+ pub(crate) unsafe fn new_unchecked(obj: u32) -> Self {
+ // Chance at catching in-development mistakes
+ debug_assert_ne!(obj, 0);
+ Self(IoObject::new_unchecked(obj))
+ }
+
+ #[inline]
+ pub(crate) fn inner(&self) -> u32 {
+ self.0.get()
+ }
+}
+
+impl Drop for IOReleaser {
+ fn drop(&mut self) {
+ unsafe { super::ffi::IOObjectRelease(self.0.get() as _) };
+ }
+}
diff --git a/vendor/sysinfo/src/apple/mod.rs b/vendor/sysinfo/src/apple/mod.rs
index daff800a2..fd6fdec2c 100644
--- a/vendor/sysinfo/src/apple/mod.rs
+++ b/vendor/sysinfo/src/apple/mod.rs
@@ -2,6 +2,7 @@
#[cfg(target_os = "macos")]
pub(crate) mod macos;
+
#[cfg(target_os = "macos")]
pub(crate) use self::macos as inner;
diff --git a/vendor/sysinfo/src/apple/network.rs b/vendor/sysinfo/src/apple/network.rs
index f1316920e..3c4918155 100644
--- a/vendor/sysinfo/src/apple/network.rs
+++ b/vendor/sysinfo/src/apple/network.rs
@@ -26,6 +26,7 @@ impl Networks {
}
}
+ #[allow(unknown_lints)]
#[allow(clippy::cast_ptr_alignment)]
#[allow(clippy::uninit_vec)]
fn update_networks(&mut self) {
diff --git a/vendor/sysinfo/src/apple/system.rs b/vendor/sysinfo/src/apple/system.rs
index abe617dee..12abbd23b 100644
--- a/vendor/sysinfo/src/apple/system.rs
+++ b/vendor/sysinfo/src/apple/system.rs
@@ -3,12 +3,8 @@
use crate::sys::component::Component;
use crate::sys::cpu::*;
use crate::sys::disk::*;
-#[cfg(target_os = "macos")]
-use crate::sys::ffi;
use crate::sys::network::Networks;
use crate::sys::process::*;
-#[cfg(target_os = "macos")]
-use core_foundation_sys::base::{kCFAllocatorDefault, CFRelease};
use crate::{
CpuExt, CpuRefreshKind, LoadAvg, Pid, ProcessRefreshKind, RefreshKind, SystemExt, User,
@@ -32,6 +28,9 @@ use libc::{
vm_statistics64, _SC_PAGESIZE,
};
+#[cfg(not(any(target_os = "ios", feature = "apple-sandbox")))]
+use super::inner::component::Components;
+
#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
declare_signals! {
c_int,
@@ -87,55 +86,23 @@ pub struct System {
global_cpu: Cpu,
cpus: Vec<Cpu>,
page_size_kb: u64,
- components: Vec<Component>,
- // Used to get CPU information, not supported on iOS, or inside the default macOS sandbox.
- #[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
- connection: Option<ffi::io_connect_t>,
+ #[cfg(not(any(target_os = "ios", feature = "apple-sandbox")))]
+ components: Components,
disks: Vec<Disk>,
networks: Networks,
port: mach_port_t,
users: Vec<User>,
boot_time: u64,
- // Used to get disk information, to be more specific, it's needed by the
- // DADiskCreateFromVolumePath function. Not supported on iOS.
- #[cfg(target_os = "macos")]
- session: ffi::SessionWrap,
#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
clock_info: Option<crate::sys::macos::system::SystemTimeInfo>,
got_cpu_frequency: bool,
}
-impl Drop for System {
- fn drop(&mut self) {
- #[cfg(target_os = "macos")]
- unsafe {
- #[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
- if let Some(conn) = self.connection {
- ffi::IOServiceClose(conn);
- }
-
- if !self.session.0.is_null() {
- CFRelease(self.session.0 as _);
- }
- }
- }
-}
-
pub(crate) struct Wrap<'a>(pub UnsafeCell<&'a mut HashMap<Pid, Process>>);
unsafe impl<'a> Send for Wrap<'a> {}
unsafe impl<'a> Sync for Wrap<'a> {}
-#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
-impl System {
- fn clear_procs(&mut self) {
- use crate::sys::macos::process;
-
- self.process_list
- .retain(|_, proc_| process::has_been_updated(proc_));
- }
-}
-
fn boot_time() -> u64 {
let mut boot_time = timeval {
tv_sec: 0,
@@ -192,17 +159,14 @@ impl SystemExt for System {
String::new(),
),
cpus: Vec::new(),
- page_size_kb: sysconf(_SC_PAGESIZE) as u64 / 1_000,
- components: Vec::with_capacity(2),
- #[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
- connection: get_io_service_connection(),
+ page_size_kb: sysconf(_SC_PAGESIZE) as _,
+ #[cfg(not(any(target_os = "ios", feature = "apple-sandbox")))]
+ components: Components::new(),
disks: Vec::with_capacity(1),
networks: Networks::new(),
port,
users: Vec::new(),
boot_time: boot_time(),
- #[cfg(target_os = "macos")]
- session: ffi::SessionWrap(::std::ptr::null_mut()),
#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
clock_info: crate::sys::macos::system::SystemTimeInfo::new(port),
got_cpu_frequency: false,
@@ -226,8 +190,8 @@ impl SystemExt for System {
&mut xs as *mut _ as *mut c_void,
&mut mib,
) {
- self.swap_total = xs.xsu_total / 1_000;
- self.swap_free = xs.xsu_avail / 1_000;
+ self.swap_total = xs.xsu_total;
+ self.swap_free = xs.xsu_avail;
}
// get ram info
if self.mem_total < 1 {
@@ -238,7 +202,6 @@ impl SystemExt for System {
&mut self.mem_total as *mut u64 as *mut c_void,
&mut mib,
);
- self.mem_total /= 1_000;
}
let mut count: u32 = libc::HOST_VM_INFO64_COUNT as _;
let mut stat = mem::zeroed::<vm_statistics64>();
@@ -257,16 +220,14 @@ impl SystemExt for System {
// * used to hold data that was read speculatively from disk but
// * haven't actually been used by anyone so far.
// */
- self.mem_available = self
- .mem_total
- .saturating_sub(
- u64::from(stat.active_count)
- .saturating_add(u64::from(stat.inactive_count))
- .saturating_add(u64::from(stat.wire_count))
- .saturating_add(u64::from(stat.speculative_count))
- .saturating_sub(u64::from(stat.purgeable_count)),
- )
- .saturating_mul(self.page_size_kb);
+ self.mem_available = self.mem_total.saturating_sub(
+ u64::from(stat.active_count)
+ .saturating_add(u64::from(stat.inactive_count))
+ .saturating_add(u64::from(stat.wire_count))
+ .saturating_add(u64::from(stat.speculative_count))
+ .saturating_sub(u64::from(stat.purgeable_count))
+ .saturating_mul(self.page_size_kb),
+ );
self.mem_free = u64::from(stat.free_count).saturating_mul(self.page_size_kb);
}
}
@@ -275,22 +236,9 @@ impl SystemExt for System {
#[cfg(any(target_os = "ios", feature = "apple-sandbox"))]
fn refresh_components_list(&mut self) {}
- #[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
+ #[cfg(not(any(target_os = "ios", feature = "apple-sandbox")))]
fn refresh_components_list(&mut self) {
- if let Some(con) = self.connection {
- self.components.clear();
- // getting CPU critical temperature
- let critical_temp = crate::apple::component::get_temperature(
- con,
- &['T' as i8, 'C' as i8, '0' as i8, 'D' as i8, 0],
- );
-
- for (id, v) in crate::apple::component::COMPONENTS_TEMPERATURE_IDS.iter() {
- if let Some(c) = Component::new((*id).to_owned(), None, critical_temp, v, con) {
- self.components.push(c);
- }
- }
- }
+ self.components.refresh();
}
fn refresh_cpu_specifics(&mut self, refresh_kind: CpuRefreshKind) {
@@ -356,6 +304,7 @@ impl SystemExt for System {
time_interval,
now,
refresh_kind,
+ false,
) {
Ok(x) => x,
_ => None,
@@ -366,7 +315,8 @@ impl SystemExt for System {
entries.into_iter().for_each(|entry| {
self.process_list.insert(entry.pid(), entry);
});
- self.clear_procs();
+ self.process_list
+ .retain(|_, proc_| std::mem::replace(&mut proc_.updated, false));
}
}
@@ -390,6 +340,7 @@ impl SystemExt for System {
time_interval,
now,
refresh_kind,
+ true,
)
} {
Ok(Some(p)) => {
@@ -401,17 +352,8 @@ impl SystemExt for System {
}
}
- #[cfg(target_os = "ios")]
- fn refresh_disks_list(&mut self) {}
-
- #[cfg(target_os = "macos")]
fn refresh_disks_list(&mut self) {
- unsafe {
- if self.session.0.is_null() {
- self.session.0 = ffi::DASessionCreate(kCFAllocatorDefault as _);
- }
- self.disks = get_disks(self.session.0);
- }
+ self.disks = unsafe { get_disks() };
}
fn refresh_users_list(&mut self) {
@@ -491,12 +433,24 @@ impl SystemExt for System {
self.swap_total - self.swap_free
}
+ #[cfg(not(any(target_os = "ios", feature = "apple-sandbox")))]
fn components(&self) -> &[Component] {
- &self.components
+ &self.components.inner
}
+ #[cfg(any(target_os = "ios", feature = "apple-sandbox"))]
+ fn components(&self) -> &[Component] {
+ &[]
+ }
+
+ #[cfg(not(any(target_os = "ios", feature = "apple-sandbox")))]
fn components_mut(&mut self) -> &mut [Component] {
- &mut self.components
+ &mut self.components.inner
+ }
+
+ #[cfg(any(target_os = "ios", feature = "apple-sandbox"))]
+ fn components_mut(&mut self) -> &mut [Component] {
+ &mut []
}
fn disks(&self) -> &[Disk] {
@@ -507,6 +461,13 @@ impl SystemExt for System {
&mut self.disks
}
+ fn sort_disks_by<F>(&mut self, compare: F)
+ where
+ F: FnMut(&Disk, &Disk) -> std::cmp::Ordering,
+ {
+ self.disks.sort_unstable_by(compare);
+ }
+
fn uptime(&self) -> u64 {
unsafe {
let csec = libc::time(::std::ptr::null_mut());
@@ -598,7 +559,7 @@ impl SystemExt for System {
&& size > 0
{
// now create a buffer with the size and get the real value
- let mut buf = vec![0_u8; size as usize];
+ let mut buf = vec![0_u8; size as _];
if get_sys_value_by_name(
b"kern.osproductversion\0",
@@ -621,6 +582,10 @@ impl SystemExt for System {
}
}
}
+
+ fn distribution_id(&self) -> String {
+ std::env::consts::OS.to_owned()
+ }
}
impl Default for System {
@@ -629,43 +594,6 @@ impl Default for System {
}
}
-// code from https://github.com/Chris911/iStats
-// Not supported on iOS, or in the default macOS
-#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
-fn get_io_service_connection() -> Option<ffi::io_connect_t> {
- let mut master_port: mach_port_t = 0;
- let mut iterator: ffi::io_iterator_t = 0;
-
- unsafe {
- ffi::IOMasterPort(libc::MACH_PORT_NULL, &mut master_port);
-
- let matching_dictionary = ffi::IOServiceMatching(b"AppleSMC\0".as_ptr() as *const i8);
- let result =
- ffi::IOServiceGetMatchingServices(master_port, matching_dictionary, &mut iterator);
- if result != ffi::KIO_RETURN_SUCCESS {
- sysinfo_debug!("Error: IOServiceGetMatchingServices() = {}", result);
- return None;
- }
-
- let device = ffi::IOIteratorNext(iterator);
- ffi::IOObjectRelease(iterator);
- if device == 0 {
- sysinfo_debug!("Error: no SMC found");
- return None;
- }
-
- let mut conn = 0;
- let result = ffi::IOServiceOpen(device, libc::mach_task_self(), 0, &mut conn);
- ffi::IOObjectRelease(device);
- if result != ffi::KIO_RETURN_SUCCESS {
- sysinfo_debug!("Error: IOServiceOpen() = {}", result);
- return None;
- }
-
- Some(conn)
- }
-}
-
#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))]
fn get_arg_max() -> usize {
let mut mib = [libc::CTL_KERN, libc::KERN_ARGMAX];
@@ -737,7 +665,7 @@ fn get_system_info(value: c_int, default: Option<&str>) -> Option<String> {
default.map(|s| s.to_owned())
} else {
// set the buffer to the correct size
- let mut buf = vec![0_u8; size as usize];
+ let mut buf = vec![0_u8; size as _];
if sysctl(
mib.as_mut_ptr(),
diff --git a/vendor/sysinfo/src/apple/utils.rs b/vendor/sysinfo/src/apple/utils.rs
index 019295b95..408c02c31 100644
--- a/vendor/sysinfo/src/apple/utils.rs
+++ b/vendor/sysinfo/src/apple/utils.rs
@@ -1,6 +1,39 @@
// Take a look at the license at the top of the repository in the LICENSE file.
+use core_foundation_sys::base::CFRelease;
use libc::c_char;
+use std::ptr::NonNull;
+
+// A helper using to auto release the resource got from CoreFoundation.
+// More information about the ownership policy for CoreFoundation pelease refer the link below:
+// https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFMemoryMgmt/Concepts/Ownership.html#//apple_ref/doc/uid/20001148-CJBEJBHH
+#[repr(transparent)]
+pub(crate) struct CFReleaser<T>(NonNull<T>);
+
+impl<T> CFReleaser<T> {
+ pub(crate) fn new(ptr: *const T) -> Option<Self> {
+ // This cast is OK because `NonNull` is a transparent wrapper
+ // over a `*const T`. Additionally, mutability doesn't matter with
+ // pointers here.
+ NonNull::new(ptr as *mut T).map(Self)
+ }
+
+ pub(crate) fn inner(&self) -> *const T {
+ self.0.as_ptr().cast()
+ }
+}
+
+impl<T> Drop for CFReleaser<T> {
+ fn drop(&mut self) {
+ unsafe { CFRelease(self.0.as_ptr().cast()) }
+ }
+}
+
+// Safety: These are safe to implement because we only wrap non-mutable
+// CoreFoundation types, which are generally threadsafe unless noted
+// otherwise.
+unsafe impl<T> Send for CFReleaser<T> {}
+unsafe impl<T> Sync for CFReleaser<T> {}
pub(crate) fn cstr_to_rust(c: *const c_char) -> Option<String> {
cstr_to_rust_with_size(c, None)
@@ -28,7 +61,6 @@ pub(crate) fn cstr_to_rust_with_size(c: *const c_char, size: Option<usize>) -> O
}
}
-#[cfg(target_os = "macos")]
pub(crate) fn vec_to_rust(buf: Vec<i8>) -> Option<String> {
String::from_utf8(
buf.into_iter()
diff --git a/vendor/sysinfo/src/c_interface.rs b/vendor/sysinfo/src/c_interface.rs
index e7cc5359b..0914a8135 100644
--- a/vendor/sysinfo/src/c_interface.rs
+++ b/vendor/sysinfo/src/c_interface.rs
@@ -462,7 +462,7 @@ pub extern "C" fn sysinfo_process_current_directory(process: CProcess) -> RStrin
pub extern "C" fn sysinfo_rstring_free(s: RString) {
if !s.is_null() {
unsafe {
- let _ = CString::from_raw(s as usize as *mut i8);
+ let _ = CString::from_raw(s as usize as *mut _);
}
}
}
diff --git a/vendor/sysinfo/src/common.rs b/vendor/sysinfo/src/common.rs
index 15cbe87be..2710204f5 100644
--- a/vendor/sysinfo/src/common.rs
+++ b/vendor/sysinfo/src/common.rs
@@ -283,7 +283,7 @@ on Windows as other platforms get this information alongside the Process informa
);
}
-/// Used to determine what you want to refresh specifically on the [`Process`] type.
+/// Used to determine what you want to refresh specifically on the [`Cpu`] type.
///
/// ⚠️ Just like all other refresh types, ruling out a refresh doesn't assure you that
/// the information won't be retrieved if the information is accessible without needing
@@ -302,7 +302,7 @@ on Windows as other platforms get this information alongside the Process informa
/// }
/// ```
///
-/// [`Process`]: crate::Process
+/// [`Cpu`]: crate::Cpu
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct CpuRefreshKind {
cpu_usage: bool,
@@ -667,7 +667,7 @@ macro_rules! xid {
($(#[$outer:meta])+ $name:ident, $type:ty) => {
$(#[$outer])+
#[repr(transparent)]
- #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
+ #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
pub struct $name(pub(crate) $type);
impl std::ops::Deref for $name {
diff --git a/vendor/sysinfo/src/debug.rs b/vendor/sysinfo/src/debug.rs
index e2f4361d9..ef460eb49 100644
--- a/vendor/sysinfo/src/debug.rs
+++ b/vendor/sysinfo/src/debug.rs
@@ -105,7 +105,7 @@ impl fmt::Debug for Networks {
f,
"Networks {{ {} }}",
self.iter()
- .map(|x| format!("{:?}", x))
+ .map(|x| format!("{x:?}"))
.collect::<Vec<_>>()
.join(", ")
)
diff --git a/vendor/sysinfo/src/freebsd/component.rs b/vendor/sysinfo/src/freebsd/component.rs
index 6529be73c..c4e84fe63 100644
--- a/vendor/sysinfo/src/freebsd/component.rs
+++ b/vendor/sysinfo/src/freebsd/component.rs
@@ -55,9 +55,7 @@ pub unsafe fn get_components(nb_cpus: usize) -> Vec<Component> {
let mut components = Vec::with_capacity(nb_cpus);
for core in 0..nb_cpus {
- let id = format!("dev.cpu.{}.temperature\0", core)
- .as_bytes()
- .to_vec();
+ let id = format!("dev.cpu.{core}.temperature\0").as_bytes().to_vec();
if let Some(temperature) = refresh_component(&id) {
components.push(Component {
id,
diff --git a/vendor/sysinfo/src/freebsd/process.rs b/vendor/sysinfo/src/freebsd/process.rs
index b3302edbe..b0dda0f76 100644
--- a/vendor/sysinfo/src/freebsd/process.rs
+++ b/vendor/sysinfo/src/freebsd/process.rs
@@ -5,6 +5,8 @@ use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessRefreshKind, ProcessStatus,
use std::fmt;
use std::path::{Path, PathBuf};
+use libc::kill;
+
use super::utils::{get_sys_value_str, WrapMap};
#[doc(hidden)]
@@ -141,6 +143,20 @@ impl ProcessExt for Process {
fn group_id(&self) -> Option<Gid> {
Some(self.group_id)
}
+
+ fn wait(&self) {
+ let mut status = 0;
+ // attempt waiting
+ unsafe {
+ if libc::waitpid(self.pid.0, &mut status, 0) < 0 {
+ // attempt failed (non-child process) so loop until process ends
+ let duration = std::time::Duration::from_millis(10);
+ while kill(self.pid.0, 0) == 0 {
+ std::thread::sleep(duration);
+ }
+ }
+ }
+ }
}
pub(crate) unsafe fn get_process_data(
@@ -171,28 +187,34 @@ pub(crate) unsafe fn get_process_data(
let status = ProcessStatus::from(kproc.ki_stat);
// from FreeBSD source /src/usr.bin/top/machine.c
- let virtual_memory = (kproc.ki_size / 1_000) as u64;
- let memory = (kproc.ki_rssize as u64).saturating_mul(page_size as _) / 1_000;
+ let virtual_memory = kproc.ki_size as _;
+ let memory = (kproc.ki_rssize as u64).saturating_mul(page_size as _);
// FIXME: This is to get the "real" run time (in micro-seconds).
// let run_time = (kproc.ki_runtime + 5_000) / 10_000;
+ let start_time = kproc.ki_start.tv_sec as u64;
+
if let Some(proc_) = (*wrap.0.get()).get_mut(&Pid(kproc.ki_pid)) {
- proc_.cpu_usage = cpu_usage;
- proc_.parent = parent;
- proc_.status = status;
- proc_.virtual_memory = virtual_memory;
- proc_.memory = memory;
- proc_.run_time = now.saturating_sub(proc_.start_time);
proc_.updated = true;
-
- if refresh_kind.disk_usage() {
- proc_.old_read_bytes = proc_.read_bytes;
- proc_.read_bytes = kproc.ki_rusage.ru_inblock as _;
- proc_.old_written_bytes = proc_.written_bytes;
- proc_.written_bytes = kproc.ki_rusage.ru_oublock as _;
+ // If the `start_time` we just got is different from the one stored, it means it's not the
+ // same process.
+ if proc_.start_time == start_time {
+ proc_.cpu_usage = cpu_usage;
+ proc_.parent = parent;
+ proc_.status = status;
+ proc_.virtual_memory = virtual_memory;
+ proc_.memory = memory;
+ proc_.run_time = now.saturating_sub(proc_.start_time);
+
+ if refresh_kind.disk_usage() {
+ proc_.old_read_bytes = proc_.read_bytes;
+ proc_.read_bytes = kproc.ki_rusage.ru_inblock as _;
+ proc_.old_written_bytes = proc_.written_bytes;
+ proc_.written_bytes = kproc.ki_rusage.ru_oublock as _;
+ }
+
+ return Ok(None);
}
-
- return Ok(None);
}
// This is a new process, we need to get more information!
@@ -222,7 +244,6 @@ pub(crate) unsafe fn get_process_data(
// .map(|s| s.into())
// .unwrap_or_else(PathBuf::new);
- let start_time = kproc.ki_start.tv_sec as u64;
Ok(Some(Process {
pid: Pid(kproc.ki_pid),
parent,
@@ -249,6 +270,6 @@ pub(crate) unsafe fn get_process_data(
old_read_bytes: 0,
written_bytes: kproc.ki_rusage.ru_oublock as _,
old_written_bytes: 0,
- updated: true,
+ updated: false,
}))
}
diff --git a/vendor/sysinfo/src/freebsd/system.rs b/vendor/sysinfo/src/freebsd/system.rs
index 16da2de50..12298bbcf 100644
--- a/vendor/sysinfo/src/freebsd/system.rs
+++ b/vendor/sysinfo/src/freebsd/system.rs
@@ -126,11 +126,8 @@ impl SystemExt for System {
frequency = get_frequency_for_cpu(pos);
}
}
- self.cpus.push(Cpu::new(
- format!("cpu {}", pos),
- vendor_id.clone(),
- frequency,
- ));
+ self.cpus
+ .push(Cpu::new(format!("cpu {pos}"), vendor_id.clone(), frequency));
}
self.global_cpu.vendor_id = vendor_id;
self.got_cpu_frequency = refresh_kind.frequency();
@@ -307,6 +304,13 @@ impl SystemExt for System {
&mut self.disks
}
+ fn sort_disks_by<F>(&mut self, compare: F)
+ where
+ F: FnMut(&Disk, &Disk) -> std::cmp::Ordering,
+ {
+ self.disks.sort_unstable_by(compare);
+ }
+
fn uptime(&self) -> u64 {
unsafe {
let csec = libc::time(::std::ptr::null_mut());
@@ -354,6 +358,10 @@ impl SystemExt for System {
fn os_version(&self) -> Option<String> {
self.system_info.get_os_release()
}
+
+ fn distribution_id(&self) -> String {
+ std::env::consts::OS.to_owned()
+ }
}
impl Default for System {
@@ -377,10 +385,6 @@ impl System {
#[cfg(not(feature = "multithread"))]
use std::iter::Iterator as IterTrait;
- crate::utils::into_iter(&mut self.process_list).for_each(|(_, proc_)| {
- proc_.updated = false;
- });
-
let fscale = self.system_info.fscale;
let page_size = self.system_info.page_size as isize;
let now = super::utils::get_now();
@@ -404,7 +408,8 @@ impl System {
};
// We remove all processes that don't exist anymore.
- self.process_list.retain(|_, v| v.updated);
+ self.process_list
+ .retain(|_, v| std::mem::replace(&mut v.updated, false));
for (kproc, proc_) in procs {
self.add_missing_proc_info(kd, kproc, proc_);
@@ -651,8 +656,8 @@ impl SystemInfo {
)
});
(
- used.saturating_mul(self.page_size as _) / 1_000,
- total.saturating_mul(self.page_size as _) / 1_000,
+ used.saturating_mul(self.page_size as _),
+ total.saturating_mul(self.page_size as _),
)
}
}
@@ -661,14 +666,14 @@ impl SystemInfo {
let mut nb_pages: u64 = 0;
unsafe {
if get_sys_value(&self.virtual_page_count, &mut nb_pages) {
- return nb_pages.saturating_mul(self.page_size as _) / 1_000;
+ return nb_pages.saturating_mul(self.page_size as _);
}
// This is a fallback. It includes all the available memory, not just the one available for
// the users.
let mut total_memory: u64 = 0;
get_sys_value(&self.hw_physical_memory, &mut total_memory);
- total_memory / 1_000
+ total_memory
}
}
@@ -686,10 +691,9 @@ impl SystemInfo {
if let Some(arc_size) = self.zfs.arc_size() {
mem_wire -= arc_size;
}
- let used = mem_active
+ mem_active
.saturating_mul(self.page_size as _)
- .saturating_add(mem_wire);
- used / 1_000
+ .saturating_add(mem_wire)
}
}
@@ -705,11 +709,10 @@ impl SystemInfo {
get_sys_value(&self.virtual_cache_count, &mut cached_mem);
get_sys_value(&self.virtual_free_count, &mut free_mem);
// For whatever reason, buffers_mem is already the right value...
- let free = buffers_mem
- .saturating_add(inactive_mem.saturating_mul(self.page_size as u64))
- .saturating_add(cached_mem.saturating_mul(self.page_size as u64))
- .saturating_add(free_mem.saturating_mul(self.page_size as u64));
- free / 1_000
+ buffers_mem
+ .saturating_add(inactive_mem.saturating_mul(self.page_size as _))
+ .saturating_add(cached_mem.saturating_mul(self.page_size as _))
+ .saturating_add(free_mem.saturating_mul(self.page_size as _))
}
}
@@ -730,8 +733,10 @@ impl SystemInfo {
if i != libc::CP_IDLE as usize {
cp_diff += new_cp_time[i] - old_cp_time[i];
}
- total_new += new_cp_time[i] as u64;
- total_old += old_cp_time[i] as u64;
+ let mut tmp: u64 = new_cp_time[i] as _;
+ total_new += tmp;
+ tmp = old_cp_time[i] as _;
+ total_old += tmp;
}
let total_diff = total_new - total_old;
diff --git a/vendor/sysinfo/src/freebsd/utils.rs b/vendor/sysinfo/src/freebsd/utils.rs
index 00de3e9d9..5745a37f6 100644
--- a/vendor/sysinfo/src/freebsd/utils.rs
+++ b/vendor/sysinfo/src/freebsd/utils.rs
@@ -169,7 +169,7 @@ pub(crate) fn get_sys_value_str_by_name(name: &[u8]) -> Option<String> {
&& size > 0
{
// now create a buffer with the size and get the real value
- let mut buf: Vec<libc::c_char> = vec![0; size as usize];
+ let mut buf: Vec<libc::c_char> = vec![0; size as _];
if libc::sysctlbyname(
name.as_ptr() as *const c_char,
@@ -210,7 +210,7 @@ pub(crate) fn get_system_info(mib: &[c_int], default: Option<&str>) -> Option<St
default.map(|s| s.to_owned())
} else {
// set the buffer to the correct size
- let mut buf: Vec<libc::c_char> = vec![0; size as usize];
+ let mut buf: Vec<libc::c_char> = vec![0; size as _];
if libc::sysctl(
mib.as_ptr(),
@@ -287,7 +287,7 @@ pub(crate) unsafe fn get_frequency_for_cpu(cpu_nb: c_int) -> u64 {
// The information can be missing if it's running inside a VM.
if !get_sys_value_by_name(
- format!("dev.cpu.{}.freq\0", cpu_nb).as_bytes(),
+ format!("dev.cpu.{cpu_nb}.freq\0").as_bytes(),
&mut frequency,
) {
frequency = 0;
diff --git a/vendor/sysinfo/src/lib.rs b/vendor/sysinfo/src/lib.rs
index 977de23a3..0800d2562 100644
--- a/vendor/sysinfo/src/lib.rs
+++ b/vendor/sysinfo/src/lib.rs
@@ -7,6 +7,7 @@
#![allow(clippy::upper_case_acronyms)]
#![allow(clippy::non_send_fields_in_send_ty)]
#![allow(renamed_and_removed_lints)]
+#![allow(clippy::assertions_on_constants)]
#![allow(unknown_lints)]
#[macro_use]
@@ -328,9 +329,10 @@ mod test {
#[test]
fn check_system_info() {
+ let s = System::new();
+
// We don't want to test on unsupported systems.
if System::IS_SUPPORTED {
- let s = System::new();
assert!(!s.name().expect("Failed to get system name").is_empty());
assert!(!s
@@ -345,6 +347,8 @@ mod test {
.expect("Failed to get long OS version")
.is_empty());
}
+
+ assert!(!s.distribution_id().is_empty());
}
#[test]
@@ -429,7 +433,6 @@ mod test {
// Ensure that the CPUs frequency isn't retrieved until we ask for it.
#[test]
- #[cfg(not(target_os = "freebsd"))] // In a VM, it'll fail.
fn check_cpu_frequency() {
if !System::IS_SUPPORTED {
return;
@@ -441,7 +444,48 @@ mod test {
}
s.refresh_cpu();
for proc_ in s.cpus() {
- assert_ne!(proc_.frequency(), 0);
+ assert_eq!(proc_.frequency(), 0);
+ }
+ // In a VM, it'll fail.
+ if std::env::var("APPLE_CI").is_err() && std::env::var("FREEBSD_CI").is_err() {
+ s.refresh_cpu_specifics(CpuRefreshKind::everything());
+ for proc_ in s.cpus() {
+ assert_ne!(proc_.frequency(), 0);
+ }
+ }
+ }
+
+ // In case `Process::updated` is misused, `System::refresh_processes` might remove them
+ // so this test ensures that it doesn't happen.
+ #[test]
+ fn check_refresh_process_update() {
+ if !System::IS_SUPPORTED {
+ return;
}
+ let mut s = System::new_all();
+ let total = s.processes().len() as isize;
+ s.refresh_processes();
+ let new_total = s.processes().len() as isize;
+ // There should be almost no difference in the processes count.
+ assert!(
+ (new_total - total).abs() <= 5,
+ "{} <= 5",
+ (new_total - total).abs()
+ );
+ }
+
+ // We ensure that the `Process` cmd information is retrieved as expected.
+ #[test]
+ fn check_cmd_line() {
+ if !System::IS_SUPPORTED {
+ return;
+ }
+ let mut sys = System::new();
+ sys.refresh_processes_specifics(ProcessRefreshKind::new());
+
+ assert!(sys
+ .processes()
+ .iter()
+ .any(|(_, process)| !process.cmd().is_empty()));
}
}
diff --git a/vendor/sysinfo/src/linux/component.rs b/vendor/sysinfo/src/linux/component.rs
index 3a10588e5..7815103b4 100644
--- a/vendor/sysinfo/src/linux/component.rs
+++ b/vendor/sysinfo/src/linux/component.rs
@@ -1,143 +1,309 @@
// Take a look at the license at the top of the repository in the LICENSE file.
+// Information about values readable from `hwmon` sysfs.
+//
+// Values in /sys/class/hwmonN are `c_long` or `c_ulong`
+// transposed to rust we only read `u32` or `i32` values.
use crate::ComponentExt;
use std::collections::HashMap;
-use std::fs::{metadata, read_dir, File};
+use std::fs::{read_dir, File};
use std::io::Read;
use std::path::{Path, PathBuf};
#[doc = include_str!("../../md_doc/component.md")]
+#[derive(Default)]
pub struct Component {
- temperature: f32,
- max: f32,
- critical: Option<f32>,
+ /// Optional associated device of a `Component`.
+ device_model: Option<String>,
+ /// The chip name.
+ ///
+ /// Kernel documentation extract:
+ /// ```txt
+ /// This should be a short, lowercase string, not containing
+ /// whitespace, dashes, or the wildcard character '*'.
+ /// This attribute represents the chip name. It is the only
+ /// mandatory attribute.
+ /// I2C devices get this attribute created automatically.
+ /// ```
+ name: String,
+ /// Temperature current value
+ /// - Read in: `temp[1-*]_input`.
+ /// - Unit: read as millidegree Celsius converted to Celsius.
+ temperature: Option<f32>,
+ /// Maximum value computed by sysinfo
+ max: Option<f32>,
+ /// Max threshold provided by the chip/kernel
+ /// - Read in:`temp[1-*]_max`
+ /// - Unit: read as millidegree Celsius converted to Celsius.
+ threshold_max: Option<f32>,
+ /// Min threshold provided by the chip/kernel.
+ /// - Read in:`temp[1-*]_min`
+ /// - Unit: read as millidegree Celsius converted to Celsius.
+ threshold_min: Option<f32>,
+ /// Critical threshold provided by the chip/kernel previous user write.
+ /// Read in `temp[1-*]_crit`:
+ /// Typically greater than corresponding temp_max values.
+ /// - Unit: read as millidegree Celsius converted to Celsius.
+ threshold_critical: Option<f32>,
+ /// Sensor type, not common but can exist!
+ ///
+ /// Read in: `temp[1-*]_type` Sensor type selection.
+ /// Values integer:
+ /// - 1: CPU embedded diode
+ /// - 2: 3904 transistor
+ /// - 3: thermal diode
+ /// - 4: thermistor
+ /// - 5: AMD AMDSI
+ /// - 6: Intel PECI
+ /// Not all types are supported by all chips
+ sensor_type: Option<TermalSensorType>,
+ /// Component Label
+ ///
+ /// For formating detail see `Component::label` function docstring.
+ ///
+ /// ## Linux implementation details
+ ///
+ /// read n: `temp[1-*]_label` Suggested temperature channel label.
+ /// Value: Text string
+ ///
+ /// Should only be created if the driver has hints about what
+ /// this temperature channel is being used for, and user-space
+ /// doesn't. In all other cases, the label is provided by user-space.
label: String,
- input_file: PathBuf,
+ // TODO: not used now.
+ // Historical minimum temperature
+ // - Read in:`temp[1-*]_lowest
+ // - Unit: millidegree Celsius
+ //
+ // Temperature critical min value, typically lower than
+ // corresponding temp_min values.
+ // - Read in:`temp[1-*]_lcrit`
+ // - Unit: millidegree Celsius
+ //
+ // Temperature emergency max value, for chips supporting more than
+ // two upper temperature limits. Must be equal or greater than
+ // corresponding temp_crit values.
+ // - temp[1-*]_emergency
+ // - Unit: millidegree Celsius
+ /// File to read current temperature shall be `temp[1-*]_input`
+ /// It may be absent but we don't continue if absent.
+ input_file: Option<PathBuf>,
+ /// `temp[1-*]_highest file` to read if disponnible highest value.
+ highest_file: Option<PathBuf>,
}
+// Read arbitrary data from sysfs.
fn get_file_line(file: &Path, capacity: usize) -> Option<String> {
let mut reader = String::with_capacity(capacity);
- if let Ok(mut f) = File::open(file) {
- if f.read_to_string(&mut reader).is_ok() {
- Some(reader)
- } else {
- None
- }
- } else {
- None
+ let mut f = File::open(file).ok()?;
+ f.read_to_string(&mut reader).ok()?;
+ reader.truncate(reader.trim_end().len());
+ Some(reader)
+}
+
+/// Designed at first for reading an `i32` or `u32` aka `c_long`
+/// from a `/sys/class/hwmon` sysfs file.
+fn read_number_from_file<N>(file: &Path) -> Option<N>
+where
+ N: std::str::FromStr,
+{
+ let mut reader = [0u8; 32];
+ let mut f = File::open(file).ok()?;
+ let n = f.read(&mut reader).ok()?;
+ // parse and trim would complain about `\0`.
+ let number = &reader[..n];
+ let number = std::str::from_utf8(number).ok()?;
+ let number = number.trim();
+ // Assert that we cleaned a little bit that string.
+ if cfg!(feature = "debug") {
+ assert!(!number.contains('\n') && !number.contains('\0'));
}
+ number.parse().ok()
}
-fn is_file<T: AsRef<Path>>(path: T) -> bool {
- metadata(path).ok().map(|m| m.is_file()).unwrap_or(false)
+// Read a temperature from a `tempN_item` sensor form the sysfs.
+// number returned will be in mili-celsius.
+//
+// Don't call it on `label`, `name` or `type` file.
+#[inline]
+fn get_temperature_from_file(file: &Path) -> Option<f32> {
+ let temp = read_number_from_file(file);
+ convert_temp_celsius(temp)
}
-fn append_files(components: &mut Vec<Component>, folder: &Path) {
- let mut matchings: HashMap<u32, Vec<String>> = HashMap::with_capacity(10);
+/// Takes a raw temperature in mili-celsius and convert it to celsius
+#[inline]
+fn convert_temp_celsius(temp: Option<i32>) -> Option<f32> {
+ temp.map(|n| (n as f32) / 1000f32)
+}
- if let Ok(dir) = read_dir(folder) {
- for entry in dir.flatten() {
- let entry = entry.path();
- if entry.is_dir()
- || !entry
- .file_name()
- .and_then(|x| x.to_str())
- .unwrap_or("")
- .starts_with("temp")
- {
- continue;
- }
- if let Some(entry) = entry.file_name() {
- if let Some(entry) = entry.to_str() {
- let mut parts = entry.split('_');
- if let Some(Some(id)) = parts.next().map(|s| s[4..].parse::<u32>().ok()) {
- matchings
- .entry(id)
- .or_insert_with(|| Vec::with_capacity(5))
- .push(
- parts
- .next()
- .map(|s| format!("_{}", s))
- .unwrap_or_else(String::new),
- );
- }
- }
- }
+/// Information about thermal sensor. It may be unavailable as it's
+/// kernel module and chip dependant.
+enum TermalSensorType {
+ /// 1: CPU embedded diode
+ CPUEmbeddedDiode,
+ /// 2: 3904 transistor
+ Transistor3904,
+ /// 3: thermal diode
+ ThermalDiode,
+ /// 4: thermistor
+ Thermistor,
+ /// 5: AMD AMDSI
+ AMDAMDSI,
+ /// 6: Intel PECI
+ IntelPECI,
+ /// Not all types are supported by all chips so we keep space for
+ /// unknown sensors.
+ Unknown(u8),
+}
+
+impl From<u8> for TermalSensorType {
+ fn from(input: u8) -> Self {
+ match input {
+ 0 => Self::CPUEmbeddedDiode,
+ 1 => Self::Transistor3904,
+ 3 => Self::ThermalDiode,
+ 4 => Self::Thermistor,
+ 5 => Self::AMDAMDSI,
+ 6 => Self::IntelPECI,
+ n => Self::Unknown(n),
}
- for (key, val) in &matchings {
- let mut found_input = None;
- let mut found_label = None;
- for (pos, v) in val.iter().enumerate() {
- match v.as_str() {
- // raspberry has empty string for temperature input
- "_input" | "" => {
- found_input = Some(pos);
- }
- "_label" => {
- found_label = Some(pos);
- }
- _ => {}
- }
- }
- if let (Some(_), Some(found_input)) = (found_label, found_input) {
- let mut p_label = folder.to_path_buf();
- let mut p_input = folder.to_path_buf();
- let mut p_crit = folder.to_path_buf();
- let mut p_max = folder.to_path_buf();
-
- p_label.push(&format!("temp{}_label", key));
- p_input.push(&format!("temp{}{}", key, val[found_input]));
- p_max.push(&format!("temp{}_max", key));
- p_crit.push(&format!("temp{}_crit", key));
- if is_file(&p_input) {
- let label = get_file_line(p_label.as_path(), 10)
- .unwrap_or_else(|| format!("Component {}", key)) // needed for raspberry pi
- .replace('\n', "");
- let max = get_file_line(p_max.as_path(), 10).map(|max| {
- max.replace('\n', "").parse::<f32>().unwrap_or(100_000f32) / 1000f32
- });
- let crit = get_file_line(p_crit.as_path(), 10).map(|crit| {
- crit.replace('\n', "").parse::<f32>().unwrap_or(100_000f32) / 1000f32
- });
- components.push(Component::new(label, p_input.as_path(), max, crit));
- }
+ }
+}
+
+/// Check given `item` dispatch to read the right `file` with the right parsing and store data in
+/// given `component`. `id` is provided for `label` creation.
+fn fill_component(component: &mut Component, item: &str, folder: &Path, file: &str) {
+ let hwmon_file = folder.join(file);
+ match item {
+ "type" => {
+ component.sensor_type =
+ read_number_from_file::<u8>(&hwmon_file).map(TermalSensorType::from)
+ }
+ "input" => {
+ let temperature = get_temperature_from_file(&hwmon_file);
+ component.input_file = Some(hwmon_file);
+ component.temperature = temperature;
+ // Maximum know try to get it from `highest` if not available
+ // use current temperature
+ if component.max.is_none() {
+ component.max = temperature;
}
}
+ "label" => component.label = get_file_line(&hwmon_file, 10).unwrap_or_default(),
+ "highest" => {
+ component.max = get_temperature_from_file(&hwmon_file).or(component.temperature);
+ component.highest_file = Some(hwmon_file);
+ }
+ "max" => component.threshold_max = get_temperature_from_file(&hwmon_file),
+ "min" => component.threshold_min = get_temperature_from_file(&hwmon_file),
+ "crit" => component.threshold_critical = get_temperature_from_file(&hwmon_file),
+ _ => {
+ sysinfo_debug!(
+ "This hwmon-temp file is still not supported! Contributions are appreciated.;) {:?}",
+ hwmon_file,
+ );
+ }
}
}
impl Component {
- /// Creates a new component with the given information.
- pub(crate) fn new(
- label: String,
- input_path: &Path,
- max: Option<f32>,
- critical: Option<f32>,
- ) -> Component {
- let mut c = Component {
- temperature: 0f32,
+ /// Read out `hwmon` info (hardware monitor) from `folder`
+ /// to get values' path to be used on refresh as well as files containing `max`,
+ /// `critical value` and `label`. Then we store everything into `components`.
+ ///
+ /// Note that a thermal [Component] must have a way to read its temperature.
+ /// If not, it will be ignored and not added into `components`.
+ ///
+ /// ## What is read:
+ ///
+ /// - Mandatory: `name` the name of the `hwmon`.
+ /// - Mandatory: `tempN_input` Drop [Component] if missing
+ /// - Optional: sensor `label`, in the general case content of `tempN_label`
+ /// see below for special cases
+ /// - Optional: `label`
+ /// - Optional: `/device/model`
+ /// - Optional: hightest historic value in `tempN_hightest`.
+ /// - Optional: max threshold value defined in `tempN_max`
+ /// - Optional: critical threshold value defined in `tempN_crit`
+ ///
+ /// Where `N` is a u32 associated to a sensor like `temp1_max`, `temp1_input`.
+ ///
+ /// ## Doc to Linux kernel API.
+ ///
+ /// Kernel hwmon API: https://www.kernel.org/doc/html/latest/hwmon/hwmon-kernel-api.html
+ /// DriveTemp kernel API: https://docs.kernel.org/gpu/amdgpu/thermal.html#hwmon-interfaces
+ /// Amdgpu hwmon interface: https://www.kernel.org/doc/html/latest/hwmon/drivetemp.html
+ fn from_hwmon(components: &mut Vec<Component>, folder: &Path) -> Option<()> {
+ let dir = read_dir(folder).ok()?;
+ let mut matchings: HashMap<u32, Component> = HashMap::with_capacity(10);
+ for entry in dir.flatten() {
+ let entry = entry.path();
+ let filename = entry.file_name().and_then(|x| x.to_str()).unwrap_or("");
+ if entry.is_dir() || !filename.starts_with("temp") {
+ continue;
+ }
+
+ let (id, item) = filename.split_once('_')?;
+ let id = id.get(4..)?.parse::<u32>().ok()?;
+
+ let component = matchings.entry(id).or_insert_with(Component::default);
+ let name = get_file_line(&folder.join("name"), 16);
+ component.name = name.unwrap_or_default();
+ let device_model = get_file_line(&folder.join("device/model"), 16);
+ component.device_model = device_model;
+ fill_component(component, item, folder, filename);
+ }
+ let compo = matchings
+ .into_iter()
+ .map(|(id, mut c)| {
+ // sysinfo expose a generic interface with a `label`.
+ // Problem: a lot of sensors don't have a label or a device model! ¯\_(ツ)_/¯
+ // So let's pretend we have a unique label!
+ // See the table in `Component::label` documentation for the table detail.
+ c.label = c.format_label("temp", id);
+ c
+ })
+ // Remove components without `tempN_input` file termal. `Component` doesn't support this kind of sensors yet
+ .filter(|c| c.input_file.is_some());
+
+ components.extend(compo);
+ Some(())
+ }
+
+ /// Compute a label out of available information.
+ /// See the table in `Component::label`'s documentation.
+ fn format_label(&self, class: &str, id: u32) -> String {
+ let Component {
+ device_model,
+ name,
label,
- input_file: input_path.to_path_buf(),
- max: max.unwrap_or(0.0),
- critical,
- };
- c.refresh();
- c
+ ..
+ } = self;
+ let has_label = !label.is_empty();
+ match (has_label, device_model) {
+ (true, Some(device_model)) => {
+ format!("{name} {label} {device_model} {class}{id}")
+ }
+ (true, None) => format!("{name} {label}"),
+ (false, Some(device_model)) => format!("{name} {device_model}"),
+ (false, None) => format!("{name} {class}{id}"),
+ }
}
}
impl ComponentExt for Component {
fn temperature(&self) -> f32 {
- self.temperature
+ self.temperature.unwrap_or(f32::NAN)
}
fn max(&self) -> f32 {
- self.max
+ self.max.unwrap_or(f32::NAN)
}
fn critical(&self) -> Option<f32> {
- self.critical
+ self.threshold_critical
}
fn label(&self) -> &str {
@@ -145,22 +311,28 @@ impl ComponentExt for Component {
}
fn refresh(&mut self) {
- if let Some(content) = get_file_line(self.input_file.as_path(), 10) {
- self.temperature = content
- .replace('\n', "")
- .parse::<f32>()
- .unwrap_or(100_000f32)
- / 1000f32;
- if self.temperature > self.max {
- self.max = self.temperature;
- }
- }
+ let current = self
+ .input_file
+ .as_ref()
+ .and_then(|file| get_temperature_from_file(file.as_path()));
+ // tries to read out kernel highest if not compute something from temperature.
+ let max = self
+ .highest_file
+ .as_ref()
+ .and_then(|file| get_temperature_from_file(file.as_path()))
+ .or_else(|| {
+ let last = self.temperature?;
+ let current = current?;
+ Some(last.max(current))
+ });
+ self.max = max;
+ self.temperature = current;
}
}
pub(crate) fn get_components() -> Vec<Component> {
let mut components = Vec::with_capacity(10);
- if let Ok(dir) = read_dir(&Path::new("/sys/class/hwmon/")) {
+ if let Ok(dir) = read_dir(Path::new("/sys/class/hwmon/")) {
for entry in dir.flatten() {
let entry = entry.path();
if !entry.is_dir()
@@ -172,18 +344,9 @@ pub(crate) fn get_components() -> Vec<Component> {
{
continue;
}
- append_files(&mut components, &entry);
+ Component::from_hwmon(&mut components, &entry);
}
components.sort_by(|c1, c2| c1.label.to_lowercase().cmp(&c2.label.to_lowercase()));
}
- if is_file("/sys/class/thermal/thermal_zone0/temp") {
- // Specfic to raspberry pi.
- components.push(Component::new(
- "CPU".to_owned(),
- Path::new("/sys/class/thermal/thermal_zone0/temp"),
- None,
- None,
- ));
- }
components
}
diff --git a/vendor/sysinfo/src/linux/cpu.rs b/vendor/sysinfo/src/linux/cpu.rs
index f3970c318..103f5362a 100644
--- a/vendor/sysinfo/src/linux/cpu.rs
+++ b/vendor/sysinfo/src/linux/cpu.rs
@@ -4,9 +4,209 @@
use std::collections::HashSet;
use std::fs::File;
-use std::io::Read;
+use std::io::{BufRead, BufReader, Read};
-use crate::CpuExt;
+use crate::sys::utils::to_u64;
+use crate::{CpuExt, CpuRefreshKind};
+
+macro_rules! to_str {
+ ($e:expr) => {
+ unsafe { std::str::from_utf8_unchecked($e) }
+ };
+}
+
+pub(crate) struct CpusWrapper {
+ pub(crate) global_cpu: Cpu,
+ pub(crate) cpus: Vec<Cpu>,
+ /// Field set to `false` in `update_cpus` and to `true` in `refresh_processes_specifics`.
+ ///
+ /// The reason behind this is to avoid calling the `update_cpus` more than necessary.
+ /// For example when running `refresh_all` or `refresh_specifics`.
+ need_cpus_update: bool,
+ got_cpu_frequency: bool,
+}
+
+impl CpusWrapper {
+ pub(crate) fn new() -> Self {
+ Self {
+ global_cpu: Cpu::new_with_values(
+ "",
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ String::new(),
+ String::new(),
+ ),
+ cpus: Vec::with_capacity(4),
+ need_cpus_update: true,
+ got_cpu_frequency: false,
+ }
+ }
+
+ pub(crate) fn refresh_if_needed(
+ &mut self,
+ only_update_global_cpu: bool,
+ refresh_kind: CpuRefreshKind,
+ ) {
+ if self.need_cpus_update {
+ self.refresh(only_update_global_cpu, refresh_kind);
+ }
+ }
+
+ pub(crate) fn refresh(&mut self, only_update_global_cpu: bool, refresh_kind: CpuRefreshKind) {
+ let f = match File::open("/proc/stat") {
+ Ok(f) => f,
+ Err(_e) => {
+ sysinfo_debug!("failed to retrieve CPU information: {:?}", _e);
+ return;
+ }
+ };
+ let buf = BufReader::new(f);
+
+ self.need_cpus_update = false;
+ let mut i: usize = 0;
+ let first = self.cpus.is_empty();
+ let mut it = buf.split(b'\n');
+ let (vendor_id, brand) = if first {
+ get_vendor_id_and_brand()
+ } else {
+ (String::new(), String::new())
+ };
+
+ if first || refresh_kind.cpu_usage() {
+ if let Some(Ok(line)) = it.next() {
+ if &line[..4] != b"cpu " {
+ return;
+ }
+ let mut parts = line.split(|x| *x == b' ').filter(|s| !s.is_empty());
+ if first {
+ self.global_cpu.name = to_str!(parts.next().unwrap_or(&[])).to_owned();
+ } else {
+ parts.next();
+ }
+ self.global_cpu.set(
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ );
+ }
+ if first || !only_update_global_cpu {
+ while let Some(Ok(line)) = it.next() {
+ if &line[..3] != b"cpu" {
+ break;
+ }
+
+ let mut parts = line.split(|x| *x == b' ').filter(|s| !s.is_empty());
+ if first {
+ self.cpus.push(Cpu::new_with_values(
+ to_str!(parts.next().unwrap_or(&[])),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ 0,
+ vendor_id.clone(),
+ brand.clone(),
+ ));
+ } else {
+ parts.next(); // we don't want the name again
+ self.cpus[i].set(
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ parts.next().map(to_u64).unwrap_or(0),
+ );
+ }
+
+ i += 1;
+ }
+ }
+ }
+
+ if refresh_kind.frequency() {
+ #[cfg(feature = "multithread")]
+ use rayon::iter::{
+ IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator,
+ };
+
+ #[cfg(feature = "multithread")]
+ // This function is voluntarily made generic in case we want to generalize it.
+ fn iter_mut<'a, T>(
+ val: &'a mut T,
+ ) -> <&'a mut T as rayon::iter::IntoParallelIterator>::Iter
+ where
+ &'a mut T: rayon::iter::IntoParallelIterator,
+ {
+ val.par_iter_mut()
+ }
+
+ #[cfg(not(feature = "multithread"))]
+ fn iter_mut<'a>(val: &'a mut Vec<Cpu>) -> std::slice::IterMut<'a, Cpu> {
+ val.iter_mut()
+ }
+
+ // `get_cpu_frequency` is very slow, so better run it in parallel.
+ self.global_cpu.frequency = iter_mut(&mut self.cpus)
+ .enumerate()
+ .map(|(pos, proc_)| {
+ proc_.frequency = get_cpu_frequency(pos);
+ proc_.frequency
+ })
+ .max()
+ .unwrap_or(0);
+
+ self.got_cpu_frequency = true;
+ }
+
+ if first {
+ self.global_cpu.vendor_id = vendor_id;
+ self.global_cpu.brand = brand;
+ }
+ }
+
+ pub(crate) fn get_global_raw_times(&self) -> (u64, u64) {
+ (self.global_cpu.total_time, self.global_cpu.old_total_time)
+ }
+
+ pub(crate) fn len(&self) -> usize {
+ self.cpus.len()
+ }
+
+ pub(crate) fn is_empty(&self) -> bool {
+ self.cpus.is_empty()
+ }
+
+ pub(crate) fn set_need_cpus_update(&mut self) {
+ self.need_cpus_update = true;
+ }
+}
/// Struct containing values to compute a CPU usage.
#[derive(Clone, Copy)]
@@ -224,10 +424,6 @@ impl CpuExt for Cpu {
}
}
-pub(crate) fn get_raw_times(p: &Cpu) -> (u64, u64) {
- (p.total_time, p.old_total_time)
-}
-
pub(crate) fn get_cpu_frequency(cpu_core_index: usize) -> u64 {
let mut s = String::new();
if File::open(format!(
diff --git a/vendor/sysinfo/src/linux/disk.rs b/vendor/sysinfo/src/linux/disk.rs
index 5a313fd27..6d7fc083c 100644
--- a/vendor/sysinfo/src/linux/disk.rs
+++ b/vendor/sysinfo/src/linux/disk.rs
@@ -1,7 +1,7 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use crate::sys::utils::get_all_data;
-use crate::{utils, DiskExt, DiskType};
+use crate::sys::utils::{get_all_data, to_cpath};
+use crate::{DiskExt, DiskType};
use libc::statvfs;
use std::ffi::{OsStr, OsString};
@@ -60,7 +60,7 @@ impl DiskExt for Disk {
fn refresh(&mut self) -> bool {
unsafe {
let mut stat: statvfs = mem::zeroed();
- let mount_point_cpath = utils::to_cpath(&self.mount_point);
+ let mount_point_cpath = to_cpath(&self.mount_point);
if statvfs(mount_point_cpath.as_ptr() as *const _, &mut stat) == 0 {
let tmp = cast!(stat.f_bsize).saturating_mul(cast!(stat.f_bavail));
self.available_space = cast!(tmp);
@@ -78,7 +78,7 @@ fn new_disk(
file_system: &[u8],
removable_entries: &[PathBuf],
) -> Option<Disk> {
- let mount_point_cpath = utils::to_cpath(mount_point);
+ let mount_point_cpath = to_cpath(mount_point);
let type_ = find_type_for_device_name(device_name);
let mut total = 0;
let mut available = 0;
@@ -136,9 +136,10 @@ fn find_type_for_device_name(device_name: &OsStr) -> DiskType {
real_path = real_path.trim_end_matches(|c| c >= '0' && c <= '9');
} else if device_name_path.starts_with("/dev/nvme") {
// Turn "nvme0n1p1" into "nvme0n1"
- real_path = real_path.trim_start_matches("/dev/");
- real_path = real_path.trim_end_matches(|c| c >= '0' && c <= '9');
- real_path = real_path.trim_end_matches(|c| c == 'p');
+ real_path = match real_path.find('p') {
+ Some(idx) => &real_path["/dev/".len()..idx],
+ None => &real_path["/dev/".len()..],
+ };
} else if device_name_path.starts_with("/dev/root") {
// Recursively solve, for example /dev/mmcblk0p1
if real_path != device_name_path {
@@ -146,9 +147,10 @@ fn find_type_for_device_name(device_name: &OsStr) -> DiskType {
}
} else if device_name_path.starts_with("/dev/mmcblk") {
// Turn "mmcblk0p1" into "mmcblk0"
- real_path = real_path.trim_start_matches("/dev/");
- real_path = real_path.trim_end_matches(|c| c >= '0' && c <= '9');
- real_path = real_path.trim_end_matches(|c| c == 'p');
+ real_path = match real_path.find('p') {
+ Some(idx) => &real_path["/dev/".len()..idx],
+ None => &real_path["/dev/".len()..],
+ };
} else {
// Default case: remove /dev/ and expects the name presents under /sys/block/
// For example, /dev/dm-0 to dm-0
diff --git a/vendor/sysinfo/src/linux/network.rs b/vendor/sysinfo/src/linux/network.rs
index 0153c151a..c8da2bcb3 100644
--- a/vendor/sysinfo/src/linux/network.rs
+++ b/vendor/sysinfo/src/linux/network.rs
@@ -297,7 +297,7 @@ mod test {
let itf1_dir = sys_net_dir.path().join("itf1");
let itf2_dir = sys_net_dir.path().join("itf2");
fs::create_dir(&itf1_dir).expect("failed to create subdirectory");
- fs::create_dir(&itf2_dir).expect("failed to create subdirectory");
+ fs::create_dir(itf2_dir).expect("failed to create subdirectory");
let mut interfaces = HashMap::new();
diff --git a/vendor/sysinfo/src/linux/process.rs b/vendor/sysinfo/src/linux/process.rs
index 0b06e26f1..d7d61b5bc 100644
--- a/vendor/sysinfo/src/linux/process.rs
+++ b/vendor/sysinfo/src/linux/process.rs
@@ -11,8 +11,10 @@ use std::str::FromStr;
use libc::{gid_t, kill, uid_t};
-use crate::sys::system::{SystemInfo, REMAINING_FILES};
-use crate::sys::utils::{get_all_data, get_all_data_from_file, realpath};
+use crate::sys::system::SystemInfo;
+use crate::sys::utils::{
+ get_all_data, get_all_data_from_file, realpath, FileCounter, PathHandler, PathPush,
+};
use crate::utils::into_iter;
use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessRefreshKind, ProcessStatus, Signal, Uid};
@@ -93,7 +95,7 @@ pub struct Process {
pub(crate) status: ProcessStatus,
/// Tasks run by this process.
pub tasks: HashMap<Pid, Process>,
- pub(crate) stat_file: Option<File>,
+ pub(crate) stat_file: Option<FileCounter>,
old_read_bytes: u64,
old_written_bytes: u64,
read_bytes: u64,
@@ -101,16 +103,11 @@ pub struct Process {
}
impl Process {
- pub(crate) fn new(
- pid: Pid,
- parent: Option<Pid>,
- start_time_without_boot_time: u64,
- info: &SystemInfo,
- ) -> Process {
+ pub(crate) fn new(pid: Pid) -> Process {
Process {
name: String::with_capacity(20),
pid,
- parent,
+ parent: None,
cmd: Vec::with_capacity(2),
environ: Vec::with_capacity(10),
exe: PathBuf::new(),
@@ -124,8 +121,8 @@ impl Process {
old_utime: 0,
old_stime: 0,
updated: true,
- start_time_without_boot_time,
- start_time: start_time_without_boot_time.saturating_add(info.boot_time),
+ start_time_without_boot_time: 0,
+ start_time: 0,
run_time: 0,
user_id: None,
group_id: None,
@@ -222,14 +219,16 @@ impl ProcessExt for Process {
fn group_id(&self) -> Option<Gid> {
self.group_id
}
-}
-impl Drop for Process {
- fn drop(&mut self) {
- if self.stat_file.is_some() {
- unsafe {
- if let Ok(ref mut x) = crate::sys::system::REMAINING_FILES.lock() {
- **x += 1;
+ fn wait(&self) {
+ let mut status = 0;
+ // attempt waiting
+ unsafe {
+ if libc::waitpid(self.pid.0, &mut status, 0) < 0 {
+ // attempt failed (non-child process) so loop until process ends
+ let duration = std::time::Duration::from_millis(10);
+ while kill(self.pid.0, 0) == 0 {
+ std::thread::sleep(duration);
}
}
}
@@ -260,9 +259,7 @@ pub(crate) fn set_time(p: &mut Process, utime: u64, stime: u64) {
}
pub(crate) fn update_process_disk_activity(p: &mut Process, path: &Path) {
- let mut path = PathBuf::from(path);
- path.push("io");
- let data = match get_all_data(&path, 16_384) {
+ let data = match get_all_data(path.join("io"), 16_384) {
Ok(d) => d,
Err(_) => return,
};
@@ -306,75 +303,50 @@ impl<'a, T> Wrap<'a, T> {
unsafe impl<'a, T> Send for Wrap<'a, T> {}
unsafe impl<'a, T> Sync for Wrap<'a, T> {}
-pub(crate) fn _get_process_data(
- path: &Path,
- proc_list: &mut Process,
- pid: Pid,
- uptime: u64,
- info: &SystemInfo,
- refresh_kind: ProcessRefreshKind,
-) -> Result<(Option<Process>, Pid), ()> {
- let pid = match path.file_name().and_then(|x| x.to_str()).map(Pid::from_str) {
- Some(Ok(nb)) if nb != pid => nb,
- _ => return Err(()),
- };
+#[inline(always)]
+fn compute_start_time_without_boot_time(parts: &[&str], info: &SystemInfo) -> u64 {
+ // To be noted that the start time is invalid here, it still needs to be converted into
+ // "real" time.
+ u64::from_str(parts[21]).unwrap_or(0) / info.clock_cycle
+}
- let get_status = |p: &mut Process, part: &str| {
- p.status = part
- .chars()
- .next()
- .map(ProcessStatus::from)
- .unwrap_or_else(|| ProcessStatus::Unknown(0));
- };
- let parent_memory = proc_list.memory;
- let parent_virtual_memory = proc_list.virtual_memory;
- if let Some(ref mut entry) = proc_list.tasks.get_mut(&pid) {
- let data = if let Some(ref mut f) = entry.stat_file {
- get_all_data_from_file(f, 1024).map_err(|_| ())?
- } else {
- let mut tmp = PathBuf::from(path);
- tmp.push("stat");
- let mut file = File::open(tmp).map_err(|_| ())?;
- let data = get_all_data_from_file(&mut file, 1024).map_err(|_| ())?;
- entry.stat_file = check_nb_open_files(file);
- data
- };
- let parts = parse_stat_file(&data)?;
- get_status(entry, parts[2]);
- update_time_and_memory(
- path,
- entry,
- &parts,
- parent_memory,
- parent_virtual_memory,
- uptime,
- info,
- refresh_kind,
- );
- if refresh_kind.disk_usage() {
- update_process_disk_activity(entry, path);
- }
- if refresh_kind.user() && entry.user_id.is_none() {
- let mut tmp = PathBuf::from(path);
- tmp.push("status");
- if let Some((user_id, group_id)) = get_uid_and_gid(&tmp) {
- entry.user_id = Some(Uid(user_id));
- entry.group_id = Some(Gid(group_id));
- }
- }
- return Ok((None, pid));
- }
+fn _get_stat_data(path: &Path, stat_file: &mut Option<FileCounter>) -> Result<String, ()> {
+ let mut file = File::open(path.join("stat")).map_err(|_| ())?;
+ let data = get_all_data_from_file(&mut file, 1024).map_err(|_| ())?;
+ *stat_file = FileCounter::new(file);
+ Ok(data)
+}
- let mut tmp = PathBuf::from(path);
+#[inline(always)]
+fn get_status(p: &mut Process, part: &str) {
+ p.status = part
+ .chars()
+ .next()
+ .map(ProcessStatus::from)
+ .unwrap_or_else(|| ProcessStatus::Unknown(0));
+}
- tmp.push("stat");
- let mut file = std::fs::File::open(&tmp).map_err(|_| ())?;
- let data = get_all_data_from_file(&mut file, 1024).map_err(|_| ())?;
- let stat_file = check_nb_open_files(file);
- let parts = parse_stat_file(&data)?;
+fn refresh_user_group_ids<P: PathPush>(p: &mut Process, path: &mut P) {
+ if let Some((user_id, group_id)) = get_uid_and_gid(path.join("status")) {
+ p.user_id = Some(Uid(user_id));
+ p.group_id = Some(Gid(group_id));
+ }
+}
+
+fn retrieve_all_new_process_info(
+ pid: Pid,
+ proc_list: &Process,
+ parts: &[&str],
+ path: &Path,
+ info: &SystemInfo,
+ refresh_kind: ProcessRefreshKind,
+ uptime: u64,
+) -> Process {
+ let mut p = Process::new(pid);
+ let mut tmp = PathHandler::new(path);
let name = parts[1];
- let parent_pid = if proc_list.pid.0 != 0 {
+ p.parent = if proc_list.pid.0 != 0 {
Some(proc_list.pid)
} else {
match Pid::from_str(parts[3]) {
@@ -383,20 +355,15 @@ pub(crate) fn _get_process_data(
}
};
- // To be noted that the start time is invalid here, it still needs
- let start_time = u64::from_str(parts[21]).unwrap_or(0) / info.clock_cycle;
- let mut p = Process::new(pid, parent_pid, start_time, info);
+ p.start_time_without_boot_time = compute_start_time_without_boot_time(parts, info);
+ p.start_time = p
+ .start_time_without_boot_time
+ .saturating_add(info.boot_time);
- p.stat_file = stat_file;
get_status(&mut p, parts[2]);
if refresh_kind.user() {
- tmp.pop();
- tmp.push("status");
- if let Some((user_id, group_id)) = get_uid_and_gid(&tmp) {
- p.user_id = Some(Uid(user_id));
- p.group_id = Some(Gid(group_id));
- }
+ refresh_user_group_ids(&mut p, &mut tmp);
}
if proc_list.pid.0 != 0 {
@@ -410,38 +377,28 @@ pub(crate) fn _get_process_data(
p.root = proc_list.root.clone();
} else {
p.name = name.into();
- tmp.pop();
- tmp.push("cmdline");
- p.cmd = copy_from_file(&tmp);
- tmp.pop();
- tmp.push("exe");
- match tmp.read_link() {
+
+ match tmp.join("exe").read_link() {
Ok(exe_path) => {
p.exe = exe_path;
}
Err(_) => {
- p.exe = if let Some(cmd) = p.cmd.get(0) {
- PathBuf::from(cmd)
- } else {
- PathBuf::new()
- };
+ // Do not use cmd[0] because it is not the same thing.
+ // See https://github.com/GuillaumeGomez/sysinfo/issues/697.
+ p.exe = PathBuf::new()
}
}
- tmp.pop();
- tmp.push("environ");
- p.environ = copy_from_file(&tmp);
- tmp.pop();
- tmp.push("cwd");
- p.cwd = realpath(&tmp);
- tmp.pop();
- tmp.push("root");
- p.root = realpath(&tmp);
+
+ p.cmd = copy_from_file(tmp.join("cmdline"));
+ p.environ = copy_from_file(tmp.join("environ"));
+ p.cwd = realpath(tmp.join("cwd"));
+ p.root = realpath(tmp.join("root"));
}
update_time_and_memory(
path,
&mut p,
- &parts,
+ parts,
proc_list.memory,
proc_list.virtual_memory,
uptime,
@@ -451,7 +408,91 @@ pub(crate) fn _get_process_data(
if refresh_kind.disk_usage() {
update_process_disk_activity(&mut p, path);
}
- Ok((Some(p), pid))
+ p
+}
+
+pub(crate) fn _get_process_data(
+ path: &Path,
+ proc_list: &mut Process,
+ pid: Pid,
+ uptime: u64,
+ info: &SystemInfo,
+ refresh_kind: ProcessRefreshKind,
+) -> Result<(Option<Process>, Pid), ()> {
+ let pid = match path.file_name().and_then(|x| x.to_str()).map(Pid::from_str) {
+ Some(Ok(nb)) if nb != pid => nb,
+ _ => return Err(()),
+ };
+
+ let parent_memory = proc_list.memory;
+ let parent_virtual_memory = proc_list.virtual_memory;
+
+ let data;
+ let parts = if let Some(ref mut entry) = proc_list.tasks.get_mut(&pid) {
+ data = if let Some(mut f) = entry.stat_file.take() {
+ match get_all_data_from_file(&mut f, 1024) {
+ Ok(data) => {
+ // Everything went fine, we put back the file descriptor.
+ entry.stat_file = Some(f);
+ data
+ }
+ Err(_) => {
+ // It's possible that the file descriptor is no longer valid in case the
+ // original process was terminated and another one took its place.
+ _get_stat_data(path, &mut entry.stat_file)?
+ }
+ }
+ } else {
+ _get_stat_data(path, &mut entry.stat_file)?
+ };
+ let parts = parse_stat_file(&data).ok_or(())?;
+ let start_time_without_boot_time = compute_start_time_without_boot_time(&parts, info);
+
+ // It's possible that a new process took this same PID when the "original one" terminated.
+ // If the start time differs, then it means it's not the same process anymore and that we
+ // need to get all its information, hence why we check it here.
+ if start_time_without_boot_time == entry.start_time_without_boot_time {
+ get_status(entry, parts[2]);
+ update_time_and_memory(
+ path,
+ entry,
+ &parts,
+ parent_memory,
+ parent_virtual_memory,
+ uptime,
+ info,
+ refresh_kind,
+ );
+ if refresh_kind.disk_usage() {
+ update_process_disk_activity(entry, path);
+ }
+ if refresh_kind.user() && entry.user_id.is_none() {
+ refresh_user_group_ids(entry, &mut PathBuf::from(path));
+ }
+ return Ok((None, pid));
+ }
+ parts
+ } else {
+ let mut stat_file = None;
+ let data = _get_stat_data(path, &mut stat_file)?;
+ let parts = parse_stat_file(&data).ok_or(())?;
+
+ let mut p =
+ retrieve_all_new_process_info(pid, proc_list, &parts, path, info, refresh_kind, uptime);
+ p.stat_file = stat_file;
+ return Ok((Some(p), pid));
+ };
+
+ // If we're here, it means that the PID still exists but it's a different process.
+ let p = retrieve_all_new_process_info(pid, proc_list, &parts, path, info, refresh_kind, uptime);
+ match proc_list.tasks.get_mut(&pid) {
+ Some(ref mut entry) => **entry = p,
+ // If it ever enters this case, it means that the process was removed from the HashMap
+ // in-between with the usage of dark magic.
+ None => unreachable!(),
+ }
+ // Since this PID is already in the HashMap, no need to add it again.
+ Ok((None, pid))
}
#[allow(clippy::too_many_arguments)]
@@ -473,9 +514,9 @@ fn update_time_and_memory(
if entry.memory >= parent_memory {
entry.memory -= parent_memory;
}
- // vsz correspond to the Virtual memory size in bytes. Divising by 1_000 gives us kb.
+ // vsz correspond to the Virtual memory size in bytes.
// see: https://man7.org/linux/man-pages/man5/proc.5.html
- entry.virtual_memory = u64::from_str(parts[22]).unwrap_or(0) / 1_000;
+ entry.virtual_memory = u64::from_str(parts[22]).unwrap_or(0);
if entry.virtual_memory >= parent_virtual_memory {
entry.virtual_memory -= parent_virtual_memory;
}
@@ -504,73 +545,65 @@ pub(crate) fn refresh_procs(
info: &SystemInfo,
refresh_kind: ProcessRefreshKind,
) -> bool {
- if let Ok(d) = fs::read_dir(path) {
- let folders = d
- .filter_map(|entry| {
- if let Ok(entry) = entry {
- let entry = entry.path();
-
- if entry.is_dir() {
- Some(entry)
- } else {
- None
- }
- } else {
- None
- }
+ let d = match fs::read_dir(path) {
+ Ok(d) => d,
+ Err(_) => return false,
+ };
+ let folders = d
+ .filter_map(|entry| {
+ let entry = entry.ok()?;
+ let entry = entry.path();
+
+ if entry.is_dir() {
+ Some(entry)
+ } else {
+ None
+ }
+ })
+ .collect::<Vec<_>>();
+ if pid.0 == 0 {
+ let proc_list = Wrap(UnsafeCell::new(proc_list));
+
+ #[cfg(feature = "multithread")]
+ use rayon::iter::ParallelIterator;
+
+ into_iter(folders)
+ .filter_map(|e| {
+ let (p, _) = _get_process_data(
+ e.as_path(),
+ proc_list.get(),
+ pid,
+ uptime,
+ info,
+ refresh_kind,
+ )
+ .ok()?;
+ p
})
- .collect::<Vec<_>>();
- if pid.0 == 0 {
- let proc_list = Wrap(UnsafeCell::new(proc_list));
-
- #[cfg(feature = "multithread")]
- use rayon::iter::ParallelIterator;
-
- into_iter(folders)
- .filter_map(|e| {
- if let Ok((p, _)) = _get_process_data(
- e.as_path(),
- proc_list.get(),
- pid,
- uptime,
- info,
- refresh_kind,
- ) {
- p
- } else {
- None
- }
- })
- .collect::<Vec<_>>()
- } else {
- let mut updated_pids = Vec::with_capacity(folders.len());
- let new_tasks = folders
- .iter()
- .filter_map(|e| {
- if let Ok((p, pid)) =
- _get_process_data(e.as_path(), proc_list, pid, uptime, info, refresh_kind)
- {
- updated_pids.push(pid);
- p
- } else {
- None
- }
- })
- .collect::<Vec<_>>();
- // Sub-tasks are not cleaned up outside so we do it here directly.
- proc_list
- .tasks
- .retain(|&pid, _| updated_pids.iter().any(|&x| x == pid));
- new_tasks
- }
- .into_iter()
- .for_each(|e| {
- proc_list.tasks.insert(e.pid(), e);
- });
- true
+ .collect::<Vec<_>>()
} else {
- false
- }
+ let mut updated_pids = Vec::with_capacity(folders.len());
+ let new_tasks = folders
+ .iter()
+ .filter_map(|e| {
+ let (p, pid) =
+ _get_process_data(e.as_path(), proc_list, pid, uptime, info, refresh_kind)
+ .ok()?;
+ updated_pids.push(pid);
+ p
+ })
+ .collect::<Vec<_>>();
+ // Sub-tasks are not cleaned up outside so we do it here directly.
+ proc_list
+ .tasks
+ .retain(|&pid, _| updated_pids.iter().any(|&x| x == pid));
+ new_tasks
+ }
+ .into_iter()
+ .for_each(|e| {
+ proc_list.tasks.insert(e.pid(), e);
+ });
+ true
}
fn copy_from_file(entry: &Path) -> Vec<String> {
@@ -618,7 +651,7 @@ fn get_uid_and_gid(file_path: &Path) -> Option<(uid_t, gid_t)> {
}
}
- let status_data = get_all_data(&file_path, 16_385).ok()?;
+ let status_data = get_all_data(file_path, 16_385).ok()?;
// We're only interested in the lines starting with Uid: and Gid:
// here. From these lines, we're looking at the second entry to get
@@ -653,29 +686,7 @@ fn get_uid_and_gid(file_path: &Path) -> Option<(uid_t, gid_t)> {
}
}
-fn check_nb_open_files(f: File) -> Option<File> {
- unsafe {
- if let Ok(ref mut x) = REMAINING_FILES.lock() {
- if **x > 0 {
- **x -= 1;
- return Some(f);
- }
- }
- }
- // Something bad happened...
- None
-}
-
-macro_rules! unwrap_or_return {
- ($data:expr) => {{
- match $data {
- Some(x) => x,
- None => return Err(()),
- }
- }};
-}
-
-fn parse_stat_file(data: &str) -> Result<Vec<&str>, ()> {
+fn parse_stat_file(data: &str) -> Option<Vec<&str>> {
// The stat file is "interesting" to parse, because spaces cannot
// be used as delimiters. The second field stores the command name
// surrounded by parentheses. Unfortunately, whitespace and
@@ -687,14 +698,14 @@ fn parse_stat_file(data: &str) -> Result<Vec<&str>, ()> {
let mut parts = Vec::with_capacity(52);
let mut data_it = data.splitn(2, ' ');
- parts.push(unwrap_or_return!(data_it.next()));
- let mut data_it = unwrap_or_return!(data_it.next()).rsplitn(2, ')');
- let data = unwrap_or_return!(data_it.next());
- parts.push(unwrap_or_return!(data_it.next()));
+ parts.push(data_it.next()?);
+ let mut data_it = data_it.next()?.rsplitn(2, ')');
+ let data = data_it.next()?;
+ parts.push(data_it.next()?);
parts.extend(data.split_whitespace());
// Remove command name '('
if let Some(name) = parts[1].strip_prefix('(') {
parts[1] = name;
}
- Ok(parts)
+ Some(parts)
}
diff --git a/vendor/sysinfo/src/linux/system.rs b/vendor/sysinfo/src/linux/system.rs
index 7a8d0a010..3c4fce345 100644
--- a/vendor/sysinfo/src/linux/system.rs
+++ b/vendor/sysinfo/src/linux/system.rs
@@ -4,7 +4,7 @@ use crate::sys::component::{self, Component};
use crate::sys::cpu::*;
use crate::sys::disk;
use crate::sys::process::*;
-use crate::sys::utils::get_all_data;
+use crate::sys::utils::{get_all_data, to_u64};
use crate::{
CpuRefreshKind, Disk, LoadAvg, Networks, Pid, ProcessRefreshKind, RefreshKind, SystemExt, User,
};
@@ -63,12 +63,6 @@ pub(crate) fn get_max_nb_fds() -> isize {
}
}
-macro_rules! to_str {
- ($e:expr) => {
- unsafe { std::str::from_utf8_unchecked($e) }
- };
-}
-
fn boot_time() -> u64 {
if let Ok(f) = File::open("/proc/stat") {
let buf = BufReader::new(f);
@@ -111,7 +105,7 @@ impl SystemInfo {
fn new() -> Self {
unsafe {
Self {
- page_size_kb: (sysconf(_SC_PAGESIZE) / 1024) as _,
+ page_size_kb: sysconf(_SC_PAGESIZE) as _,
clock_cycle: sysconf(_SC_CLK_TCK) as _,
boot_time: boot_time(),
}
@@ -163,22 +157,16 @@ pub struct System {
mem_available: u64,
mem_buffers: u64,
mem_page_cache: u64,
+ mem_shmem: u64,
mem_slab_reclaimable: u64,
swap_total: u64,
swap_free: u64,
- global_cpu: Cpu,
- cpus: Vec<Cpu>,
components: Vec<Component>,
disks: Vec<Disk>,
networks: Networks,
users: Vec<User>,
- /// Field set to `false` in `update_cpus` and to `true` in `refresh_processes_specifics`.
- ///
- /// The reason behind this is to avoid calling the `update_cpus` more than necessary.
- /// For example when running `refresh_all` or `refresh_specifics`.
- need_cpus_update: bool,
info: SystemInfo,
- got_cpu_frequency: bool,
+ cpus: CpusWrapper,
}
impl System {
@@ -193,15 +181,14 @@ impl System {
fn clear_procs(&mut self, refresh_kind: ProcessRefreshKind) {
let (total_time, compute_cpu, max_value) = if refresh_kind.cpu() {
- if self.need_cpus_update {
- self.refresh_cpus(true, CpuRefreshKind::new().with_cpu_usage());
- }
+ self.cpus
+ .refresh_if_needed(true, CpuRefreshKind::new().with_cpu_usage());
if self.cpus.is_empty() {
sysinfo_debug!("cannot compute processes CPU usage: no CPU found...");
(0., false, 0.)
} else {
- let (new, old) = get_raw_times(&self.global_cpu);
+ let (new, old) = self.cpus.get_global_raw_times();
let total_time = if old > new { 1 } else { new - old };
(
total_time as f32 / self.cpus.len() as f32,
@@ -226,128 +213,7 @@ impl System {
}
fn refresh_cpus(&mut self, only_update_global_cpu: bool, refresh_kind: CpuRefreshKind) {
- if let Ok(f) = File::open("/proc/stat") {
- self.need_cpus_update = false;
-
- let buf = BufReader::new(f);
- let mut i: usize = 0;
- let first = self.cpus.is_empty();
- let mut it = buf.split(b'\n');
- let (vendor_id, brand) = if first {
- get_vendor_id_and_brand()
- } else {
- (String::new(), String::new())
- };
-
- if first || refresh_kind.cpu_usage() {
- if let Some(Ok(line)) = it.next() {
- if &line[..4] != b"cpu " {
- return;
- }
- let mut parts = line.split(|x| *x == b' ').filter(|s| !s.is_empty());
- if first {
- self.global_cpu.name = to_str!(parts.next().unwrap_or(&[])).to_owned();
- } else {
- parts.next();
- }
- self.global_cpu.set(
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- );
- }
- if first || !only_update_global_cpu {
- while let Some(Ok(line)) = it.next() {
- if &line[..3] != b"cpu" {
- break;
- }
-
- let mut parts = line.split(|x| *x == b' ').filter(|s| !s.is_empty());
- if first {
- self.cpus.push(Cpu::new_with_values(
- to_str!(parts.next().unwrap_or(&[])),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- 0,
- vendor_id.clone(),
- brand.clone(),
- ));
- } else {
- parts.next(); // we don't want the name again
- self.cpus[i].set(
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- parts.next().map(to_u64).unwrap_or(0),
- );
- }
-
- i += 1;
- }
- }
- }
-
- if refresh_kind.frequency() && !self.got_cpu_frequency {
- #[cfg(feature = "multithread")]
- use rayon::iter::{
- IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator,
- };
-
- #[cfg(feature = "multithread")]
- // This function is voluntarily made generic in case we want to generalize it.
- fn iter_mut<'a, T>(
- val: &'a mut T,
- ) -> <&'a mut T as rayon::iter::IntoParallelIterator>::Iter
- where
- &'a mut T: rayon::iter::IntoParallelIterator,
- {
- val.par_iter_mut()
- }
-
- #[cfg(not(feature = "multithread"))]
- fn iter_mut<'a>(val: &'a mut Vec<Cpu>) -> std::slice::IterMut<'a, Cpu> {
- val.iter_mut()
- }
-
- // `get_cpu_frequency` is very slow, so better run it in parallel.
- self.global_cpu.frequency = iter_mut(&mut self.cpus)
- .enumerate()
- .map(|(pos, proc_)| {
- proc_.frequency = get_cpu_frequency(pos);
- proc_.frequency
- })
- .max()
- .unwrap_or(0);
-
- self.got_cpu_frequency = true;
- }
-
- if first {
- self.global_cpu.vendor_id = vendor_id;
- self.global_cpu.brand = brand;
- }
- }
+ self.cpus.refresh(only_update_global_cpu, refresh_kind);
}
}
@@ -356,8 +222,7 @@ impl SystemExt for System {
const SUPPORTED_SIGNALS: &'static [Signal] = supported_signals();
fn new_with_specifics(refreshes: RefreshKind) -> System {
- let info = SystemInfo::new();
- let process_list = Process::new(Pid(0), None, 0, &info);
+ let process_list = Process::new(Pid(0));
let mut s = System {
process_list,
mem_total: 0,
@@ -365,33 +230,16 @@ impl SystemExt for System {
mem_available: 0,
mem_buffers: 0,
mem_page_cache: 0,
+ mem_shmem: 0,
mem_slab_reclaimable: 0,
swap_total: 0,
swap_free: 0,
- global_cpu: Cpu::new_with_values(
- "",
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- String::new(),
- String::new(),
- ),
- cpus: Vec::with_capacity(4),
+ cpus: CpusWrapper::new(),
components: Vec::new(),
disks: Vec::with_capacity(2),
networks: Networks::new(),
users: Vec::new(),
- need_cpus_update: true,
- info,
- got_cpu_frequency: false,
+ info: SystemInfo::new(),
};
s.refresh_specifics(refreshes);
s
@@ -403,14 +251,20 @@ impl SystemExt for System {
fn refresh_memory(&mut self) {
if let Ok(data) = get_all_data("/proc/meminfo", 16_385) {
+ let mut mem_available_found = false;
+
for line in data.split('\n') {
let mut iter = line.split(':');
let field = match iter.next() {
Some("MemTotal") => &mut self.mem_total,
Some("MemFree") => &mut self.mem_free,
- Some("MemAvailable") => &mut self.mem_available,
+ Some("MemAvailable") => {
+ mem_available_found = true;
+ &mut self.mem_available
+ }
Some("Buffers") => &mut self.mem_buffers,
Some("Cached") => &mut self.mem_page_cache,
+ Some("Shmem") => &mut self.mem_shmem,
Some("SReclaimable") => &mut self.mem_slab_reclaimable,
Some("SwapTotal") => &mut self.swap_total,
Some("SwapFree") => &mut self.swap_free,
@@ -419,10 +273,21 @@ impl SystemExt for System {
if let Some(val_str) = iter.next().and_then(|s| s.trim_start().split(' ').next()) {
if let Ok(value) = u64::from_str(val_str) {
// /proc/meminfo reports KiB, though it says "kB". Convert it.
- *field = value.saturating_mul(128) / 125;
+ *field = value.saturating_mul(1_024);
}
}
}
+
+ // Linux < 3.14 may not have MemAvailable in /proc/meminfo
+ // So it should fallback to the old way of estimating available memory
+ // https://github.com/KittyKatt/screenFetch/issues/386#issuecomment-249312716
+ if !mem_available_found {
+ self.mem_available = self.mem_free
+ + self.mem_buffers
+ + self.mem_page_cache
+ + self.mem_slab_reclaimable
+ - self.mem_shmem;
+ }
}
}
@@ -441,7 +306,7 @@ impl SystemExt for System {
refresh_kind,
);
self.clear_procs(refresh_kind);
- self.need_cpus_update = true;
+ self.cpus.set_need_cpus_update();
}
fn refresh_process_specifics(&mut self, pid: Pid, refresh_kind: ProcessRefreshKind) -> bool {
@@ -469,7 +334,7 @@ impl SystemExt for System {
sysinfo_debug!("Cannot compute process CPU usage: no cpus found...");
return found;
}
- let (new, old) = get_raw_times(&self.global_cpu);
+ let (new, old) = self.cpus.get_global_raw_times();
let total_time = (if old >= new { 1 } else { new - old }) as f32;
let max_cpu_usage = self.get_max_process_cpu_usage();
@@ -513,11 +378,11 @@ impl SystemExt for System {
}
fn global_cpu_info(&self) -> &Cpu {
- &self.global_cpu
+ &self.cpus.global_cpu
}
fn cpus(&self) -> &[Cpu] {
- &self.cpus
+ &self.cpus.cpus
}
fn physical_core_count(&self) -> Option<usize> {
@@ -537,11 +402,7 @@ impl SystemExt for System {
}
fn used_memory(&self) -> u64 {
- self.mem_total
- - self.mem_free
- - self.mem_buffers
- - self.mem_page_cache
- - self.mem_slab_reclaimable
+ self.mem_total - self.mem_available
}
fn total_swap(&self) -> u64 {
@@ -573,6 +434,13 @@ impl SystemExt for System {
&mut self.disks
}
+ fn sort_disks_by<F>(&mut self, compare: F)
+ where
+ F: FnMut(&Disk, &Disk) -> std::cmp::Ordering,
+ {
+ self.disks.sort_unstable_by(compare);
+ }
+
fn uptime(&self) -> u64 {
let content = get_all_data("/proc/uptime", 50).unwrap_or_default();
content
@@ -691,6 +559,25 @@ impl SystemExt for System {
fn os_version(&self) -> Option<String> {
get_system_info_android(InfoType::OsVersion)
}
+
+ #[cfg(not(target_os = "android"))]
+ fn distribution_id(&self) -> String {
+ get_system_info_linux(
+ InfoType::DistributionID,
+ Path::new("/etc/os-release"),
+ Path::new(""),
+ )
+ .unwrap_or_else(|| std::env::consts::OS.to_owned())
+ }
+
+ #[cfg(target_os = "android")]
+ fn distribution_id(&self) -> String {
+ // Currently get_system_info_android doesn't support InfoType::DistributionID and always
+ // returns None. This call is done anyway for consistency with non-Android implementation
+ // and to suppress dead-code warning for DistributionID on Android.
+ get_system_info_android(InfoType::DistributionID)
+ .unwrap_or_else(|| std::env::consts::OS.to_owned())
+ }
}
impl Default for System {
@@ -699,16 +586,6 @@ impl Default for System {
}
}
-fn to_u64(v: &[u8]) -> u64 {
- let mut x = 0;
-
- for c in v {
- x *= 10;
- x += u64::from(c - b'0');
- }
- x
-}
-
#[derive(PartialEq, Eq)]
enum InfoType {
/// The end-user friendly name of:
@@ -716,6 +593,9 @@ enum InfoType {
/// - Linux: The distributions name
Name,
OsVersion,
+ /// Machine-parseable ID of a distribution, see
+ /// https://www.freedesktop.org/software/systemd/man/os-release.html#ID=
+ DistributionID,
}
#[cfg(not(target_os = "android"))]
@@ -726,6 +606,7 @@ fn get_system_info_linux(info: InfoType, path: &Path, fallback_path: &Path) -> O
let info_str = match info {
InfoType::Name => "NAME=",
InfoType::OsVersion => "VERSION_ID=",
+ InfoType::DistributionID => "ID=",
};
for line in reader.lines().flatten() {
@@ -744,6 +625,10 @@ fn get_system_info_linux(info: InfoType, path: &Path, fallback_path: &Path) -> O
let info_str = match info {
InfoType::OsVersion => "DISTRIB_RELEASE=",
InfoType::Name => "DISTRIB_ID=",
+ InfoType::DistributionID => {
+ // lsb-release is inconsistent with os-release and unsupported.
+ return None;
+ }
};
for line in reader.lines().flatten() {
if let Some(stripped) = line.strip_prefix(info_str) {
@@ -759,6 +644,10 @@ fn get_system_info_android(info: InfoType) -> Option<String> {
let name: &'static [u8] = match info {
InfoType::Name => b"ro.product.model\0",
InfoType::OsVersion => b"ro.build.version.release\0",
+ InfoType::DistributionID => {
+ // Not supported.
+ return None;
+ }
};
let mut value_buffer = vec![0u8; libc::PROP_VALUE_MAX as usize];
@@ -792,6 +681,7 @@ mod test {
fn lsb_release_fallback_android() {
assert!(get_system_info_android(InfoType::OsVersion).is_some());
assert!(get_system_info_android(InfoType::Name).is_some());
+ assert!(get_system_info_android(InfoType::DistributionID).is_none());
}
#[test]
@@ -838,6 +728,10 @@ DISTRIB_DESCRIPTION="Ubuntu 20.10"
get_system_info_linux(InfoType::Name, &tmp1, Path::new("")),
Some("Ubuntu".to_owned())
);
+ assert_eq!(
+ get_system_info_linux(InfoType::DistributionID, &tmp1, Path::new("")),
+ Some("ubuntu".to_owned())
+ );
// Check for the "fallback" path: "/etc/lsb-release"
assert_eq!(
@@ -848,5 +742,9 @@ DISTRIB_DESCRIPTION="Ubuntu 20.10"
get_system_info_linux(InfoType::Name, Path::new(""), &tmp2),
Some("Ubuntu".to_owned())
);
+ assert_eq!(
+ get_system_info_linux(InfoType::DistributionID, Path::new(""), &tmp2),
+ None
+ );
}
}
diff --git a/vendor/sysinfo/src/linux/utils.rs b/vendor/sysinfo/src/linux/utils.rs
index cd881a3d1..60a9aa2b0 100644
--- a/vendor/sysinfo/src/linux/utils.rs
+++ b/vendor/sysinfo/src/linux/utils.rs
@@ -2,7 +2,9 @@
use std::fs::File;
use std::io::{self, Read, Seek, SeekFrom};
-use std::path::Path;
+use std::path::{Path, PathBuf};
+
+use crate::sys::system::REMAINING_FILES;
pub(crate) fn get_all_data_from_file(file: &mut File, size: usize) -> io::Result<String> {
let mut buf = String::with_capacity(size);
@@ -17,39 +19,105 @@ pub(crate) fn get_all_data<P: AsRef<Path>>(file_path: P, size: usize) -> io::Res
}
#[allow(clippy::useless_conversion)]
-pub(crate) fn realpath(original: &Path) -> std::path::PathBuf {
- use libc::{lstat, stat, S_IFLNK, S_IFMT};
- use std::fs;
- use std::mem::MaybeUninit;
- use std::path::PathBuf;
-
- fn and(x: u32, y: u32) -> u32 {
- x & y
- }
-
- // let ori = Path::new(original.to_str().unwrap());
- // Right now lstat on windows doesn't work quite well
- // if cfg!(windows) {
- // return PathBuf::from(ori);
- // }
- let result = PathBuf::from(original);
- let mut result_s = result.to_str().unwrap_or("").as_bytes().to_vec();
- result_s.push(0);
- let mut buf = MaybeUninit::<stat>::uninit();
- unsafe {
- let res = lstat(result_s.as_ptr() as *const _, buf.as_mut_ptr());
- if res < 0 {
+pub(crate) fn realpath(path: &Path) -> std::path::PathBuf {
+ match std::fs::read_link(path) {
+ Ok(f) => f,
+ Err(_e) => {
+ sysinfo_debug!("failed to get real path for {:?}: {:?}", path, _e);
PathBuf::new()
- } else {
- let buf = buf.assume_init();
- if and(buf.st_mode.into(), S_IFMT.into()) != S_IFLNK.into() {
- PathBuf::new()
- } else {
- match fs::read_link(&result) {
- Ok(f) => f,
- Err(_) => PathBuf::new(),
+ }
+ }
+}
+
+/// Type used to correctly handle the `REMAINING_FILES` global.
+pub(crate) struct FileCounter(File);
+
+impl FileCounter {
+ pub(crate) fn new(f: File) -> Option<Self> {
+ unsafe {
+ if let Ok(ref mut x) = REMAINING_FILES.lock() {
+ if **x > 0 {
+ **x -= 1;
+ return Some(Self(f));
}
+ // All file descriptors we were allowed are being used.
+ }
+ }
+ None
+ }
+}
+
+impl std::ops::Deref for FileCounter {
+ type Target = File;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+impl std::ops::DerefMut for FileCounter {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+impl Drop for FileCounter {
+ fn drop(&mut self) {
+ unsafe {
+ if let Ok(ref mut x) = crate::sys::system::REMAINING_FILES.lock() {
+ **x += 1;
}
}
}
}
+
+/// This type is used in `retrieve_all_new_process_info` because we have a "parent" path and
+/// from it, we `pop`/`join` every time because it's more memory efficient than using `Path::join`.
+pub(crate) struct PathHandler(PathBuf);
+
+impl PathHandler {
+ pub(crate) fn new(path: &Path) -> Self {
+ // `path` is the "parent" for all paths which will follow so we add a fake element at
+ // the end since every `PathHandler::join` call will first call `pop` internally.
+ Self(path.join("a"))
+ }
+}
+
+pub(crate) trait PathPush {
+ fn join(&mut self, p: &str) -> &Path;
+}
+
+impl PathPush for PathHandler {
+ fn join(&mut self, p: &str) -> &Path {
+ self.0.pop();
+ self.0.push(p);
+ self.0.as_path()
+ }
+}
+
+// This implementation allows to skip one allocation that is done in `PathHandler`.
+impl PathPush for PathBuf {
+ fn join(&mut self, p: &str) -> &Path {
+ self.push(p);
+ self.as_path()
+ }
+}
+
+pub(crate) fn to_u64(v: &[u8]) -> u64 {
+ let mut x = 0;
+
+ for c in v {
+ x *= 10;
+ x += u64::from(c - b'0');
+ }
+ x
+}
+
+/// Converts a path to a NUL-terminated `Vec<u8>` suitable for use with C functions.
+pub(crate) fn to_cpath(path: &std::path::Path) -> Vec<u8> {
+ use std::{ffi::OsStr, os::unix::ffi::OsStrExt};
+
+ let path_os: &OsStr = path.as_ref();
+ let mut cpath = path_os.as_bytes().to_vec();
+ cpath.push(0);
+ cpath
+}
diff --git a/vendor/sysinfo/src/traits.rs b/vendor/sysinfo/src/traits.rs
index 3d5eafaa8..7b442990c 100644
--- a/vendor/sysinfo/src/traits.rs
+++ b/vendor/sysinfo/src/traits.rs
@@ -208,6 +208,18 @@ pub trait ProcessExt: Debug {
/// println!("{}", process.exe().display());
/// }
/// ```
+ ///
+ /// ### Implementation notes
+ ///
+ /// On Linux, this method will return an empty path if there
+ /// was an error trying to read `/proc/<pid>/exe`. This can
+ /// happen, for example, if the permission levels or UID namespaces
+ /// between the caller and target processes are different.
+ ///
+ /// It is also the case that `cmd[0]` is _not_ usually a correct
+ /// replacement for this.
+ /// A process [may change its `cmd[0]` value](https://man7.org/linux/man-pages/man5/proc.5.html)
+ /// freely, making this an untrustworthy source of information.
fn exe(&self) -> &Path;
/// Returns the pid of the process.
@@ -258,26 +270,26 @@ pub trait ProcessExt: Debug {
/// ```
fn root(&self) -> &Path;
- /// Returns the memory usage (in KB).
+ /// Returns the memory usage (in bytes).
///
/// ```no_run
/// use sysinfo::{Pid, ProcessExt, System, SystemExt};
///
/// let s = System::new();
/// if let Some(process) = s.process(Pid::from(1337)) {
- /// println!("{} KB", process.memory());
+ /// println!("{} bytes", process.memory());
/// }
/// ```
fn memory(&self) -> u64;
- /// Returns the virtual memory usage (in KB).
+ /// Returns the virtual memory usage (in bytes).
///
/// ```no_run
/// use sysinfo::{Pid, ProcessExt, System, SystemExt};
///
/// let s = System::new();
/// if let Some(process) = s.process(Pid::from(1337)) {
- /// println!("{} KB", process.virtual_memory());
+ /// println!("{} bytes", process.virtual_memory());
/// }
/// ```
fn virtual_memory(&self) -> u64;
@@ -400,6 +412,21 @@ pub trait ProcessExt: Debug {
/// }
/// ```
fn group_id(&self) -> Option<Gid>;
+
+ /// Wait for process termination.
+ ///
+ /// ```no_run
+ /// use sysinfo::{Pid, ProcessExt, System, SystemExt};
+ ///
+ /// let mut s = System::new_all();
+ ///
+ /// if let Some(process) = s.process(Pid::from(1337)) {
+ /// eprintln!("Waiting for pid 1337");
+ /// process.wait();
+ /// eprintln!("Pid 1337 exited");
+ /// }
+ /// ```
+ fn wait(&self);
}
/// Contains all the methods of the [`Cpu`][crate::Cpu] struct.
@@ -650,7 +677,7 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// 200ms) to get accurate values as it uses previous results to compute the next value.
///
/// Calling this method is the same as calling
- /// `refresh_cpu_specifics(CpuRefreshKind::everything())`.
+ /// `refresh_cpu_specifics(CpuRefreshKind::new().with_cpu_usage())`.
///
/// ```no_run
/// use sysinfo::{System, SystemExt};
@@ -659,7 +686,7 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// s.refresh_cpu();
/// ```
fn refresh_cpu(&mut self) {
- self.refresh_cpu_specifics(CpuRefreshKind::everything())
+ self.refresh_cpu_specifics(CpuRefreshKind::new().with_cpu_usage())
}
/// Refreshes CPUs specific information.
@@ -668,10 +695,10 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// list nor users list.
///
/// ```no_run
- /// use sysinfo::{System, SystemExt};
+ /// use sysinfo::{System, SystemExt, CpuRefreshKind};
///
/// let mut s = System::new_all();
- /// s.refresh_all();
+ /// s.refresh_cpu_specifics(CpuRefreshKind::everything());
/// ```
fn refresh_cpu_specifics(&mut self, refresh_kind: CpuRefreshKind);
@@ -866,6 +893,12 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// If you want only the processes with exactly the given `name`, take a look at
/// [`SystemExt::processes_by_exact_name`].
///
+ /// **⚠️ Important ⚠️**
+ ///
+ /// On **linux**, there are two things to know about processes' name:
+ /// 1. It is limited to 15 characters.
+ /// 2. It is not always the exe name.
+ ///
/// ```no_run
/// use sysinfo::{ProcessExt, System, SystemExt};
///
@@ -891,6 +924,12 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// If you instead want the processes containing `name`, take a look at
/// [`SystemExt::processes_by_name`].
///
+ /// **⚠️ Important ⚠️**
+ ///
+ /// On **linux**, there are two things to know about processes' name:
+ /// 1. It is limited to 15 characters.
+ /// 2. It is not always the exe name.
+ ///
/// ```no_run
/// use sysinfo::{ProcessExt, System, SystemExt};
///
@@ -957,17 +996,17 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// ```
fn physical_core_count(&self) -> Option<usize>;
- /// Returns the RAM size in KB.
+ /// Returns the RAM size in bytes.
///
/// ```no_run
/// use sysinfo::{System, SystemExt};
///
/// let s = System::new_all();
- /// println!("{} KB", s.total_memory());
+ /// println!("{} bytes", s.total_memory());
/// ```
fn total_memory(&self) -> u64;
- /// Returns the amount of free RAM in KB.
+ /// Returns the amount of free RAM in bytes.
///
/// Generally, "free" memory refers to unallocated memory whereas "available" memory refers to
/// memory that is available for (re)use.
@@ -979,11 +1018,11 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// use sysinfo::{System, SystemExt};
///
/// let s = System::new_all();
- /// println!("{} KB", s.free_memory());
+ /// println!("{} bytes", s.free_memory());
/// ```
fn free_memory(&self) -> u64;
- /// Returns the amount of available RAM in KB.
+ /// Returns the amount of available RAM in bytes.
///
/// Generally, "free" memory refers to unallocated memory whereas "available" memory refers to
/// memory that is available for (re)use.
@@ -995,47 +1034,47 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// use sysinfo::{System, SystemExt};
///
/// let s = System::new_all();
- /// println!("{} KB", s.available_memory());
+ /// println!("{} bytes", s.available_memory());
/// ```
fn available_memory(&self) -> u64;
- /// Returns the amount of used RAM in KB.
+ /// Returns the amount of used RAM in bytes.
///
/// ```no_run
/// use sysinfo::{System, SystemExt};
///
/// let s = System::new_all();
- /// println!("{} KB", s.used_memory());
+ /// println!("{} bytes", s.used_memory());
/// ```
fn used_memory(&self) -> u64;
- /// Returns the SWAP size in KB.
+ /// Returns the SWAP size in bytes.
///
/// ```no_run
/// use sysinfo::{System, SystemExt};
///
/// let s = System::new_all();
- /// println!("{} KB", s.total_swap());
+ /// println!("{} bytes", s.total_swap());
/// ```
fn total_swap(&self) -> u64;
- /// Returns the amount of free SWAP in KB.
+ /// Returns the amount of free SWAP in bytes.
///
/// ```no_run
/// use sysinfo::{System, SystemExt};
///
/// let s = System::new_all();
- /// println!("{} KB", s.free_swap());
+ /// println!("{} bytes", s.free_swap());
/// ```
fn free_swap(&self) -> u64;
- /// Returns the amount of used SWAP in KB.
+ /// Returns the amount of used SWAP in bytes.
///
/// ```no_run
/// use sysinfo::{System, SystemExt};
///
/// let s = System::new_all();
- /// println!("{} KB", s.used_swap());
+ /// println!("{} bytes", s.used_swap());
/// ```
fn used_swap(&self) -> u64;
@@ -1063,18 +1102,6 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// ```
fn components_mut(&mut self) -> &mut [Component];
- /// Returns the disks list.
- ///
- /// ```no_run
- /// use sysinfo::{DiskExt, System, SystemExt};
- ///
- /// let s = System::new_all();
- /// for disk in s.disks() {
- /// println!("{:?}", disk.name());
- /// }
- /// ```
- fn disks(&self) -> &[Disk];
-
/// Returns the users list.
///
/// ```no_run
@@ -1092,6 +1119,18 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// ```no_run
/// use sysinfo::{DiskExt, System, SystemExt};
///
+ /// let s = System::new_all();
+ /// for disk in s.disks() {
+ /// println!("{:?}", disk.name());
+ /// }
+ /// ```
+ fn disks(&self) -> &[Disk];
+
+ /// Returns the disks list.
+ ///
+ /// ```no_run
+ /// use sysinfo::{DiskExt, System, SystemExt};
+ ///
/// let mut s = System::new_all();
/// for disk in s.disks_mut() {
/// disk.refresh();
@@ -1099,6 +1138,17 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// ```
fn disks_mut(&mut self) -> &mut [Disk];
+ /// Sort the disk list with the provided callback.
+ ///
+ /// Internally, it is using the [`slice::sort_unstable_by`] function, so please refer to it
+ /// for implementation details.
+ ///
+ /// ⚠️ If you use [`SystemExt::refresh_disks_list`], you need to use this method before using
+ /// [`SystemExt::disks`] or [`SystemExt::disks_mut`] if you want them to be sorted.
+ fn sort_disks_by<F>(&mut self, compare: F)
+ where
+ F: FnMut(&Disk, &Disk) -> std::cmp::Ordering;
+
/// Returns the network interfaces object.
///
/// ```no_run
@@ -1212,6 +1262,23 @@ pub trait SystemExt: Sized + Debug + Default + Send + Sync {
/// ```
fn long_os_version(&self) -> Option<String>;
+ /// Returns the distribution id as defined by os-release,
+ /// or [`std::env::consts::OS`].
+ ///
+ /// See also
+ /// - <https://www.freedesktop.org/software/systemd/man/os-release.html#ID=>
+ /// - <https://doc.rust-lang.org/std/env/consts/constant.OS.html>
+ ///
+ /// **Important**: this information is computed every time this function is called.
+ ///
+ /// ```no_run
+ /// use sysinfo::{System, SystemExt};
+ ///
+ /// let s = System::new();
+ /// println!("Distribution ID: {:?}", s.distribution_id());
+ /// ```
+ fn distribution_id(&self) -> String;
+
/// Returns the system hostname based off DNS
///
/// **Important**: this information is computed every time this function is called.
@@ -1463,10 +1530,17 @@ pub trait ComponentExt: Debug {
/// println!("{}°C", component.temperature());
/// }
/// ```
+ ///
+ /// ## Linux
+ ///
+ /// Returns `f32::NAN` if it failed to retrieve it.
fn temperature(&self) -> f32;
/// Returns the maximum temperature of the component (in celsius degree).
///
+ /// Note: if `temperature` is higher than the current `max`,
+ /// `max` value will be updated on refresh.
+ ///
/// ```no_run
/// use sysinfo::{ComponentExt, System, SystemExt};
///
@@ -1475,6 +1549,11 @@ pub trait ComponentExt: Debug {
/// println!("{}°C", component.max());
/// }
/// ```
+ ///
+ /// ## Linux
+ ///
+ /// May be computed by sysinfo from kernel.
+ /// Returns `f32::NAN` if it failed to retrieve it.
fn max(&self) -> f32;
/// Returns the highest temperature before the component halts (in celsius degree).
@@ -1487,6 +1566,10 @@ pub trait ComponentExt: Debug {
/// println!("{:?}°C", component.critical());
/// }
/// ```
+ ///
+ /// ## Linux
+ ///
+ /// Critical threshold defined by chip or kernel.
fn critical(&self) -> Option<f32>;
/// Returns the label of the component.
@@ -1499,6 +1582,19 @@ pub trait ComponentExt: Debug {
/// println!("{}", component.label());
/// }
/// ```
+ ///
+ /// ## Linux
+ ///
+ /// Since components informations are retrieved thanks to `hwmon`,
+ /// the labels are generated as follows.
+ /// Note: it may change and it was inspired by `sensors` own formatting.
+ ///
+ /// | name | label | device_model | id_sensor | Computed label by `sysinfo` |
+ /// |---------|--------|------------|----------|----------------------|
+ /// | ✓ | ✓ | ✓ | ✓ | `"{name} {label} {device_model} temp{id}"` |
+ /// | ✓ | ✓ | ✗ | ✓ | `"{name} {label} {id}"` |
+ /// | ✓ | ✗ | ✓ | ✓ | `"{name} {device_model}"` |
+ /// | ✓ | ✗ | ✗ | ✓ | `"{name} temp{id}"` |
fn label(&self) -> &str;
/// Refreshes component.
diff --git a/vendor/sysinfo/src/unknown/process.rs b/vendor/sysinfo/src/unknown/process.rs
index c4656d3f5..4a12ec829 100644
--- a/vendor/sysinfo/src/unknown/process.rs
+++ b/vendor/sysinfo/src/unknown/process.rs
@@ -89,4 +89,6 @@ impl ProcessExt for Process {
fn group_id(&self) -> Option<Gid> {
None
}
+
+ fn wait(&self) {}
}
diff --git a/vendor/sysinfo/src/unknown/system.rs b/vendor/sysinfo/src/unknown/system.rs
index 4603ae737..c205cdf96 100644
--- a/vendor/sysinfo/src/unknown/system.rs
+++ b/vendor/sysinfo/src/unknown/system.rs
@@ -123,6 +123,13 @@ impl SystemExt for System {
&mut []
}
+ fn sort_disks_by<F>(&mut self, _compare: F)
+ where
+ F: FnMut(&Disk, &Disk) -> std::cmp::Ordering,
+ {
+ // does nothing.
+ }
+
fn uptime(&self) -> u64 {
0
}
@@ -159,6 +166,10 @@ impl SystemExt for System {
None
}
+ fn distribution_id(&self) -> String {
+ std::env::consts::OS.to_owned()
+ }
+
fn host_name(&self) -> Option<String> {
None
}
diff --git a/vendor/sysinfo/src/utils.rs b/vendor/sysinfo/src/utils.rs
index 578ab61c6..70d96d9fa 100644
--- a/vendor/sysinfo/src/utils.rs
+++ b/vendor/sysinfo/src/utils.rs
@@ -1,19 +1,5 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-/* convert a path to a NUL-terminated Vec<u8> suitable for use with C functions */
-#[cfg(all(
- not(feature = "unknown-ci"),
- any(target_os = "linux", target_os = "android", target_vendor = "apple")
-))]
-pub(crate) fn to_cpath(path: &std::path::Path) -> Vec<u8> {
- use std::{ffi::OsStr, os::unix::ffi::OsStrExt};
-
- let path_os: &OsStr = path.as_ref();
- let mut cpath = path_os.as_bytes().to_vec();
- cpath.push(0);
- cpath
-}
-
/// Converts the value into a parallel iterator (if the multithread feature is enabled)
/// Uses the rayon::iter::IntoParallelIterator trait
#[cfg(all(
@@ -27,7 +13,7 @@ pub(crate) fn to_cpath(path: &std::path::Path) -> Vec<u8> {
),
feature = "multithread"
),
- not(feature = "apple-sandbox"),
+ not(all(target_os = "macos", feature = "apple-sandbox")),
not(feature = "unknown-ci")
))]
pub(crate) fn into_iter<T>(val: T) -> T::Iter
@@ -51,7 +37,7 @@ where
not(feature = "multithread")
),
not(feature = "unknown-ci"),
- not(feature = "apple-sandbox")
+ not(all(target_os = "macos", feature = "apple-sandbox"))
))]
pub(crate) fn into_iter<T>(val: T) -> T::IntoIter
where
diff --git a/vendor/sysinfo/src/windows/disk.rs b/vendor/sysinfo/src/windows/disk.rs
index ae393afb2..215fb8c58 100644
--- a/vendor/sysinfo/src/windows/disk.rs
+++ b/vendor/sysinfo/src/windows/disk.rs
@@ -16,9 +16,10 @@ use winapi::um::handleapi::{CloseHandle, INVALID_HANDLE_VALUE};
use winapi::um::ioapiset::DeviceIoControl;
use winapi::um::winbase::{DRIVE_FIXED, DRIVE_REMOVABLE};
use winapi::um::winioctl::{
- DEVICE_TRIM_DESCRIPTOR, IOCTL_STORAGE_QUERY_PROPERTY, STORAGE_PROPERTY_QUERY,
+ PropertyStandardQuery, StorageDeviceSeekPenaltyProperty, IOCTL_STORAGE_QUERY_PROPERTY,
+ STORAGE_PROPERTY_QUERY,
};
-use winapi::um::winnt::{FILE_SHARE_READ, FILE_SHARE_WRITE, HANDLE, ULARGE_INTEGER};
+use winapi::um::winnt::{BOOLEAN, FILE_SHARE_READ, FILE_SHARE_WRITE, HANDLE, ULARGE_INTEGER};
#[doc = include_str!("../../md_doc/disk.md")]
pub struct Disk {
@@ -122,14 +123,23 @@ unsafe fn get_drive_size(mount_point: &[u16]) -> Option<(u64, u64)> {
) != 0
{
Some((
- *total_size.QuadPart() as u64,
- *available_space.QuadPart() as u64,
+ *total_size.QuadPart() as _,
+ *available_space.QuadPart() as _,
))
} else {
None
}
}
+// FIXME: To be removed once <https://github.com/retep998/winapi-rs/pull/1028> has been merged.
+#[allow(non_snake_case)]
+#[repr(C)]
+struct DEVICE_SEEK_PENALTY_DESCRIPTOR {
+ Version: DWORD,
+ Size: DWORD,
+ IncursSeekPenalty: BOOLEAN,
+}
+
pub(crate) unsafe fn get_disks() -> Vec<Disk> {
let drives = GetLogicalDrives();
if drives == 0 {
@@ -201,16 +211,12 @@ pub(crate) unsafe fn get_disks() -> Vec<Disk> {
if total_space == 0 {
return None;
}
- /*let mut spq_trim: STORAGE_PROPERTY_QUERY = std::mem::zeroed();
- spq_trim.PropertyId = StorageDeviceTrimProperty;
- spq_trim.QueryType = PropertyStandardQuery;
- let mut dtd: DEVICE_TRIM_DESCRIPTOR = std::mem::zeroed();*/
let mut spq_trim = STORAGE_PROPERTY_QUERY {
- PropertyId: 8,
- QueryType: 0,
+ PropertyId: StorageDeviceSeekPenaltyProperty,
+ QueryType: PropertyStandardQuery,
AdditionalParameters: [0],
};
- let mut dtd: DEVICE_TRIM_DESCRIPTOR = std::mem::zeroed();
+ let mut result: DEVICE_SEEK_PENALTY_DESCRIPTOR = std::mem::zeroed();
let mut dw_size = 0;
let type_ = if DeviceIoControl(
@@ -218,16 +224,16 @@ pub(crate) unsafe fn get_disks() -> Vec<Disk> {
IOCTL_STORAGE_QUERY_PROPERTY,
&mut spq_trim as *mut STORAGE_PROPERTY_QUERY as *mut c_void,
size_of::<STORAGE_PROPERTY_QUERY>() as DWORD,
- &mut dtd as *mut DEVICE_TRIM_DESCRIPTOR as *mut c_void,
- size_of::<DEVICE_TRIM_DESCRIPTOR>() as DWORD,
+ &mut result as *mut DEVICE_SEEK_PENALTY_DESCRIPTOR as *mut c_void,
+ size_of::<DEVICE_SEEK_PENALTY_DESCRIPTOR>() as DWORD,
&mut dw_size,
std::ptr::null_mut(),
) == 0
- || dw_size != size_of::<DEVICE_TRIM_DESCRIPTOR>() as DWORD
+ || dw_size != size_of::<DEVICE_SEEK_PENALTY_DESCRIPTOR>() as DWORD
{
DiskType::Unknown(-1)
} else {
- let is_ssd = dtd.TrimEnabled != 0;
+ let is_ssd = result.IncursSeekPenalty == 0;
if is_ssd {
DiskType::SSD
} else {
diff --git a/vendor/sysinfo/src/windows/macros.rs b/vendor/sysinfo/src/windows/macros.rs
deleted file mode 100644
index b0c024c7c..000000000
--- a/vendor/sysinfo/src/windows/macros.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Take a look at the license at the top of the repository in the LICENSE file.
-
-/// Allows to cast only when needed.
-#[macro_export]
-macro_rules! auto_cast {
- ($t:expr, $cast:ty) => {{
- #[cfg(target_pointer_width = "32")]
- {
- $t as $cast
- }
- #[cfg(not(target_pointer_width = "32"))]
- {
- $t
- }
- }};
-}
diff --git a/vendor/sysinfo/src/windows/mod.rs b/vendor/sysinfo/src/windows/mod.rs
index fa5d66beb..805e85269 100644
--- a/vendor/sysinfo/src/windows/mod.rs
+++ b/vendor/sysinfo/src/windows/mod.rs
@@ -3,8 +3,6 @@
mod component;
mod cpu;
mod disk;
-#[macro_use]
-mod macros;
mod network;
mod process;
mod system;
diff --git a/vendor/sysinfo/src/windows/process.rs b/vendor/sysinfo/src/windows/process.rs
index bdc35c53e..7561c658f 100644
--- a/vendor/sysinfo/src/windows/process.rs
+++ b/vendor/sysinfo/src/windows/process.rs
@@ -1,5 +1,6 @@
// Take a look at the license at the top of the repository in the LICENSE file.
+use crate::sys::system::is_proc_running;
use crate::sys::utils::to_str;
use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessRefreshKind, ProcessStatus, Signal, Uid};
@@ -48,8 +49,8 @@ use winapi::um::securitybaseapi::GetTokenInformation;
use winapi::um::winbase::{GetProcessIoCounters, CREATE_NO_WINDOW};
use winapi::um::winnt::{
TokenUser, HANDLE, HEAP_ZERO_MEMORY, IO_COUNTERS, MEMORY_BASIC_INFORMATION,
- PROCESS_QUERY_INFORMATION, PROCESS_VM_READ, RTL_OSVERSIONINFOEXW, TOKEN_QUERY, TOKEN_USER,
- ULARGE_INTEGER,
+ PROCESS_QUERY_INFORMATION, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_VM_READ,
+ RTL_OSVERSIONINFOEXW, TOKEN_QUERY, TOKEN_USER, ULARGE_INTEGER,
};
impl fmt::Display for ProcessStatus {
@@ -67,7 +68,19 @@ fn get_process_handler(pid: Pid) -> Option<HandleWrapper> {
}
let options = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ;
- unsafe { HandleWrapper::new(OpenProcess(options, FALSE, pid.0 as DWORD)) }
+ HandleWrapper::new(unsafe { OpenProcess(options, FALSE, pid.0 as DWORD) })
+ .or_else(|| {
+ sysinfo_debug!("OpenProcess failed, error: {:?}", unsafe { GetLastError() });
+ HandleWrapper::new(unsafe {
+ OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid.0 as DWORD)
+ })
+ })
+ .or_else(|| {
+ sysinfo_debug!("OpenProcess limited failed, error: {:?}", unsafe {
+ GetLastError()
+ });
+ None
+ })
}
unsafe fn get_process_user_id(
@@ -266,11 +279,11 @@ unsafe fn get_h_mod(process_handler: &HandleWrapper, h_mod: &mut *mut c_void) ->
) != 0
}
-unsafe fn get_exe(process_handler: &HandleWrapper, h_mod: *mut c_void) -> PathBuf {
+unsafe fn get_exe(process_handler: &HandleWrapper) -> PathBuf {
let mut exe_buf = [0u16; MAX_PATH + 1];
GetModuleFileNameExW(
**process_handler,
- h_mod as _,
+ std::ptr::null_mut(),
exe_buf.as_mut_ptr(),
MAX_PATH as DWORD + 1,
);
@@ -306,7 +319,7 @@ impl Process {
String::new()
};
- let exe = get_exe(&process_handler, h_mod);
+ let exe = get_exe(&process_handler);
let mut root = exe.clone();
root.pop();
let (cmd, environ, cwd) = match get_process_params(&process_handler) {
@@ -316,7 +329,7 @@ impl Process {
(Vec::new(), Vec::new(), PathBuf::new())
}
};
- let (start_time, run_time) = get_start_and_run_time(&process_handler, now);
+ let (start_time, run_time) = get_start_and_run_time(*process_handler, now);
let parent = if info.InheritedFromUniqueProcessId as usize != 0 {
Some(Pid(info.InheritedFromUniqueProcessId as _))
} else {
@@ -360,14 +373,8 @@ impl Process {
refresh_kind: ProcessRefreshKind,
) -> Process {
if let Some(handle) = get_process_handler(pid) {
- let mut h_mod = null_mut();
-
unsafe {
- let exe = if get_h_mod(&handle, &mut h_mod) {
- get_exe(&handle, h_mod)
- } else {
- PathBuf::new()
- };
+ let exe = get_exe(&handle);
let mut root = exe.clone();
root.pop();
let (cmd, environ, cwd) = match get_process_params(&handle) {
@@ -377,7 +384,7 @@ impl Process {
(Vec::new(), Vec::new(), PathBuf::new())
}
};
- let (start_time, run_time) = get_start_and_run_time(&handle, now);
+ let (start_time, run_time) = get_start_and_run_time(*handle, now);
let user_id = get_process_user_id(&handle, refresh_kind);
Process {
handle: Some(Arc::new(handle)),
@@ -451,6 +458,10 @@ impl Process {
pub(crate) fn get_handle(&self) -> Option<HANDLE> {
self.handle.as_ref().map(|h| ***h)
}
+
+ pub(crate) fn get_start_time(&self) -> Option<u64> {
+ self.handle.as_ref().map(|handle| get_start_time(***handle))
+ }
}
impl ProcessExt for Process {
@@ -537,25 +548,60 @@ impl ProcessExt for Process {
fn group_id(&self) -> Option<Gid> {
None
}
+
+ fn wait(&self) {
+ if let Some(handle) = self.get_handle() {
+ while is_proc_running(handle) {
+ if get_start_time(handle) != self.start_time() {
+ // PID owner changed so the previous process was finished!
+ return;
+ }
+ std::thread::sleep(std::time::Duration::from_millis(10));
+ }
+ } else {
+ // In this case, we can't do anything so we just return.
+ sysinfo_debug!("can't wait on this process so returning");
+ }
+ }
}
-unsafe fn get_start_and_run_time(handle: &HandleWrapper, now: u64) -> (u64, u64) {
+#[inline]
+unsafe fn get_process_times(handle: HANDLE) -> u64 {
let mut fstart: FILETIME = zeroed();
let mut x = zeroed();
GetProcessTimes(
- **handle,
+ handle,
&mut fstart as *mut FILETIME,
&mut x as *mut FILETIME,
&mut x as *mut FILETIME,
&mut x as *mut FILETIME,
);
- let tmp = super::utils::filetime_to_u64(fstart);
+ super::utils::filetime_to_u64(fstart)
+}
+
+#[inline]
+fn compute_start(process_times: u64) -> u64 {
// 11_644_473_600 is the number of seconds between the Windows epoch (1601-01-01) and
// the linux epoch (1970-01-01).
- let start = tmp / 10_000_000 - 11_644_473_600;
- let run_time = check_sub(now, start);
- (start, run_time)
+ process_times / 10_000_000 - 11_644_473_600
+}
+
+fn get_start_and_run_time(handle: HANDLE, now: u64) -> (u64, u64) {
+ unsafe {
+ let process_times = get_process_times(handle);
+ let start = compute_start(process_times);
+ let run_time = check_sub(now, start);
+ (start, run_time)
+ }
+}
+
+#[inline]
+pub(crate) fn get_start_time(handle: HANDLE) -> u64 {
+ unsafe {
+ let process_times = get_process_times(handle);
+ compute_start(process_times)
+ }
}
#[allow(clippy::uninit_vec)]
@@ -976,7 +1022,7 @@ pub(crate) fn compute_cpu_usage(p: &mut Process, nb_cpus: u64) {
}
p.cpu_usage = 100.0
- * (delta_user_time.saturating_add(delta_sys_time) as f32 / denominator as f32)
+ * (delta_user_time.saturating_add(delta_sys_time) as f32 / denominator)
* nb_cpus as f32;
}
}
@@ -1011,8 +1057,8 @@ pub(crate) fn update_memory(p: &mut Process) {
size_of::<PROCESS_MEMORY_COUNTERS_EX>() as DWORD,
) != 0
{
- p.memory = (pmc.WorkingSetSize as u64) / 1_000;
- p.virtual_memory = (pmc.PrivateUsage as u64) / 1_000;
+ p.memory = pmc.WorkingSetSize as _;
+ p.virtual_memory = pmc.PrivateUsage as _;
}
}
}
diff --git a/vendor/sysinfo/src/windows/system.rs b/vendor/sysinfo/src/windows/system.rs
index 6abd30db5..643a7b4bc 100644
--- a/vendor/sysinfo/src/windows/system.rs
+++ b/vendor/sysinfo/src/windows/system.rs
@@ -9,7 +9,7 @@ use winapi::um::winreg::HKEY_LOCAL_MACHINE;
use crate::sys::component::{self, Component};
use crate::sys::cpu::*;
use crate::sys::disk::{get_disks, Disk};
-use crate::sys::process::{update_memory, Process};
+use crate::sys::process::{get_start_time, update_memory, Process};
use crate::sys::tools::*;
use crate::sys::users::get_users;
use crate::sys::utils::get_now;
@@ -64,6 +64,19 @@ pub struct System {
users: Vec<User>,
}
+static WINDOWS_ELEVEN_BUILD_NUMBER: u32 = 22000;
+
+impl System {
+ fn is_windows_eleven(&self) -> bool {
+ WINDOWS_ELEVEN_BUILD_NUMBER
+ <= self
+ .kernel_version()
+ .unwrap_or_default()
+ .parse()
+ .unwrap_or(0)
+ }
+}
+
// Useful for parallel iterations.
struct Wrap<T>(T);
@@ -73,7 +86,7 @@ unsafe impl<T> Sync for Wrap<T> {}
unsafe fn boot_time() -> u64 {
match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
- Ok(n) => n.as_secs().saturating_sub(GetTickCount64()) / 1000,
+ Ok(n) => n.as_secs().saturating_sub(GetTickCount64() / 1_000),
Err(_e) => {
sysinfo_debug!("Failed to compute boot time: {:?}", _e);
0
@@ -117,10 +130,10 @@ impl SystemExt for System {
);
for (pos, proc_) in self.cpus.iter_mut(refresh_kind).enumerate() {
add_english_counter(
- format!(r"\Processor({})\% Processor Time", pos),
+ format!(r"\Processor({pos})\% Processor Time"),
query,
get_key_used(proc_),
- format!("{}_0", pos),
+ format!("{pos}_0"),
);
}
}
@@ -162,8 +175,8 @@ impl SystemExt for System {
let mut mem_info: MEMORYSTATUSEX = zeroed();
mem_info.dwLength = size_of::<MEMORYSTATUSEX>() as u32;
GlobalMemoryStatusEx(&mut mem_info);
- self.mem_total = auto_cast!(mem_info.ullTotalPhys, u64) / 1_000;
- self.mem_available = auto_cast!(mem_info.ullAvailPhys, u64) / 1_000;
+ self.mem_total = mem_info.ullTotalPhys as _;
+ self.mem_available = mem_info.ullAvailPhys as _;
let mut perf_info: PERFORMANCE_INFORMATION = zeroed();
if GetPerformanceInfo(&mut perf_info, size_of::<PERFORMANCE_INFORMATION>() as u32)
== TRUE
@@ -178,8 +191,8 @@ impl SystemExt for System {
.CommitTotal
.saturating_sub(perf_info.PhysicalTotal),
);
- self.swap_total = (swap_total / 1000) as u64;
- self.swap_used = (swap_used / 1000) as u64;
+ self.swap_total = swap_total as _;
+ self.swap_used = swap_used as _;
}
}
}
@@ -190,12 +203,17 @@ impl SystemExt for System {
#[allow(clippy::map_entry)]
fn refresh_process_specifics(&mut self, pid: Pid, refresh_kind: ProcessRefreshKind) -> bool {
- if self.process_list.contains_key(&pid) {
- return refresh_existing_process(self, pid, refresh_kind);
- }
let now = get_now();
+ let nb_cpus = self.cpus.len() as u64;
+
+ if let Some(proc_) = self.process_list.get_mut(&pid) {
+ if let Some(ret) = refresh_existing_process(proc_, nb_cpus, now, refresh_kind) {
+ return ret;
+ }
+ // We need to re-make the process because the PID owner changed.
+ }
if let Some(mut p) = Process::new_from_pid(pid, now, refresh_kind) {
- p.update(refresh_kind, self.cpus.len() as u64, now);
+ p.update(refresh_kind, nb_cpus, now);
p.updated = false;
self.process_list.insert(pid, p);
true
@@ -266,10 +284,18 @@ impl SystemExt for System {
let pi = *pi.0;
let pid = Pid(pi.UniqueProcessId as _);
if let Some(proc_) = (*process_list.0.get()).get_mut(&pid) {
- proc_.memory = (pi.WorkingSetSize as u64) / 1_000;
- proc_.virtual_memory = (pi.VirtualSize as u64) / 1_000;
- proc_.update(refresh_kind, nb_cpus, now);
- return None;
+ if proc_
+ .get_start_time()
+ .map(|start| start == proc_.start_time())
+ .unwrap_or(true)
+ {
+ proc_.memory = pi.WorkingSetSize as _;
+ proc_.virtual_memory = pi.VirtualSize as _;
+ proc_.update(refresh_kind, nb_cpus, now);
+ return None;
+ }
+ // If the PID owner changed, we need to recompute the whole process.
+ sysinfo_debug!("owner changed for PID {}", proc_.pid());
}
let name = get_process_name(&pi, pid);
let mut p = Process::new_full(
@@ -279,8 +305,8 @@ impl SystemExt for System {
} else {
None
},
- (pi.WorkingSetSize as u64) / 1_000,
- (pi.VirtualSize as u64) / 1_000,
+ pi.WorkingSetSize as _,
+ pi.VirtualSize as _,
name,
now,
refresh_kind,
@@ -386,6 +412,13 @@ impl SystemExt for System {
&mut self.disks
}
+ fn sort_disks_by<F>(&mut self, compare: F)
+ where
+ F: FnMut(&Disk, &Disk) -> std::cmp::Ordering,
+ {
+ self.disks.sort_unstable_by(compare);
+ }
+
fn users(&self) -> &[User] {
&self.users
}
@@ -399,7 +432,7 @@ impl SystemExt for System {
}
fn uptime(&self) -> u64 {
- unsafe { GetTickCount64() / 1000 }
+ unsafe { GetTickCount64() / 1_000 }
}
fn boot_time(&self) -> u64 {
@@ -415,6 +448,14 @@ impl SystemExt for System {
}
fn long_os_version(&self) -> Option<String> {
+ if self.is_windows_eleven() {
+ return get_reg_string_value(
+ HKEY_LOCAL_MACHINE,
+ "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
+ "ProductName",
+ )
+ .map(|product_name| product_name.replace("Windows 10 ", "Windows 11 "));
+ }
get_reg_string_value(
HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
@@ -435,23 +476,29 @@ impl SystemExt for System {
}
fn os_version(&self) -> Option<String> {
- let major = get_reg_value_u32(
- HKEY_LOCAL_MACHINE,
- "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
- "CurrentMajorVersionNumber",
- );
-
let build_number = get_reg_string_value(
HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
"CurrentBuildNumber",
- );
+ )
+ .unwrap_or_default();
+ let major = if self.is_windows_eleven() {
+ 11u32
+ } else {
+ u32::from_le_bytes(
+ get_reg_value_u32(
+ HKEY_LOCAL_MACHINE,
+ "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
+ "CurrentMajorVersionNumber",
+ )
+ .unwrap_or_default(),
+ )
+ };
+ Some(format!("{major} ({build_number})"))
+ }
- Some(format!(
- "{} ({})",
- u32::from_le_bytes(major.unwrap_or_default()),
- build_number.unwrap_or_default()
- ))
+ fn distribution_id(&self) -> String {
+ std::env::consts::OS.to_owned()
}
}
@@ -461,7 +508,7 @@ impl Default for System {
}
}
-fn is_proc_running(handle: HANDLE) -> bool {
+pub(crate) fn is_proc_running(handle: HANDLE) -> bool {
let mut exit_code = 0;
unsafe {
let ret = GetExitCodeProcess(handle, &mut exit_code);
@@ -469,22 +516,30 @@ fn is_proc_running(handle: HANDLE) -> bool {
}
}
-fn refresh_existing_process(s: &mut System, pid: Pid, refresh_kind: ProcessRefreshKind) -> bool {
- if let Some(ref mut entry) = s.process_list.get_mut(&pid) {
- if let Some(handle) = entry.get_handle() {
- if !is_proc_running(handle) {
- return false;
- }
- } else {
- return false;
+/// If it returns `None`, it means that the PID owner changed and that the `Process` must be
+/// completely recomputed.
+fn refresh_existing_process(
+ proc_: &mut Process,
+ nb_cpus: u64,
+ now: u64,
+ refresh_kind: ProcessRefreshKind,
+) -> Option<bool> {
+ if let Some(handle) = proc_.get_handle() {
+ if get_start_time(handle) != proc_.start_time() {
+ sysinfo_debug!("owner changed for PID {}", proc_.pid());
+ // PID owner changed!
+ return None;
+ }
+ if !is_proc_running(handle) {
+ return Some(false);
}
- update_memory(entry);
- entry.update(refresh_kind, s.cpus.len() as u64, get_now());
- entry.updated = false;
- true
} else {
- false
+ return Some(false);
}
+ update_memory(proc_);
+ proc_.update(refresh_kind, nb_cpus, now);
+ proc_.updated = false;
+ Some(true)
}
#[allow(clippy::size_of_in_element_count)]
@@ -495,7 +550,7 @@ pub(crate) fn get_process_name(process: &SYSTEM_PROCESS_INFORMATION, process_id:
match process_id.0 {
0 => "Idle".to_owned(),
4 => "System".to_owned(),
- _ => format!("<no name> Process {}", process_id),
+ _ => format!("<no name> Process {process_id}"),
}
} else {
unsafe {
diff --git a/vendor/sysinfo/tests/code_checkers/docs.rs b/vendor/sysinfo/tests/code_checkers/docs.rs
index 918e64bb0..7720d2dcf 100644
--- a/vendor/sysinfo/tests/code_checkers/docs.rs
+++ b/vendor/sysinfo/tests/code_checkers/docs.rs
@@ -21,14 +21,9 @@ fn to_correct_name(s: &str) -> String {
}
fn check_md_doc_path(p: &Path, md_line: &str, ty_line: &str) -> bool {
- let parts = md_line.split("/").collect::<Vec<_>>();
+ let parts = md_line.split('/').collect::<Vec<_>>();
if let Some(md_name) = parts.last().and_then(|n| n.split(".md").next()) {
- if let Some(name) = ty_line
- .split_whitespace()
- .filter(|s| !s.is_empty())
- .skip(2)
- .next()
- {
+ if let Some(name) = ty_line.split_whitespace().filter(|s| !s.is_empty()).nth(2) {
if let Some(name) = name
.split('<')
.next()
@@ -50,11 +45,11 @@ fn check_md_doc_path(p: &Path, md_line: &str, ty_line: &str) -> bool {
return false;
}
}
- show_error(p, &format!("Cannot extract type name from `{}`", ty_line));
+ show_error(p, &format!("Cannot extract type name from `{ty_line}`"));
} else {
- show_error(p, &format!("Cannot extract md name from `{}`", md_line));
+ show_error(p, &format!("Cannot extract md name from `{md_line}`"));
}
- return false;
+ false
}
fn check_doc_comments_before(p: &Path, lines: &[&str], start: usize) -> bool {
diff --git a/vendor/sysinfo/tests/code_checkers/headers.rs b/vendor/sysinfo/tests/code_checkers/headers.rs
index ac7a34ddb..d66aa4202 100644
--- a/vendor/sysinfo/tests/code_checkers/headers.rs
+++ b/vendor/sysinfo/tests/code_checkers/headers.rs
@@ -19,7 +19,7 @@ pub fn check_license_header(content: &str, p: &Path) -> TestResult {
Some(s) => {
show_error(
p,
- &format!("Expected empty line after license header, found `{}`", s),
+ &format!("Expected empty line after license header, found `{s}`"),
);
TestResult {
nb_tests: 1,
diff --git a/vendor/sysinfo/tests/code_checkers/mod.rs b/vendor/sysinfo/tests/code_checkers/mod.rs
index f6012da95..db645341d 100644
--- a/vendor/sysinfo/tests/code_checkers/mod.rs
+++ b/vendor/sysinfo/tests/code_checkers/mod.rs
@@ -8,6 +8,7 @@ mod utils;
use std::path::Path;
use utils::TestResult;
+#[allow(clippy::type_complexity)]
const CHECKS: &[(fn(&str, &Path) -> TestResult, &[&str])] = &[
(headers::check_license_header, &["src", "tests", "examples"]),
(signals::check_signals, &["src"]),
diff --git a/vendor/sysinfo/tests/code_checkers/utils.rs b/vendor/sysinfo/tests/code_checkers/utils.rs
index dadbc0a54..893201961 100644
--- a/vendor/sysinfo/tests/code_checkers/utils.rs
+++ b/vendor/sysinfo/tests/code_checkers/utils.rs
@@ -45,5 +45,5 @@ fn read_file<P: AsRef<Path>>(p: P) -> String {
}
pub fn show_error(p: &Path, err: &str) {
- eprintln!("=> [{}]: {}", p.display(), err);
+ eprintln!("=> [{}]: {err}", p.display());
}
diff --git a/vendor/sysinfo/tests/process.rs b/vendor/sysinfo/tests/process.rs
index 6745fc444..2b88c7b24 100644
--- a/vendor/sysinfo/tests/process.rs
+++ b/vendor/sysinfo/tests/process.rs
@@ -11,7 +11,6 @@ fn test_process() {
return;
}
assert!(!s.processes().is_empty());
- #[cfg(not(windows))]
assert!(s
.processes()
.values()
@@ -39,7 +38,7 @@ fn test_cwd() {
.unwrap()
};
- let pid = Pid::from_u32(p.id() as u32);
+ let pid = Pid::from_u32(p.id() as _);
std::thread::sleep(std::time::Duration::from_secs(1));
let mut s = sysinfo::System::new();
s.refresh_processes();
@@ -82,7 +81,7 @@ fn test_cmd() {
s.refresh_processes();
p.kill().expect("Unable to kill process.");
assert!(!s.processes().is_empty());
- if let Some(process) = s.process(Pid::from_u32(p.id() as u32)) {
+ if let Some(process) = s.process(Pid::from_u32(p.id() as _)) {
if cfg!(target_os = "windows") {
// Sometimes, we get the full path instead for some reasons... So just in case,
// we check for the command independently that from the arguments.
@@ -121,7 +120,7 @@ fn test_environ() {
.unwrap()
};
- let pid = Pid::from_u32(p.id() as u32);
+ let pid = Pid::from_u32(p.id() as _);
std::thread::sleep(std::time::Duration::from_secs(1));
let mut s = sysinfo::System::new();
s.refresh_processes();
@@ -225,6 +224,8 @@ fn cpu_usage_is_not_nan() {
return;
}
+ // We need `collect` otherwise we can't have mutable access to `system`.
+ #[allow(clippy::needless_collect)]
let first_pids = system
.processes()
.iter()
@@ -266,7 +267,7 @@ fn test_process_times() {
.unwrap()
};
- let pid = Pid::from_u32(p.id() as u32);
+ let pid = Pid::from_u32(p.id() as _);
std::thread::sleep(std::time::Duration::from_secs(1));
let mut s = sysinfo::System::new();
s.refresh_processes();
@@ -314,7 +315,7 @@ fn test_refresh_processes() {
.unwrap()
};
- let pid = Pid::from_u32(p.id() as u32);
+ let pid = Pid::from_u32(p.id() as _);
std::thread::sleep(std::time::Duration::from_secs(1));
// Checks that the process is listed as it should.
@@ -358,7 +359,7 @@ fn test_refresh_process() {
.unwrap()
};
- let pid = Pid::from_u32(p.id() as u32);
+ let pid = Pid::from_u32(p.id() as _);
std::thread::sleep(std::time::Duration::from_secs(1));
// Checks that the process is listed as it should.
@@ -379,3 +380,78 @@ fn test_refresh_process() {
// Checks that the process is still listed.
assert!(s.process(pid).is_some());
}
+
+#[test]
+fn test_wait_child() {
+ if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") {
+ return;
+ }
+ let p = if cfg!(target_os = "windows") {
+ std::process::Command::new("waitfor")
+ .arg("/t")
+ .arg("300")
+ .arg("RefreshProcess")
+ .stdout(std::process::Stdio::null())
+ .spawn()
+ .unwrap()
+ } else {
+ std::process::Command::new("sleep")
+ .arg("300")
+ .stdout(std::process::Stdio::null())
+ .spawn()
+ .unwrap()
+ };
+
+ let before = std::time::Instant::now();
+ let pid = Pid::from_u32(p.id() as _);
+
+ let mut s = sysinfo::System::new();
+ s.refresh_process(pid);
+ let process = s.process(pid).unwrap();
+
+ // Kill the child process.
+ process.kill();
+ // Wait for child process should work.
+ process.wait();
+
+ // Child process should not be present.
+ assert!(!s.refresh_process(pid));
+ assert!(before.elapsed() < std::time::Duration::from_millis(1000));
+}
+
+#[test]
+fn test_wait_non_child() {
+ if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") {
+ return;
+ }
+
+ // spawn non child process.
+ let p = if !cfg!(target_os = "linux") {
+ return;
+ } else {
+ std::process::Command::new("setsid")
+ .arg("-w")
+ .arg("sleep")
+ .arg("2")
+ .stdout(std::process::Stdio::null())
+ .spawn()
+ .unwrap()
+ };
+ let pid = Pid::from_u32(p.id());
+
+ let before = std::time::Instant::now();
+
+ let mut s = sysinfo::System::new();
+ s.refresh_process(pid);
+ let process = s.process(pid).expect("Process not found!");
+
+ // Wait for a non child process.
+ process.wait();
+
+ // Child process should not be present.
+ assert!(!s.refresh_process(pid));
+
+ // should wait for 2s.
+ assert!(before.elapsed() > std::time::Duration::from_millis(2000));
+ assert!(before.elapsed() < std::time::Duration::from_millis(3000));
+}