diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
| commit | 698f8c2f01ea549d77d7dc3338a12e04c11057b9 (patch) | |
| tree | 173a775858bd501c378080a10dca74132f05bc50 /vendor/sysinfo | |
| parent | Initial commit. (diff) | |
| download | rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.tar.xz rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.zip | |
Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/sysinfo')
96 files changed, 18298 insertions, 0 deletions
diff --git a/vendor/sysinfo/.cargo-checksum.json b/vendor/sysinfo/.cargo-checksum.json new file mode 100644 index 000000000..f63622edd --- /dev/null +++ b/vendor/sysinfo/.cargo-checksum.json @@ -0,0 +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 diff --git a/vendor/sysinfo/ADDING_NEW_PLATFORMS.md b/vendor/sysinfo/ADDING_NEW_PLATFORMS.md new file mode 100644 index 000000000..4d9330a07 --- /dev/null +++ b/vendor/sysinfo/ADDING_NEW_PLATFORMS.md @@ -0,0 +1,8 @@ +To get the `target_os` etc: +``` +rustc --print cfg +``` + +In `src/lib.rs` add the matching based on the `cfg` data. + +Create `src/<new_platform>`. diff --git a/vendor/sysinfo/CHANGELOG.md b/vendor/sysinfo/CHANGELOG.md new file mode 100644 index 000000000..8a0defd4d --- /dev/null +++ b/vendor/sysinfo/CHANGELOG.md @@ -0,0 +1,421 @@ +# 0.24.2 + + * Windows: Fix CPU usage computation. + * Windows: Enable extra feature on `winapi`. + * macOS: Fix executable path retrieval. + +# 0.24.1 + + * Use `saturating_*` function for mathematical operations to prevent overflows/underflows. + +# 0.24.0 + + * Rename `Processor` into `Cpu` and `ProcessorExt` into `CpuExt`. + * Retrieve information about a process' owner. + * Add `SystemExt::get_user_by_id`. + * Add `ProcessExt::user_id`. + * Add `ProcessExt::group_id`. + * Add `user`-related methods to `ProcessRefreshKind`. + * Linux: Improve performance when creating new `Process` by improving retrieval of user ID and group ID. + +# 0.23.14 + + * Linux: Fix processes' virtual memory computation. + +# 0.23.13 + + * macOS/FreeBSD: Fix `System::refresh_process` and `System::refresh_process_specifics` returned value. + * Linux: Small performance improvement when updating process list. + +# 0.23.12 + + * Linux: Improve `System::refresh_cpu` performance. + * Fix clippy lints. + +# 0.23.11 + + * Add FreeBSD to the "supported OS" list + * Remove useless benchmark results + +# 0.23.10 + + * Improve documentation of `SystemExt::refresh_cpu`. + +# 0.23.9 + + * macOS: Fix disk retrieval + +# 0.23.8 + + * Windows: Fix underflow for `Process` run_time computation + +# 0.23.7 + + * macOS: Ignore non-root drive partitions + +# 0.23.6 + + * Windows: Fix process name retrieval + * Windows: Unify internal process creation methods + * FreeBSD: Simplify code for process update + +# 0.23.5 + + * Windows: Fix a bug which prevent all disks to be listed. + +# 0.23.4 + + * Linux (raspberry): Fix physical core count. + +# 0.23.3 + + * Impl `From<Pid>` for Pid inner type. + * Code cleanup. + +# 0.23.2 + + * Fix unsafe "correctness". + * Correctly handle `MaybeUninit::assume_init`. + +# 0.23.1 + + * Implement `Into` trait on `Pid` + * Add `#[repr(transparent)]` on `Pid` + * Clean up `refresh_process` and `refresh_processes`: only `refresh_processes` removes non-existing processes. + +# 0.23.0 + + * Linux: Fix process uptime. + * Rename `process_by_name` into `processes_by_name`. + * Rename `process_by_name_exact` into `processes_by_name_exact`. + * Change returned type of `process_by_name` and of `process_by_name_exact` into an iterator. + * Improved `Signal` documentation. + * Turned `Pid` type alias into a newtype. + +# 0.22.5 + + * Linux: Improve documentation on how processes queries are handled. + * FreeBSD: Fix type error for 32-bit (on i386, armv6, armv7, powerpc). + * Improve Pid type documentation. + * Add `SystemExt::process_by_exact_name` method. + * Add `SUPPORTED_SIGNALS` constant on `SystemExt`. + * Fix common type aliases. + * Implement `Display` for `Signal`. + +# 0.22.4 + + * Windows: Correctly handle COM initialization/deinitialization. + * Linux: Fix panic when changing the limit of open files. + +# 0.22.3 + + * FreeBSD: Take ZFS ARC value into account when computing used system memory. + * Add some missing `#[must_use]`. + +# 0.22.2 + + * FreeBSD: Improve memory information retrieval. + +# 0.22.1 + + * Remove forgotten debug. + +# 0.22.0 + + * Add FreeBSD support. + * Create `SystemExt::refresh_processes_specifics` and `SystemExt::refresh_process_specifics` methods. + * Update `ProcessExt::kill` API and add `ProcessExt::kill_with`. + * Add `ProcessExt::run_time`. + +# 0.21.2 + + * Unsupported targets: Fix build. + * Linux: Exclude rootfs disk type as well. + * Windows: Performance improvement by lazily creating queries. + +# 0.21.1 + + * Linux: Process CPU usage cannot go above maximum value (number of CPUs * 100) anymore. + * Linux: Improve processors update. + * Linux: Improve processes CPU usage computation speed. + +# 0.21.0 + + * Linux: Fix processes CPU computation (if `System::refresh_cpu` wasn't used). + * Fix build for unsupported targets. + * Make `ProcessStatus` enum unique for all platforms. + * Unify documentation over all platforms. + +# 0.20.5 + + * Linux: Prevented overflow in disk size computation (bug in `davfs2`). + * Fixed clippy lints + +# 0.20.4 + + * Update libc version, allowing to remove a lot of FFI bindings. + +# 0.20.3 + + * Windows: Reworked process information retrieval + * Windows: Fixed issue on `c_void` size. + * Improved documentation of `ProcessExt::environ`. + +# 0.20.2 + + * Windows: Added support for getting process' current working directory + * Windows: Added support for getting process' environment variables + * Removed more FFI bindings and replaced them with libc's. + +# 0.20.1 + + * macOS: Added better support for sandboxing. + * macOS: Added support for getting process current working directory. + * Added more explanations in crate level code example. + * Updated rayon version to 1.5.1. + +# 0.20.0 + + * macOS: Improved code readability. + * Windows: Prevented the `taskkill.exe` console window from appearing when using `kill`. + * Fixed benchmarks compilation issue. + * Upgraded minimum supported Rust version to 1.54. + * Removed doc-comment dependency. + * Merged README and crate documentation. + +# 0.19.2 + + * Windows: Fixed swap memory information computation. + +# 0.19.1 + + * Windows: Got swap memory information. + * Linux: Fixed memory information gathering (bad parsing of `/proc/meminfo`). + +# 0.19.0 + + * Renamed functions/methods to follow [Rust API guidelines on naming](https://rust-lang.github.io/api-guidelines/naming.html#getter-names-follow-rust-convention-c-getter). + * Linux: Set processes' executable path from command line if not found. + * Linux: Added extra information about `ProcessExt::name()`. + * macOS: Removed unneeded (re)import of CoreFoundation library at compile-time. + * Reworked `DiskType` enum: there is no more `Removable` variant, it's now set into the `Disk` struct. `DiskExt::is_removable` was added. + * Linux: Added support for removable disks. + * Linux: Ensured there's a value in `global_processor` frequency. + * Fixed tests to make them a bit less strict (which was problematic when run on VMs). + * Linux: Fixed CPU usage subtraction overflow. + +# 0.18.2 + + * macOS: Brand and vendor ID information were reversed. + * macOS: On Apple M1 processors, the vendor ID is empty, so instead we return "Apple". + * Added tests to ensure that the processors are always set after `System::new()`. + +# 0.18.1 + + * Added `SystemExt::IS_SUPPORTED` constant to allow to easily query if a system is supported or not. + * Used `SystemExt::IS_SUPPORTED` to fix tests on non-supported platforms and simplify others. + +# 0.18.0 + + * Improved documentation to make it more clear how to use the different information. + * Turned the `Signal` enum into a full rust one by removing the `#[repr(C)]` attribute on it. Each platform now implements its own conversion. + * Removed `Signal::Stklft` which wasn't used on any supported system. + * Linux: Added support for paravirtualized disks. + +# 0.17.5 + + * Improved network code: network interfaces were handled a bit differently depending on the platform, it is now unified. + +# 0.17.4 + + * Linux: fixed invalid network interface cleanup when an interface was removed from the system in `refresh_networks_list`. + * Added freebsd to CI runs. + * Added `cargo test` command for freebsd on CI. + * freebsd: Fixed build. + +# 0.17.3 + + * Removed manual FFI bindings in both Apple and Windows targets. + * Fixed C-interface compilation. + * Added information on how to add new platform. + +# 0.17.2 + + * Linux: fixed `System::refresh_process` return value. + +# 0.17.1 + + * Windows: fixed process CPU usage computation. + * Linux: improved CPU usage values on first query by returning 0: it now waits the second cycle before computing it to avoid abherent values. + * Linux: fixed process name retrieval by using `stat` information instead. + * Apple: only list local users. + +# 0.17.0 + + * Linux: fixed OS version retrieval by adding a fallback to `/etc/lsb-release`. + * iOS: fixed warnings. + * Renamed `ProcessStatus::to_string` method to `as_str`. + * macOS: fixed CPU usage computation. + +# 0.16.5 + + * Windows: Removed trailing NUL bytes in hostname. + * Added user ID and group ID. + +# 0.16.4 + + * macOS: Removed trailing NUL bytes in various values returned by the `sysctl` calls. + +# 0.16.3 + + * Updated minimum libc version to 0.2.86. + +# 0.16.2 + + * Fixed network values computation: replaced the simple arithmetic with `saturating_sub` and `saturating_add`. + * Converted values read in `/proc/meminfo` from KiB to KB (because contrary to what is said in the manual, they are in KiB, not in KB). + * macOS: Rewrote `get_disks` function to remove the Objective-C dependency. + * Added `SystemExt::get_long_os_version`. + * Linux: Fixed sequences for disks. + * Linux: Allowed `/run/media` as a mount path. + * Windows: Fixed disk size computation. + * Linux: Fixed virtual memory size computation. + +# 0.16.1 + + * Added support for Android. + * Added flag to remove APIs prohibited in Apple store. + +# 0.16.0 + + * Windows: show removeable drives on Windows. + * Switched to Rust 2018 edition. + * Split `SystemExt::get_version` into `SystemExt::get_kernel_version` and `SystemExt::get_os_version`. + * Windows: added support for `get_kernel_version` and `get_os_version`. + * Changed return type of `SystemExt::get_physical_core_count` from `usize` to `Option<usize>`. + * Added `SystemExt::get_physical_core_numbers`. + +# 0.15.9 + + * iOS: Fixed build. + * Fixed cross-compilation. + +# 0.15.8 + + * Apple: fixed Objective-C library imports. + +# 0.15.7 + + * Added `SystemExt::get_host_name`. + +# 0.15.6 + + * Upgraded `cfg-if` dependency version to `1.0`. + +# 0.15.5 + + * Added `SystemExt::get_name` and `SystemExt::get_version`. + * Added `multithread` feature, making the `rayon` dependency optional. + +# 0.15.4 + + * Apple: gig source code cleanup. + * Apple: improved disk handling. + * Removed manual FFI code and used libc's instead. + +# 0.15.3 + + * Prevented CPU value to be NaN. + +# 0.15.2 + + * macOS: fixed disk space computation. + +# 0.15.1 + + * Improved documentation. + * Extended example. + +# 0.15.0 + + * Added `SystemExt::get_available_memory`. + +# 0.14.15 + + * Linux: improved task source code. + +# 0.14.14 + + * macOS: renamed "CPU" into "CPU Die". + * macOS: added "CPU proximity" information. + +# 0.14.13 + + * Linux: improved process name retrieval. + +# 0.14.12 + + * Linux: fixed infinite recursion when gathering disk information. + +# 0.14.11 + + * Added iOS support. + +# 0.14.10 + + * Simplified `DiskType` handling by removing `From` implementation. + * Linux: fixed SSD/HDD detection. + +# 0.14.9 + + * Linux: fixed CPU usage computation. + * Windows: fixed load average constants. + +# 0.14.8 + + * Linux: fixed network information retrieval by replacing `usize` with `u64` because it was too small on 32 bits systems. + * Linux: get each core frequency. + +# 0.14.7 + + * Raspberry Pi: fixed temperature retrieval. + +# 0.14.6 + + * Linux: fixed infinite recursion when getting disk. + +# 0.14.5 + + * Strengthened cfg checks: use "linux" and "android" instead of "unix". + +# 0.14.4 + + * Linux: fixed memory usage computation. + +# 0.14.3 + + * Linux: fixed memory usage computation. + +# 0.14.2 + + * Windows: fixed CPU usage computation overflow. + * macOS: fixed CPU usage computation overflow. + * Windows: retrieved command line. + +# 0.14.1 + +* Removed empty disks. + +# 0.14.0 + + * Converted KiB to KB. + +# 0.13.4 + + * Code improvements. + +# 0.13.3 + + * Linux: fixed some issues on disks retrieval. + * Linux: fixed out-of-bound access in `boot_time`. + * Added benchmark on `Disk::refresh`. diff --git a/vendor/sysinfo/Cargo.lock b/vendor/sysinfo/Cargo.lock new file mode 100644 index 000000000..6d06a3fac --- /dev/null +++ b/vendor/sysinfo/Cargo.lock @@ -0,0 +1,294 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "autocfg" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "core-foundation-sys" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc" + +[[package]] +name = "crossbeam-channel" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4" +dependencies = [ + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e" +dependencies = [ + "cfg-if", + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd" +dependencies = [ + "cfg-if", + "crossbeam-utils", + "lazy_static", + "memoffset", + "scopeguard", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db" +dependencies = [ + "cfg-if", + "lazy_static", +] + +[[package]] +name = "either" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457" + +[[package]] +name = "getrandom" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.121" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f" + +[[package]] +name = "memoffset" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9" +dependencies = [ + "autocfg", +] + +[[package]] +name = "ntapi" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44" +dependencies = [ + "winapi", +] + +[[package]] +name = "num_cpus" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3" +dependencies = [ + "hermit-abi", + "libc", +] + +[[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" +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", +] + +[[package]] +name = "rayon" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90" +dependencies = [ + "autocfg", + "crossbeam-deque", + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e" +dependencies = [ + "crossbeam-channel", + "crossbeam-deque", + "crossbeam-utils", + "lazy_static", + "num_cpus", +] + +[[package]] +name = "redox_syscall" +version = "0.2.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff" +dependencies = [ + "bitflags", +] + +[[package]] +name = "remove_dir_all" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7" +dependencies = [ + "winapi", +] + +[[package]] +name = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "sysinfo" +version = "0.24.2" +dependencies = [ + "cfg-if", + "core-foundation-sys", + "libc", + "ntapi", + "once_cell", + "rayon", + "tempfile", + "winapi", +] + +[[package]] +name = "tempfile" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22" +dependencies = [ + "cfg-if", + "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" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" diff --git a/vendor/sysinfo/Cargo.toml b/vendor/sysinfo/Cargo.toml new file mode 100644 index 000000000..2dac4e344 --- /dev/null +++ b/vendor/sysinfo/Cargo.toml @@ -0,0 +1,101 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +rust-version = "1.54" +name = "sysinfo" +version = "0.24.2" +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" +categories = [ + "filesystem", + "os", + "api-bindings", +] +license = "MIT" +repository = "https://github.com/GuillaumeGomez/sysinfo" + +[lib] +name = "sysinfo" +crate_type = [ + "rlib", + "cdylib", +] + +[dependencies.cfg-if] +version = "1.0" + +[dependencies.once_cell] +version = "1.0" + +[dependencies.rayon] +version = "^1.5.1" +optional = true + +[features] +apple-app-store = ["apple-sandbox"] +apple-sandbox = [] +c-interface = [] +debug = ["libc/extra_traits"] +default = ["multithread"] +multithread = ["rayon"] +unknown-ci = [] + +[target."cfg(all(target_os = \"linux\", not(target_os = \"android\")))".dev-dependencies.tempfile] +version = "3.2" + +[target."cfg(any(target_os = \"macos\", target_os = \"ios\"))".dependencies.core-foundation-sys] +version = "0.8" + +[target."cfg(not(any(target_os = \"unknown\", target_arch = \"wasm32\")))".dependencies.libc] +version = "^0.2.112" + +[target."cfg(windows)".dependencies.ntapi] +version = "0.3" + +[target."cfg(windows)".dependencies.winapi] +version = "0.3.9" +features = [ + "errhandlingapi", + "fileapi", + "handleapi", + "heapapi", + "ifdef", + "ioapiset", + "minwindef", + "pdh", + "psapi", + "synchapi", + "sysinfoapi", + "winbase", + "winerror", + "winioctl", + "winnt", + "oleauto", + "wbemcli", + "rpcdce", + "combaseapi", + "objidl", + "powerbase", + "netioapi", + "lmcons", + "lmaccess", + "lmapibuf", + "memoryapi", + "ntlsa", + "securitybaseapi", + "shellapi", + "std", +] diff --git a/vendor/sysinfo/LICENSE b/vendor/sysinfo/LICENSE new file mode 100644 index 000000000..04d6c8eaa --- /dev/null +++ b/vendor/sysinfo/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Guillaume Gomez + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/vendor/sysinfo/Makefile b/vendor/sysinfo/Makefile new file mode 100644 index 000000000..0dc114ce8 --- /dev/null +++ b/vendor/sysinfo/Makefile @@ -0,0 +1,45 @@ +# +# Sysinfo +# +# Copyright (c) 2017 Guillaume Gomez +# + +# +# Please note that this Makefile only generates the c example. +# + +IDIR = ./src +CC = gcc +CFLAGS = -I$(IDIR) + +ODIR = examples/ +LDIR = ./target/debug/ +LDIR-RELEASE = ./target/release/ + +LIBS = -lsysinfo -lpthread + +_DEPS = sysinfo.h +DEPS = $(patsubst %,$(IDIR)/%,$(_DEPS)) + +_OBJ = simple.o +OBJ = $(patsubst %,$(ODIR)/%,$(_OBJ)) + + +simple: $(OBJ) + @echo "Compiling in debug mode" + cargo build --features=c-interface + gcc -o $@ $^ $(CFLAGS) -L$(LDIR) $(LIBS) + +release: $(OBJ) + @echo "Compiling in release mode" + cargo build --features=c-interface --release + gcc -o simple $^ $(CFLAGS) -L$(LDIR-RELEASE) $(LIBS) + +$(ODIR)/%.o: %.c $(DEPS) + $(CC) -c -o $@ $< $(CFLAGS) + +.PHONY: simple + +clean: + @echo "Cleaning mess" + rm -f $(ODIR)/*.o *~ core $(INCDIR)/*~ diff --git a/vendor/sysinfo/README.md b/vendor/sysinfo/README.md new file mode 100644 index 000000000..a58fb10e5 --- /dev/null +++ b/vendor/sysinfo/README.md @@ -0,0 +1,174 @@ +# sysinfo ![img_github_ci] [![][img_crates]][crates] [![][img_doc]][doc] + +`sysinfo` is a crate used to get a system's information. + +## Supported Oses + +It currently supports the following OSes (alphabetically sorted): + + * Android + * FreeBSD + * iOS + * Linux + * macOS + * Raspberry Pi + * Windows + +You can still use `sysinfo` on non-supported OSes, it'll simply do nothing and always return +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**. + +## Usage + +⚠️ Before any attempt to read the different structs' information, you need to update them to +get up-to-date information because for most of them, it works on diff between the current value +and the old one. + +Which is why, it's much better to keep the same instance of [`System`] around instead of +recreating it multiple times. + +You have an example into the `examples` folder. You can run it with `cargo run --example simple`. + +Otherwise, here is a little code sample: + +```rust +use sysinfo::{NetworkExt, NetworksExt, ProcessExt, System, SystemExt}; + +// Please note that we use "new_all" to ensure that all list of +// components, network interfaces, disks and users are already +// filled! +let mut sys = System::new_all(); + +// First we update all information of our `System` struct. +sys.refresh_all(); + +// We display all disks' information: +println!("=> disks:"); +for disk in sys.disks() { + println!("{:?}", disk); +} + +// Network interfaces name, data received and data transmitted: +println!("=> networks:"); +for (interface_name, data) in sys.networks() { + println!("{}: {}/{} B", interface_name, data.received(), data.transmitted()); +} + +// Components temperature: +println!("=> components:"); +for component in sys.components() { + println!("{:?}", component); +} + +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()); + +// Display system information: +println!("System name: {:?}", sys.name()); +println!("System kernel version: {:?}", sys.kernel_version()); +println!("System OS version: {:?}", sys.os_version()); +println!("System host name: {:?}", sys.host_name()); + +// Number of CPUs: +println!("NB CPUs: {}", sys.cpus().len()); + +// Display processes ID, name na disk usage: +for (pid, process) in sys.processes() { + println!("[{}] {} {:?}", pid, process.name(), process.disk_usage()); +} + +``` + +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). + +### Running on Raspberry Pi + +It'll be difficult to build on Raspberry Pi. A good way-around is to cross-build, then send the +executable to your Raspberry Pi. + +First install the arm toolchain, for example on Ubuntu: + +```bash +> sudo apt-get install gcc-multilib-arm-linux-gnueabihf +``` + +Then configure cargo to use the corresponding toolchain: + +```bash +cat << EOF > ~/.cargo/config +[target.armv7-unknown-linux-gnueabihf] +linker = "arm-linux-gnueabihf-gcc" +EOF +``` + +Finally, cross compile: + +```bash +rustup target add armv7-unknown-linux-gnueabihf +cargo build --target=armv7-unknown-linux-gnueabihf +``` + +### Linux on Docker & Windows Subsystem for Linux (WSL) + +Virtual Linux systems, such as those run through Docker and Windows Subsystem for Linux (WSL), do +not receive host hardware information via `/sys/class/hwmon` or `/sys/class/thermal`. As such, +querying for components may return no results (or unexpected results) when using this library on +virtual systems. + +### Use in binaries running inside the macOS or iOS Sandbox/stores + +Apple has restrictions as to which APIs can be linked into binaries that are distributed through the app store. +By default, `sysinfo` is not compatible with these restrictions. You can use the `apple-app-store` +feature flag to disable the Apple prohibited features. This also enables the `apple-sandbox` feature. +In the case of applications using the sandbox outside of the app store, the `apple-sandbox` feature +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. + +[sysinfo-blog]: https://blog.guillaume-gomez.fr/articles/2021-09-06+sysinfo%3A+how+to+extract+systems%27+information + +### C interface + +It's possible to use this crate directly from C. Take a look at the `Makefile` and at the +`examples/simple.c` file. + +To build the C example, just run: + +```bash +> make +> ./simple +# If needed: +> LD_LIBRARY_PATH=target/release/ ./simple +``` + +### Benchmarks + +You can run the benchmarks locally with rust **nightly** by doing: + +```bash +> cargo bench +``` + +## Donations + +If you appreciate my work and want to support me, you can do it with +[github sponsors](https://github.com/sponsors/GuillaumeGomez) or with +[patreon](https://www.patreon.com/GuillaumeGomez). + +[img_github_ci]: https://github.com/GuillaumeGomez/sysinfo/workflows/CI/badge.svg +[img_crates]: https://img.shields.io/crates/v/sysinfo.svg +[img_doc]: https://img.shields.io/badge/rust-documentation-blue.svg + +[crates]: https://crates.io/crates/sysinfo +[doc]: https://docs.rs/sysinfo/ diff --git a/vendor/sysinfo/benches/basic.rs b/vendor/sysinfo/benches/basic.rs new file mode 100644 index 000000000..a9771e740 --- /dev/null +++ b/vendor/sysinfo/benches/basic.rs @@ -0,0 +1,161 @@ +#![feature(test)] + +extern crate test; + +use sysinfo::get_current_pid; +use sysinfo::{DiskExt, SystemExt}; + +#[bench] +fn bench_new(b: &mut test::Bencher) { + b.iter(|| { + sysinfo::System::new(); + }); +} + +#[bench] +fn bench_new_all(b: &mut test::Bencher) { + b.iter(|| { + sysinfo::System::new_all(); + }); +} + +#[bench] +fn bench_refresh_all(b: &mut test::Bencher) { + let mut s = sysinfo::System::new_all(); + + b.iter(move || { + s.refresh_all(); + }); +} + +#[bench] +fn bench_refresh_system(b: &mut test::Bencher) { + let mut s = sysinfo::System::new_all(); + + s.refresh_system(); + b.iter(move || { + s.refresh_system(); + }); +} + +#[bench] +fn bench_refresh_processes(b: &mut test::Bencher) { + let mut s = sysinfo::System::new(); + + s.refresh_processes(); // to load the whole processes list a first time. + b.iter(move || { + s.refresh_processes(); + }); +} + +#[bench] +fn bench_first_refresh_processes(b: &mut test::Bencher) { + b.iter(move || { + let mut s = sysinfo::System::new(); + s.refresh_processes(); + }); +} + +#[bench] +fn bench_refresh_process(b: &mut test::Bencher) { + let mut s = sysinfo::System::new(); + + s.refresh_all(); + // to be sure it'll exist for at least as long as we run + let pid = get_current_pid().expect("failed to get current pid"); + b.iter(move || { + s.refresh_process(pid); + }); +} + +#[bench] +fn bench_refresh_disk(b: &mut test::Bencher) { + let mut s = sysinfo::System::new_all(); + + let disks = s.disks_mut(); + let disk = &mut disks[0]; + b.iter(move || { + disk.refresh(); + }); +} + +#[bench] +fn bench_refresh_disks(b: &mut test::Bencher) { + let mut s = sysinfo::System::new_all(); + + b.iter(move || { + s.refresh_disks(); + }); +} + +#[bench] +fn bench_refresh_disks_list(b: &mut test::Bencher) { + let mut s = sysinfo::System::new(); + + b.iter(move || { + s.refresh_disks_list(); + }); +} + +#[bench] +fn bench_refresh_networks(b: &mut test::Bencher) { + let mut s = sysinfo::System::new_all(); + + b.iter(move || { + s.refresh_networks(); + }); +} + +#[bench] +fn bench_refresh_networks_list(b: &mut test::Bencher) { + let mut s = sysinfo::System::new(); + + b.iter(move || { + s.refresh_networks_list(); + }); +} + +#[bench] +fn bench_refresh_memory(b: &mut test::Bencher) { + let mut s = sysinfo::System::new(); + + b.iter(move || { + s.refresh_memory(); + }); +} + +#[bench] +fn bench_refresh_cpu(b: &mut test::Bencher) { + let mut s = sysinfo::System::new(); + + b.iter(move || { + s.refresh_cpu(); + }); +} + +#[bench] +fn bench_refresh_components(b: &mut test::Bencher) { + let mut s = sysinfo::System::new_all(); + + b.iter(move || { + s.refresh_components(); + }); +} + +#[bench] +fn bench_refresh_components_list(b: &mut test::Bencher) { + let mut s = sysinfo::System::new_all(); + + b.iter(move || { + s.refresh_components_list(); + }); +} + +#[bench] +fn bench_refresh_users_list(b: &mut test::Bencher) { + let mut s = sysinfo::System::new_all(); + + b.iter(move || { + s.refresh_users_list(); + }); +} diff --git a/vendor/sysinfo/build.rs b/vendor/sysinfo/build.rs new file mode 100644 index 000000000..437300934 --- /dev/null +++ b/vendor/sysinfo/build.rs @@ -0,0 +1,19 @@ +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.c b/vendor/sysinfo/examples/simple.c new file mode 100644 index 000000000..28a23beef --- /dev/null +++ b/vendor/sysinfo/examples/simple.c @@ -0,0 +1,86 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <unistd.h> +#include <pthread.h> +#include "sysinfo.h" + +void print_process(CProcess process) { + RString exe = sysinfo_process_get_executable_path(process); + printf("process[%d]: parent: %d,\n" + " cpu_usage: %f,\n" + " memory: %ld,\n" + " virtual memory: %ld,\n" + " executable path: '%s'\n", + sysinfo_process_get_pid(process), + sysinfo_process_get_parent_pid(process), + sysinfo_process_get_cpu_usage(process), + sysinfo_process_get_memory(process), + sysinfo_process_get_virtual_memory(process), + exe); + sysinfo_rstring_free(exe); +} + +void check_tasks(CSystem system) { +#ifdef __linux__ + bool task_loop(pid_t pid, CProcess process, void *data) { + (void)data; + printf(" "); + print_process(process); + return true; + } + + void *sleeping_func(void *data) { + sleep(3); + return data; + } + pthread_t thread; + pthread_create(&thread, NULL, sleeping_func, NULL); + sysinfo_refresh_system(system); + CProcess process = sysinfo_get_process_by_pid(system, getpid()); + printf("\n== Task(s) for current process: ==\n"); + print_process(process); + printf("Got %ld task(s)\n", sysinfo_process_get_tasks(process, task_loop, NULL)); +#else + (void)system; +#endif +} + +bool process_loop(pid_t pid, CProcess process, void *data) { + unsigned int *i = data; + + print_process(process); + *i += 1; + return *i < 10; +} + +int main() { + CSystem system = sysinfo_init(); + sysinfo_refresh_all(system); + printf("total memory: %ld\n", sysinfo_get_total_memory(system)); + printf("free memory: %ld\n", sysinfo_get_free_memory(system)); + printf("used memory: %ld\n", sysinfo_get_used_memory(system)); + printf("total swap: %ld\n", sysinfo_get_total_swap(system)); + printf("free swap: %ld\n", sysinfo_get_free_swap(system)); + printf("used swap: %ld\n", sysinfo_get_used_swap(system)); + printf("networks received: %ld\n", sysinfo_get_networks_received(system)); + printf("networks transmitted: %ld\n", sysinfo_get_networks_transmitted(system)); + unsigned int len = 0, i = 0; + float *procs = NULL; + sysinfo_get_cpus_usage(system, &len, &procs); + while (i < len) { + printf("CPU #%d usage: %f%%\n", i, procs[i]); + i += 1; + } + free(procs); + + // processes part + i = 0; + printf("For a total of %ld processes.\n", sysinfo_get_processes(system, process_loop, &i)); + check_tasks(system); + // we can now free the CSystem object. + sysinfo_destroy(system); + return 0; +} diff --git a/vendor/sysinfo/examples/simple.rs b/vendor/sysinfo/examples/simple.rs new file mode 100644 index 000000000..43115b007 --- /dev/null +++ b/vendor/sysinfo/examples/simple.rs @@ -0,0 +1,431 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#![crate_type = "bin"] +#![allow(unused_must_use, non_upper_case_globals)] + +extern crate sysinfo; + +use std::io::{self, BufRead, Write}; +use std::str::FromStr; +use sysinfo::Signal::*; +use sysinfo::{ + CpuExt, NetworkExt, NetworksExt, Pid, ProcessExt, Signal, System, SystemExt, UserExt, +}; + +const signals: &[Signal] = &[ + Hangup, + Interrupt, + Quit, + Illegal, + Trap, + Abort, + Bus, + FloatingPointException, + Kill, + User1, + Segv, + User2, + Pipe, + Alarm, + Term, + Child, + Continue, + Stop, + TSTP, + TTIN, + TTOU, + Urgent, + XCPU, + XFSZ, + VirtualAlarm, + Profiling, + Winch, + IO, + Power, + Sys, +]; + +fn print_help() { + writeln!(&mut io::stdout(), "== Help menu =="); + writeln!(&mut io::stdout(), "help : show this menu"); + writeln!( + &mut io::stdout(), + "signals : show the available signals" + ); + writeln!( + &mut io::stdout(), + "refresh : reloads all processes' information" + ); + writeln!( + &mut io::stdout(), + "refresh [pid] : reloads corresponding process' information" + ); + writeln!( + &mut io::stdout(), + "refresh_disks : reloads only disks' information" + ); + writeln!( + &mut io::stdout(), + "refresh_users : reloads only users' information" + ); + writeln!( + &mut io::stdout(), + "show [pid | name] : show information of the given process \ + corresponding to [pid | name]" + ); + writeln!( + &mut io::stdout(), + "kill [pid] [signal]: send [signal] to the process with this \ + [pid]. 0 < [signal] < 32" + ); + writeln!( + &mut io::stdout(), + "cpus : Displays CPUs state" + ); + writeln!( + &mut io::stdout(), + "memory : Displays memory state" + ); + writeln!( + &mut io::stdout(), + "temperature : Displays components' temperature" + ); + writeln!( + &mut io::stdout(), + "disks : Displays disks' information" + ); + writeln!( + &mut io::stdout(), + "network : Displays network' information" + ); + writeln!( + &mut io::stdout(), + "all : Displays all process name and pid" + ); + writeln!( + &mut io::stdout(), + "uptime : Displays system uptime" + ); + writeln!( + &mut io::stdout(), + "boot_time : Displays system boot time" + ); + writeln!( + &mut io::stdout(), + "vendor_id : Displays CPU vendor id" + ); + writeln!(&mut io::stdout(), "brand : Displays CPU brand"); + writeln!( + &mut io::stdout(), + "load_avg : Displays system load average" + ); + writeln!( + &mut io::stdout(), + "frequency : Displays CPU frequency" + ); + writeln!(&mut io::stdout(), "users : Displays all users"); + writeln!( + &mut io::stdout(), + "system : Displays system information (such as name, version and hostname)" + ); + writeln!( + &mut io::stdout(), + "pid : Display this example's PID" + ); + writeln!(&mut io::stdout(), "quit : Exit the program"); +} + +fn interpret_input(input: &str, sys: &mut System) -> bool { + match input.trim() { + "help" => print_help(), + "refresh_disks" => { + writeln!(&mut io::stdout(), "Refreshing disk list..."); + sys.refresh_disks_list(); + writeln!(&mut io::stdout(), "Done."); + } + "refresh_users" => { + writeln!(&mut io::stdout(), "Refreshing user list..."); + sys.refresh_users_list(); + writeln!(&mut io::stdout(), "Done."); + } + "signals" => { + let mut nb = 1i32; + + for sig in signals { + writeln!(&mut io::stdout(), "{:2}:{:?}", nb, sig); + nb += 1; + } + } + "cpus" => { + // Note: you should refresh a few times before using this, so that usage statistics + // can be ascertained + writeln!( + &mut io::stdout(), + "number of physical cores: {}", + sys.physical_core_count() + .map(|c| c.to_string()) + .unwrap_or_else(|| "Unknown".to_owned()), + ); + writeln!( + &mut io::stdout(), + "total process usage: {}%", + sys.global_cpu_info().cpu_usage() + ); + for proc_ in sys.cpus() { + 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()); + } + "quit" | "exit" => return true, + "all" => { + for (pid, proc_) in sys.processes() { + writeln!( + &mut io::stdout(), + "{}:{} status={:?}", + pid, + proc_.name(), + proc_.status() + ); + } + } + "frequency" => { + writeln!( + &mut io::stdout(), + "{} MHz", + sys.global_cpu_info().frequency() + ); + } + "vendor_id" => { + writeln!( + &mut io::stdout(), + "vendor ID: {}", + sys.cpus()[0].vendor_id() + ); + } + "brand" => { + writeln!(&mut io::stdout(), "brand: {}", sys.cpus()[0].brand()); + } + "load_avg" => { + let load_avg = sys.load_average(); + writeln!(&mut io::stdout(), "one minute : {}%", load_avg.one); + writeln!(&mut io::stdout(), "five minutes : {}%", load_avg.five); + writeln!(&mut io::stdout(), "fifteen minutes: {}%", load_avg.fifteen); + } + e if e.starts_with("show ") => { + let tmp: Vec<&str> = e.split(' ').collect(); + + if tmp.len() != 2 { + writeln!( + &mut io::stdout(), + "show command takes a pid or a name in parameter!" + ); + writeln!(&mut io::stdout(), "example: show 1254"); + } 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), + }; + } 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_); + } + } + } + "temperature" => { + for component in sys.components() { + writeln!(&mut io::stdout(), "{:?}", component); + } + } + "network" => { + for (interface_name, data) in sys.networks().iter() { + writeln!( + &mut io::stdout(), + "{}:\n input data (new / total): {} / {} B\n output data (new / total): {} / {} B", + interface_name, + data.received(), + data.total_received(), + data.transmitted(), + data.total_transmitted(), + ); + } + } + "show" => { + writeln!( + &mut io::stdout(), + "'show' command expects a pid number or a process name" + ); + } + e if e.starts_with("kill ") => { + let tmp: Vec<&str> = e.split(' ').collect(); + + if tmp.len() != 3 { + writeln!( + &mut io::stdout(), + "kill command takes the pid and a signal number in parameter!" + ); + writeln!(&mut io::stdout(), "example: kill 1254 9"); + } else { + let pid = Pid::from_str(tmp[1]).unwrap(); + let signal = i32::from_str(tmp[2]).unwrap(); + + if signal < 1 || signal > 31 { + writeln!( + &mut io::stdout(), + "Signal must be between 0 and 32 ! See the signals list with the \ + signals command" + ); + } else { + match sys.process(pid) { + Some(p) => { + if let Some(res) = + p.kill_with(*signals.get(signal as usize - 1).unwrap()) + { + writeln!(&mut io::stdout(), "kill: {}", res,); + } else { + writeln!( + &mut io::stdout(), + "kill: signal not supported on this platform" + ); + } + } + None => { + writeln!(&mut io::stdout(), "pid not found"); + } + }; + } + } + } + "disks" => { + for disk in sys.disks() { + writeln!(&mut io::stdout(), "{:?}", disk); + } + } + "users" => { + for user in sys.users() { + writeln!(&mut io::stdout(), "{:?}", user.name()); + } + } + "boot_time" => { + writeln!(&mut io::stdout(), "{} seconds", sys.boot_time()); + } + "uptime" => { + let up = sys.uptime(); + let mut uptime = sys.uptime(); + let days = uptime / 86400; + uptime -= days * 86400; + let hours = uptime / 3600; + uptime -= hours * 3600; + let minutes = uptime / 60; + writeln!( + &mut io::stdout(), + "{} days {} hours {} minutes ({} seconds in total)", + days, + hours, + minutes, + up, + ); + } + x if x.starts_with("refresh") => { + if x == "refresh" { + writeln!(&mut io::stdout(), "Getting processes' information..."); + sys.refresh_all(); + writeln!(&mut io::stdout(), "Done."); + } else if x.starts_with("refresh ") { + writeln!(&mut io::stdout(), "Getting process' information..."); + if let Some(pid) = x + .split(' ') + .filter_map(|pid| pid.parse().ok()) + .take(1) + .next() + { + if sys.refresh_process(pid) { + writeln!(&mut io::stdout(), "Process `{}` updated successfully", pid); + } else { + writeln!( + &mut io::stdout(), + "Process `{}` couldn't be updated...", + pid + ); + } + } else { + writeln!(&mut io::stdout(), "Invalid [pid] received..."); + } + } else { + writeln!( + &mut io::stdout(), + "\"{}\": Unknown command. Enter 'help' if you want to get the commands' \ + list.", + x + ); + } + } + "pid" => { + writeln!( + &mut io::stdout(), + "PID: {}", + sysinfo::get_current_pid().expect("failed to get PID") + ); + } + "system" => { + writeln!( + &mut io::stdout(), + "System name: {}\n\ + System kernel version: {}\n\ + System OS version: {}\n\ + System OS (long) version: {}\n\ + System host name: {}", + sys.name().unwrap_or_else(|| "<unknown>".to_owned()), + sys.kernel_version() + .unwrap_or_else(|| "<unknown>".to_owned()), + sys.os_version().unwrap_or_else(|| "<unknown>".to_owned()), + sys.long_os_version() + .unwrap_or_else(|| "<unknown>".to_owned()), + sys.host_name().unwrap_or_else(|| "<unknown>".to_owned()), + ); + } + e => { + writeln!( + &mut io::stdout(), + "\"{}\": Unknown command. Enter 'help' if you want to get the commands' \ + list.", + e + ); + } + } + false +} + +fn main() { + println!("Getting processes' information..."); + let mut t = System::new_all(); + println!("Done."); + let t_stin = io::stdin(); + let mut stin = t_stin.lock(); + let mut done = false; + + println!("To get the commands' list, enter 'help'."); + while !done { + let mut input = String::new(); + write!(&mut io::stdout(), "> "); + io::stdout().flush(); + + stin.read_line(&mut input); + if input.is_empty() { + // The string is empty, meaning there is no '\n', meaning + // that the user used CTRL+D so we can just quit! + println!("\nLeaving, bye!"); + break; + } + if (&input as &str).ends_with('\n') { + input.pop(); + } + done = interpret_input(input.as_ref(), &mut t); + } +} diff --git a/vendor/sysinfo/md_doc/component.md b/vendor/sysinfo/md_doc/component.md new file mode 100644 index 000000000..618cace2f --- /dev/null +++ b/vendor/sysinfo/md_doc/component.md @@ -0,0 +1,16 @@ +Struct containing a component information (temperature and name for the moment). + +## Linux + +More information can be found at [kernel.org][k]. + +Note: these may not be present on virtual Linux systems, such as **Docker** +or **Windows Subsystem for Linux**. These hosts do not expose this information +and therefore `Component` elements may be missing or not as expected. + +[k]: https://www.kernel.org/doc/Documentation/hwmon/sysfs-interface + +## Windows + +Please note that on Windows, you need to have Administrator priviledges to get this +information. diff --git a/vendor/sysinfo/md_doc/cpu.md b/vendor/sysinfo/md_doc/cpu.md new file mode 100644 index 000000000..6281e0980 --- /dev/null +++ b/vendor/sysinfo/md_doc/cpu.md @@ -0,0 +1 @@ +Struct containing information of a CPU. diff --git a/vendor/sysinfo/md_doc/disk.md b/vendor/sysinfo/md_doc/disk.md new file mode 100644 index 000000000..f94b7c1b8 --- /dev/null +++ b/vendor/sysinfo/md_doc/disk.md @@ -0,0 +1 @@ +Struct containing a disk information. diff --git a/vendor/sysinfo/md_doc/network_data.md b/vendor/sysinfo/md_doc/network_data.md new file mode 100644 index 000000000..070794948 --- /dev/null +++ b/vendor/sysinfo/md_doc/network_data.md @@ -0,0 +1 @@ +Contains network interface information. diff --git a/vendor/sysinfo/md_doc/networks.md b/vendor/sysinfo/md_doc/networks.md new file mode 100644 index 000000000..d8b6cc632 --- /dev/null +++ b/vendor/sysinfo/md_doc/networks.md @@ -0,0 +1,8 @@ +Networks interfaces. + +```no_run +use sysinfo::{NetworksExt, System, SystemExt}; + +let s = System::new_all(); +let networks = s.networks(); +``` diff --git a/vendor/sysinfo/md_doc/pid.md b/vendor/sysinfo/md_doc/pid.md new file mode 100644 index 000000000..d80e1ab9f --- /dev/null +++ b/vendor/sysinfo/md_doc/pid.md @@ -0,0 +1,20 @@ +Process id + +Can be used as an integer type by simple casting. For example: + +``` +use sysinfo::{PidExt, Pid}; + +// 0's type will be different depending on the platform! +let p = Pid::from(0); + +// For something more "general": +let p = Pid::from_u32(0); +let i: u32 = p.as_u32(); +``` + +On glibc systems this is a glibc [`pid_t`](https://www.gnu.org/software/libc/manual/html_node/Process-Identification.html). + +On Windows systems this is a [`usize` and represents a windows process identifier](https://docs.microsoft.com/en-us/windows/win32/procthread/process-handles-and-identifiers). + +On unsupported systems, this is also a `usize`. diff --git a/vendor/sysinfo/md_doc/process.md b/vendor/sysinfo/md_doc/process.md new file mode 100644 index 000000000..0b7f9f7f7 --- /dev/null +++ b/vendor/sysinfo/md_doc/process.md @@ -0,0 +1,10 @@ +Struct containing information of a process. + +## iOS + +This information cannot be retrieved on iOS due to sandboxing. + +## Apple app store + +If you are building a macOS Apple app store, it won't be able +to retrieve this information. diff --git a/vendor/sysinfo/md_doc/system.md b/vendor/sysinfo/md_doc/system.md new file mode 100644 index 000000000..faf50b915 --- /dev/null +++ b/vendor/sysinfo/md_doc/system.md @@ -0,0 +1 @@ +Structs containing system's information. diff --git a/vendor/sysinfo/src/apple/app_store/component.rs b/vendor/sysinfo/src/apple/app_store/component.rs new file mode 100644 index 000000000..914fc9406 --- /dev/null +++ b/vendor/sysinfo/src/apple/app_store/component.rs @@ -0,0 +1,26 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::ComponentExt; + +#[doc = include_str!("../../../md_doc/component.md")] +pub struct Component {} + +impl ComponentExt for Component { + fn temperature(&self) -> f32 { + 0.0 + } + + fn max(&self) -> f32 { + 0.0 + } + + fn critical(&self) -> Option<f32> { + None + } + + fn label(&self) -> &str { + "" + } + + fn refresh(&mut self) {} +} diff --git a/vendor/sysinfo/src/apple/app_store/mod.rs b/vendor/sysinfo/src/apple/app_store/mod.rs new file mode 100644 index 000000000..0df24cabf --- /dev/null +++ b/vendor/sysinfo/src/apple/app_store/mod.rs @@ -0,0 +1,4 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +pub mod component; +pub mod process; diff --git a/vendor/sysinfo/src/apple/app_store/process.rs b/vendor/sysinfo/src/apple/app_store/process.rs new file mode 100644 index 000000000..8c3348ee9 --- /dev/null +++ b/vendor/sysinfo/src/apple/app_store/process.rs @@ -0,0 +1,82 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::path::Path; + +use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessStatus, Signal, Uid}; + +#[doc = include_str!("../../../md_doc/process.md")] +pub struct Process; + +impl ProcessExt for Process { + fn kill_with(&self, _signal: Signal) -> Option<bool> { + None + } + + fn name(&self) -> &str { + "" + } + + fn cmd(&self) -> &[String] { + &[] + } + + fn exe(&self) -> &Path { + Path::new("/") + } + + fn pid(&self) -> Pid { + Pid(0) + } + + fn environ(&self) -> &[String] { + &[] + } + + fn cwd(&self) -> &Path { + Path::new("/") + } + + fn root(&self) -> &Path { + Path::new("/") + } + + fn memory(&self) -> u64 { + 0 + } + + fn virtual_memory(&self) -> u64 { + 0 + } + + fn parent(&self) -> Option<Pid> { + None + } + + fn status(&self) -> ProcessStatus { + ProcessStatus::Unknown(0) + } + + fn start_time(&self) -> u64 { + 0 + } + + fn run_time(&self) -> u64 { + 0 + } + + fn cpu_usage(&self) -> f32 { + 0.0 + } + + fn disk_usage(&self) -> DiskUsage { + DiskUsage::default() + } + + fn user_id(&self) -> Option<&Uid> { + None + } + + fn group_id(&self) -> Option<Gid> { + None + } +} diff --git a/vendor/sysinfo/src/apple/component.rs b/vendor/sysinfo/src/apple/component.rs new file mode 100644 index 000000000..7c4196e72 --- /dev/null +++ b/vendor/sysinfo/src/apple/component.rs @@ -0,0 +1,3 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +pub use crate::sys::inner::component::*; diff --git a/vendor/sysinfo/src/apple/cpu.rs b/vendor/sysinfo/src/apple/cpu.rs new file mode 100644 index 000000000..b1068e971 --- /dev/null +++ b/vendor/sysinfo/src/apple/cpu.rs @@ -0,0 +1,331 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::sys::system::get_sys_value; + +use crate::{CpuExt, CpuRefreshKind}; + +use libc::{c_char, host_processor_info, mach_task_self}; +use std::mem; +use std::ops::Deref; +use std::sync::Arc; + +pub(crate) struct UnsafePtr<T>(*mut T); + +unsafe impl<T> Send for UnsafePtr<T> {} +unsafe impl<T> Sync for UnsafePtr<T> {} + +impl<T> Deref for UnsafePtr<T> { + type Target = *mut T; + + fn deref(&self) -> &*mut T { + &self.0 + } +} + +pub(crate) struct CpuData { + pub cpu_info: UnsafePtr<i32>, + pub num_cpu_info: u32, +} + +impl CpuData { + pub fn new(cpu_info: *mut i32, num_cpu_info: u32) -> CpuData { + CpuData { + cpu_info: UnsafePtr(cpu_info), + num_cpu_info, + } + } +} + +impl Drop for CpuData { + fn drop(&mut self) { + if !self.cpu_info.0.is_null() { + let prev_cpu_info_size = std::mem::size_of::<i32>() as u32 * self.num_cpu_info; + unsafe { + libc::vm_deallocate( + mach_task_self(), + self.cpu_info.0 as _, + prev_cpu_info_size as _, + ); + } + self.cpu_info.0 = std::ptr::null_mut(); + } + } +} + +#[doc = include_str!("../../md_doc/cpu.md")] +pub struct Cpu { + name: String, + cpu_usage: f32, + cpu_data: Arc<CpuData>, + frequency: u64, + vendor_id: String, + brand: String, +} + +impl Cpu { + pub(crate) fn new( + name: String, + cpu_data: Arc<CpuData>, + frequency: u64, + vendor_id: String, + brand: String, + ) -> Cpu { + Cpu { + name, + cpu_usage: 0f32, + cpu_data, + frequency, + vendor_id, + brand, + } + } + + pub(crate) fn set_cpu_usage(&mut self, cpu_usage: f32) { + self.cpu_usage = cpu_usage; + } + + pub(crate) fn update(&mut self, cpu_usage: f32, cpu_data: Arc<CpuData>) { + self.cpu_usage = cpu_usage; + self.cpu_data = cpu_data; + } + + pub(crate) fn data(&self) -> Arc<CpuData> { + Arc::clone(&self.cpu_data) + } + + pub(crate) fn set_frequency(&mut self, frequency: u64) { + self.frequency = frequency; + } +} + +impl CpuExt for Cpu { + fn cpu_usage(&self) -> f32 { + self.cpu_usage + } + + fn name(&self) -> &str { + &self.name + } + + /// Returns the CPU frequency in MHz. + fn frequency(&self) -> u64 { + self.frequency + } + + fn vendor_id(&self) -> &str { + &self.vendor_id + } + + fn brand(&self) -> &str { + &self.brand + } +} + +pub(crate) fn get_cpu_frequency() -> u64 { + let mut speed: u64 = 0; + let mut len = std::mem::size_of::<u64>(); + unsafe { + libc::sysctlbyname( + b"hw.cpufrequency\0".as_ptr() as *const c_char, + &mut speed as *mut _ as _, + &mut len, + std::ptr::null_mut(), + 0, + ); + speed / 1_000_000 + } +} + +#[inline] +fn get_in_use(cpu_info: *mut i32, offset: isize) -> i32 { + unsafe { + *cpu_info.offset(offset + libc::CPU_STATE_USER as isize) + + *cpu_info.offset(offset + libc::CPU_STATE_SYSTEM as isize) + + *cpu_info.offset(offset + libc::CPU_STATE_NICE as isize) + } +} + +#[inline] +fn get_idle(cpu_info: *mut i32, offset: isize) -> i32 { + unsafe { *cpu_info.offset(offset + libc::CPU_STATE_IDLE as isize) } +} + +pub(crate) fn compute_usage_of_cpu(proc_: &Cpu, cpu_info: *mut i32, offset: isize) -> f32 { + let old_cpu_info = proc_.data().cpu_info.0; + let in_use; + let total; + + // In case we are initializing cpus, there is no "old value" yet. + if old_cpu_info == cpu_info { + in_use = get_in_use(cpu_info, offset); + total = in_use + get_idle(cpu_info, offset); + } else { + in_use = get_in_use(cpu_info, offset) - get_in_use(old_cpu_info, offset); + total = in_use + (get_idle(cpu_info, offset) - get_idle(old_cpu_info, offset)); + } + in_use as f32 / total as f32 * 100. +} + +pub(crate) fn update_cpu_usage<F: FnOnce(Arc<CpuData>, *mut i32) -> (f32, usize)>( + port: libc::mach_port_t, + global_cpu: &mut Cpu, + f: F, +) { + let mut num_cpu_u = 0u32; + let mut cpu_info: *mut i32 = std::ptr::null_mut(); + let mut num_cpu_info = 0u32; + + let mut total_cpu_usage = 0f32; + + unsafe { + if host_processor_info( + port, + libc::PROCESSOR_CPU_LOAD_INFO, + &mut num_cpu_u as *mut u32, + &mut cpu_info as *mut *mut i32, + &mut num_cpu_info as *mut u32, + ) == libc::KERN_SUCCESS + { + let (total_percentage, len) = + f(Arc::new(CpuData::new(cpu_info, num_cpu_info)), cpu_info); + total_cpu_usage = total_percentage / len as f32; + } + global_cpu.set_cpu_usage(total_cpu_usage); + } +} + +pub(crate) fn init_cpus( + port: libc::mach_port_t, + cpus: &mut Vec<Cpu>, + global_cpu: &mut Cpu, + refresh_kind: CpuRefreshKind, +) { + let mut num_cpu = 0; + let mut mib = [0, 0]; + + let (vendor_id, brand) = get_vendor_id_and_brand(); + let frequency = if refresh_kind.frequency() { + get_cpu_frequency() + } else { + 0 + }; + + unsafe { + if !get_sys_value( + libc::CTL_HW as _, + libc::HW_NCPU as _, + mem::size_of::<u32>(), + &mut num_cpu as *mut _ as *mut _, + &mut mib, + ) { + num_cpu = 1; + } + } + update_cpu_usage(port, global_cpu, |proc_data, cpu_info| { + let mut percentage = 0f32; + let mut offset = 0; + for i in 0..num_cpu { + let mut p = Cpu::new( + format!("{}", i + 1), + Arc::clone(&proc_data), + frequency, + vendor_id.clone(), + brand.clone(), + ); + if refresh_kind.cpu_usage() { + let cpu_usage = compute_usage_of_cpu(&p, cpu_info, offset); + p.set_cpu_usage(cpu_usage); + percentage += p.cpu_usage(); + } + cpus.push(p); + + offset += libc::CPU_STATE_MAX as isize; + } + (percentage, cpus.len()) + }); + + // We didn't set them above to avoid cloning them unnecessarily. + global_cpu.brand = brand; + global_cpu.vendor_id = vendor_id; + global_cpu.frequency = frequency; +} + +fn get_sysctl_str(s: &[u8]) -> String { + let mut len = 0; + + unsafe { + libc::sysctlbyname( + s.as_ptr() as *const c_char, + std::ptr::null_mut(), + &mut len, + std::ptr::null_mut(), + 0, + ); + if len < 1 { + return String::new(); + } + + let mut buf = Vec::with_capacity(len); + libc::sysctlbyname( + s.as_ptr() as *const c_char, + buf.as_mut_ptr() as _, + &mut len, + std::ptr::null_mut(), + 0, + ); + if len > 0 { + buf.set_len(len); + while buf.last() == Some(&b'\0') { + buf.pop(); + } + String::from_utf8(buf).unwrap_or_else(|_| String::new()) + } else { + String::new() + } + } +} + +pub(crate) fn get_vendor_id_and_brand() -> (String, String) { + // On apple M1, `sysctl machdep.cpu.vendor` returns "", so fallback to "Apple" if the result + // is empty. + let mut vendor = get_sysctl_str(b"machdep.cpu.vendor\0"); + if vendor.is_empty() { + vendor = "Apple".to_string(); + } + + (vendor, get_sysctl_str(b"machdep.cpu.brand_string\0")) +} + +#[cfg(test)] +mod test { + use crate::*; + use std::process::Command; + + #[test] + fn check_vendor_and_brand() { + let child = Command::new("sysctl") + .arg("-a") + .output() + .expect("Failed to start command..."); + + assert!(child.status.success()); + let stdout = String::from_utf8(child.stdout).expect("Not valid UTF8"); + + let sys = System::new_with_specifics( + crate::RefreshKind::new().with_cpu(CpuRefreshKind::new().with_cpu_usage()), + ); + 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(); + 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(); + assert_eq!(cpus[0].brand(), sysctl_value.trim()); + } + } +} diff --git a/vendor/sysinfo/src/apple/disk.rs b/vendor/sysinfo/src/apple/disk.rs new file mode 100644 index 000000000..9f0b4a3a3 --- /dev/null +++ b/vendor/sysinfo/src/apple/disk.rs @@ -0,0 +1,66 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::utils::to_cpath; +use crate::{DiskExt, DiskType}; + +#[cfg(target_os = "macos")] +pub(crate) use crate::sys::inner::disk::*; + +use libc::statfs; +use std::ffi::{OsStr, OsString}; +use std::mem; +use std::path::{Path, PathBuf}; + +#[doc = include_str!("../../md_doc/disk.md")] +pub struct Disk { + pub(crate) type_: DiskType, + pub(crate) name: OsString, + pub(crate) file_system: Vec<u8>, + pub(crate) mount_point: PathBuf, + pub(crate) total_space: u64, + pub(crate) available_space: u64, + pub(crate) is_removable: bool, +} + +impl DiskExt for Disk { + fn type_(&self) -> DiskType { + self.type_ + } + + fn name(&self) -> &OsStr { + &self.name + } + + fn file_system(&self) -> &[u8] { + &self.file_system + } + + fn mount_point(&self) -> &Path { + &self.mount_point + } + + fn total_space(&self) -> u64 { + self.total_space + } + + fn available_space(&self) -> u64 { + self.available_space + } + + fn is_removable(&self) -> bool { + self.is_removable + } + + 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 + } else { + false + } + } + } +} diff --git a/vendor/sysinfo/src/apple/ffi.rs b/vendor/sysinfo/src/apple/ffi.rs new file mode 100644 index 000000000..7a8248537 --- /dev/null +++ b/vendor/sysinfo/src/apple/ffi.rs @@ -0,0 +1,28 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use libc::c_void; + +// 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); + +// #[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; + +#[cfg_attr(feature = "debug", derive(Eq, Hash, PartialEq))] +#[derive(Clone)] +#[repr(C)] +pub struct Val_t { + pub key: [i8; 5], + pub data_size: u32, + pub data_type: [i8; 5], // UInt32Char_t + pub bytes: [i8; 32], // SMCBytes_t +} diff --git a/vendor/sysinfo/src/apple/ios.rs b/vendor/sysinfo/src/apple/ios.rs new file mode 100644 index 000000000..0393c5ec6 --- /dev/null +++ b/vendor/sysinfo/src/apple/ios.rs @@ -0,0 +1,5 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +pub mod ffi {} +pub use crate::sys::app_store::component; +pub use crate::sys::app_store::process; diff --git a/vendor/sysinfo/src/apple/macos/component.rs b/vendor/sysinfo/src/apple/macos/component.rs new file mode 100644 index 000000000..384efb950 --- /dev/null +++ b/vendor/sysinfo/src/apple/macos/component.rs @@ -0,0 +1,221 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::sys::ffi; +use crate::ComponentExt; + +use libc::{c_char, c_int, c_void}; + +use std::mem; + +pub(crate) 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" + ( + "CPU Proximity", + &['T' as i8, 'C' as i8, '0' as i8, 'P' as i8], + ), // CPU Proximity (heat spreader) "TC0P" + ("GPU", &['T' as i8, 'G' as i8, '0' as i8, 'P' as i8]), // GPU "TG0P" + ("Battery", &['T' as i8, 'B' as i8, '0' as i8, 'T' as i8]), // Battery "TB0T" +]; + +pub(crate) struct ComponentFFI { + input_structure: ffi::KeyData_t, + val: ffi::Val_t, +} + +impl ComponentFFI { + fn new(key: &[i8], con: ffi::io_connect_t) -> Option<ComponentFFI> { + unsafe { + get_key_size(con, key) + .ok() + .map(|(input_structure, val)| ComponentFFI { + input_structure, + val, + }) + } + } + + fn temperature(&self, con: ffi::io_connect_t) -> Option<f32> { + get_temperature_inner(con, &self.input_structure, &self.val) + } +} + +#[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 { + /// Creates a new `Component` with the given information. + pub(crate) fn new( + label: String, + max: Option<f32>, + critical: Option<f32>, + key: &[i8], + 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, + }) + } +} + +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) { + if let Some(temp) = self.ffi_part.temperature(self.connection) { + self.temperature = temp; + if self.temperature > self.max { + self.max = self.temperature; + } + } + } +} + +unsafe fn perform_call( + conn: ffi::io_connect_t, + index: c_int, + input_structure: *const ffi::KeyData_t, + output_structure: *mut ffi::KeyData_t, +) -> i32 { + let mut structure_output_size = mem::size_of::<ffi::KeyData_t>(); + + ffi::IOConnectCallStructMethod( + conn, + index as u32, + input_structure, + mem::size_of::<ffi::KeyData_t>(), + output_structure, + &mut structure_output_size, + ) +} + +// Adapted from https://github.com/lavoiesl/osx-cpu-temp/blob/master/smc.c#L28 +#[inline] +fn strtoul(s: &[i8]) -> u32 { + unsafe { + ((*s.get_unchecked(0) as u32) << (3u32 << 3)) + + ((*s.get_unchecked(1) as u32) << (2u32 << 3)) + + ((*s.get_unchecked(2) as u32) << (1u32 << 3)) + + (*s.get_unchecked(3) as u32) + } +} + +#[inline] +unsafe fn ultostr(s: *mut c_char, val: u32) { + *s.offset(0) = ((val >> 24) % 128) as i8; + *s.offset(1) = ((val >> 16) % 128) as i8; + *s.offset(2) = ((val >> 8) % 128) as i8; + *s.offset(3) = (val % 128) as i8; + *s.offset(4) = 0; +} + +unsafe fn get_key_size( + con: ffi::io_connect_t, + key: &[i8], +) -> Result<(ffi::KeyData_t, ffi::Val_t), i32> { + let mut input_structure: ffi::KeyData_t = mem::zeroed::<ffi::KeyData_t>(); + let mut output_structure: ffi::KeyData_t = mem::zeroed::<ffi::KeyData_t>(); + let mut val: ffi::Val_t = mem::zeroed::<ffi::Val_t>(); + + input_structure.key = strtoul(key); + input_structure.data8 = ffi::SMC_CMD_READ_KEYINFO; + + let result = perform_call( + con, + ffi::KERNEL_INDEX_SMC, + &input_structure, + &mut output_structure, + ); + if result != ffi::KIO_RETURN_SUCCESS { + return Err(result); + } + + val.data_size = output_structure.key_info.data_size; + ultostr( + val.data_type.as_mut_ptr(), + output_structure.key_info.data_type, + ); + input_structure.key_info.data_size = val.data_size; + input_structure.data8 = ffi::SMC_CMD_READ_BYTES; + Ok((input_structure, val)) +} + +unsafe fn read_key( + con: ffi::io_connect_t, + input_structure: &ffi::KeyData_t, + mut val: ffi::Val_t, +) -> Result<ffi::Val_t, i32> { + let mut output_structure: ffi::KeyData_t = mem::zeroed::<ffi::KeyData_t>(); + + match perform_call( + con, + ffi::KERNEL_INDEX_SMC, + input_structure, + &mut output_structure, + ) { + ffi::KIO_RETURN_SUCCESS => { + libc::memcpy( + val.bytes.as_mut_ptr() as *mut c_void, + output_structure.bytes.as_mut_ptr() as *mut c_void, + mem::size_of::<[u8; 32]>(), + ); + Ok(val) + } + result => Err(result), + } +} + +fn get_temperature_inner( + con: ffi::io_connect_t, + input_structure: &ffi::KeyData_t, + original_val: &ffi::Val_t, +) -> Option<f32> { + unsafe { + if let Ok(val) = read_key(con, input_structure, (*original_val).clone()) { + if val.data_size > 0 + && libc::strcmp(val.data_type.as_ptr(), b"sp78\0".as_ptr() as *const i8) == 0 + { + // convert sp78 value to temperature + let x = (i32::from(val.bytes[0]) << 6) + (i32::from(val.bytes[1]) >> 2); + return Some(x as f32 / 64f32); + } + } + } + None +} + +pub(crate) 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) + } +} diff --git a/vendor/sysinfo/src/apple/macos/disk.rs b/vendor/sysinfo/src/apple/macos/disk.rs new file mode 100644 index 000000000..7cc5a83ce --- /dev/null +++ b/vendor/sysinfo/src/apple/macos/disk.rs @@ -0,0 +1,199 @@ +// 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 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::string as cfs; + +use libc::{c_char, c_int, c_void, statfs}; + +use std::ffi::{OsStr, OsString}; +use std::mem; +use std::os::unix::ffi::OsStrExt; +use std::path::PathBuf; +use std::ptr; + +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)) + } +} + +pub(crate) fn get_disks(session: ffi::DASessionRef) -> Vec<Disk> { + if session.is_null() { + return Vec::new(); + } + 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<_>>() + } +} + +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 +} + +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 + } + } 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)) +} + +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; + } + + 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; + } + 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, + }) + } +} diff --git a/vendor/sysinfo/src/apple/macos/ffi.rs b/vendor/sysinfo/src/apple/macos/ffi.rs new file mode 100644 index 000000000..f884701d9 --- /dev/null +++ b/vendor/sysinfo/src/apple/macos/ffi.rs @@ -0,0 +1,156 @@ +// 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 libc::{c_char, c_void}; +#[cfg(not(feature = "apple-sandbox"))] +use libc::{mach_port_t, size_t}; + +pub(crate) use crate::sys::ffi::*; + +#[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. + + // 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 fn IOServiceMatching(a: *const c_char) -> *mut c_void; + + pub fn IOServiceGetMatchingServices( + a: mach_port_t, + b: *mut c_void, + c: *mut io_iterator_t, + ) -> i32; + + 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; +} + +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( + allocator: CFAllocatorRef, + session: DASessionRef, + path: *const c_char, + ) -> DADiskRef; + // pub fn DADiskGetBSDName(disk: DADiskRef) -> *const c_char; + + pub fn DADiskCopyDescription(disk: DADiskRef) -> CFMutableDictionaryRef; +} + +pub type DADiskRef = *const __DADisk; +pub type DASessionRef = *const __DASession; + +// 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 {} + +#[cfg(not(feature = "apple-sandbox"))] +mod io_service { + use super::mach_port_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; + + #[cfg_attr(feature = "debug", derive(Debug, Eq, Hash, PartialEq))] + #[repr(C)] + pub struct KeyData_vers_t { + pub major: u8, + pub minor: u8, + pub build: u8, + pub reserved: [u8; 1], + pub release: u16, + } + + #[cfg_attr(feature = "debug", derive(Debug, Eq, Hash, PartialEq))] + #[repr(C)] + pub struct KeyData_pLimitData_t { + pub version: u16, + pub length: u16, + pub cpu_plimit: u32, + pub gpu_plimit: u32, + pub mem_plimit: u32, + } + + #[cfg_attr(feature = "debug", derive(Debug, Eq, Hash, PartialEq))] + #[repr(C)] + pub struct KeyData_keyInfo_t { + pub data_size: u32, + pub data_type: u32, + pub data_attributes: u8, + } + + #[cfg_attr(feature = "debug", derive(Debug, Eq, Hash, PartialEq))] + #[repr(C)] + pub struct KeyData_t { + pub key: u32, + pub vers: KeyData_vers_t, + pub p_limit_data: KeyData_pLimitData_t, + pub key_info: KeyData_keyInfo_t, + pub result: u8, + pub status: u8, + pub data8: u8, + pub data32: u32, + pub bytes: [i8; 32], // SMCBytes_t + } + + pub const KERNEL_INDEX_SMC: i32 = 2; + pub const SMC_CMD_READ_KEYINFO: u8 = 9; + pub const SMC_CMD_READ_BYTES: u8 = 5; + + pub const KIO_RETURN_SUCCESS: i32 = 0; +} + +#[cfg(feature = "apple-sandbox")] +mod io_service {} + +pub use io_service::*; diff --git a/vendor/sysinfo/src/apple/macos/mod.rs b/vendor/sysinfo/src/apple/macos/mod.rs new file mode 100644 index 000000000..172bbfddc --- /dev/null +++ b/vendor/sysinfo/src/apple/macos/mod.rs @@ -0,0 +1,17 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +pub mod disk; +pub mod ffi; + +#[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 new file mode 100644 index 000000000..f146126cf --- /dev/null +++ b/vendor/sysinfo/src/apple/macos/process.rs @@ -0,0 +1,643 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::ffi::CStr; +use std::mem::{self, MaybeUninit}; +use std::ops::Deref; +use std::path::{Path, PathBuf}; + +use std::borrow::Borrow; + +use libc::{c_int, c_void, kill, size_t}; + +use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessRefreshKind, ProcessStatus, Signal, Uid}; + +use crate::sys::process::ThreadStatus; +use crate::sys::system::Wrap; + +#[doc = include_str!("../../../md_doc/process.md")] +pub struct Process { + pub(crate) name: String, + pub(crate) cmd: Vec<String>, + pub(crate) exe: PathBuf, + pid: Pid, + parent: Option<Pid>, + pub(crate) environ: Vec<String>, + cwd: PathBuf, + pub(crate) root: PathBuf, + pub(crate) memory: u64, + pub(crate) virtual_memory: u64, + old_utime: u64, + old_stime: u64, + start_time: u64, + run_time: u64, + updated: bool, + cpu_usage: f32, + user_id: Option<Uid>, + group_id: Option<Gid>, + pub(crate) process_status: ProcessStatus, + /// Status of process (running, stopped, waiting, etc). `None` means `sysinfo` doesn't have + /// enough rights to get this information. + /// + /// This is very likely this one that you want instead of `process_status`. + pub status: Option<ThreadStatus>, + pub(crate) old_read_bytes: u64, + pub(crate) old_written_bytes: u64, + pub(crate) read_bytes: u64, + pub(crate) written_bytes: u64, +} + +impl Process { + pub(crate) fn new_empty(pid: Pid, exe: PathBuf, name: String, cwd: PathBuf) -> Process { + Process { + name, + pid, + parent: None, + cmd: Vec::new(), + environ: Vec::new(), + exe, + cwd, + root: PathBuf::new(), + memory: 0, + virtual_memory: 0, + cpu_usage: 0., + old_utime: 0, + old_stime: 0, + updated: true, + start_time: 0, + run_time: 0, + user_id: None, + group_id: None, + process_status: ProcessStatus::Unknown(0), + status: None, + old_read_bytes: 0, + old_written_bytes: 0, + read_bytes: 0, + written_bytes: 0, + } + } + + pub(crate) fn new(pid: Pid, parent: Option<Pid>, start_time: u64, run_time: u64) -> Process { + Process { + name: String::new(), + pid, + parent, + cmd: Vec::new(), + environ: Vec::new(), + exe: PathBuf::new(), + cwd: PathBuf::new(), + root: PathBuf::new(), + memory: 0, + virtual_memory: 0, + cpu_usage: 0., + old_utime: 0, + old_stime: 0, + updated: true, + start_time, + run_time, + user_id: None, + group_id: None, + process_status: ProcessStatus::Unknown(0), + status: None, + old_read_bytes: 0, + old_written_bytes: 0, + read_bytes: 0, + written_bytes: 0, + } + } +} + +impl ProcessExt for Process { + fn kill_with(&self, signal: Signal) -> Option<bool> { + let c_signal = crate::sys::system::convert_signal(signal)?; + unsafe { Some(kill(self.pid.0, c_signal) == 0) } + } + + fn name(&self) -> &str { + &self.name + } + + fn cmd(&self) -> &[String] { + &self.cmd + } + + fn exe(&self) -> &Path { + self.exe.as_path() + } + + fn pid(&self) -> Pid { + self.pid + } + + fn environ(&self) -> &[String] { + &self.environ + } + + fn cwd(&self) -> &Path { + self.cwd.as_path() + } + + fn root(&self) -> &Path { + self.root.as_path() + } + + fn memory(&self) -> u64 { + self.memory + } + + fn virtual_memory(&self) -> u64 { + self.virtual_memory + } + + fn parent(&self) -> Option<Pid> { + self.parent + } + + fn status(&self) -> ProcessStatus { + self.process_status + } + + fn start_time(&self) -> u64 { + self.start_time + } + + fn run_time(&self) -> u64 { + self.run_time + } + + fn cpu_usage(&self) -> f32 { + self.cpu_usage + } + + fn disk_usage(&self) -> DiskUsage { + DiskUsage { + read_bytes: self.read_bytes - self.old_read_bytes, + total_read_bytes: self.read_bytes, + written_bytes: self.written_bytes - self.old_written_bytes, + total_written_bytes: self.written_bytes, + } + } + + fn user_id(&self) -> Option<&Uid> { + self.user_id.as_ref() + } + + fn group_id(&self) -> Option<Gid> { + self.group_id + } +} + +#[allow(deprecated)] // Because of libc::mach_absolute_time. +pub(crate) fn compute_cpu_usage( + p: &mut Process, + task_info: libc::proc_taskinfo, + system_time: u64, + user_time: u64, + time_interval: Option<f64>, +) { + if let Some(time_interval) = time_interval { + let total_existing_time = p.old_stime.saturating_add(p.old_utime); + if time_interval > 0.000001 && total_existing_time > 0 { + let total_current_time = task_info + .pti_total_system + .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; + } else { + p.cpu_usage = 0.; + } + p.old_stime = task_info.pti_total_system; + p.old_utime = task_info.pti_total_user; + } else { + unsafe { + // This is the "backup way" of CPU computation. + let time = libc::mach_absolute_time(); + let task_time = user_time + .saturating_add(system_time) + .saturating_add(task_info.pti_total_user) + .saturating_add(task_info.pti_total_system); + + let system_time_delta = if task_time < p.old_utime { + task_time + } else { + task_time.saturating_sub(p.old_utime) + }; + let time_delta = if time < p.old_stime { + time + } else { + time.saturating_sub(p.old_stime) + }; + p.old_utime = task_time; + p.old_stime = time; + p.cpu_usage = if time_delta == 0 { + 0f32 + } else { + (system_time_delta as f64 * 100f64 / time_delta as f64) as f32 + }; + } + } + p.updated = true; +} + +/*pub fn set_time(p: &mut Process, utime: u64, stime: u64) { + p.old_utime = p.utime; + p.old_stime = p.stime; + p.utime = utime; + p.stime = stime; + 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 + // so it's "fine". + libc::proc_pidinfo( + pid.0, + libc::PROC_PIDTASKINFO, + 0, + &mut task_info as *mut libc::proc_taskinfo as *mut c_void, + mem::size_of::<libc::proc_taskinfo>() as _, + ); + task_info +} + +#[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 + // } +} + +#[inline] +fn do_not_get_env_path(_: &str, _: &mut PathBuf, _: &mut bool) {} + +#[inline] +fn do_get_env_path(env: &str, root: &mut PathBuf, check: &mut bool) { + if *check && env.starts_with("PATH=") { + *check = false; + *root = Path::new(&env[5..]).to_path_buf(); + } +} + +pub(crate) fn update_process( + wrap: &Wrap, + pid: Pid, + mut size: size_t, + time_interval: Option<f64>, + now: u64, + refresh_kind: ProcessRefreshKind, +) -> 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 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 mut buffer: Vec<u8> = Vec::with_capacity(libc::PROC_PIDPATHINFO_MAXSIZE as _); + match libc::proc_pidpath( + pid.0, + buffer.as_mut_ptr() as *mut _, + libc::PROC_PIDPATHINFO_MAXSIZE as _, + ) { + x if x > 0 => { + buffer.set_len(x as _); + let tmp = String::from_utf8_unchecked(buffer); + let exe = PathBuf::from(tmp); + let name = exe + .file_name() + .and_then(|x| x.to_str()) + .unwrap_or("") + .to_owned(); + return Ok(Some(Process::new_empty(pid, exe, name, cwd))); + } + _ => {} + } + 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 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 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); + } + 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 { + 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 / 1_000; + p.virtual_memory = task_info.pti_virtual_size / 1_000; + + 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)) + } +} + +fn update_proc_disk_activity(p: &mut Process) { + p.old_read_bytes = p.read_bytes; + p.old_written_bytes = p.written_bytes; + + let mut pidrusage = MaybeUninit::<libc::rusage_info_v2>::uninit(); + + unsafe { + let retval = libc::proc_pid_rusage( + p.pid().0 as _, + libc::RUSAGE_INFO_V2, + pidrusage.as_mut_ptr() as _, + ); + + if retval < 0 { + sysinfo_debug!("proc_pid_rusage failed: {:?}", retval); + } else { + let pidrusage = pidrusage.assume_init(); + p.read_bytes = pidrusage.ri_diskio_bytesread; + p.written_bytes = pidrusage.ri_diskio_byteswritten; + } + } +} + +#[allow(clippy::uninit_vec)] +pub(crate) fn get_proc_list() -> Option<Vec<Pid>> { + unsafe { + let count = libc::proc_listallpids(::std::ptr::null_mut(), 0); + if count < 1 { + return None; + } + let mut pids: Vec<Pid> = Vec::with_capacity(count as usize); + pids.set_len(count as usize); + let count = count * mem::size_of::<Pid>() as i32; + let x = libc::proc_listallpids(pids.as_mut_ptr() as *mut c_void, count); + + if x < 1 || x as usize >= pids.len() { + None + } else { + pids.set_len(x as usize); + Some(pids) + } + } +} + +unsafe fn get_unchecked_str(cp: *mut u8, start: *mut u8) -> String { + let len = cp as usize - start as usize; + let part = Vec::from_raw_parts(start, len, len); + let tmp = String::from_utf8_unchecked(part.clone()); + mem::forget(part); + tmp +} + +fn parse_command_line<T: Deref<Target = str> + Borrow<str>>(cmd: &[T]) -> Vec<String> { + let mut x = 0; + let mut command = Vec::with_capacity(cmd.len()); + while x < cmd.len() { + let mut y = x; + if cmd[y].starts_with('\'') || cmd[y].starts_with('"') { + let c = if cmd[y].starts_with('\'') { '\'' } else { '"' }; + while y < cmd.len() && !cmd[y].ends_with(c) { + y += 1; + } + command.push(cmd[x..y].join(" ")); + x = y; + } else { + command.push(cmd[x].to_owned()); + } + x += 1; + } + command +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn test_get_path() { + let mut path = PathBuf::new(); + let mut check = true; + + do_get_env_path("PATH=tadam", &mut path, &mut check); + + assert!(!check); + assert_eq!(path, PathBuf::from("tadam")); + } +} diff --git a/vendor/sysinfo/src/apple/macos/system.rs b/vendor/sysinfo/src/apple/macos/system.rs new file mode 100644 index 000000000..949532234 --- /dev/null +++ b/vendor/sysinfo/src/apple/macos/system.rs @@ -0,0 +1,136 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#[allow(deprecated)] +use libc::{mach_timebase_info, mach_timebase_info_data_t}; + +use libc::{ + host_processor_info, mach_port_t, munmap, natural_t, processor_cpu_load_info, + processor_cpu_load_info_t, sysconf, vm_page_size, PROCESSOR_CPU_LOAD_INFO, _SC_CLK_TCK, +}; +use std::ptr::null_mut; + +unsafe fn free_cpu_load_info(cpu_load: &mut processor_cpu_load_info_t) { + if !cpu_load.is_null() { + munmap(*cpu_load as _, vm_page_size); + *cpu_load = null_mut(); + } +} + +pub(crate) struct SystemTimeInfo { + timebase_to_ns: f64, + clock_per_sec: f64, + old_cpu_load: processor_cpu_load_info_t, + old_cpu_count: natural_t, +} + +unsafe impl Send for SystemTimeInfo {} +unsafe impl Sync for SystemTimeInfo {} + +impl SystemTimeInfo { + #[allow(deprecated)] // Everything related to mach_timebase_info_data_t + pub fn new(port: mach_port_t) -> Option<Self> { + unsafe { + let clock_ticks_per_sec = sysconf(_SC_CLK_TCK); + + // FIXME: Maybe check errno here? Problem is that if errno is not 0 before this call, + // we will get an error which isn't related... + // if let Some(er) = std::io::Error::last_os_error().raw_os_error() { + // if err != 0 { + // println!("==> {:?}", er); + // sysinfo_debug!("Failed to get _SC_CLK_TCK value, using old CPU tick measure system"); + // return None; + // } + // } + + let mut info = mach_timebase_info_data_t { numer: 0, denom: 0 }; + if mach_timebase_info(&mut info) != libc::KERN_SUCCESS { + sysinfo_debug!("mach_timebase_info failed, using default value of 1"); + info.numer = 1; + info.denom = 1; + } + + let mut old_cpu_load = null_mut(); + let old_cpu_count = match Self::update_ticks(port, &mut old_cpu_load) { + Some(c) => c, + None => { + sysinfo_debug!("host_processor_info failed, using old CPU tick measure system"); + return None; + } + }; + + let nano_per_seconds = 1_000_000_000.; + sysinfo_debug!(""); + Some(Self { + timebase_to_ns: info.numer as f64 / info.denom as f64, + clock_per_sec: nano_per_seconds / clock_ticks_per_sec as f64, + old_cpu_load, + old_cpu_count, + }) + } + } + + fn update_ticks( + port: mach_port_t, + cpu_load: &mut processor_cpu_load_info_t, + ) -> Option<natural_t> { + let mut info_size = std::mem::size_of::<processor_cpu_load_info_t>() as _; + let mut cpu_count = 0; + + unsafe { + free_cpu_load_info(cpu_load); + + if host_processor_info( + port, + PROCESSOR_CPU_LOAD_INFO, + &mut cpu_count, + cpu_load as *mut _ as *mut _, + &mut info_size, + ) != 0 + { + sysinfo_debug!("host_processor_info failed, not updating CPU ticks usage..."); + None + } else if cpu_count < 1 || cpu_load.is_null() { + None + } else { + Some(cpu_count) + } + } + } + + pub fn get_time_interval(&mut self, port: mach_port_t) -> f64 { + let mut total = 0; + let mut new_cpu_load = null_mut(); + + let new_cpu_count = match Self::update_ticks(port, &mut new_cpu_load) { + Some(c) => c, + None => return 0., + }; + let cpu_count = std::cmp::min(self.old_cpu_count, new_cpu_count); + unsafe { + for i in 0..cpu_count { + let new_load: &processor_cpu_load_info = &*new_cpu_load.offset(i as _); + let old_load: &processor_cpu_load_info = &*self.old_cpu_load.offset(i as _); + for (new, old) in new_load.cpu_ticks.iter().zip(old_load.cpu_ticks.iter()) { + if new > old { + total += new - old; + } + } + } + + free_cpu_load_info(&mut self.old_cpu_load); + self.old_cpu_load = new_cpu_load; + self.old_cpu_count = new_cpu_count; + + // Now we convert the ticks to nanoseconds: + total as f64 / self.timebase_to_ns * self.clock_per_sec / cpu_count as f64 + } + } +} + +impl Drop for SystemTimeInfo { + fn drop(&mut self) { + unsafe { + free_cpu_load_info(&mut self.old_cpu_load); + } + } +} diff --git a/vendor/sysinfo/src/apple/mod.rs b/vendor/sysinfo/src/apple/mod.rs new file mode 100644 index 000000000..daff800a2 --- /dev/null +++ b/vendor/sysinfo/src/apple/mod.rs @@ -0,0 +1,31 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#[cfg(target_os = "macos")] +pub(crate) mod macos; +#[cfg(target_os = "macos")] +pub(crate) use self::macos as inner; + +#[cfg(target_os = "ios")] +pub(crate) mod ios; +#[cfg(target_os = "ios")] +pub(crate) use self::ios as inner; + +#[cfg(any(target_os = "ios", feature = "apple-sandbox"))] +pub(crate) mod app_store; + +pub mod component; +pub mod cpu; +pub mod disk; +mod ffi; +pub mod network; +pub mod process; +pub mod system; +pub mod users; +mod utils; + +pub use self::component::Component; +pub use self::cpu::Cpu; +pub use self::disk::Disk; +pub use self::network::{NetworkData, Networks}; +pub use self::process::Process; +pub use self::system::System; diff --git a/vendor/sysinfo/src/apple/network.rs b/vendor/sysinfo/src/apple/network.rs new file mode 100644 index 000000000..f1316920e --- /dev/null +++ b/vendor/sysinfo/src/apple/network.rs @@ -0,0 +1,239 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use libc::{self, c_char, if_msghdr2, CTL_NET, NET_RT_IFLIST2, PF_ROUTE, RTM_IFINFO2}; + +use std::collections::{hash_map, HashMap}; +use std::ptr::null_mut; + +use crate::{NetworkExt, NetworksExt, NetworksIter}; + +macro_rules! old_and_new { + ($ty_:expr, $name:ident, $old:ident, $new_val:expr) => {{ + $ty_.$old = $ty_.$name; + $ty_.$name = $new_val; + }}; +} + +#[doc = include_str!("../../md_doc/networks.md")] +pub struct Networks { + interfaces: HashMap<String, NetworkData>, +} + +impl Networks { + pub(crate) fn new() -> Self { + Networks { + interfaces: HashMap::new(), + } + } + + #[allow(clippy::cast_ptr_alignment)] + #[allow(clippy::uninit_vec)] + fn update_networks(&mut self) { + let mib = &mut [CTL_NET, PF_ROUTE, 0, 0, NET_RT_IFLIST2, 0]; + let mut len = 0; + unsafe { + if libc::sysctl( + mib.as_mut_ptr(), + mib.len() as _, + null_mut(), + &mut len, + null_mut(), + 0, + ) < 0 + { + // TODO: might be nice to put an error in here... + return; + } + let mut buf = Vec::with_capacity(len); + buf.set_len(len); + if libc::sysctl( + mib.as_mut_ptr(), + mib.len() as _, + buf.as_mut_ptr(), + &mut len, + null_mut(), + 0, + ) < 0 + { + // TODO: might be nice to put an error in here... + return; + } + let buf = buf.as_ptr() as *const c_char; + let lim = buf.add(len); + let mut next = buf; + while next < lim { + let ifm = next as *const libc::if_msghdr; + next = next.offset((*ifm).ifm_msglen as isize); + if (*ifm).ifm_type == RTM_IFINFO2 as u8 { + // The interface (line description) name stored at ifname will be returned in + // the default coded character set identifier (CCSID) currently in effect for + // the job. If this is not a single byte CCSID, then storage greater than + // IFNAMSIZ (16) bytes may be needed. 22 bytes is large enough for all CCSIDs. + let mut name = vec![0u8; libc::IFNAMSIZ + 6]; + + let if2m: *const if_msghdr2 = ifm as *const if_msghdr2; + let pname = + libc::if_indextoname((*if2m).ifm_index as _, name.as_mut_ptr() as _); + if pname.is_null() { + continue; + } + name.set_len(libc::strlen(pname)); + let name = String::from_utf8_unchecked(name); + match self.interfaces.entry(name) { + hash_map::Entry::Occupied(mut e) => { + let mut interface = e.get_mut(); + old_and_new!( + interface, + current_out, + old_out, + (*if2m).ifm_data.ifi_obytes + ); + old_and_new!( + interface, + current_in, + old_in, + (*if2m).ifm_data.ifi_ibytes + ); + old_and_new!( + interface, + packets_in, + old_packets_in, + (*if2m).ifm_data.ifi_ipackets + ); + old_and_new!( + interface, + packets_out, + old_packets_out, + (*if2m).ifm_data.ifi_opackets + ); + old_and_new!( + interface, + errors_in, + old_errors_in, + (*if2m).ifm_data.ifi_ierrors + ); + old_and_new!( + interface, + errors_out, + old_errors_out, + (*if2m).ifm_data.ifi_oerrors + ); + interface.updated = true; + } + hash_map::Entry::Vacant(e) => { + let current_in = (*if2m).ifm_data.ifi_ibytes; + let current_out = (*if2m).ifm_data.ifi_obytes; + let packets_in = (*if2m).ifm_data.ifi_ipackets; + let packets_out = (*if2m).ifm_data.ifi_opackets; + let errors_in = (*if2m).ifm_data.ifi_ierrors; + let errors_out = (*if2m).ifm_data.ifi_oerrors; + + e.insert(NetworkData { + current_in, + old_in: current_in, + current_out, + old_out: current_out, + packets_in, + old_packets_in: packets_in, + packets_out, + old_packets_out: packets_out, + errors_in, + old_errors_in: errors_in, + errors_out, + old_errors_out: errors_out, + updated: true, + }); + } + } + } + } + } + } +} + +impl NetworksExt for Networks { + #[allow(clippy::needless_lifetimes)] + fn iter<'a>(&'a self) -> NetworksIter<'a> { + NetworksIter::new(self.interfaces.iter()) + } + + fn refresh_networks_list(&mut self) { + for (_, data) in self.interfaces.iter_mut() { + data.updated = false; + } + self.update_networks(); + self.interfaces.retain(|_, data| data.updated); + } + + fn refresh(&mut self) { + self.update_networks(); + } +} + +#[doc = include_str!("../../md_doc/network_data.md")] +#[derive(PartialEq, Eq)] +pub struct NetworkData { + current_in: u64, + old_in: u64, + current_out: u64, + old_out: u64, + packets_in: u64, + old_packets_in: u64, + packets_out: u64, + old_packets_out: u64, + errors_in: u64, + old_errors_in: u64, + errors_out: u64, + old_errors_out: u64, + updated: bool, +} + +impl NetworkExt for NetworkData { + fn received(&self) -> u64 { + self.current_in.saturating_sub(self.old_in) + } + + fn total_received(&self) -> u64 { + self.current_in + } + + fn transmitted(&self) -> u64 { + self.current_out.saturating_sub(self.old_out) + } + + fn total_transmitted(&self) -> u64 { + self.current_out + } + + fn packets_received(&self) -> u64 { + self.packets_in.saturating_sub(self.old_packets_in) + } + + fn total_packets_received(&self) -> u64 { + self.packets_in + } + + fn packets_transmitted(&self) -> u64 { + self.packets_out.saturating_sub(self.old_packets_out) + } + + fn total_packets_transmitted(&self) -> u64 { + self.packets_out + } + + fn errors_on_received(&self) -> u64 { + self.errors_in.saturating_sub(self.old_errors_in) + } + + fn total_errors_on_received(&self) -> u64 { + self.errors_in + } + + fn errors_on_transmitted(&self) -> u64 { + self.errors_out.saturating_sub(self.old_errors_out) + } + + fn total_errors_on_transmitted(&self) -> u64 { + self.errors_out + } +} diff --git a/vendor/sysinfo/src/apple/process.rs b/vendor/sysinfo/src/apple/process.rs new file mode 100644 index 000000000..e0f005bdc --- /dev/null +++ b/vendor/sysinfo/src/apple/process.rs @@ -0,0 +1,83 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::fmt; + +pub use crate::sys::inner::process::*; +use crate::ProcessStatus; + +#[doc(hidden)] +impl From<u32> for ProcessStatus { + fn from(status: u32) -> ProcessStatus { + match status { + 1 => ProcessStatus::Idle, + 2 => ProcessStatus::Run, + 3 => ProcessStatus::Sleep, + 4 => ProcessStatus::Stop, + 5 => ProcessStatus::Zombie, + x => ProcessStatus::Unknown(x), + } + } +} + +impl fmt::Display for ProcessStatus { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(match *self { + ProcessStatus::Idle => "Idle", + ProcessStatus::Run => "Runnable", + ProcessStatus::Sleep => "Sleeping", + ProcessStatus::Stop => "Stopped", + ProcessStatus::Zombie => "Zombie", + _ => "Unknown", + }) + } +} + +/// Enum describing the different status of a thread. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum ThreadStatus { + /// Thread is running normally. + Running, + /// Thread is stopped. + Stopped, + /// Thread is waiting normally. + Waiting, + /// Thread is in an uninterruptible wait + Uninterruptible, + /// Thread is halted at a clean point. + Halted, + /// Unknown. + Unknown(i32), +} + +impl From<i32> for ThreadStatus { + fn from(status: i32) -> ThreadStatus { + match status { + 1 => ThreadStatus::Running, + 2 => ThreadStatus::Stopped, + 3 => ThreadStatus::Waiting, + 4 => ThreadStatus::Uninterruptible, + 5 => ThreadStatus::Halted, + x => ThreadStatus::Unknown(x), + } + } +} + +impl ThreadStatus { + /// Used to display `ThreadStatus`. + pub fn to_string(&self) -> &str { + match *self { + ThreadStatus::Running => "Running", + ThreadStatus::Stopped => "Stopped", + ThreadStatus::Waiting => "Waiting", + ThreadStatus::Uninterruptible => "Uninterruptible", + ThreadStatus::Halted => "Halted", + ThreadStatus::Unknown(_) => "Unknown", + } + } +} + +impl fmt::Display for ThreadStatus { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.to_string()) + } +} diff --git a/vendor/sysinfo/src/apple/system.rs b/vendor/sysinfo/src/apple/system.rs new file mode 100644 index 000000000..abe617dee --- /dev/null +++ b/vendor/sysinfo/src/apple/system.rs @@ -0,0 +1,763 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +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, +}; + +#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))] +use crate::ProcessExt; + +use std::cell::UnsafeCell; +use std::collections::HashMap; +use std::mem; +use std::sync::Arc; +#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))] +use std::time::SystemTime; + +#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))] +use libc::size_t; + +use libc::{ + c_char, c_int, c_void, host_statistics64, mach_port_t, sysconf, sysctl, sysctlbyname, timeval, + vm_statistics64, _SC_PAGESIZE, +}; + +#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))] +declare_signals! { + c_int, + Signal::Hangup => libc::SIGHUP, + Signal::Interrupt => libc::SIGINT, + Signal::Quit => libc::SIGQUIT, + Signal::Illegal => libc::SIGILL, + Signal::Trap => libc::SIGTRAP, + Signal::Abort => libc::SIGABRT, + Signal::IOT => libc::SIGIOT, + Signal::Bus => libc::SIGBUS, + Signal::FloatingPointException => libc::SIGFPE, + Signal::Kill => libc::SIGKILL, + Signal::User1 => libc::SIGUSR1, + Signal::Segv => libc::SIGSEGV, + Signal::User2 => libc::SIGUSR2, + Signal::Pipe => libc::SIGPIPE, + Signal::Alarm => libc::SIGALRM, + Signal::Term => libc::SIGTERM, + Signal::Child => libc::SIGCHLD, + Signal::Continue => libc::SIGCONT, + Signal::Stop => libc::SIGSTOP, + Signal::TSTP => libc::SIGTSTP, + Signal::TTIN => libc::SIGTTIN, + Signal::TTOU => libc::SIGTTOU, + Signal::Urgent => libc::SIGURG, + Signal::XCPU => libc::SIGXCPU, + Signal::XFSZ => libc::SIGXFSZ, + Signal::VirtualAlarm => libc::SIGVTALRM, + Signal::Profiling => libc::SIGPROF, + Signal::Winch => libc::SIGWINCH, + Signal::IO => libc::SIGIO, + // SIGPOLL doesn't exist on apple targets but since it's an equivalent of SIGIO on unix, + // we simply use the SIGIO constant. + Signal::Poll => libc::SIGIO, + Signal::Sys => libc::SIGSYS, + _ => None, +} +#[cfg(any(target_os = "ios", feature = "apple-sandbox"))] +declare_signals! { + c_int, + _ => None, +} + +#[doc = include_str!("../../md_doc/system.md")] +pub struct System { + process_list: HashMap<Pid, Process>, + mem_total: u64, + mem_free: u64, + mem_available: u64, + swap_total: u64, + swap_free: u64, + 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>, + 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, + tv_usec: 0, + }; + let mut len = std::mem::size_of::<timeval>(); + let mut mib: [c_int; 2] = [libc::CTL_KERN, libc::KERN_BOOTTIME]; + + unsafe { + if sysctl( + mib.as_mut_ptr(), + mib.len() as _, + &mut boot_time as *mut timeval as *mut _, + &mut len, + std::ptr::null_mut(), + 0, + ) < 0 + { + 0 + } else { + boot_time.tv_sec as _ + } + } +} + +#[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))] +fn get_now() -> u64 { + SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .map(|n| n.as_secs()) + .unwrap_or(0) +} + +impl SystemExt for System { + const IS_SUPPORTED: bool = true; + const SUPPORTED_SIGNALS: &'static [Signal] = supported_signals(); + + fn new_with_specifics(refreshes: RefreshKind) -> System { + unsafe { + let port = libc::mach_host_self(); + + let mut s = System { + process_list: HashMap::with_capacity(200), + mem_total: 0, + mem_free: 0, + mem_available: 0, + swap_total: 0, + swap_free: 0, + global_cpu: Cpu::new( + "0".to_owned(), + Arc::new(CpuData::new(std::ptr::null_mut(), 0)), + 0, + String::new(), + 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(), + 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, + }; + s.refresh_specifics(refreshes); + s + } + } + + fn refresh_memory(&mut self) { + let mut mib = [0, 0]; + + unsafe { + // get system values + // get swap info + let mut xs: libc::xsw_usage = mem::zeroed::<libc::xsw_usage>(); + if get_sys_value( + libc::CTL_VM as _, + libc::VM_SWAPUSAGE as _, + mem::size_of::<libc::xsw_usage>(), + &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; + } + // get ram info + if self.mem_total < 1 { + get_sys_value( + libc::CTL_HW as _, + libc::HW_MEMSIZE as _, + mem::size_of::<u64>(), + &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>(); + if host_statistics64( + self.port, + libc::HOST_VM_INFO64, + &mut stat as *mut vm_statistics64 as *mut _, + &mut count, + ) == libc::KERN_SUCCESS + { + // From the apple documentation: + // + // /* + // * NB: speculative pages are already accounted for in "free_count", + // * so "speculative_count" is the number of "free" pages that are + // * 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_free = u64::from(stat.free_count).saturating_mul(self.page_size_kb); + } + } + } + + #[cfg(any(target_os = "ios", feature = "apple-sandbox"))] + fn refresh_components_list(&mut self) {} + + #[cfg(all(target_os = "macos", not(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); + } + } + } + } + + fn refresh_cpu_specifics(&mut self, refresh_kind: CpuRefreshKind) { + let cpus = &mut self.cpus; + if cpus.is_empty() { + init_cpus(self.port, cpus, &mut self.global_cpu, refresh_kind); + self.got_cpu_frequency = refresh_kind.frequency(); + return; + } + if refresh_kind.frequency() && !self.got_cpu_frequency { + let frequency = get_cpu_frequency(); + for proc_ in cpus.iter_mut() { + proc_.set_frequency(frequency); + } + self.got_cpu_frequency = true; + } + if refresh_kind.cpu_usage() { + update_cpu_usage(self.port, &mut self.global_cpu, |proc_data, cpu_info| { + let mut percentage = 0f32; + let mut offset = 0; + for proc_ in cpus.iter_mut() { + let cpu_usage = compute_usage_of_cpu(proc_, cpu_info, offset); + proc_.update(cpu_usage, Arc::clone(&proc_data)); + percentage += proc_.cpu_usage(); + + offset += libc::CPU_STATE_MAX as isize; + } + (percentage, cpus.len()) + }); + } + } + + #[cfg(any(target_os = "ios", feature = "apple-sandbox"))] + fn refresh_processes_specifics(&mut self, _refresh_kind: ProcessRefreshKind) {} + + #[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))] + fn refresh_processes_specifics(&mut self, refresh_kind: ProcessRefreshKind) { + use crate::utils::into_iter; + + unsafe { + let count = libc::proc_listallpids(::std::ptr::null_mut(), 0); + if count < 1 { + return; + } + } + if let Some(pids) = get_proc_list() { + let now = get_now(); + let arg_max = get_arg_max(); + let port = self.port; + let time_interval = self.clock_info.as_mut().map(|c| c.get_time_interval(port)); + let entries: Vec<Process> = { + let wrap = &Wrap(UnsafeCell::new(&mut self.process_list)); + + #[cfg(feature = "multithread")] + use rayon::iter::ParallelIterator; + + into_iter(pids) + .flat_map(|pid| { + match update_process( + wrap, + pid, + arg_max as size_t, + time_interval, + now, + refresh_kind, + ) { + Ok(x) => x, + _ => None, + } + }) + .collect() + }; + entries.into_iter().for_each(|entry| { + self.process_list.insert(entry.pid(), entry); + }); + self.clear_procs(); + } + } + + #[cfg(any(target_os = "ios", feature = "apple-sandbox"))] + fn refresh_process_specifics(&mut self, _pid: Pid, _refresh_kind: ProcessRefreshKind) -> bool { + false + } + + #[cfg(all(target_os = "macos", not(feature = "apple-sandbox")))] + fn refresh_process_specifics(&mut self, pid: Pid, refresh_kind: ProcessRefreshKind) -> bool { + let now = get_now(); + let arg_max = get_arg_max(); + let port = self.port; + let time_interval = self.clock_info.as_mut().map(|c| c.get_time_interval(port)); + match { + let wrap = Wrap(UnsafeCell::new(&mut self.process_list)); + update_process( + &wrap, + pid, + arg_max as size_t, + time_interval, + now, + refresh_kind, + ) + } { + Ok(Some(p)) => { + self.process_list.insert(p.pid(), p); + true + } + Ok(_) => true, + Err(_) => false, + } + } + + #[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); + } + } + + fn refresh_users_list(&mut self) { + self.users = crate::apple::users::get_users_list(); + } + + // COMMON PART + // + // Need to be moved into a "common" file to avoid duplication. + + fn processes(&self) -> &HashMap<Pid, Process> { + &self.process_list + } + + fn process(&self, pid: Pid) -> Option<&Process> { + self.process_list.get(&pid) + } + + fn global_cpu_info(&self) -> &Cpu { + &self.global_cpu + } + + fn cpus(&self) -> &[Cpu] { + &self.cpus + } + + fn physical_core_count(&self) -> Option<usize> { + let mut physical_core_count = 0; + + unsafe { + if get_sys_value_by_name( + b"hw.physicalcpu\0", + &mut mem::size_of::<u32>(), + &mut physical_core_count as *mut usize as *mut c_void, + ) { + Some(physical_core_count) + } else { + None + } + } + } + + fn networks(&self) -> &Networks { + &self.networks + } + + fn networks_mut(&mut self) -> &mut Networks { + &mut self.networks + } + + fn total_memory(&self) -> u64 { + self.mem_total + } + + fn free_memory(&self) -> u64 { + self.mem_free + } + + fn available_memory(&self) -> u64 { + self.mem_available + } + + fn used_memory(&self) -> u64 { + self.mem_total - self.mem_free + } + + fn total_swap(&self) -> u64 { + self.swap_total + } + + fn free_swap(&self) -> u64 { + self.swap_free + } + + // TODO: need to be checked + fn used_swap(&self) -> u64 { + self.swap_total - self.swap_free + } + + fn components(&self) -> &[Component] { + &self.components + } + + fn components_mut(&mut self) -> &mut [Component] { + &mut self.components + } + + fn disks(&self) -> &[Disk] { + &self.disks + } + + fn disks_mut(&mut self) -> &mut [Disk] { + &mut self.disks + } + + fn uptime(&self) -> u64 { + unsafe { + let csec = libc::time(::std::ptr::null_mut()); + + libc::difftime(csec, self.boot_time as _) as u64 + } + } + + fn load_average(&self) -> LoadAvg { + let mut loads = vec![0f64; 3]; + + unsafe { + libc::getloadavg(loads.as_mut_ptr(), 3); + LoadAvg { + one: loads[0], + five: loads[1], + fifteen: loads[2], + } + } + } + + fn users(&self) -> &[User] { + &self.users + } + + fn boot_time(&self) -> u64 { + self.boot_time + } + + fn name(&self) -> Option<String> { + get_system_info(libc::KERN_OSTYPE, Some("Darwin")) + } + + fn long_os_version(&self) -> Option<String> { + #[cfg(target_os = "macos")] + let friendly_name = match self.os_version().unwrap_or_default() { + f_n if f_n.starts_with("10.16") + | f_n.starts_with("11.0") + | f_n.starts_with("11.1") + | f_n.starts_with("11.2") => + { + "Big Sur" + } + f_n if f_n.starts_with("10.15") => "Catalina", + f_n if f_n.starts_with("10.14") => "Mojave", + f_n if f_n.starts_with("10.13") => "High Sierra", + f_n if f_n.starts_with("10.12") => "Sierra", + f_n if f_n.starts_with("10.11") => "El Capitan", + f_n if f_n.starts_with("10.10") => "Yosemite", + f_n if f_n.starts_with("10.9") => "Mavericks", + f_n if f_n.starts_with("10.8") => "Mountain Lion", + f_n if f_n.starts_with("10.7") => "Lion", + f_n if f_n.starts_with("10.6") => "Snow Leopard", + f_n if f_n.starts_with("10.5") => "Leopard", + f_n if f_n.starts_with("10.4") => "Tiger", + f_n if f_n.starts_with("10.3") => "Panther", + f_n if f_n.starts_with("10.2") => "Jaguar", + f_n if f_n.starts_with("10.1") => "Puma", + f_n if f_n.starts_with("10.0") => "Cheetah", + _ => "", + }; + + #[cfg(target_os = "macos")] + let long_name = Some(format!( + "MacOS {} {}", + self.os_version().unwrap_or_default(), + friendly_name + )); + + #[cfg(target_os = "ios")] + let long_name = Some(format!("iOS {}", self.os_version().unwrap_or_default())); + + long_name + } + + fn host_name(&self) -> Option<String> { + get_system_info(libc::KERN_HOSTNAME, None) + } + + fn kernel_version(&self) -> Option<String> { + get_system_info(libc::KERN_OSRELEASE, None) + } + + fn os_version(&self) -> Option<String> { + unsafe { + // get the size for the buffer first + let mut size = 0; + if get_sys_value_by_name(b"kern.osproductversion\0", &mut size, std::ptr::null_mut()) + && size > 0 + { + // now create a buffer with the size and get the real value + let mut buf = vec![0_u8; size as usize]; + + if get_sys_value_by_name( + b"kern.osproductversion\0", + &mut size, + buf.as_mut_ptr() as *mut c_void, + ) { + if let Some(pos) = buf.iter().position(|x| *x == 0) { + // Shrink buffer to terminate the null bytes + buf.resize(pos, 0); + } + + String::from_utf8(buf).ok() + } else { + // getting the system value failed + None + } + } else { + // getting the system value failed, or did not return a buffer size + None + } + } + } +} + +impl Default for System { + fn default() -> System { + System::new() + } +} + +// 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]; + let mut arg_max = 0i32; + let mut size = mem::size_of::<c_int>(); + unsafe { + if sysctl( + mib.as_mut_ptr(), + mib.len() as _, + (&mut arg_max) as *mut i32 as *mut c_void, + &mut size, + std::ptr::null_mut(), + 0, + ) == -1 + { + 4096 // We default to this value + } else { + arg_max as usize + } + } +} + +pub(crate) unsafe fn get_sys_value( + high: u32, + low: u32, + mut len: usize, + value: *mut c_void, + mib: &mut [i32; 2], +) -> bool { + mib[0] = high as i32; + mib[1] = low as i32; + sysctl( + mib.as_mut_ptr(), + mib.len() as _, + value, + &mut len as *mut usize, + std::ptr::null_mut(), + 0, + ) == 0 +} + +unsafe fn get_sys_value_by_name(name: &[u8], len: &mut usize, value: *mut c_void) -> bool { + sysctlbyname( + name.as_ptr() as *const c_char, + value, + len, + std::ptr::null_mut(), + 0, + ) == 0 +} + +fn get_system_info(value: c_int, default: Option<&str>) -> Option<String> { + let mut mib: [c_int; 2] = [libc::CTL_KERN, value]; + let mut size = 0; + + unsafe { + // Call first to get size + sysctl( + mib.as_mut_ptr(), + mib.len() as _, + std::ptr::null_mut(), + &mut size, + std::ptr::null_mut(), + 0, + ); + + // exit early if we did not update the size + if size == 0 { + default.map(|s| s.to_owned()) + } else { + // set the buffer to the correct size + let mut buf = vec![0_u8; size as usize]; + + if sysctl( + mib.as_mut_ptr(), + mib.len() as _, + buf.as_mut_ptr() as _, + &mut size, + std::ptr::null_mut(), + 0, + ) == -1 + { + // If command fails return default + default.map(|s| s.to_owned()) + } else { + if let Some(pos) = buf.iter().position(|x| *x == 0) { + // Shrink buffer to terminate the null bytes + buf.resize(pos, 0); + } + + String::from_utf8(buf).ok() + } + } + } +} diff --git a/vendor/sysinfo/src/apple/users.rs b/vendor/sysinfo/src/apple/users.rs new file mode 100644 index 000000000..690aceee1 --- /dev/null +++ b/vendor/sysinfo/src/apple/users.rs @@ -0,0 +1,178 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{ + common::{Gid, Uid}, + User, +}; + +use crate::sys::utils; +use libc::{c_char, endpwent, getgrgid, getgrouplist, getpwent, gid_t, setpwent, strlen}; + +fn get_user_groups(name: *const c_char, group_id: gid_t) -> Vec<String> { + let mut add = 0; + + loop { + let mut nb_groups = 256 + add; + let mut groups = Vec::with_capacity(nb_groups as _); + unsafe { + if getgrouplist(name, group_id as _, groups.as_mut_ptr(), &mut nb_groups) == -1 { + add += 100; + continue; + } + groups.set_len(nb_groups as _); + return groups + .into_iter() + .filter_map(|g| { + let group = getgrgid(g as _); + if group.is_null() { + return None; + } + utils::cstr_to_rust((*group).gr_name) + }) + .collect(); + } + } +} + +fn endswith(s1: *const c_char, s2: &[u8]) -> bool { + if s1.is_null() { + return false; + } + unsafe { + let mut len = strlen(s1) as isize - 1; + let mut i = s2.len() as isize - 1; + while len >= 0 && i >= 0 && *s1.offset(len) == s2[i as usize] as _ { + i -= 1; + len -= 1; + } + i == -1 + } +} + +fn users_list<F>(filter: F) -> Vec<User> +where + F: Fn(*const c_char, u32) -> bool, +{ + let mut users = Vec::new(); + + unsafe { + setpwent(); + loop { + let pw = getpwent(); + if pw.is_null() { + break; + } + + if !filter((*pw).pw_shell, (*pw).pw_uid) { + // This is not a "real" or "local" user. + continue; + } + + let groups = get_user_groups((*pw).pw_name, (*pw).pw_gid); + let uid = (*pw).pw_uid; + let gid = (*pw).pw_gid; + if let Some(name) = utils::cstr_to_rust((*pw).pw_name) { + users.push(User { + uid: Uid(uid), + gid: Gid(gid), + name, + groups, + }); + } + } + endpwent(); + } + users.sort_unstable_by(|x, y| x.name.partial_cmp(&y.name).unwrap()); + users.dedup_by(|a, b| a.name == b.name); + users +} + +pub(crate) fn get_users_list() -> Vec<User> { + users_list(|shell, uid| { + !endswith(shell, b"/false") && !endswith(shell, b"/uucico") && uid < 65536 + }) +} + +// This was the OSX-based solution. It provides enough information, but what a mess! +// pub fn get_users_list() -> Vec<User> { +// let mut users = Vec::new(); +// let node_name = b"/Local/Default\0"; + +// unsafe { +// let node_name = ffi::CFStringCreateWithCStringNoCopy( +// std::ptr::null_mut(), +// node_name.as_ptr() as *const c_char, +// ffi::kCFStringEncodingMacRoman, +// ffi::kCFAllocatorNull as *mut c_void, +// ); +// let node_ref = ffi::ODNodeCreateWithName( +// ffi::kCFAllocatorDefault, +// ffi::kODSessionDefault, +// node_name, +// std::ptr::null_mut(), +// ); +// let query = ffi::ODQueryCreateWithNode( +// ffi::kCFAllocatorDefault, +// node_ref, +// ffi::kODRecordTypeUsers as _, // kODRecordTypeGroups +// std::ptr::null(), +// 0, +// std::ptr::null(), +// std::ptr::null(), +// 0, +// std::ptr::null_mut(), +// ); +// if query.is_null() { +// return users; +// } +// let results = ffi::ODQueryCopyResults( +// query, +// false as _, +// std::ptr::null_mut(), +// ); +// let len = ffi::CFArrayGetCount(results); +// for i in 0..len { +// let name = match get_user_name(ffi::CFArrayGetValueAtIndex(results, i)) { +// Some(n) => n, +// None => continue, +// }; +// let groups = get_user_groups(&name); +// users.push(User { name }); +// } + +// ffi::CFRelease(results as *const c_void); +// ffi::CFRelease(query as *const c_void); +// ffi::CFRelease(node_ref as *const c_void); +// ffi::CFRelease(node_name as *const c_void); +// } +// users.sort_unstable_by(|x, y| x.name.partial_cmp(&y.name).unwrap()); +// return users; +// } + +// fn get_user_name(result: *const c_void) -> Option<String> { +// let user_name = ffi::ODRecordGetRecordName(result as _); +// let ptr = ffi::CFStringGetCharactersPtr(user_name); +// String::from_utf16(&if ptr.is_null() { +// let len = ffi::CFStringGetLength(user_name); // It returns the len in UTF-16 code pairs. +// if len == 0 { +// continue; +// } +// let mut v = Vec::with_capacity(len as _); +// for x in 0..len { +// v.push(ffi::CFStringGetCharacterAtIndex(user_name, x)); +// } +// v +// } else { +// let mut v: Vec<u16> = Vec::new(); +// let mut x = 0; +// loop { +// let letter = *ptr.offset(x); +// if letter == 0 { +// break; +// } +// v.push(letter); +// x += 1; +// } +// v +// }.ok() +// } diff --git a/vendor/sysinfo/src/apple/utils.rs b/vendor/sysinfo/src/apple/utils.rs new file mode 100644 index 000000000..019295b95 --- /dev/null +++ b/vendor/sysinfo/src/apple/utils.rs @@ -0,0 +1,39 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use libc::c_char; + +pub(crate) fn cstr_to_rust(c: *const c_char) -> Option<String> { + cstr_to_rust_with_size(c, None) +} + +pub(crate) fn cstr_to_rust_with_size(c: *const c_char, size: Option<usize>) -> Option<String> { + if c.is_null() { + return None; + } + let mut s = match size { + Some(len) => Vec::with_capacity(len), + None => Vec::new(), + }; + let mut i = 0; + unsafe { + loop { + let value = *c.offset(i) as u8; + if value == 0 { + break; + } + s.push(value); + i += 1; + } + String::from_utf8(s).ok() + } +} + +#[cfg(target_os = "macos")] +pub(crate) fn vec_to_rust(buf: Vec<i8>) -> Option<String> { + String::from_utf8( + buf.into_iter() + .flat_map(|b| if b > 0 { Some(b as u8) } else { None }) + .collect(), + ) + .ok() +} diff --git a/vendor/sysinfo/src/c_interface.rs b/vendor/sysinfo/src/c_interface.rs new file mode 100644 index 000000000..e7cc5359b --- /dev/null +++ b/vendor/sysinfo/src/c_interface.rs @@ -0,0 +1,468 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{CpuExt, NetworkExt, NetworksExt, Pid, Process, ProcessExt, System, SystemExt}; +use libc::{self, c_char, c_float, c_uint, c_void, pid_t, size_t}; +use std::borrow::BorrowMut; +use std::ffi::CString; + +/// Equivalent of [`System`][crate::System] struct. +pub type CSystem = *mut c_void; +/// Equivalent of [`Process`][crate::Process] struct. +pub type CProcess = *const c_void; +/// C string returned from `CString::into_raw`. +pub type RString = *const c_char; +/// Callback used by [`processes`][crate::System#method.processes]. +pub type ProcessLoop = extern "C" fn(pid: pid_t, process: CProcess, data: *mut c_void) -> bool; + +/// Equivalent of [`System::new()`][crate::System#method.new]. +#[no_mangle] +pub extern "C" fn sysinfo_init() -> CSystem { + let system = Box::new(System::new()); + Box::into_raw(system) as CSystem +} + +/// Equivalent of `System::drop()`. Important in C to cleanup memory. +#[no_mangle] +pub extern "C" fn sysinfo_destroy(system: CSystem) { + assert!(!system.is_null()); + unsafe { + Box::from_raw(system as *mut System); + } +} + +/// Equivalent of [`System::refresh_system()`][crate::System#method.refresh_system]. +#[no_mangle] +pub extern "C" fn sysinfo_refresh_system(system: CSystem) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_system(); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::refresh_memory()`][crate::System#method.refresh_memory]. +#[no_mangle] +pub extern "C" fn sysinfo_refresh_memory(system: CSystem) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_memory(); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::refresh_cpu()`][crate::System#method.refresh_cpu]. +#[no_mangle] +pub extern "C" fn sysinfo_refresh_cpu(system: CSystem) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_cpu(); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::refresh_components()`][crate::System#method.refresh_temperatures]. +#[no_mangle] +pub extern "C" fn sysinfo_refresh_components(system: CSystem) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_components(); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::refresh_all()`][crate::System#method.refresh_all]. +#[no_mangle] +pub extern "C" fn sysinfo_refresh_all(system: CSystem) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_all(); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::refresh_processes()`][crate::System#method.refresh_processes]. +#[no_mangle] +pub extern "C" fn sysinfo_refresh_processes(system: CSystem) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_processes(); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::refresh_process()`][crate::System#method.refresh_process]. +#[cfg(target_os = "linux")] +#[no_mangle] +pub extern "C" fn sysinfo_refresh_process(system: CSystem, pid: pid_t) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_process(Pid(pid)); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::refresh_disks()`][crate::System#method.refresh_disks]. +#[no_mangle] +pub extern "C" fn sysinfo_refresh_disks(system: CSystem) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_disks(); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::refresh_disks_list()`][crate::System#method.refresh_disks_list]. +#[no_mangle] +pub extern "C" fn sysinfo_refresh_disks_list(system: CSystem) { + assert!(!system.is_null()); + unsafe { + let mut system: Box<System> = Box::from_raw(system as *mut System); + { + let system: &mut System = system.borrow_mut(); + system.refresh_disks_list(); + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::total_memory()`][crate::System#method.total_memory]. +#[no_mangle] +pub extern "C" fn sysinfo_total_memory(system: CSystem) -> size_t { + assert!(!system.is_null()); + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let ret = system.total_memory() as size_t; + Box::into_raw(system); + ret + } +} + +/// Equivalent of [`System::free_memory()`][crate::System#method.free_memory]. +#[no_mangle] +pub extern "C" fn sysinfo_free_memory(system: CSystem) -> size_t { + assert!(!system.is_null()); + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let ret = system.free_memory() as size_t; + Box::into_raw(system); + ret + } +} + +/// Equivalent of [`System::used_memory()`][crate::System#method.used_memory]. +#[no_mangle] +pub extern "C" fn sysinfo_used_memory(system: CSystem) -> size_t { + assert!(!system.is_null()); + let system: Box<System> = unsafe { Box::from_raw(system as *mut System) }; + let ret = system.used_memory() as size_t; + Box::into_raw(system); + ret +} + +/// Equivalent of [`System::total_swap()`][crate::System#method.total_swap]. +#[no_mangle] +pub extern "C" fn sysinfo_total_swap(system: CSystem) -> size_t { + assert!(!system.is_null()); + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let ret = system.total_swap() as size_t; + Box::into_raw(system); + ret + } +} + +/// Equivalent of [`System::free_swap()`][crate::System#method.free_swap]. +#[no_mangle] +pub extern "C" fn sysinfo_free_swap(system: CSystem) -> size_t { + assert!(!system.is_null()); + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let ret = system.free_swap() as size_t; + Box::into_raw(system); + ret + } +} + +/// Equivalent of [`System::used_swap()`][crate::System#method.used_swap]. +#[no_mangle] +pub extern "C" fn sysinfo_used_swap(system: CSystem) -> size_t { + assert!(!system.is_null()); + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let ret = system.used_swap() as size_t; + Box::into_raw(system); + ret + } +} + +/// Equivalent of +/// `system::networks().iter().fold(0, |acc, (_, data)| acc + data.received() as size_t)`. +#[no_mangle] +pub extern "C" fn sysinfo_networks_received(system: CSystem) -> size_t { + assert!(!system.is_null()); + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let ret = system.networks().iter().fold(0, |acc: size_t, (_, data)| { + acc.saturating_add(data.received() as size_t) + }); + Box::into_raw(system); + ret + } +} + +/// Equivalent of +/// `system::networks().iter().fold(0, |acc, (_, data)| acc + data.transmitted() as size_t)`. +#[no_mangle] +pub extern "C" fn sysinfo_networks_transmitted(system: CSystem) -> size_t { + assert!(!system.is_null()); + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let ret = system.networks().iter().fold(0, |acc: size_t, (_, data)| { + acc.saturating_add(data.transmitted() as size_t) + }); + Box::into_raw(system); + ret + } +} + +/// Equivalent of [`System::cpus_usage()`][crate::System#method.cpus_usage]. +/// +/// * `length` will contain the number of cpu usage added into `procs`. +/// * `procs` will be allocated if it's null and will contain of cpu usage. +#[no_mangle] +pub extern "C" fn sysinfo_cpus_usage( + system: CSystem, + length: *mut c_uint, + procs: *mut *mut c_float, +) { + assert!(!system.is_null()); + if procs.is_null() || length.is_null() { + return; + } + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + { + let cpus = system.cpus(); + if (*procs).is_null() { + (*procs) = + libc::malloc(::std::mem::size_of::<c_float>() * cpus.len()) as *mut c_float; + } + for (pos, cpu) in cpus.iter().skip(1).enumerate() { + (*(*procs).offset(pos as isize)) = cpu.cpu_usage(); + } + *length = cpus.len() as c_uint - 1; + } + Box::into_raw(system); + } +} + +/// Equivalent of [`System::processes()`][crate::System#method.processes]. Returns an +/// array ended by a null pointer. Must be freed. +/// +/// # /!\ WARNING /!\ +/// +/// While having this method returned processes, you should *never* call any refresh method! +#[no_mangle] +pub extern "C" fn sysinfo_processes( + system: CSystem, + fn_pointer: Option<ProcessLoop>, + data: *mut c_void, +) -> size_t { + assert!(!system.is_null()); + if let Some(fn_pointer) = fn_pointer { + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let len = { + let entries = system.processes(); + for (pid, process) in entries { + if !fn_pointer(pid.0, process as *const Process as CProcess, data) { + break; + } + } + entries.len() as size_t + }; + Box::into_raw(system); + len + } + } else { + 0 + } +} + +/// Equivalent of [`System::process()`][crate::System#method.process]. +/// +/// # /!\ WARNING /!\ +/// +/// While having this method returned process, you should *never* call any +/// refresh method! +#[no_mangle] +pub extern "C" fn sysinfo_process_by_pid(system: CSystem, pid: pid_t) -> CProcess { + assert!(!system.is_null()); + unsafe { + let system: Box<System> = Box::from_raw(system as *mut System); + let ret = if let Some(process) = system.process(Pid(pid)) { + process as *const Process as CProcess + } else { + std::ptr::null() + }; + Box::into_raw(system); + ret + } +} + +/// Equivalent of iterating over [`Process::tasks()`][crate::Process#method.tasks]. +/// +/// # /!\ WARNING /!\ +/// +/// While having this method processes, you should *never* call any refresh method! +#[cfg(target_os = "linux")] +#[no_mangle] +pub extern "C" fn sysinfo_process_tasks( + process: CProcess, + fn_pointer: Option<ProcessLoop>, + data: *mut c_void, +) -> size_t { + assert!(!process.is_null()); + if let Some(fn_pointer) = fn_pointer { + unsafe { + let process = process as *const Process; + for (pid, process) in (*process).tasks.iter() { + if !fn_pointer(pid.0, process as *const Process as CProcess, data) { + break; + } + } + (*process).tasks.len() as size_t + } + } else { + 0 + } +} + +/// Equivalent of [`Process::pid()`][crate::Process#method.pid]. +#[no_mangle] +pub extern "C" fn sysinfo_process_pid(process: CProcess) -> pid_t { + assert!(!process.is_null()); + let process = process as *const Process; + unsafe { (*process).pid().0 } +} + +/// Equivalent of [`Process::parent()`][crate::Process#method.parent]. +/// +/// In case there is no known parent, it returns `0`. +#[no_mangle] +pub extern "C" fn sysinfo_process_parent_pid(process: CProcess) -> pid_t { + assert!(!process.is_null()); + let process = process as *const Process; + unsafe { (*process).parent().unwrap_or(Pid(0)).0 } +} + +/// Equivalent of [`Process::cpu_usage()`][crate::Process#method.cpu_usage]. +#[no_mangle] +pub extern "C" fn sysinfo_process_cpu_usage(process: CProcess) -> c_float { + assert!(!process.is_null()); + let process = process as *const Process; + unsafe { (*process).cpu_usage() } +} + +/// Equivalent of [`Process::memory()`][crate::Process#method.memory]. +#[no_mangle] +pub extern "C" fn sysinfo_process_memory(process: CProcess) -> size_t { + assert!(!process.is_null()); + let process = process as *const Process; + unsafe { (*process).memory() as usize } +} + +/// Equivalent of [`Process::virtual_memory()`][crate::Process#method.virtual_memory]. +#[no_mangle] +pub extern "C" fn sysinfo_process_virtual_memory(process: CProcess) -> size_t { + assert!(!process.is_null()); + let process = process as *const Process; + unsafe { (*process).virtual_memory() as usize } +} + +/// Equivalent of [`Process::exe()`][crate::Process#method.exe]. +#[no_mangle] +pub extern "C" fn sysinfo_process_executable_path(process: CProcess) -> RString { + assert!(!process.is_null()); + let process = process as *const Process; + unsafe { + if let Some(p) = (*process).exe().to_str() { + if let Ok(c) = CString::new(p) { + return c.into_raw() as _; + } + } + std::ptr::null() + } +} + +/// Equivalent of [`Process::root()`][crate::Process#method.root]. +#[no_mangle] +pub extern "C" fn sysinfo_process_root_directory(process: CProcess) -> RString { + assert!(!process.is_null()); + let process = process as *const Process; + unsafe { + if let Some(p) = (*process).root().to_str() { + if let Ok(c) = CString::new(p) { + return c.into_raw() as _; + } + } + std::ptr::null() + } +} + +/// Equivalent of [`Process::cwd()`][crate::Process#method.cwd]. +#[no_mangle] +pub extern "C" fn sysinfo_process_current_directory(process: CProcess) -> RString { + assert!(!process.is_null()); + let process = process as *const Process; + unsafe { + if let Some(p) = (*process).cwd().to_str() { + if let Ok(c) = CString::new(p) { + return c.into_raw() as _; + } + } + std::ptr::null() + } +} + +/// Frees a C string created with `CString::into_raw()`. +#[no_mangle] +pub extern "C" fn sysinfo_rstring_free(s: RString) { + if !s.is_null() { + unsafe { + let _ = CString::from_raw(s as usize as *mut i8); + } + } +} diff --git a/vendor/sysinfo/src/common.rs b/vendor/sysinfo/src/common.rs new file mode 100644 index 000000000..15cbe87be --- /dev/null +++ b/vendor/sysinfo/src/common.rs @@ -0,0 +1,965 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{NetworkData, Networks, NetworksExt, UserExt}; + +use std::convert::From; +use std::fmt; +use std::str::FromStr; + +/// Trait to have a common conversions for the [`Pid`][crate::Pid] type. +/// +/// ``` +/// use sysinfo::{Pid, PidExt}; +/// +/// let p = Pid::from_u32(0); +/// let value: u32 = p.as_u32(); +/// ``` +pub trait PidExt<T>: Copy + From<T> + FromStr + fmt::Display { + /// Allows to convert [`Pid`][crate::Pid] into [`u32`]. + /// + /// ``` + /// use sysinfo::{Pid, PidExt}; + /// + /// let p = Pid::from_u32(0); + /// let value: u32 = p.as_u32(); + /// ``` + fn as_u32(self) -> u32; + /// Allows to convert a [`u32`] into [`Pid`][crate::Pid]. + /// + /// ``` + /// use sysinfo::{Pid, PidExt}; + /// + /// let p = Pid::from_u32(0); + /// ``` + fn from_u32(v: u32) -> Self; +} + +macro_rules! pid_decl { + ($typ:ty) => { + #[doc = include_str!("../md_doc/pid.md")] + #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] + #[repr(transparent)] + pub struct Pid(pub(crate) $typ); + + impl From<$typ> for Pid { + fn from(v: $typ) -> Self { + Self(v) + } + } + impl From<Pid> for $typ { + fn from(v: Pid) -> Self { + v.0 + } + } + impl PidExt<$typ> for Pid { + fn as_u32(self) -> u32 { + self.0 as u32 + } + fn from_u32(v: u32) -> Self { + Self(v as _) + } + } + impl FromStr for Pid { + type Err = <$typ as FromStr>::Err; + fn from_str(s: &str) -> Result<Self, Self::Err> { + Ok(Self(<$typ>::from_str(s)?)) + } + } + impl fmt::Display for Pid { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } + } + }; +} + +cfg_if::cfg_if! { + if #[cfg(all( + not(feature = "unknown-ci"), + any( + target_os = "freebsd", + target_os = "linux", + target_os = "android", + target_os = "macos", + target_os = "ios", + ) + ))] { + use libc::pid_t; + + pid_decl!(pid_t); + } else { + pid_decl!(usize); + } +} + +macro_rules! impl_get_set { + ($ty_name:ident, $name:ident, $with:ident, $without:ident $(, $extra_doc:literal)? $(,)?) => { + #[doc = concat!("Returns the value of the \"", stringify!($name), "\" refresh kind.")] + $(#[doc = concat!(" +", $extra_doc, " +")])? + #[doc = concat!(" +``` +use sysinfo::", stringify!($ty_name), "; + +let r = ", stringify!($ty_name), "::new(); +assert_eq!(r.", stringify!($name), "(), false); + +let r = r.with_", stringify!($name), "(); +assert_eq!(r.", stringify!($name), "(), true); + +let r = r.without_", stringify!($name), "(); +assert_eq!(r.", stringify!($name), "(), false); +```")] + pub fn $name(&self) -> bool { + self.$name + } + + #[doc = concat!("Sets the value of the \"", stringify!($name), "\" refresh kind to `true`. + +``` +use sysinfo::", stringify!($ty_name), "; + +let r = ", stringify!($ty_name), "::new(); +assert_eq!(r.", stringify!($name), "(), false); + +let r = r.with_", stringify!($name), "(); +assert_eq!(r.", stringify!($name), "(), true); +```")] + #[must_use] + pub fn $with(mut self) -> Self { + self.$name = true; + self + } + + #[doc = concat!("Sets the value of the \"", stringify!($name), "\" refresh kind to `false`. + +``` +use sysinfo::", stringify!($ty_name), "; + +let r = ", stringify!($ty_name), "::everything(); +assert_eq!(r.", stringify!($name), "(), true); + +let r = r.without_", stringify!($name), "(); +assert_eq!(r.", stringify!($name), "(), false); +```")] + #[must_use] + pub fn $without(mut self) -> Self { + self.$name = false; + self + } + }; + + ($ty_name:ident, $name:ident, $with:ident, $without:ident, $typ:ty $(,)?) => { + #[doc = concat!("Returns the value of the \"", stringify!($name), "\" refresh kind. + +``` +use sysinfo::{", stringify!($ty_name), ", ", stringify!($typ), "}; + +let r = ", stringify!($ty_name), "::new(); +assert_eq!(r.", stringify!($name), "().is_some(), false); + +let r = r.with_", stringify!($name), "(", stringify!($typ), "::everything()); +assert_eq!(r.", stringify!($name), "().is_some(), true); + +let r = r.without_", stringify!($name), "(); +assert_eq!(r.", stringify!($name), "().is_some(), false); +```")] + pub fn $name(&self) -> Option<$typ> { + self.$name + } + + #[doc = concat!("Sets the value of the \"", stringify!($name), "\" refresh kind to `true`. + +``` +use sysinfo::{", stringify!($ty_name), ", ", stringify!($typ), "}; + +let r = ", stringify!($ty_name), "::new(); +assert_eq!(r.", stringify!($name), "().is_some(), false); + +let r = r.with_", stringify!($name), "(", stringify!($typ), "::everything()); +assert_eq!(r.", stringify!($name), "().is_some(), true); +```")] + #[must_use] + pub fn $with(mut self, kind: $typ) -> Self { + self.$name = Some(kind); + self + } + + #[doc = concat!("Sets the value of the \"", stringify!($name), "\" refresh kind to `false`. + +``` +use sysinfo::", stringify!($ty_name), "; + +let r = ", stringify!($ty_name), "::everything(); +assert_eq!(r.", stringify!($name), "().is_some(), true); + +let r = r.without_", stringify!($name), "(); +assert_eq!(r.", stringify!($name), "().is_some(), false); +```")] + #[must_use] + pub fn $without(mut self) -> Self { + self.$name = None; + self + } + }; +} + +/// Used to determine what you want to refresh specifically on the [`Process`] 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 +/// extra computation. +/// +/// ``` +/// use sysinfo::{ProcessExt, ProcessRefreshKind, System, SystemExt}; +/// +/// let mut system = System::new(); +/// +/// // We don't want to update the CPU information. +/// system.refresh_processes_specifics(ProcessRefreshKind::everything().without_cpu()); +/// +/// for (_, proc_) in system.processes() { +/// // We use a `==` comparison on float only because we know it's set to 0 here. +/// assert_eq!(proc_.cpu_usage(), 0.); +/// } +/// ``` +/// +/// [`Process`]: crate::Process +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub struct ProcessRefreshKind { + cpu: bool, + disk_usage: bool, + user: bool, +} + +impl ProcessRefreshKind { + /// Creates a new `ProcessRefreshKind` with every refresh set to `false`. + /// + /// ``` + /// use sysinfo::ProcessRefreshKind; + /// + /// let r = ProcessRefreshKind::new(); + /// + /// assert_eq!(r.cpu(), false); + /// assert_eq!(r.disk_usage(), false); + /// ``` + pub fn new() -> Self { + Self::default() + } + + /// Creates a new `ProcessRefreshKind` with every refresh set to `true`. + /// + /// ``` + /// use sysinfo::ProcessRefreshKind; + /// + /// let r = ProcessRefreshKind::everything(); + /// + /// assert_eq!(r.cpu(), true); + /// assert_eq!(r.disk_usage(), true); + /// ``` + pub fn everything() -> Self { + Self { + cpu: true, + disk_usage: true, + user: true, + } + } + + impl_get_set!(ProcessRefreshKind, cpu, with_cpu, without_cpu); + impl_get_set!( + ProcessRefreshKind, + disk_usage, + with_disk_usage, + without_disk_usage + ); + impl_get_set!( + ProcessRefreshKind, + user, + with_user, + without_user, + r#"This refresh is about `user_id` and `group_id`. Please note that it has an effect mostly +on Windows as other platforms get this information alongside the Process information directly."#, + ); +} + +/// Used to determine what you want to refresh specifically on the [`Process`] 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 +/// extra computation. +/// +/// ``` +/// use sysinfo::{CpuExt, CpuRefreshKind, System, SystemExt}; +/// +/// let mut system = System::new(); +/// +/// // We don't want to update all the CPU information. +/// system.refresh_cpu_specifics(CpuRefreshKind::everything().without_frequency()); +/// +/// for cpu in system.cpus() { +/// assert_eq!(cpu.frequency(), 0); +/// } +/// ``` +/// +/// [`Process`]: crate::Process +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub struct CpuRefreshKind { + cpu_usage: bool, + frequency: bool, +} + +impl CpuRefreshKind { + /// Creates a new `CpuRefreshKind` with every refresh set to `false`. + /// + /// ``` + /// use sysinfo::CpuRefreshKind; + /// + /// let r = CpuRefreshKind::new(); + /// + /// assert_eq!(r.frequency(), false); + /// ``` + pub fn new() -> Self { + Self::default() + } + + /// Creates a new `CpuRefreshKind` with every refresh set to `true`. + /// + /// ``` + /// use sysinfo::CpuRefreshKind; + /// + /// let r = CpuRefreshKind::everything(); + /// + /// assert_eq!(r.frequency(), true); + /// ``` + pub fn everything() -> Self { + Self { + cpu_usage: true, + frequency: true, + } + } + + impl_get_set!(CpuRefreshKind, cpu_usage, with_cpu_usage, without_cpu_usage); + impl_get_set!(CpuRefreshKind, frequency, with_frequency, without_frequency); +} + +/// Used to determine what you want to refresh specifically on the [`System`] 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 +/// extra computation. +/// +/// ``` +/// use sysinfo::{RefreshKind, System, SystemExt}; +/// +/// // We want everything except disks. +/// let mut system = System::new_with_specifics(RefreshKind::everything().without_disks_list()); +/// +/// assert_eq!(system.disks().len(), 0); +/// # if System::IS_SUPPORTED && !cfg!(feature = "apple-sandbox") { +/// assert!(system.processes().len() > 0); +/// # } +/// ``` +/// +/// [`System`]: crate::System +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub struct RefreshKind { + networks: bool, + networks_list: bool, + processes: Option<ProcessRefreshKind>, + disks_list: bool, + disks: bool, + memory: bool, + cpu: Option<CpuRefreshKind>, + components: bool, + components_list: bool, + users_list: bool, +} + +impl RefreshKind { + /// Creates a new `RefreshKind` with every refresh set to `false`/`None`. + /// + /// ``` + /// use sysinfo::RefreshKind; + /// + /// let r = RefreshKind::new(); + /// + /// assert_eq!(r.networks(), false); + /// assert_eq!(r.networks_list(), false); + /// assert_eq!(r.processes().is_some(), false); + /// assert_eq!(r.disks_list(), false); + /// assert_eq!(r.disks(), false); + /// assert_eq!(r.memory(), false); + /// assert_eq!(r.cpu().is_some(), false); + /// assert_eq!(r.components(), false); + /// assert_eq!(r.components_list(), false); + /// assert_eq!(r.users_list(), false); + /// ``` + pub fn new() -> Self { + Self::default() + } + + /// Creates a new `RefreshKind` with every refresh set to `true`/`Some(...)`. + /// + /// ``` + /// use sysinfo::RefreshKind; + /// + /// let r = RefreshKind::everything(); + /// + /// assert_eq!(r.networks(), true); + /// assert_eq!(r.networks_list(), true); + /// assert_eq!(r.processes().is_some(), true); + /// assert_eq!(r.disks_list(), true); + /// assert_eq!(r.disks(), true); + /// assert_eq!(r.memory(), true); + /// assert_eq!(r.cpu().is_some(), true); + /// assert_eq!(r.components(), true); + /// assert_eq!(r.components_list(), true); + /// assert_eq!(r.users_list(), true); + /// ``` + pub fn everything() -> Self { + Self { + networks: true, + networks_list: true, + processes: Some(ProcessRefreshKind::everything()), + disks: true, + disks_list: true, + memory: true, + cpu: Some(CpuRefreshKind::everything()), + components: true, + components_list: true, + users_list: true, + } + } + + impl_get_set!( + RefreshKind, + processes, + with_processes, + without_processes, + ProcessRefreshKind + ); + impl_get_set!(RefreshKind, networks, with_networks, without_networks); + impl_get_set!( + RefreshKind, + networks_list, + with_networks_list, + without_networks_list + ); + impl_get_set!(RefreshKind, disks, with_disks, without_disks); + impl_get_set!(RefreshKind, disks_list, with_disks_list, without_disks_list); + impl_get_set!(RefreshKind, memory, with_memory, without_memory); + impl_get_set!(RefreshKind, cpu, with_cpu, without_cpu, CpuRefreshKind); + impl_get_set!(RefreshKind, components, with_components, without_components); + impl_get_set!( + RefreshKind, + components_list, + with_components_list, + without_components_list + ); + impl_get_set!(RefreshKind, users_list, with_users_list, without_users_list); +} + +/// Iterator over network interfaces. +/// +/// It is returned by [`Networks::iter`][crate::Networks#method.iter]. +/// +/// ```no_run +/// use sysinfo::{System, SystemExt, NetworksExt}; +/// +/// let system = System::new_all(); +/// let networks_iter = system.networks().iter(); +/// ``` +pub struct NetworksIter<'a> { + inner: std::collections::hash_map::Iter<'a, String, NetworkData>, +} + +impl<'a> NetworksIter<'a> { + pub(crate) fn new(v: std::collections::hash_map::Iter<'a, String, NetworkData>) -> Self { + NetworksIter { inner: v } + } +} + +impl<'a> Iterator for NetworksIter<'a> { + type Item = (&'a String, &'a NetworkData); + + fn next(&mut self) -> Option<Self::Item> { + self.inner.next() + } +} + +impl<'a> IntoIterator for &'a Networks { + type Item = (&'a String, &'a NetworkData); + type IntoIter = NetworksIter<'a>; + + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +/// Enum containing the different supported disks types. +/// +/// This type is returned by [`Disk::get_type`][crate::Disk#method.type]. +/// +/// ```no_run +/// use sysinfo::{System, SystemExt, DiskExt}; +/// +/// let system = System::new_all(); +/// for disk in system.disks() { +/// println!("{:?}: {:?}", disk.name(), disk.type_()); +/// } +/// ``` +#[derive(Debug, PartialEq, Eq, Clone, Copy)] +pub enum DiskType { + /// HDD type. + HDD, + /// SSD type. + SSD, + /// Unknown type. + Unknown(isize), +} + +/// An enum representing signals on UNIX-like systems. +/// +/// On non-unix systems, this enum is mostly useless and is only there to keep coherency between +/// the different OSes. +/// +/// If you want the list of the supported signals on the current system, use +/// [`SystemExt::SUPPORTED_SIGNALS`][crate::SystemExt::SUPPORTED_SIGNALS]. +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Debug)] +pub enum Signal { + /// Hangup detected on controlling terminal or death of controlling process. + Hangup, + /// Interrupt from keyboard. + Interrupt, + /// Quit from keyboard. + Quit, + /// Illegal instruction. + Illegal, + /// Trace/breakpoint trap. + Trap, + /// Abort signal from C abort function. + Abort, + /// IOT trap. A synonym for SIGABRT. + IOT, + /// Bus error (bad memory access). + Bus, + /// Floating point exception. + FloatingPointException, + /// Kill signal. + Kill, + /// User-defined signal 1. + User1, + /// Invalid memory reference. + Segv, + /// User-defined signal 2. + User2, + /// Broken pipe: write to pipe with no readers. + Pipe, + /// Timer signal from C alarm function. + Alarm, + /// Termination signal. + Term, + /// Child stopped or terminated. + Child, + /// Continue if stopped. + Continue, + /// Stop process. + Stop, + /// Stop typed at terminal. + TSTP, + /// Terminal input for background process. + TTIN, + /// Terminal output for background process. + TTOU, + /// Urgent condition on socket. + Urgent, + /// CPU time limit exceeded. + XCPU, + /// File size limit exceeded. + XFSZ, + /// Virtual alarm clock. + VirtualAlarm, + /// Profiling time expired. + Profiling, + /// Windows resize signal. + Winch, + /// I/O now possible. + IO, + /// Pollable event (Sys V). Synonym for IO + Poll, + /// Power failure (System V). + /// + /// Doesn't exist on apple systems so will be ignored. + Power, + /// Bad argument to routine (SVr4). + Sys, +} + +impl std::fmt::Display for Signal { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let s = match *self { + Self::Hangup => "Hangup", + Self::Interrupt => "Interrupt", + Self::Quit => "Quit", + Self::Illegal => "Illegal", + Self::Trap => "Trap", + Self::Abort => "Abort", + Self::IOT => "IOT", + Self::Bus => "Bus", + Self::FloatingPointException => "FloatingPointException", + Self::Kill => "Kill", + Self::User1 => "User1", + Self::Segv => "Segv", + Self::User2 => "User2", + Self::Pipe => "Pipe", + Self::Alarm => "Alarm", + Self::Term => "Term", + Self::Child => "Child", + Self::Continue => "Continue", + Self::Stop => "Stop", + Self::TSTP => "TSTP", + Self::TTIN => "TTIN", + Self::TTOU => "TTOU", + Self::Urgent => "Urgent", + Self::XCPU => "XCPU", + Self::XFSZ => "XFSZ", + Self::VirtualAlarm => "VirtualAlarm", + Self::Profiling => "Profiling", + Self::Winch => "Winch", + Self::IO => "IO", + Self::Poll => "Poll", + Self::Power => "Power", + Self::Sys => "Sys", + }; + f.write_str(s) + } +} + +/// A struct representing system load average value. +/// +/// It is returned by [`SystemExt::load_average`][crate::SystemExt::load_average]. +/// +/// ```no_run +/// use sysinfo::{System, SystemExt}; +/// +/// let s = System::new_all(); +/// let load_avg = s.load_average(); +/// println!( +/// "one minute: {}%, five minutes: {}%, fifteen minutes: {}%", +/// load_avg.one, +/// load_avg.five, +/// load_avg.fifteen, +/// ); +/// ``` +#[repr(C)] +#[derive(Default, Debug, Clone)] +pub struct LoadAvg { + /// Average load within one minute. + pub one: f64, + /// Average load within five minutes. + pub five: f64, + /// Average load within fifteen minutes. + pub fifteen: f64, +} + +macro_rules! xid { + ($(#[$outer:meta])+ $name:ident, $type:ty) => { + $(#[$outer])+ + #[repr(transparent)] + #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug)] + pub struct $name(pub(crate) $type); + + impl std::ops::Deref for $name { + type Target = $type; + + fn deref(&self) -> &Self::Target { + &self.0 + } + } + }; +} + +macro_rules! uid { + ($(#[$outer:meta])+ $type:ty) => { + xid!($(#[$outer])+ Uid, $type); + }; +} + +macro_rules! gid { + ($(#[$outer:meta])+ $type:ty) => { + xid!($(#[$outer])+ #[derive(Copy)] Gid, $type); + }; +} + +cfg_if::cfg_if! { + if #[cfg(all( + not(feature = "unknown-ci"), + any( + target_os = "freebsd", + target_os = "linux", + target_os = "android", + target_os = "macos", + target_os = "ios", + ) + ))] { + uid!( + /// A user id wrapping a platform specific type. + libc::uid_t + ); + gid!( + /// A group id wrapping a platform specific type. + libc::gid_t + ); + } else if #[cfg(windows)] { + uid!( + /// A user id wrapping a platform specific type. + Box<str> + ); + gid!( + /// A group id wrapping a platform specific type. + u32 + ); + } else { + uid!( + /// A user id wrapping a platform specific type. + u32 + ); + gid!( + /// A group id wrapping a platform specific type. + u32 + ); + + } +} + +/// Type containing user information. +/// +/// It is returned by [`SystemExt::users`][crate::SystemExt::users]. +/// +/// ```no_run +/// use sysinfo::{System, SystemExt}; +/// +/// let s = System::new_all(); +/// println!("users: {:?}", s.users()); +/// ``` +#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)] +pub struct User { + pub(crate) uid: Uid, + pub(crate) gid: Gid, + pub(crate) name: String, + pub(crate) groups: Vec<String>, +} + +impl UserExt for User { + fn id(&self) -> &Uid { + &self.uid + } + + fn group_id(&self) -> Gid { + self.gid + } + + fn name(&self) -> &str { + &self.name + } + + fn groups(&self) -> &[String] { + &self.groups + } +} + +/// Type containing read and written bytes. +/// +/// It is returned by [`ProcessExt::disk_usage`][crate::ProcessExt::disk_usage]. +/// +/// ```no_run +/// use sysinfo::{ProcessExt, System, SystemExt}; +/// +/// let s = System::new_all(); +/// for (pid, process) in s.processes() { +/// let disk_usage = process.disk_usage(); +/// println!("[{}] read bytes : new/total => {}/{} B", +/// pid, +/// disk_usage.read_bytes, +/// disk_usage.total_read_bytes, +/// ); +/// println!("[{}] written bytes: new/total => {}/{} B", +/// pid, +/// disk_usage.written_bytes, +/// disk_usage.total_written_bytes, +/// ); +/// } +/// ``` +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd)] +pub struct DiskUsage { + /// Total number of written bytes. + pub total_written_bytes: u64, + /// Number of written bytes since the last refresh. + pub written_bytes: u64, + /// Total number of read bytes. + pub total_read_bytes: u64, + /// Number of read bytes since the last refresh. + pub read_bytes: u64, +} + +/// Enum describing the different status of a process. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ProcessStatus { + /// ## Linux/FreeBSD + /// + /// Waiting in uninterruptible disk sleep. + /// + /// ## macOs + /// + /// Process being created by fork. + /// + /// ## Other OS + /// + /// Not available. + Idle, + /// Running. + Run, + /// ## Linux/FreeBSD + /// + /// Sleeping in an interruptible waiting. + /// + /// ## macOS + /// + /// Sleeping on an address. + /// + /// ## Other OS + /// + /// Not available. + Sleep, + /// ## Linux/FreeBSD + /// + /// Stopped (on a signal) or (before Linux 2.6.33) trace stopped. + /// + /// ## macOS + /// + /// Process debugging or suspension. + /// + /// ## Other OS + /// + /// Not available. + Stop, + /// ## Linux/FreeBSD/macOS + /// + /// Zombie process. Terminated but not reaped by its parent. + /// + /// ## Other OS + /// + /// Not available. + Zombie, + /// ## Linux + /// + /// Tracing stop (Linux 2.6.33 onward). Stopped by debugger during the tracing. + /// + /// ## Other OS + /// + /// Not available. + Tracing, + /// ## Linux/FreeBSD + /// + /// Dead/uninterruptible sleep (usually IO). + /// + /// ## Other OS + /// + /// Not available. + Dead, + /// ## Linux + /// + /// Wakekill (Linux 2.6.33 to 3.13 only). + /// + /// ## Other OS + /// + /// Not available. + Wakekill, + /// ## Linux + /// + /// Waking (Linux 2.6.33 to 3.13 only). + /// + /// ## Other OS + /// + /// Not available. + Waking, + /// ## Linux + /// + /// Parked (Linux 3.9 to 3.13 only). + /// + /// ## Other OS + /// + /// Not available. + Parked, + /// ## FreeBSD + /// + /// Blocked on a lock. + /// + /// ## Other OS + /// + /// Not available. + LockBlocked, + /// Unknown. + Unknown(u32), +} + +/// Returns the pid for the current process. +/// +/// `Err` is returned in case the platform isn't supported. +/// +/// ```no_run +/// use sysinfo::get_current_pid; +/// +/// match get_current_pid() { +/// Ok(pid) => { +/// println!("current pid: {}", pid); +/// } +/// Err(e) => { +/// eprintln!("failed to get current pid: {}", e); +/// } +/// } +/// ``` +#[allow(clippy::unnecessary_wraps)] +pub fn get_current_pid() -> Result<Pid, &'static str> { + cfg_if::cfg_if! { + if #[cfg(feature = "unknown-ci")] { + fn inner() -> Result<Pid, &'static str> { + Err("Unknown platform (CI)") + } + } else if #[cfg(any( + target_os = "freebsd", + target_os = "linux", + target_os = "android", + target_os = "macos", + target_os = "ios", + ))] { + fn inner() -> Result<Pid, &'static str> { + unsafe { Ok(Pid(libc::getpid())) } + } + } else if #[cfg(windows)] { + fn inner() -> Result<Pid, &'static str> { + use winapi::um::processthreadsapi::GetCurrentProcessId; + + unsafe { Ok(Pid(GetCurrentProcessId() as _)) } + } + } else { + fn inner() -> Result<Pid, &'static str> { + Err("Unknown platform") + } + } + } + inner() +} + +#[cfg(test)] +mod tests { + use super::ProcessStatus; + + // This test only exists to ensure that the `Display` trait is implemented on the + // `ProcessStatus` enum on all targets. + #[test] + fn check_display_impl_process_status() { + println!("{} {:?}", ProcessStatus::Parked, ProcessStatus::Idle); + } +} diff --git a/vendor/sysinfo/src/debug.rs b/vendor/sysinfo/src/debug.rs new file mode 100644 index 000000000..e2f4361d9 --- /dev/null +++ b/vendor/sysinfo/src/debug.rs @@ -0,0 +1,132 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{ + Component, ComponentExt, Cpu, CpuExt, Disk, DiskExt, NetworkData, NetworkExt, Networks, + NetworksExt, Process, ProcessExt, System, SystemExt, +}; + +use std::fmt; + +impl fmt::Debug for Cpu { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Cpu") + .field("name", &self.name()) + .field("CPU usage", &self.cpu_usage()) + .field("frequency", &self.frequency()) + .field("vendor ID", &self.vendor_id()) + .field("brand", &self.brand()) + .finish() + } +} + +impl fmt::Debug for System { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("System") + .field("global CPU usage", &self.global_cpu_info().cpu_usage()) + .field("load average", &self.load_average()) + .field("total memory", &self.total_memory()) + .field("free memory", &self.free_memory()) + .field("total swap", &self.total_swap()) + .field("free swap", &self.free_swap()) + .field("nb CPUs", &self.cpus().len()) + .field("nb network interfaces", &self.networks().iter().count()) + .field("nb processes", &self.processes().len()) + .field("nb disks", &self.disks().len()) + .field("nb components", &self.components().len()) + .finish() + } +} + +impl fmt::Debug for Disk { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + fmt, + "Disk({:?})[FS: {:?}][Type: {:?}][removable: {}] mounted on {:?}: {}/{} B", + self.name(), + self.file_system() + .iter() + .map(|c| *c as char) + .collect::<Vec<_>>(), + self.type_(), + if self.is_removable() { "yes" } else { "no" }, + self.mount_point(), + self.available_space(), + self.total_space(), + ) + } +} + +impl fmt::Debug for Process { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Process") + .field("pid", &self.pid()) + .field("parent", &self.parent()) + .field("name", &self.name()) + .field("environ", &self.environ()) + .field("command", &self.cmd()) + .field("executable path", &self.exe()) + .field("current working directory", &self.cwd()) + .field("memory usage", &self.memory()) + .field("virtual memory usage", &self.virtual_memory()) + .field("CPU usage", &self.cpu_usage()) + .field("status", &self.status()) + .field("root", &self.root()) + .field("disk_usage", &self.disk_usage()) + .finish() + } +} + +impl fmt::Debug for Component { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + if let Some(critical) = self.critical() { + write!( + f, + "{}: {}°C (max: {}°C / critical: {}°C)", + self.label(), + self.temperature(), + self.max(), + critical + ) + } else { + write!( + f, + "{}: {}°C (max: {}°C)", + self.label(), + self.temperature(), + self.max() + ) + } + } +} + +impl fmt::Debug for Networks { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "Networks {{ {} }}", + self.iter() + .map(|x| format!("{:?}", x)) + .collect::<Vec<_>>() + .join(", ") + ) + } +} + +impl fmt::Debug for NetworkData { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("NetworkData") + .field("income", &self.received()) + .field("total income", &self.total_received()) + .field("outcome", &self.transmitted()) + .field("total outcome", &self.total_transmitted()) + .field("packets income", &self.packets_received()) + .field("total packets income", &self.total_packets_received()) + .field("packets outcome", &self.packets_transmitted()) + .field("total packets outcome", &self.total_packets_transmitted()) + .field("errors income", &self.errors_on_received()) + .field("total errors income", &self.total_errors_on_received()) + .field("errors outcome", &self.errors_on_transmitted()) + .field("total errors outcome", &self.total_errors_on_transmitted()) + .finish() + } +} diff --git a/vendor/sysinfo/src/freebsd/component.rs b/vendor/sysinfo/src/freebsd/component.rs new file mode 100644 index 000000000..6529be73c --- /dev/null +++ b/vendor/sysinfo/src/freebsd/component.rs @@ -0,0 +1,71 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use super::utils::get_sys_value_by_name; +use crate::ComponentExt; + +#[doc = include_str!("../../md_doc/component.md")] +pub struct Component { + id: Vec<u8>, + label: String, + temperature: f32, + max: f32, +} + +impl ComponentExt for Component { + fn temperature(&self) -> f32 { + self.temperature + } + + fn max(&self) -> f32 { + self.max + } + + fn critical(&self) -> Option<f32> { + None + } + + fn label(&self) -> &str { + &self.label + } + + fn refresh(&mut self) { + unsafe { + if let Some(temperature) = refresh_component(&self.id) { + self.temperature = temperature; + if self.temperature > self.max { + self.max = self.temperature; + } + } + } + } +} + +unsafe fn refresh_component(id: &[u8]) -> Option<f32> { + let mut temperature: libc::c_int = 0; + if !get_sys_value_by_name(id, &mut temperature) { + None + } else { + // convert from Kelvin (x 10 -> 273.2 x 10) to Celsius + Some((temperature - 2732) as f32 / 10.) + } +} + +pub unsafe fn get_components(nb_cpus: usize) -> Vec<Component> { + // For now, we only have temperature for CPUs... + 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(); + if let Some(temperature) = refresh_component(&id) { + components.push(Component { + id, + label: format!("CPU {}", core + 1), + temperature, + max: temperature, + }); + } + } + components +} diff --git a/vendor/sysinfo/src/freebsd/cpu.rs b/vendor/sysinfo/src/freebsd/cpu.rs new file mode 100644 index 000000000..9d6c8e506 --- /dev/null +++ b/vendor/sysinfo/src/freebsd/cpu.rs @@ -0,0 +1,44 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::CpuExt; + +#[doc = include_str!("../../md_doc/cpu.md")] +pub struct Cpu { + pub(crate) cpu_usage: f32, + name: String, + pub(crate) vendor_id: String, + pub(crate) frequency: u64, +} + +impl Cpu { + pub(crate) fn new(name: String, vendor_id: String, frequency: u64) -> Cpu { + Cpu { + cpu_usage: 0., + name, + vendor_id, + frequency, + } + } +} + +impl CpuExt for Cpu { + fn cpu_usage(&self) -> f32 { + self.cpu_usage + } + + fn name(&self) -> &str { + &self.name + } + + fn frequency(&self) -> u64 { + self.frequency + } + + fn vendor_id(&self) -> &str { + &self.vendor_id + } + + fn brand(&self) -> &str { + "" + } +} diff --git a/vendor/sysinfo/src/freebsd/disk.rs b/vendor/sysinfo/src/freebsd/disk.rs new file mode 100644 index 000000000..5156f1215 --- /dev/null +++ b/vendor/sysinfo/src/freebsd/disk.rs @@ -0,0 +1,143 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{DiskExt, DiskType}; + +use std::ffi::{OsStr, OsString}; +use std::path::{Path, PathBuf}; + +use super::utils::c_buf_to_str; + +#[doc = include_str!("../../md_doc/disk.md")] +pub struct Disk { + name: OsString, + c_mount_point: Vec<libc::c_char>, + mount_point: PathBuf, + total_space: u64, + available_space: u64, + file_system: Vec<u8>, + is_removable: bool, +} + +impl DiskExt for Disk { + fn type_(&self) -> DiskType { + DiskType::Unknown(-1) + } + + fn name(&self) -> &OsStr { + &self.name + } + + fn file_system(&self) -> &[u8] { + &self.file_system + } + + fn mount_point(&self) -> &Path { + &self.mount_point + } + + fn total_space(&self) -> u64 { + self.total_space + } + + fn available_space(&self) -> u64 { + self.available_space + } + + fn is_removable(&self) -> bool { + self.is_removable + } + + fn refresh(&mut self) -> bool { + unsafe { + let mut vfs: libc::statvfs = std::mem::zeroed(); + refresh_disk(self, &mut vfs) + } + } +} + +// FIXME: if you want to get disk I/O usage: +// statfs.[f_syncwrites, f_asyncwrites, f_syncreads, f_asyncreads] + +unsafe fn refresh_disk(disk: &mut Disk, vfs: &mut libc::statvfs) -> bool { + if libc::statvfs(disk.c_mount_point.as_ptr() as *const _, vfs) < 0 { + return false; + } + let f_frsize: u64 = vfs.f_frsize as _; + + disk.total_space = vfs.f_blocks.saturating_mul(f_frsize); + disk.available_space = vfs.f_favail.saturating_mul(f_frsize); + true +} + +pub unsafe fn get_all_disks() -> Vec<Disk> { + let mut fs_infos: *mut libc::statfs = std::ptr::null_mut(); + + let count = libc::getmntinfo(&mut fs_infos, libc::MNT_WAIT); + + if count < 1 { + return Vec::new(); + } + let mut vfs: libc::statvfs = std::mem::zeroed(); + let fs_infos: &[libc::statfs] = std::slice::from_raw_parts(fs_infos as _, count as _); + let mut disks = Vec::new(); + + for fs_info in fs_infos { + if fs_info.f_mntfromname[0] == 0 || fs_info.f_mntonname[0] == 0 { + // If we have missing information, no need to look any further... + continue; + } + let fs_type: &[libc::c_char] = + if let Some(pos) = fs_info.f_fstypename.iter().position(|x| *x == 0) { + &fs_info.f_fstypename[..pos] + } else { + &fs_info.f_fstypename + }; + let fs_type: &[u8] = std::slice::from_raw_parts(fs_type.as_ptr() as _, fs_type.len()); + match fs_type { + b"autofs" | b"devfs" | b"linprocfs" | b"procfs" | b"fdesckfs" | b"tmpfs" + | b"linsysfs" => { + sysinfo_debug!( + "Memory filesystem `{:?}`, ignoring it.", + c_buf_to_str(&fs_info.f_fstypename).unwrap(), + ); + continue; + } + _ => {} + } + + if libc::statvfs(fs_info.f_mntonname.as_ptr(), &mut vfs) != 0 { + continue; + } + + let mount_point = match c_buf_to_str(&fs_info.f_mntonname) { + Some(m) => m, + None => { + sysinfo_debug!("Cannot get disk mount point, ignoring it."); + continue; + } + }; + + let name = if mount_point == "/" { + OsString::from("root") + } else { + OsString::from(mount_point) + }; + + // USB keys and CDs are removable. + let is_removable = + [b"USB", b"usb"].iter().any(|b| b == &fs_type) || fs_type.starts_with(b"/dev/cd"); + + let f_frsize: u64 = vfs.f_frsize as _; + + disks.push(Disk { + name, + c_mount_point: fs_info.f_mntonname.to_vec(), + mount_point: PathBuf::from(mount_point), + total_space: vfs.f_blocks.saturating_mul(f_frsize), + available_space: vfs.f_favail.saturating_mul(f_frsize), + file_system: fs_type.to_vec(), + is_removable, + }); + } + disks +} diff --git a/vendor/sysinfo/src/freebsd/mod.rs b/vendor/sysinfo/src/freebsd/mod.rs new file mode 100644 index 000000000..8a8726812 --- /dev/null +++ b/vendor/sysinfo/src/freebsd/mod.rs @@ -0,0 +1,16 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +pub mod component; +pub mod cpu; +pub mod disk; +pub mod network; +pub mod process; +pub mod system; +mod utils; + +pub use self::component::Component; +pub use self::cpu::Cpu; +pub use self::disk::Disk; +pub use self::network::{NetworkData, Networks}; +pub use self::process::Process; +pub use self::system::System; diff --git a/vendor/sysinfo/src/freebsd/network.rs b/vendor/sysinfo/src/freebsd/network.rs new file mode 100644 index 000000000..e58ad823a --- /dev/null +++ b/vendor/sysinfo/src/freebsd/network.rs @@ -0,0 +1,199 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::collections::{hash_map, HashMap}; +use std::mem::MaybeUninit; + +use super::utils; +use crate::{NetworkExt, NetworksExt, NetworksIter}; + +macro_rules! old_and_new { + ($ty_:expr, $name:ident, $old:ident, $data:expr) => {{ + $ty_.$old = $ty_.$name; + $ty_.$name = $data.$name; + }}; +} + +#[doc = include_str!("../../md_doc/networks.md")] +pub struct Networks { + interfaces: HashMap<String, NetworkData>, +} + +impl Networks { + pub(crate) fn new() -> Networks { + Networks { + interfaces: HashMap::new(), + } + } +} + +impl NetworksExt for Networks { + fn iter(&self) -> NetworksIter { + NetworksIter::new(self.interfaces.iter()) + } + + fn refresh_networks_list(&mut self) { + unsafe { + self.refresh_interfaces(true); + } + // Remove interfaces which are gone. + self.interfaces.retain(|_, n| n.updated); + } + + fn refresh(&mut self) { + unsafe { + self.refresh_interfaces(false); + } + } +} + +impl Networks { + unsafe fn refresh_interfaces(&mut self, refresh_all: bool) { + let mut nb_interfaces: libc::c_int = 0; + if !utils::get_sys_value( + &[ + libc::CTL_NET, + libc::PF_LINK, + libc::NETLINK_GENERIC, + libc::IFMIB_SYSTEM, + libc::IFMIB_IFCOUNT, + ], + &mut nb_interfaces, + ) { + return; + } + if refresh_all { + // We don't need to update this value if we're not updating all interfaces. + for interface in self.interfaces.values_mut() { + interface.updated = false; + } + } + let mut data: libc::ifmibdata = MaybeUninit::zeroed().assume_init(); + for row in 1..nb_interfaces { + let mib = [ + libc::CTL_NET, + libc::PF_LINK, + libc::NETLINK_GENERIC, + libc::IFMIB_IFDATA, + row, + libc::IFDATA_GENERAL, + ]; + + if !utils::get_sys_value(&mib, &mut data) { + continue; + } + if let Some(name) = utils::c_buf_to_string(&data.ifmd_name) { + let data = &data.ifmd_data; + match self.interfaces.entry(name) { + hash_map::Entry::Occupied(mut e) => { + let mut interface = e.get_mut(); + + old_and_new!(interface, ifi_ibytes, old_ifi_ibytes, data); + old_and_new!(interface, ifi_obytes, old_ifi_obytes, data); + old_and_new!(interface, ifi_ipackets, old_ifi_ipackets, data); + old_and_new!(interface, ifi_opackets, old_ifi_opackets, data); + old_and_new!(interface, ifi_ierrors, old_ifi_ierrors, data); + old_and_new!(interface, ifi_oerrors, old_ifi_oerrors, data); + interface.updated = true; + } + hash_map::Entry::Vacant(e) => { + if !refresh_all { + // This is simply a refresh, we don't want to add new interfaces! + continue; + } + e.insert(NetworkData { + ifi_ibytes: data.ifi_ibytes, + old_ifi_ibytes: 0, + ifi_obytes: data.ifi_obytes, + old_ifi_obytes: 0, + ifi_ipackets: data.ifi_ipackets, + old_ifi_ipackets: 0, + ifi_opackets: data.ifi_opackets, + old_ifi_opackets: 0, + ifi_ierrors: data.ifi_ierrors, + old_ifi_ierrors: 0, + ifi_oerrors: data.ifi_oerrors, + old_ifi_oerrors: 0, + updated: true, + }); + } + } + } + } + } +} + +#[doc = include_str!("../../md_doc/network_data.md")] +pub struct NetworkData { + /// Total number of bytes received over interface. + ifi_ibytes: u64, + old_ifi_ibytes: u64, + /// Total number of bytes transmitted over interface. + ifi_obytes: u64, + old_ifi_obytes: u64, + /// Total number of packets received. + ifi_ipackets: u64, + old_ifi_ipackets: u64, + /// Total number of packets transmitted. + ifi_opackets: u64, + old_ifi_opackets: u64, + /// Shows the total number of packets received with error. This includes + /// too-long-frames errors, ring-buffer overflow errors, CRC errors, + /// frame alignment errors, fifo overruns, and missed packets. + ifi_ierrors: u64, + old_ifi_ierrors: u64, + /// similar to `ifi_ierrors` + ifi_oerrors: u64, + old_ifi_oerrors: u64, + /// Whether or not the above data has been updated during refresh + updated: bool, +} + +impl NetworkExt for NetworkData { + fn received(&self) -> u64 { + self.ifi_ibytes.saturating_sub(self.old_ifi_ibytes) + } + + fn total_received(&self) -> u64 { + self.ifi_ibytes + } + + fn transmitted(&self) -> u64 { + self.ifi_obytes.saturating_sub(self.old_ifi_obytes) + } + + fn total_transmitted(&self) -> u64 { + self.ifi_obytes + } + + fn packets_received(&self) -> u64 { + self.ifi_ipackets.saturating_sub(self.old_ifi_ipackets) + } + + fn total_packets_received(&self) -> u64 { + self.ifi_ipackets + } + + fn packets_transmitted(&self) -> u64 { + self.ifi_opackets.saturating_sub(self.old_ifi_opackets) + } + + fn total_packets_transmitted(&self) -> u64 { + self.ifi_opackets + } + + fn errors_on_received(&self) -> u64 { + self.ifi_ierrors.saturating_sub(self.old_ifi_ierrors) + } + + fn total_errors_on_received(&self) -> u64 { + self.ifi_ierrors + } + + fn errors_on_transmitted(&self) -> u64 { + self.ifi_oerrors.saturating_sub(self.old_ifi_oerrors) + } + + fn total_errors_on_transmitted(&self) -> u64 { + self.ifi_oerrors + } +} diff --git a/vendor/sysinfo/src/freebsd/process.rs b/vendor/sysinfo/src/freebsd/process.rs new file mode 100644 index 000000000..b3302edbe --- /dev/null +++ b/vendor/sysinfo/src/freebsd/process.rs @@ -0,0 +1,254 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessRefreshKind, ProcessStatus, Signal, Uid}; + +use std::fmt; +use std::path::{Path, PathBuf}; + +use super::utils::{get_sys_value_str, WrapMap}; + +#[doc(hidden)] +impl From<libc::c_char> for ProcessStatus { + fn from(status: libc::c_char) -> ProcessStatus { + match status { + libc::SIDL => ProcessStatus::Idle, + libc::SRUN => ProcessStatus::Run, + libc::SSLEEP => ProcessStatus::Sleep, + libc::SSTOP => ProcessStatus::Stop, + libc::SZOMB => ProcessStatus::Zombie, + libc::SWAIT => ProcessStatus::Dead, + libc::SLOCK => ProcessStatus::LockBlocked, + x => ProcessStatus::Unknown(x as _), + } + } +} + +impl fmt::Display for ProcessStatus { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(match *self { + ProcessStatus::Idle => "Idle", + ProcessStatus::Run => "Runnable", + ProcessStatus::Sleep => "Sleeping", + ProcessStatus::Stop => "Stopped", + ProcessStatus::Zombie => "Zombie", + ProcessStatus::Dead => "Dead", + ProcessStatus::LockBlocked => "LockBlocked", + _ => "Unknown", + }) + } +} + +#[doc = include_str!("../../md_doc/process.md")] +pub struct Process { + pub(crate) name: String, + pub(crate) cmd: Vec<String>, + pub(crate) exe: PathBuf, + pub(crate) pid: Pid, + parent: Option<Pid>, + pub(crate) environ: Vec<String>, + pub(crate) cwd: PathBuf, + pub(crate) root: PathBuf, + pub(crate) memory: u64, + pub(crate) virtual_memory: u64, + pub(crate) updated: bool, + cpu_usage: f32, + start_time: u64, + run_time: u64, + pub(crate) status: ProcessStatus, + user_id: Uid, + group_id: Gid, + read_bytes: u64, + old_read_bytes: u64, + written_bytes: u64, + old_written_bytes: u64, +} + +impl ProcessExt for Process { + fn kill_with(&self, signal: Signal) -> Option<bool> { + let c_signal = super::system::convert_signal(signal)?; + unsafe { Some(libc::kill(self.pid.0, c_signal) == 0) } + } + + fn name(&self) -> &str { + &self.name + } + + fn cmd(&self) -> &[String] { + &self.cmd + } + + fn exe(&self) -> &Path { + self.exe.as_path() + } + + fn pid(&self) -> Pid { + self.pid + } + + fn environ(&self) -> &[String] { + &self.environ + } + + fn cwd(&self) -> &Path { + self.cwd.as_path() + } + + fn root(&self) -> &Path { + self.root.as_path() + } + + fn memory(&self) -> u64 { + self.memory + } + + fn virtual_memory(&self) -> u64 { + self.virtual_memory + } + + fn parent(&self) -> Option<Pid> { + self.parent + } + + fn status(&self) -> ProcessStatus { + self.status + } + + fn start_time(&self) -> u64 { + self.start_time + } + + fn run_time(&self) -> u64 { + self.run_time + } + + fn cpu_usage(&self) -> f32 { + self.cpu_usage + } + + fn disk_usage(&self) -> DiskUsage { + DiskUsage { + written_bytes: self.written_bytes.saturating_sub(self.old_written_bytes), + total_written_bytes: self.written_bytes, + read_bytes: self.read_bytes.saturating_sub(self.old_read_bytes), + total_read_bytes: self.read_bytes, + } + } + + fn user_id(&self) -> Option<&Uid> { + Some(&self.user_id) + } + + fn group_id(&self) -> Option<Gid> { + Some(self.group_id) + } +} + +pub(crate) unsafe fn get_process_data( + kproc: &libc::kinfo_proc, + wrap: &WrapMap, + page_size: isize, + fscale: f32, + now: u64, + refresh_kind: ProcessRefreshKind, +) -> Result<Option<Process>, ()> { + if kproc.ki_pid != 1 && (kproc.ki_flag as libc::c_int & libc::P_SYSTEM) != 0 { + // We filter out the kernel threads. + return Err(()); + } + + // We now get the values needed for both new and existing process. + let cpu_usage = if refresh_kind.cpu() { + (100 * kproc.ki_pctcpu) as f32 / fscale + } else { + 0. + }; + // Processes can be reparented apparently? + let parent = if kproc.ki_ppid != 0 { + Some(Pid(kproc.ki_ppid)) + } else { + None + }; + 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; + // FIXME: This is to get the "real" run time (in micro-seconds). + // let run_time = (kproc.ki_runtime + 5_000) / 10_000; + + 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 _; + } + + return Ok(None); + } + + // This is a new process, we need to get more information! + let mut buffer = [0; libc::PATH_MAX as usize + 1]; + + let exe = get_sys_value_str( + &[ + libc::CTL_KERN, + libc::KERN_PROC, + libc::KERN_PROC_PATHNAME, + kproc.ki_pid, + ], + &mut buffer, + ) + .unwrap_or_default(); + // For some reason, it can return completely invalid path like `p\u{5}`. So we need to use + // procstat to get around this problem. + // let cwd = get_sys_value_str( + // &[ + // libc::CTL_KERN, + // libc::KERN_PROC, + // libc::KERN_PROC_CWD, + // kproc.ki_pid, + // ], + // &mut buffer, + // ) + // .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, + user_id: Uid(kproc.ki_ruid), + group_id: Gid(kproc.ki_rgid), + start_time, + run_time: now.saturating_sub(start_time), + cpu_usage, + virtual_memory, + memory, + // procstat_getfiles + cwd: PathBuf::new(), + exe: exe.into(), + // kvm_getargv isn't thread-safe so we get it in the main thread. + name: String::new(), + // kvm_getargv isn't thread-safe so we get it in the main thread. + cmd: Vec::new(), + // kvm_getargv isn't thread-safe so we get it in the main thread. + root: PathBuf::new(), + // kvm_getenvv isn't thread-safe so we get it in the main thread. + environ: Vec::new(), + status, + read_bytes: kproc.ki_rusage.ru_inblock as _, + old_read_bytes: 0, + written_bytes: kproc.ki_rusage.ru_oublock as _, + old_written_bytes: 0, + updated: true, + })) +} diff --git a/vendor/sysinfo/src/freebsd/system.rs b/vendor/sysinfo/src/freebsd/system.rs new file mode 100644 index 000000000..16da2de50 --- /dev/null +++ b/vendor/sysinfo/src/freebsd/system.rs @@ -0,0 +1,803 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{ + sys::{component::Component, Cpu, Disk, Networks, Process}, + CpuRefreshKind, LoadAvg, Pid, ProcessRefreshKind, RefreshKind, SystemExt, User, +}; + +use std::cell::UnsafeCell; +use std::collections::HashMap; +use std::ffi::CStr; +use std::mem::MaybeUninit; +use std::path::{Path, PathBuf}; +use std::ptr::NonNull; + +use super::utils::{ + self, boot_time, c_buf_to_string, from_cstr_array, get_frequency_for_cpu, get_sys_value, + get_sys_value_array, get_sys_value_by_name, get_sys_value_str_by_name, get_system_info, + init_mib, +}; + +use libc::c_int; + +declare_signals! { + c_int, + Signal::Hangup => libc::SIGHUP, + Signal::Interrupt => libc::SIGINT, + Signal::Quit => libc::SIGQUIT, + Signal::Illegal => libc::SIGILL, + Signal::Trap => libc::SIGTRAP, + Signal::Abort => libc::SIGABRT, + Signal::IOT => libc::SIGIOT, + Signal::Bus => libc::SIGBUS, + Signal::FloatingPointException => libc::SIGFPE, + Signal::Kill => libc::SIGKILL, + Signal::User1 => libc::SIGUSR1, + Signal::Segv => libc::SIGSEGV, + Signal::User2 => libc::SIGUSR2, + Signal::Pipe => libc::SIGPIPE, + Signal::Alarm => libc::SIGALRM, + Signal::Term => libc::SIGTERM, + Signal::Child => libc::SIGCHLD, + Signal::Continue => libc::SIGCONT, + Signal::Stop => libc::SIGSTOP, + Signal::TSTP => libc::SIGTSTP, + Signal::TTIN => libc::SIGTTIN, + Signal::TTOU => libc::SIGTTOU, + Signal::Urgent => libc::SIGURG, + Signal::XCPU => libc::SIGXCPU, + Signal::XFSZ => libc::SIGXFSZ, + Signal::VirtualAlarm => libc::SIGVTALRM, + Signal::Profiling => libc::SIGPROF, + Signal::Winch => libc::SIGWINCH, + Signal::IO => libc::SIGIO, + Signal::Sys => libc::SIGSYS, + _ => None, +} + +#[doc = include_str!("../../md_doc/system.md")] +pub struct System { + process_list: HashMap<Pid, Process>, + mem_total: u64, + mem_free: u64, + mem_used: u64, + swap_total: u64, + swap_used: u64, + global_cpu: Cpu, + cpus: Vec<Cpu>, + components: Vec<Component>, + disks: Vec<Disk>, + networks: Networks, + users: Vec<User>, + boot_time: u64, + system_info: SystemInfo, + got_cpu_frequency: bool, +} + +impl SystemExt for System { + const IS_SUPPORTED: bool = true; + const SUPPORTED_SIGNALS: &'static [Signal] = supported_signals(); + + fn new_with_specifics(refreshes: RefreshKind) -> System { + let system_info = SystemInfo::new(); + + let mut s = System { + process_list: HashMap::with_capacity(200), + mem_total: 0, + mem_free: 0, + mem_used: 0, + swap_total: 0, + swap_used: 0, + global_cpu: Cpu::new(String::new(), String::new(), 0), + cpus: Vec::with_capacity(system_info.nb_cpus as _), + components: Vec::with_capacity(2), + disks: Vec::with_capacity(1), + networks: Networks::new(), + users: Vec::new(), + boot_time: boot_time(), + system_info, + got_cpu_frequency: false, + }; + s.refresh_specifics(refreshes); + s + } + + fn refresh_memory(&mut self) { + if self.mem_total == 0 { + self.mem_total = self.system_info.get_total_memory(); + } + self.mem_used = self.system_info.get_used_memory(); + self.mem_free = self.system_info.get_free_memory(); + let (swap_used, swap_total) = self.system_info.get_swap_info(); + self.swap_total = swap_total; + self.swap_used = swap_used; + } + + fn refresh_cpu_specifics(&mut self, refresh_kind: CpuRefreshKind) { + if self.cpus.is_empty() { + let mut frequency = 0; + + // We get the CPU vendor ID in here. + let vendor_id = + get_sys_value_str_by_name(b"hw.model\0").unwrap_or_else(|| "<unknown>".to_owned()); + for pos in 0..self.system_info.nb_cpus { + if refresh_kind.frequency() { + unsafe { + frequency = get_frequency_for_cpu(pos); + } + } + 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(); + } else if refresh_kind.frequency() && !self.got_cpu_frequency { + for (pos, proc_) in self.cpus.iter_mut().enumerate() { + unsafe { + proc_.frequency = get_frequency_for_cpu(pos as _); + } + } + self.got_cpu_frequency = true; + } + if refresh_kind.cpu_usage() { + self.system_info + .get_cpu_usage(&mut self.global_cpu, &mut self.cpus); + } + } + + fn refresh_components_list(&mut self) { + if self.cpus.is_empty() { + self.refresh_cpu(); + } + self.components = unsafe { super::component::get_components(self.cpus.len()) }; + } + + fn refresh_processes_specifics(&mut self, refresh_kind: ProcessRefreshKind) { + unsafe { self.refresh_procs(refresh_kind) } + } + + fn refresh_process_specifics(&mut self, pid: Pid, refresh_kind: ProcessRefreshKind) -> bool { + unsafe { + let kd = self.system_info.kd.as_ptr(); + let mut count = 0; + let procs = libc::kvm_getprocs(kd, libc::KERN_PROC_PROC, 0, &mut count); + if count < 1 { + sysinfo_debug!("kvm_getprocs returned nothing..."); + return false; + } + let now = super::utils::get_now(); + + let fscale = self.system_info.fscale; + let page_size = self.system_info.page_size as isize; + let proc_list = utils::WrapMap(UnsafeCell::new(&mut self.process_list)); + let procs: &mut [utils::KInfoProc] = + std::slice::from_raw_parts_mut(procs as _, count as _); + + #[cfg(feature = "multithread")] + use rayon::iter::ParallelIterator; + + macro_rules! multi_iter { + ($name:ident, $($iter:tt)+) => { + $name = crate::utils::into_iter(procs).$($iter)+; + } + } + + let ret; + #[cfg(not(feature = "multithread"))] + multi_iter!(ret, find(|kproc| kproc.ki_pid == pid.0)); + #[cfg(feature = "multithread")] + multi_iter!(ret, find_any(|kproc| kproc.ki_pid == pid.0)); + + let kproc = if let Some(kproc) = ret { + kproc + } else { + return false; + }; + match super::process::get_process_data( + kproc, + &proc_list, + page_size, + fscale, + now, + refresh_kind, + ) { + Ok(Some(proc_)) => { + self.add_missing_proc_info(self.system_info.kd.as_ptr(), kproc, proc_); + true + } + Ok(None) => true, + Err(_) => false, + } + } + } + + fn refresh_disks_list(&mut self) { + self.disks = unsafe { super::disk::get_all_disks() }; + } + + fn refresh_users_list(&mut self) { + self.users = crate::users::get_users_list(); + } + + // COMMON PART + // + // Need to be moved into a "common" file to avoid duplication. + + fn processes(&self) -> &HashMap<Pid, Process> { + &self.process_list + } + + fn process(&self, pid: Pid) -> Option<&Process> { + self.process_list.get(&pid) + } + + fn networks(&self) -> &Networks { + &self.networks + } + + fn networks_mut(&mut self) -> &mut Networks { + &mut self.networks + } + + fn global_cpu_info(&self) -> &Cpu { + &self.global_cpu + } + + fn cpus(&self) -> &[Cpu] { + &self.cpus + } + + fn physical_core_count(&self) -> Option<usize> { + let mut physical_core_count: u32 = 0; + + unsafe { + if get_sys_value_by_name(b"hw.ncpu\0", &mut physical_core_count) { + Some(physical_core_count as _) + } else { + None + } + } + } + + fn total_memory(&self) -> u64 { + self.mem_total + } + + fn free_memory(&self) -> u64 { + self.mem_free + } + + fn available_memory(&self) -> u64 { + self.mem_free + } + + fn used_memory(&self) -> u64 { + self.mem_used + } + + fn total_swap(&self) -> u64 { + self.swap_total + } + + fn free_swap(&self) -> u64 { + self.swap_total - self.swap_used + } + + // TODO: need to be checked + fn used_swap(&self) -> u64 { + self.swap_used + } + + fn components(&self) -> &[Component] { + &self.components + } + + fn components_mut(&mut self) -> &mut [Component] { + &mut self.components + } + + fn disks(&self) -> &[Disk] { + &self.disks + } + + fn disks_mut(&mut self) -> &mut [Disk] { + &mut self.disks + } + + fn uptime(&self) -> u64 { + unsafe { + let csec = libc::time(::std::ptr::null_mut()); + + libc::difftime(csec, self.boot_time as _) as u64 + } + } + + fn boot_time(&self) -> u64 { + self.boot_time + } + + fn load_average(&self) -> LoadAvg { + let mut loads = vec![0f64; 3]; + unsafe { + libc::getloadavg(loads.as_mut_ptr(), 3); + LoadAvg { + one: loads[0], + five: loads[1], + fifteen: loads[2], + } + } + } + + fn users(&self) -> &[User] { + &self.users + } + + fn name(&self) -> Option<String> { + self.system_info.get_os_name() + } + + fn long_os_version(&self) -> Option<String> { + self.system_info.get_os_release_long() + } + + fn host_name(&self) -> Option<String> { + self.system_info.get_hostname() + } + + fn kernel_version(&self) -> Option<String> { + self.system_info.get_kernel_version() + } + + fn os_version(&self) -> Option<String> { + self.system_info.get_os_release() + } +} + +impl Default for System { + fn default() -> Self { + Self::new() + } +} + +impl System { + unsafe fn refresh_procs(&mut self, refresh_kind: ProcessRefreshKind) { + let kd = self.system_info.kd.as_ptr(); + let procs = { + let mut count = 0; + let procs = libc::kvm_getprocs(kd, libc::KERN_PROC_PROC, 0, &mut count); + if count < 1 { + sysinfo_debug!("kvm_getprocs returned nothing..."); + return; + } + #[cfg(feature = "multithread")] + use rayon::iter::{ParallelIterator, ParallelIterator as IterTrait}; + #[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(); + let proc_list = utils::WrapMap(UnsafeCell::new(&mut self.process_list)); + let procs: &mut [utils::KInfoProc] = + std::slice::from_raw_parts_mut(procs as _, count as _); + + IterTrait::filter_map(crate::utils::into_iter(procs), |kproc| { + super::process::get_process_data( + kproc, + &proc_list, + page_size, + fscale, + now, + refresh_kind, + ) + .ok() + .and_then(|p| p.map(|p| (kproc, p))) + }) + .collect::<Vec<_>>() + }; + + // We remove all processes that don't exist anymore. + self.process_list.retain(|_, v| v.updated); + + for (kproc, proc_) in procs { + self.add_missing_proc_info(kd, kproc, proc_); + } + } + + unsafe fn add_missing_proc_info( + &mut self, + kd: *mut libc::kvm_t, + kproc: &libc::kinfo_proc, + mut proc_: Process, + ) { + proc_.cmd = from_cstr_array(libc::kvm_getargv(kd, kproc, 0) as _); + self.system_info.get_proc_missing_info(kproc, &mut proc_); + if !proc_.cmd.is_empty() { + // First, we try to retrieve the name from the command line. + let p = Path::new(&proc_.cmd[0]); + if let Some(name) = p.file_name().and_then(|s| s.to_str()) { + proc_.name = name.to_owned(); + } + if proc_.root.as_os_str().is_empty() { + if let Some(parent) = p.parent() { + proc_.root = parent.to_path_buf(); + } + } + } + if proc_.name.is_empty() { + // The name can be cut short because the `ki_comm` field size is limited, + // which is why we prefer to get the name from the command line as much as + // possible. + proc_.name = c_buf_to_string(&kproc.ki_comm).unwrap_or_default(); + } + proc_.environ = from_cstr_array(libc::kvm_getenvv(kd, kproc, 0) as _); + self.process_list.insert(proc_.pid, proc_); + } +} + +#[derive(Debug)] +struct Zfs { + enabled: bool, + mib_arcstats_size: [c_int; 5], +} + +impl Zfs { + fn new() -> Self { + let mut zfs = Self { + enabled: false, + mib_arcstats_size: Default::default(), + }; + unsafe { + init_mib( + b"kstat.zfs.misc.arcstats.size\0", + &mut zfs.mib_arcstats_size, + ); + let mut arc_size: u64 = 0; + if get_sys_value(&zfs.mib_arcstats_size, &mut arc_size) { + zfs.enabled = arc_size != 0; + } + } + zfs + } + + fn arc_size(&self) -> Option<u64> { + if self.enabled { + let mut arc_size: u64 = 0; + unsafe { + get_sys_value(&self.mib_arcstats_size, &mut arc_size); + Some(arc_size) + } + } else { + None + } + } +} + +/// This struct is used to get system information more easily. +#[derive(Debug)] +struct SystemInfo { + hw_physical_memory: [c_int; 2], + page_size: c_int, + virtual_page_count: [c_int; 4], + virtual_wire_count: [c_int; 4], + virtual_active_count: [c_int; 4], + virtual_cache_count: [c_int; 4], + virtual_inactive_count: [c_int; 4], + virtual_free_count: [c_int; 4], + os_type: [c_int; 2], + os_release: [c_int; 2], + kern_version: [c_int; 2], + hostname: [c_int; 2], + buf_space: [c_int; 2], + nb_cpus: c_int, + kd: NonNull<libc::kvm_t>, + // For these two fields, we could use `kvm_getcptime` but the function isn't very efficient... + mib_cp_time: [c_int; 2], + mib_cp_times: [c_int; 2], + // For the global CPU usage. + cp_time: utils::VecSwitcher<libc::c_ulong>, + // For each CPU usage. + cp_times: utils::VecSwitcher<libc::c_ulong>, + /// From FreeBSD manual: "The kernel fixed-point scale factor". It's used when computing + /// processes' CPU usage. + fscale: f32, + procstat: *mut libc::procstat, + zfs: Zfs, +} + +// This is needed because `kd: *mut libc::kvm_t` isn't thread-safe. +unsafe impl Send for SystemInfo {} +unsafe impl Sync for SystemInfo {} + +impl SystemInfo { + fn new() -> Self { + unsafe { + let mut errbuf = + MaybeUninit::<[libc::c_char; libc::_POSIX2_LINE_MAX as usize]>::uninit(); + let kd = NonNull::new(libc::kvm_openfiles( + std::ptr::null(), + b"/dev/null\0".as_ptr() as *const _, + std::ptr::null(), + 0, + errbuf.as_mut_ptr() as *mut _, + )) + .expect("kvm_openfiles failed"); + + let mut smp: c_int = 0; + let mut nb_cpus: c_int = 1; + if !get_sys_value_by_name(b"kern.smp.active\0", &mut smp) { + smp = 0; + } + #[allow(clippy::collapsible_if)] // I keep as is for readability reasons. + if smp != 0 { + if !get_sys_value_by_name(b"kern.smp.cpus\0", &mut nb_cpus) || nb_cpus < 1 { + nb_cpus = 1; + } + } + + let mut si = SystemInfo { + hw_physical_memory: Default::default(), + page_size: 0, + virtual_page_count: Default::default(), + virtual_wire_count: Default::default(), + virtual_active_count: Default::default(), + virtual_cache_count: Default::default(), + virtual_inactive_count: Default::default(), + virtual_free_count: Default::default(), + buf_space: Default::default(), + os_type: Default::default(), + os_release: Default::default(), + kern_version: Default::default(), + hostname: Default::default(), + nb_cpus, + kd, + mib_cp_time: Default::default(), + mib_cp_times: Default::default(), + cp_time: utils::VecSwitcher::new(vec![0; libc::CPUSTATES as usize]), + cp_times: utils::VecSwitcher::new(vec![ + 0; + nb_cpus as usize * libc::CPUSTATES as usize + ]), + fscale: 0., + procstat: std::ptr::null_mut(), + zfs: Zfs::new(), + }; + let mut fscale: c_int = 0; + if !get_sys_value_by_name(b"kern.fscale\0", &mut fscale) { + // Default value used in htop. + fscale = 2048; + } + si.fscale = fscale as f32; + + if !get_sys_value_by_name(b"vm.stats.vm.v_page_size\0", &mut si.page_size) { + panic!("cannot get page size..."); + } + + init_mib(b"hw.physmem\0", &mut si.hw_physical_memory); + init_mib(b"vm.stats.vm.v_page_count\0", &mut si.virtual_page_count); + init_mib(b"vm.stats.vm.v_wire_count\0", &mut si.virtual_wire_count); + init_mib( + b"vm.stats.vm.v_active_count\0", + &mut si.virtual_active_count, + ); + init_mib(b"vm.stats.vm.v_cache_count\0", &mut si.virtual_cache_count); + init_mib( + b"vm.stats.vm.v_inactive_count\0", + &mut si.virtual_inactive_count, + ); + init_mib(b"vm.stats.vm.v_free_count\0", &mut si.virtual_free_count); + init_mib(b"vfs.bufspace\0", &mut si.buf_space); + + init_mib(b"kern.ostype\0", &mut si.os_type); + init_mib(b"kern.osrelease\0", &mut si.os_release); + init_mib(b"kern.version\0", &mut si.kern_version); + init_mib(b"kern.hostname\0", &mut si.hostname); + + init_mib(b"kern.cp_time\0", &mut si.mib_cp_time); + init_mib(b"kern.cp_times\0", &mut si.mib_cp_times); + + si + } + } + + fn get_os_name(&self) -> Option<String> { + get_system_info(&[self.os_type[0], self.os_type[1]], Some("FreeBSD")) + } + + fn get_kernel_version(&self) -> Option<String> { + get_system_info(&[self.kern_version[0], self.kern_version[1]], None) + } + + fn get_os_release_long(&self) -> Option<String> { + get_system_info(&[self.os_release[0], self.os_release[1]], None) + } + + fn get_os_release(&self) -> Option<String> { + // It returns something like "13.0-RELEASE". We want to keep everything until the "-". + get_system_info(&[self.os_release[0], self.os_release[1]], None) + .and_then(|s| s.split('-').next().map(|s| s.to_owned())) + } + + fn get_hostname(&self) -> Option<String> { + get_system_info(&[self.hostname[0], self.hostname[1]], Some("")) + } + + /// Returns (used, total). + fn get_swap_info(&self) -> (u64, u64) { + // Magic number used in htop. Cannot find how they got it when reading `kvm_getswapinfo` + // source code so here we go... + const LEN: usize = 16; + let mut swap = MaybeUninit::<[libc::kvm_swap; LEN]>::uninit(); + unsafe { + let nswap = + libc::kvm_getswapinfo(self.kd.as_ptr(), swap.as_mut_ptr() as *mut _, LEN as _, 0) + as usize; + if nswap < 1 { + return (0, 0); + } + let swap = + std::slice::from_raw_parts(swap.as_ptr() as *mut libc::kvm_swap, nswap.min(LEN)); + let (used, total) = swap.iter().fold((0, 0), |(used, total): (u64, u64), swap| { + ( + used.saturating_add(swap.ksw_used as _), + total.saturating_add(swap.ksw_total as _), + ) + }); + ( + used.saturating_mul(self.page_size as _) / 1_000, + total.saturating_mul(self.page_size as _) / 1_000, + ) + } + } + + fn get_total_memory(&self) -> u64 { + 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; + } + + // 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 + } + } + + fn get_used_memory(&self) -> u64 { + let mut mem_active: u64 = 0; + let mut mem_wire: u64 = 0; + + unsafe { + get_sys_value(&self.virtual_active_count, &mut mem_active); + get_sys_value(&self.virtual_wire_count, &mut mem_wire); + + let mut mem_wire = mem_wire.saturating_mul(self.page_size as _); + // We need to subtract "ZFS ARC" from the "wired memory" because it should belongs to cache + // but the kernel reports it as "wired memory" instead... + if let Some(arc_size) = self.zfs.arc_size() { + mem_wire -= arc_size; + } + let used = mem_active + .saturating_mul(self.page_size as _) + .saturating_add(mem_wire); + used / 1_000 + } + } + + fn get_free_memory(&self) -> u64 { + let mut buffers_mem: u64 = 0; + let mut inactive_mem: u64 = 0; + let mut cached_mem: u64 = 0; + let mut free_mem: u64 = 0; + + unsafe { + get_sys_value(&self.buf_space, &mut buffers_mem); + get_sys_value(&self.virtual_inactive_count, &mut inactive_mem); + 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 + } + } + + fn get_cpu_usage(&mut self, global: &mut Cpu, cpus: &mut [Cpu]) { + unsafe { + get_sys_value_array(&self.mib_cp_time, self.cp_time.get_mut()); + get_sys_value_array(&self.mib_cp_times, self.cp_times.get_mut()); + } + + fn fill_cpu(proc_: &mut Cpu, new_cp_time: &[libc::c_ulong], old_cp_time: &[libc::c_ulong]) { + let mut total_new: u64 = 0; + let mut total_old: u64 = 0; + let mut cp_diff: libc::c_ulong = 0; + + for i in 0..(libc::CPUSTATES as usize) { + // We obviously don't want to get the idle part of the CPU usage, otherwise + // we would always be at 100%... + 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 total_diff = total_new - total_old; + if total_diff < 1 { + proc_.cpu_usage = 0.; + } else { + proc_.cpu_usage = cp_diff as f32 / total_diff as f32 * 100.; + } + } + + fill_cpu(global, self.cp_time.get_new(), self.cp_time.get_old()); + let old_cp_times = self.cp_times.get_old(); + let new_cp_times = self.cp_times.get_new(); + for (pos, proc_) in cpus.iter_mut().enumerate() { + let index = pos * libc::CPUSTATES as usize; + + fill_cpu(proc_, &new_cp_times[index..], &old_cp_times[index..]); + } + } + + #[allow(clippy::collapsible_if)] // I keep as is for readability reasons. + unsafe fn get_proc_missing_info(&mut self, kproc: &libc::kinfo_proc, proc_: &mut Process) { + if self.procstat.is_null() { + self.procstat = libc::procstat_open_sysctl(); + } + if self.procstat.is_null() { + return; + } + let head = libc::procstat_getfiles(self.procstat, kproc as *const _ as usize as *mut _, 0); + if head.is_null() { + return; + } + let mut entry = (*head).stqh_first; + let mut done = 0; + while !entry.is_null() && done < 2 { + { + let tmp = &*entry; + if tmp.fs_uflags & libc::PS_FST_UFLAG_CDIR != 0 { + if !tmp.fs_path.is_null() { + if let Ok(p) = CStr::from_ptr(tmp.fs_path).to_str() { + proc_.cwd = PathBuf::from(p); + done += 1; + } + } + } else if tmp.fs_uflags & libc::PS_FST_UFLAG_RDIR != 0 { + if !tmp.fs_path.is_null() { + if let Ok(p) = CStr::from_ptr(tmp.fs_path).to_str() { + proc_.root = PathBuf::from(p); + done += 1; + } + } + } + } + entry = (*entry).next.stqe_next; + } + libc::procstat_freefiles(self.procstat, head); + } +} + +impl Drop for SystemInfo { + fn drop(&mut self) { + unsafe { + libc::kvm_close(self.kd.as_ptr()); + if !self.procstat.is_null() { + libc::procstat_close(self.procstat); + } + } + } +} diff --git a/vendor/sysinfo/src/freebsd/utils.rs b/vendor/sysinfo/src/freebsd/utils.rs new file mode 100644 index 000000000..00de3e9d9 --- /dev/null +++ b/vendor/sysinfo/src/freebsd/utils.rs @@ -0,0 +1,296 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{Pid, Process}; +use libc::{c_char, c_int, timeval}; +use std::cell::UnsafeCell; +use std::collections::HashMap; +use std::ffi::CStr; +use std::mem; +use std::time::SystemTime; + +/// This struct is used to switch between the "old" and "new" every time you use "get_mut". +#[derive(Debug)] +pub(crate) struct VecSwitcher<T> { + v1: Vec<T>, + v2: Vec<T>, + first: bool, +} + +impl<T: Clone> VecSwitcher<T> { + pub fn new(v1: Vec<T>) -> Self { + let v2 = v1.clone(); + + Self { + v1, + v2, + first: true, + } + } + + pub fn get_mut(&mut self) -> &mut [T] { + self.first = !self.first; + if self.first { + // It means that `v2` will be the "new". + &mut self.v2 + } else { + // It means that `v1` will be the "new". + &mut self.v1 + } + } + + pub fn get_old(&self) -> &[T] { + if self.first { + &self.v1 + } else { + &self.v2 + } + } + + pub fn get_new(&self) -> &[T] { + if self.first { + &self.v2 + } else { + &self.v1 + } + } +} + +#[inline] +pub unsafe fn init_mib(name: &[u8], mib: &mut [c_int]) { + let mut len = mib.len(); + libc::sysctlnametomib(name.as_ptr() as _, mib.as_mut_ptr(), &mut len); +} + +pub(crate) fn boot_time() -> u64 { + let mut boot_time = timeval { + tv_sec: 0, + tv_usec: 0, + }; + let mut len = std::mem::size_of::<timeval>(); + let mut mib: [c_int; 2] = [libc::CTL_KERN, libc::KERN_BOOTTIME]; + unsafe { + if libc::sysctl( + mib.as_mut_ptr(), + mib.len() as _, + &mut boot_time as *mut timeval as *mut _, + &mut len, + std::ptr::null_mut(), + 0, + ) < 0 + { + 0 + } else { + boot_time.tv_sec as _ + } + } +} + +pub(crate) unsafe fn get_sys_value<T: Sized>(mib: &[c_int], value: &mut T) -> bool { + let mut len = mem::size_of::<T>() as libc::size_t; + libc::sysctl( + mib.as_ptr(), + mib.len() as _, + value as *mut _ as *mut _, + &mut len, + std::ptr::null_mut(), + 0, + ) == 0 +} + +pub(crate) unsafe fn get_sys_value_array<T: Sized>(mib: &[c_int], value: &mut [T]) -> bool { + let mut len = (mem::size_of::<T>() * value.len()) as libc::size_t; + libc::sysctl( + mib.as_ptr(), + mib.len() as _, + value.as_mut_ptr() as *mut _, + &mut len as *mut _, + std::ptr::null_mut(), + 0, + ) == 0 +} + +pub(crate) fn c_buf_to_str(buf: &[libc::c_char]) -> Option<&str> { + unsafe { + let buf: &[u8] = std::slice::from_raw_parts(buf.as_ptr() as _, buf.len()); + if let Some(pos) = buf.iter().position(|x| *x == 0) { + // Shrink buffer to terminate the null bytes + std::str::from_utf8(&buf[..pos]).ok() + } else { + std::str::from_utf8(buf).ok() + } + } +} + +pub(crate) fn c_buf_to_string(buf: &[libc::c_char]) -> Option<String> { + c_buf_to_str(buf).map(|s| s.to_owned()) +} + +pub(crate) unsafe fn get_sys_value_str(mib: &[c_int], buf: &mut [libc::c_char]) -> Option<String> { + let mut len = (mem::size_of::<libc::c_char>() * buf.len()) as libc::size_t; + if libc::sysctl( + mib.as_ptr(), + mib.len() as _, + buf.as_mut_ptr() as *mut _, + &mut len, + std::ptr::null_mut(), + 0, + ) != 0 + { + return None; + } + c_buf_to_string(&buf[..len / mem::size_of::<libc::c_char>()]) +} + +pub(crate) unsafe fn get_sys_value_by_name<T: Sized>(name: &[u8], value: &mut T) -> bool { + let mut len = mem::size_of::<T>() as libc::size_t; + let original = len; + + libc::sysctlbyname( + name.as_ptr() as *const c_char, + value as *mut _ as *mut _, + &mut len, + std::ptr::null_mut(), + 0, + ) == 0 + && original == len +} + +pub(crate) fn get_sys_value_str_by_name(name: &[u8]) -> Option<String> { + let mut size = 0; + + unsafe { + if libc::sysctlbyname( + name.as_ptr() as *const c_char, + std::ptr::null_mut(), + &mut size, + std::ptr::null_mut(), + 0, + ) == 0 + && 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]; + + if libc::sysctlbyname( + name.as_ptr() as *const c_char, + buf.as_mut_ptr() as *mut _, + &mut size, + std::ptr::null_mut(), + 0, + ) == 0 + && size > 0 + { + c_buf_to_string(&buf) + } else { + // getting the system value failed + None + } + } else { + None + } + } +} + +pub(crate) fn get_system_info(mib: &[c_int], default: Option<&str>) -> Option<String> { + let mut size = 0; + + unsafe { + // Call first to get size + libc::sysctl( + mib.as_ptr(), + mib.len() as _, + std::ptr::null_mut(), + &mut size, + std::ptr::null_mut(), + 0, + ); + + // exit early if we did not update the size + if size == 0 { + 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]; + + if libc::sysctl( + mib.as_ptr(), + mib.len() as _, + buf.as_mut_ptr() as _, + &mut size, + std::ptr::null_mut(), + 0, + ) == -1 + { + // If command fails return default + default.map(|s| s.to_owned()) + } else { + c_buf_to_string(&buf) + } + } + } +} + +pub(crate) unsafe fn from_cstr_array(ptr: *const *const c_char) -> Vec<String> { + if ptr.is_null() { + return Vec::new(); + } + let mut max = 0; + loop { + let ptr = ptr.add(max); + if (*ptr).is_null() { + break; + } + max += 1; + } + if max == 0 { + return Vec::new(); + } + let mut ret = Vec::with_capacity(max); + + for pos in 0..max { + let p = ptr.add(pos); + if let Ok(s) = CStr::from_ptr(*p).to_str() { + ret.push(s.to_owned()); + } + } + ret +} + +pub(crate) fn get_now() -> u64 { + SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .map(|n| n.as_secs()) + .unwrap_or(0) +} + +// All this is needed because `kinfo_proc` doesn't implement `Send` (because it contains pointers). +pub(crate) struct WrapMap<'a>(pub UnsafeCell<&'a mut HashMap<Pid, Process>>); + +unsafe impl<'a> Send for WrapMap<'a> {} +unsafe impl<'a> Sync for WrapMap<'a> {} + +#[repr(transparent)] +pub(crate) struct KInfoProc(libc::kinfo_proc); +unsafe impl Send for KInfoProc {} +unsafe impl Sync for KInfoProc {} + +impl std::ops::Deref for KInfoProc { + type Target = libc::kinfo_proc; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +pub(crate) unsafe fn get_frequency_for_cpu(cpu_nb: c_int) -> u64 { + let mut frequency = 0; + + // 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(), + &mut frequency, + ) { + frequency = 0; + } + frequency as _ +} diff --git a/vendor/sysinfo/src/lib.rs b/vendor/sysinfo/src/lib.rs new file mode 100644 index 000000000..977de23a3 --- /dev/null +++ b/vendor/sysinfo/src/lib.rs @@ -0,0 +1,447 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#![doc = include_str!("../README.md")] +#![allow(unknown_lints)] +#![deny(missing_docs)] +#![deny(rustdoc::broken_intra_doc_links)] +#![allow(clippy::upper_case_acronyms)] +#![allow(clippy::non_send_fields_in_send_ty)] +#![allow(renamed_and_removed_lints)] +#![allow(unknown_lints)] + +#[macro_use] +mod macros; + +cfg_if::cfg_if! { + if #[cfg(feature = "unknown-ci")] { + // This is used in CI to check that the build for unknown targets is compiling fine. + mod unknown; + use unknown as sys; + + #[cfg(test)] + pub(crate) const MIN_USERS: usize = 0; + } else if #[cfg(any(target_os = "macos", target_os = "ios"))] { + mod apple; + use apple as sys; + extern crate core_foundation_sys; + + #[cfg(test)] + pub(crate) const MIN_USERS: usize = 1; + } else if #[cfg(windows)] { + mod windows; + use windows as sys; + extern crate winapi; + extern crate ntapi; + + #[cfg(test)] + pub(crate) const MIN_USERS: usize = 1; + } else if #[cfg(any(target_os = "linux", target_os = "android"))] { + mod linux; + use linux as sys; + pub(crate) mod users; + + #[cfg(test)] + pub(crate) const MIN_USERS: usize = 1; + } else if #[cfg(target_os = "freebsd")] { + mod freebsd; + use freebsd as sys; + pub(crate) mod users; + + #[cfg(test)] + pub(crate) const MIN_USERS: usize = 1; + } else { + mod unknown; + use unknown as sys; + + #[cfg(test)] + pub(crate) const MIN_USERS: usize = 0; + } +} + +pub use common::{ + get_current_pid, CpuRefreshKind, DiskType, DiskUsage, Gid, LoadAvg, NetworksIter, Pid, PidExt, + ProcessRefreshKind, ProcessStatus, RefreshKind, Signal, Uid, User, +}; +pub use sys::{Component, Cpu, Disk, NetworkData, Networks, Process, System}; +pub use traits::{ + ComponentExt, CpuExt, DiskExt, NetworkExt, NetworksExt, ProcessExt, SystemExt, UserExt, +}; + +#[cfg(feature = "c-interface")] +pub use c_interface::*; + +#[cfg(feature = "c-interface")] +mod c_interface; +mod common; +mod debug; +mod system; +mod traits; +mod utils; + +/// This function is only used on linux targets, on the other platforms it does nothing and returns +/// `false`. +/// +/// On linux, to improve performance, we keep a `/proc` file open for each process we index with +/// a maximum number of files open equivalent to half of the system limit. +/// +/// The problem is that some users might need all the available file descriptors so we need to +/// allow them to change this limit. +/// +/// Note that if you set a limit bigger than the system limit, the system limit will be set. +/// +/// Returns `true` if the new value has been set. +/// +/// ```no_run +/// use sysinfo::{System, SystemExt, set_open_files_limit}; +/// +/// // We call the function before any call to the processes update. +/// if !set_open_files_limit(10) { +/// // It'll always return false on non-linux targets. +/// eprintln!("failed to update the open files limit..."); +/// } +/// let s = System::new_all(); +/// ``` +pub fn set_open_files_limit(mut _new_limit: isize) -> bool { + cfg_if::cfg_if! { + if #[cfg(all(not(feature = "unknown-ci"), any(target_os = "linux", target_os = "android")))] + { + if _new_limit < 0 { + _new_limit = 0; + } + let max = sys::system::get_max_nb_fds(); + if _new_limit > max { + _new_limit = max; + } + unsafe { + if let Ok(ref mut x) = sys::system::REMAINING_FILES.lock() { + // If files are already open, to be sure that the number won't be bigger when those + // files are closed, we subtract the current number of opened files to the new + // limit. + let diff = max.saturating_sub(**x); + **x = _new_limit.saturating_sub(diff); + true + } else { + false + } + } + } else { + false + } + } +} + +// FIXME: Can be removed once negative trait bounds are supported. +#[cfg(doctest)] +mod doctest { + /// Check that `Process` doesn't implement `Clone`. + /// + /// First we check that the "basic" code works: + /// + /// ```no_run + /// use sysinfo::{Process, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// let p: &Process = s.processes().values().next().unwrap(); + /// ``` + /// + /// And now we check if it fails when we try to clone it: + /// + /// ```compile_fail + /// use sysinfo::{Process, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// let p: &Process = s.processes().values().next().unwrap(); + /// let p = (*p).clone(); + /// ``` + mod process_clone {} + + /// Check that `System` doesn't implement `Clone`. + /// + /// First we check that the "basic" code works: + /// + /// ```no_run + /// use sysinfo::{Process, System, SystemExt}; + /// + /// let s = System::new(); + /// ``` + /// + /// And now we check if it fails when we try to clone it: + /// + /// ```compile_fail + /// use sysinfo::{Process, System, SystemExt}; + /// + /// let s = System::new(); + /// let s = s.clone(); + /// ``` + mod system_clone {} +} + +#[cfg(test)] +mod test { + use crate::*; + + #[cfg(feature = "unknown-ci")] + #[test] + fn check_unknown_ci_feature() { + assert!(!System::IS_SUPPORTED); + } + + #[test] + fn check_process_memory_usage() { + let mut s = System::new(); + s.refresh_all(); + + if System::IS_SUPPORTED { + // No process should have 0 as memory usage. + #[cfg(not(feature = "apple-sandbox"))] + assert!(!s.processes().iter().all(|(_, proc_)| proc_.memory() == 0)); + } else { + // There should be no process, but if there is one, its memory usage should be 0. + assert!(s.processes().iter().all(|(_, proc_)| proc_.memory() == 0)); + } + } + + #[test] + fn check_memory_usage() { + let mut s = System::new(); + + assert_eq!(s.total_memory(), 0); + assert_eq!(s.free_memory(), 0); + assert_eq!(s.available_memory(), 0); + assert_eq!(s.used_memory(), 0); + assert_eq!(s.total_swap(), 0); + assert_eq!(s.free_swap(), 0); + assert_eq!(s.used_swap(), 0); + + s.refresh_memory(); + if System::IS_SUPPORTED { + assert!(s.total_memory() > 0); + assert!(s.used_memory() > 0); + if s.total_swap() > 0 { + // I think it's pretty safe to assume that there is still some swap left... + assert!(s.free_swap() > 0); + } + } else { + assert_eq!(s.total_memory(), 0); + assert_eq!(s.used_memory(), 0); + assert_eq!(s.total_swap(), 0); + assert_eq!(s.free_swap(), 0); + } + } + + #[cfg(target_os = "linux")] + #[test] + fn check_processes_cpu_usage() { + if !System::IS_SUPPORTED { + return; + } + let mut s = System::new(); + + s.refresh_processes(); + // All CPU usage will start at zero until the second refresh + assert!(s + .processes() + .iter() + .all(|(_, proc_)| proc_.cpu_usage() == 0.0)); + + // Wait a bit to update CPU usage values + std::thread::sleep(std::time::Duration::from_millis(100)); + s.refresh_processes(); + assert!(s + .processes() + .iter() + .all(|(_, proc_)| proc_.cpu_usage() >= 0.0 + && proc_.cpu_usage() <= (s.cpus().len() as f32) * 100.0)); + assert!(s + .processes() + .iter() + .any(|(_, proc_)| proc_.cpu_usage() > 0.0)); + } + + #[test] + fn check_cpu_usage() { + if !System::IS_SUPPORTED { + return; + } + let mut s = System::new(); + for _ in 0..10 { + s.refresh_cpu(); + // Wait a bit to update CPU usage values + std::thread::sleep(std::time::Duration::from_millis(100)); + if s.cpus().iter().any(|c| c.cpu_usage() > 0.0) { + // All good! + return; + } + } + panic!("CPU usage is always zero..."); + } + + #[test] + fn check_users() { + let mut s = System::new(); + assert!(s.users().is_empty()); + s.refresh_users_list(); + assert!(s.users().len() >= MIN_USERS); + + let mut s = System::new(); + assert!(s.users().is_empty()); + s.refresh_all(); + assert!(s.users().is_empty()); + + let s = System::new_all(); + assert!(s.users().len() >= MIN_USERS); + } + + #[test] + fn check_uid_gid() { + let mut s = System::new(); + assert!(s.users().is_empty()); + s.refresh_users_list(); + let users = s.users(); + assert!(users.len() >= MIN_USERS); + + if System::IS_SUPPORTED { + #[cfg(not(target_os = "windows"))] + { + let user = users + .iter() + .find(|u| u.name() == "root") + .expect("no root user"); + assert_eq!(**user.id(), 0); + assert_eq!(*user.group_id(), 0); + if let Some(user) = users.iter().find(|u| *u.group_id() > 0) { + assert!(**user.id() > 0); + assert!(*user.group_id() > 0); + } + assert!(users.iter().filter(|u| **u.id() > 0).count() > 0); + } + + // And now check that our `get_user_by_id` method works. + s.refresh_processes(); + assert!(s + .processes() + .iter() + .filter_map(|(_, p)| p.user_id()) + .any(|uid| s.get_user_by_id(uid).is_some())); + } + } + + #[test] + fn check_system_info() { + // 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 + .kernel_version() + .expect("Failed to get kernel version") + .is_empty()); + + assert!(!s.os_version().expect("Failed to get os version").is_empty()); + + assert!(!s + .long_os_version() + .expect("Failed to get long OS version") + .is_empty()); + } + } + + #[test] + fn check_host_name() { + // We don't want to test on unsupported systems. + if System::IS_SUPPORTED { + let s = System::new(); + assert!(s.host_name().is_some()); + } + } + + #[test] + fn check_refresh_process_return_value() { + // We don't want to test on unsupported systems. + if System::IS_SUPPORTED { + let _pid = get_current_pid().expect("Failed to get current PID"); + + #[cfg(not(feature = "apple-sandbox"))] + { + let mut s = System::new(); + // First check what happens in case the process isn't already in our process list. + assert!(s.refresh_process(_pid)); + // Then check that it still returns true if the process is already in our process list. + assert!(s.refresh_process(_pid)); + } + } + } + + #[test] + fn ensure_is_supported_is_set_correctly() { + if MIN_USERS > 0 { + assert!(System::IS_SUPPORTED); + } else { + assert!(!System::IS_SUPPORTED); + } + } + + #[test] + fn check_cpus_number() { + let mut s = System::new(); + + // This information isn't retrieved by default. + assert!(s.cpus().is_empty()); + if System::IS_SUPPORTED { + // The physical cores count is recomputed every time the function is called, so the + // information must be relevant even with nothing initialized. + let physical_cores_count = s + .physical_core_count() + .expect("failed to get number of physical cores"); + + s.refresh_cpu(); + // The cpus shouldn't be empty anymore. + assert!(!s.cpus().is_empty()); + + // In case we are running inside a VM, it's possible to not have a physical core, only + // logical ones, which is why we don't test `physical_cores_count > 0`. + let physical_cores_count2 = s + .physical_core_count() + .expect("failed to get number of physical cores"); + assert!(physical_cores_count2 <= s.cpus().len()); + assert_eq!(physical_cores_count, physical_cores_count2); + } else { + assert_eq!(s.physical_core_count(), None); + } + assert!(s.physical_core_count().unwrap_or(0) <= s.cpus().len()); + } + + #[test] + fn check_nb_supported_signals() { + if System::IS_SUPPORTED { + assert!( + !System::SUPPORTED_SIGNALS.is_empty(), + "SUPPORTED_SIGNALS shoudn't be empty on supported systems!" + ); + } else { + assert!( + System::SUPPORTED_SIGNALS.is_empty(), + "SUPPORTED_SIGNALS should be empty on not support systems!" + ); + } + } + + // 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; + } + let mut s = System::new(); + s.refresh_processes(); + for proc_ in s.cpus() { + assert_eq!(proc_.frequency(), 0); + } + s.refresh_cpu(); + for proc_ in s.cpus() { + assert_ne!(proc_.frequency(), 0); + } + } +} diff --git a/vendor/sysinfo/src/linux/component.rs b/vendor/sysinfo/src/linux/component.rs new file mode 100644 index 000000000..3a10588e5 --- /dev/null +++ b/vendor/sysinfo/src/linux/component.rs @@ -0,0 +1,189 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::ComponentExt; + +use std::collections::HashMap; +use std::fs::{metadata, read_dir, File}; +use std::io::Read; +use std::path::{Path, PathBuf}; + +#[doc = include_str!("../../md_doc/component.md")] +pub struct Component { + temperature: f32, + max: f32, + critical: Option<f32>, + label: String, + input_file: PathBuf, +} + +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 + } +} + +fn is_file<T: AsRef<Path>>(path: T) -> bool { + metadata(path).ok().map(|m| m.is_file()).unwrap_or(false) +} + +fn append_files(components: &mut Vec<Component>, folder: &Path) { + let mut matchings: HashMap<u32, Vec<String>> = HashMap::with_capacity(10); + + 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), + ); + } + } + } + } + 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)); + } + } + } + } +} + +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, + label, + input_file: input_path.to_path_buf(), + max: max.unwrap_or(0.0), + critical, + }; + c.refresh(); + c + } +} + +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) { + 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; + } + } + } +} + +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/")) { + 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("hwmon") + { + continue; + } + append_files(&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 new file mode 100644 index 000000000..f3970c318 --- /dev/null +++ b/vendor/sysinfo/src/linux/cpu.rs @@ -0,0 +1,357 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#![allow(clippy::too_many_arguments)] + +use std::collections::HashSet; +use std::fs::File; +use std::io::Read; + +use crate::CpuExt; + +/// Struct containing values to compute a CPU usage. +#[derive(Clone, Copy)] +pub(crate) struct CpuValues { + user: u64, + nice: u64, + system: u64, + idle: u64, + iowait: u64, + irq: u64, + softirq: u64, + steal: u64, + _guest: u64, + _guest_nice: u64, +} + +impl CpuValues { + /// Creates a new instance of `CpuValues` with everything set to `0`. + pub fn new() -> CpuValues { + CpuValues { + user: 0, + nice: 0, + system: 0, + idle: 0, + iowait: 0, + irq: 0, + softirq: 0, + steal: 0, + _guest: 0, + _guest_nice: 0, + } + } + + /// Creates a new instance of `CpuValues` with everything set to the corresponding argument. + pub fn new_with_values( + user: u64, + nice: u64, + system: u64, + idle: u64, + iowait: u64, + irq: u64, + softirq: u64, + steal: u64, + guest: u64, + guest_nice: u64, + ) -> CpuValues { + CpuValues { + user, + nice, + system, + idle, + iowait, + irq, + softirq, + steal, + _guest: guest, + _guest_nice: guest_nice, + } + } + + /*pub fn is_zero(&self) -> bool { + self.user == 0 && self.nice == 0 && self.system == 0 && self.idle == 0 && + self.iowait == 0 && self.irq == 0 && self.softirq == 0 && self.steal == 0 && + self.guest == 0 && self.guest_nice == 0 + }*/ + + /// Sets the given argument to the corresponding fields. + pub fn set( + &mut self, + user: u64, + nice: u64, + system: u64, + idle: u64, + iowait: u64, + irq: u64, + softirq: u64, + steal: u64, + guest: u64, + guest_nice: u64, + ) { + self.user = user; + self.nice = nice; + self.system = system; + self.idle = idle; + self.iowait = iowait; + self.irq = irq; + self.softirq = softirq; + self.steal = steal; + self._guest = guest; + self._guest_nice = guest_nice; + } + + /// Returns work time. + pub fn work_time(&self) -> u64 { + self.user + .saturating_add(self.nice) + .saturating_add(self.system) + .saturating_add(self.irq) + .saturating_add(self.softirq) + .saturating_add(self.steal) + } + + /// Returns total time. + pub fn total_time(&self) -> u64 { + // `guest` is already included in `user` + // `guest_nice` is already included in `nice` + self.work_time() + .saturating_add(self.idle) + .saturating_add(self.iowait) + } +} + +#[doc = include_str!("../../md_doc/cpu.md")] +pub struct Cpu { + old_values: CpuValues, + new_values: CpuValues, + pub(crate) name: String, + cpu_usage: f32, + total_time: u64, + old_total_time: u64, + pub(crate) frequency: u64, + pub(crate) vendor_id: String, + pub(crate) brand: String, +} + +impl Cpu { + pub(crate) fn new_with_values( + name: &str, + user: u64, + nice: u64, + system: u64, + idle: u64, + iowait: u64, + irq: u64, + softirq: u64, + steal: u64, + guest: u64, + guest_nice: u64, + frequency: u64, + vendor_id: String, + brand: String, + ) -> Cpu { + Cpu { + name: name.to_owned(), + old_values: CpuValues::new(), + new_values: CpuValues::new_with_values( + user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice, + ), + cpu_usage: 0f32, + total_time: 0, + old_total_time: 0, + frequency, + vendor_id, + brand, + } + } + + pub(crate) fn set( + &mut self, + user: u64, + nice: u64, + system: u64, + idle: u64, + iowait: u64, + irq: u64, + softirq: u64, + steal: u64, + guest: u64, + guest_nice: u64, + ) { + macro_rules! min { + ($a:expr, $b:expr) => { + if $a > $b { + ($a - $b) as f32 + } else { + 1. + } + }; + } + self.old_values = self.new_values; + self.new_values.set( + user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice, + ); + self.total_time = self.new_values.total_time(); + self.old_total_time = self.old_values.total_time(); + self.cpu_usage = min!(self.new_values.work_time(), self.old_values.work_time()) + / min!(self.total_time, self.old_total_time) + * 100.; + if self.cpu_usage > 100. { + self.cpu_usage = 100.; // to prevent the percentage to go above 100% + } + } +} + +impl CpuExt for Cpu { + fn cpu_usage(&self) -> f32 { + self.cpu_usage + } + + fn name(&self) -> &str { + &self.name + } + + /// Returns the CPU frequency in MHz. + fn frequency(&self) -> u64 { + self.frequency + } + + fn vendor_id(&self) -> &str { + &self.vendor_id + } + + fn brand(&self) -> &str { + &self.brand + } +} + +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!( + "/sys/devices/system/cpu/cpu{}/cpufreq/scaling_cur_freq", + cpu_core_index + )) + .and_then(|mut f| f.read_to_string(&mut s)) + .is_ok() + { + let freq_option = s.trim().split('\n').next(); + if let Some(freq_string) = freq_option { + if let Ok(freq) = freq_string.parse::<u64>() { + return freq / 1000; + } + } + } + s.clear(); + if File::open("/proc/cpuinfo") + .and_then(|mut f| f.read_to_string(&mut s)) + .is_err() + { + return 0; + } + let find_cpu_mhz = s.split('\n').find(|line| { + line.starts_with("cpu MHz\t") + || line.starts_with("BogoMIPS") + || line.starts_with("clock\t") + || line.starts_with("bogomips per cpu") + }); + find_cpu_mhz + .and_then(|line| line.split(':').last()) + .and_then(|val| val.replace("MHz", "").trim().parse::<f64>().ok()) + .map(|speed| speed as u64) + .unwrap_or_default() +} + +#[allow(unused_assignments)] +pub(crate) fn get_physical_core_count() -> Option<usize> { + let mut s = String::new(); + if let Err(_e) = File::open("/proc/cpuinfo").and_then(|mut f| f.read_to_string(&mut s)) { + sysinfo_debug!("Cannot read `/proc/cpuinfo` file: {:?}", _e); + return None; + } + + macro_rules! add_core { + ($core_ids_and_physical_ids:ident, $core_id:ident, $physical_id:ident, $cpu:ident) => {{ + if !$core_id.is_empty() && !$physical_id.is_empty() { + $core_ids_and_physical_ids.insert(format!("{} {}", $core_id, $physical_id)); + } else if !$cpu.is_empty() { + // On systems with only physical cores like raspberry, there is no "core id" or + // "physical id" fields. So if one of them is missing, we simply use the "CPU" + // info and count it as a physical core. + $core_ids_and_physical_ids.insert($cpu.to_owned()); + } + $core_id = ""; + $physical_id = ""; + $cpu = ""; + }}; + } + + let mut core_ids_and_physical_ids: HashSet<String> = HashSet::new(); + let mut core_id = ""; + let mut physical_id = ""; + let mut cpu = ""; + + for line in s.lines() { + if line.is_empty() { + add_core!(core_ids_and_physical_ids, core_id, physical_id, cpu); + } else if line.starts_with("processor") { + cpu = line + .splitn(2, ':') + .last() + .map(|x| x.trim()) + .unwrap_or_default(); + } else if line.starts_with("core id") { + core_id = line + .splitn(2, ':') + .last() + .map(|x| x.trim()) + .unwrap_or_default(); + } else if line.starts_with("physical id") { + physical_id = line + .splitn(2, ':') + .last() + .map(|x| x.trim()) + .unwrap_or_default(); + } + } + add_core!(core_ids_and_physical_ids, core_id, physical_id, cpu); + + Some(core_ids_and_physical_ids.len()) +} + +/// Returns the brand/vendor string for the first CPU (which should be the same for all CPUs). +pub(crate) fn get_vendor_id_and_brand() -> (String, String) { + let mut s = String::new(); + if File::open("/proc/cpuinfo") + .and_then(|mut f| f.read_to_string(&mut s)) + .is_err() + { + return (String::new(), String::new()); + } + + fn get_value(s: &str) -> String { + s.split(':') + .last() + .map(|x| x.trim().to_owned()) + .unwrap_or_default() + } + + let mut vendor_id = None; + let mut brand = None; + + for it in s.split('\n') { + if it.starts_with("vendor_id\t") { + vendor_id = Some(get_value(it)); + } else if it.starts_with("model name\t") { + brand = Some(get_value(it)); + } else { + continue; + } + if brand.is_some() && vendor_id.is_some() { + break; + } + } + (vendor_id.unwrap_or_default(), brand.unwrap_or_default()) +} diff --git a/vendor/sysinfo/src/linux/disk.rs b/vendor/sysinfo/src/linux/disk.rs new file mode 100644 index 000000000..5a313fd27 --- /dev/null +++ b/vendor/sysinfo/src/linux/disk.rs @@ -0,0 +1,292 @@ +// 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 libc::statvfs; +use std::ffi::{OsStr, OsString}; +use std::fs; +use std::mem; +use std::os::unix::ffi::OsStrExt; +use std::path::{Path, PathBuf}; + +macro_rules! cast { + ($x:expr) => { + u64::from($x) + }; +} + +#[doc = include_str!("../../md_doc/disk.md")] +#[derive(PartialEq, Eq)] +pub struct Disk { + type_: DiskType, + device_name: OsString, + file_system: Vec<u8>, + mount_point: PathBuf, + total_space: u64, + available_space: u64, + is_removable: bool, +} + +impl DiskExt for Disk { + fn type_(&self) -> DiskType { + self.type_ + } + + fn name(&self) -> &OsStr { + &self.device_name + } + + fn file_system(&self) -> &[u8] { + &self.file_system + } + + fn mount_point(&self) -> &Path { + &self.mount_point + } + + fn total_space(&self) -> u64 { + self.total_space + } + + fn available_space(&self) -> u64 { + self.available_space + } + + fn is_removable(&self) -> bool { + self.is_removable + } + + fn refresh(&mut self) -> bool { + unsafe { + let mut stat: statvfs = mem::zeroed(); + let mount_point_cpath = utils::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); + true + } else { + false + } + } + } +} + +fn new_disk( + device_name: &OsStr, + mount_point: &Path, + file_system: &[u8], + removable_entries: &[PathBuf], +) -> Option<Disk> { + let mount_point_cpath = utils::to_cpath(mount_point); + let type_ = find_type_for_device_name(device_name); + let mut total = 0; + let mut available = 0; + unsafe { + let mut stat: statvfs = mem::zeroed(); + if statvfs(mount_point_cpath.as_ptr() as *const _, &mut stat) == 0 { + let bsize = cast!(stat.f_bsize); + let blocks = cast!(stat.f_blocks); + let bavail = cast!(stat.f_bavail); + total = bsize.saturating_mul(blocks); + available = bsize.saturating_mul(bavail); + } + if total == 0 { + return None; + } + let mount_point = mount_point.to_owned(); + let is_removable = removable_entries + .iter() + .any(|e| e.as_os_str() == device_name); + Some(Disk { + type_, + device_name: device_name.to_owned(), + file_system: file_system.to_owned(), + mount_point, + total_space: cast!(total), + available_space: cast!(available), + is_removable, + }) + } +} + +#[allow(clippy::manual_range_contains)] +fn find_type_for_device_name(device_name: &OsStr) -> DiskType { + // The format of devices are as follows: + // - device_name is symbolic link in the case of /dev/mapper/ + // and /dev/root, and the target is corresponding device under + // /sys/block/ + // - In the case of /dev/sd, the format is /dev/sd[a-z][1-9], + // corresponding to /sys/block/sd[a-z] + // - In the case of /dev/nvme, the format is /dev/nvme[0-9]n[0-9]p[0-9], + // corresponding to /sys/block/nvme[0-9]n[0-9] + // - In the case of /dev/mmcblk, the format is /dev/mmcblk[0-9]p[0-9], + // corresponding to /sys/block/mmcblk[0-9] + let device_name_path = device_name.to_str().unwrap_or_default(); + let real_path = fs::canonicalize(device_name).unwrap_or_else(|_| PathBuf::from(device_name)); + let mut real_path = real_path.to_str().unwrap_or_default(); + if device_name_path.starts_with("/dev/mapper/") { + // Recursively solve, for example /dev/dm-0 + if real_path != device_name_path { + return find_type_for_device_name(OsStr::new(&real_path)); + } + } else if device_name_path.starts_with("/dev/sd") || device_name_path.starts_with("/dev/vd") { + // Turn "sda1" into "sda" or "vda1" into "vda" + real_path = real_path.trim_start_matches("/dev/"); + 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'); + } else if device_name_path.starts_with("/dev/root") { + // Recursively solve, for example /dev/mmcblk0p1 + if real_path != device_name_path { + return find_type_for_device_name(OsStr::new(&real_path)); + } + } 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'); + } else { + // Default case: remove /dev/ and expects the name presents under /sys/block/ + // For example, /dev/dm-0 to dm-0 + real_path = real_path.trim_start_matches("/dev/"); + } + + let trimmed: &OsStr = OsStrExt::from_bytes(real_path.as_bytes()); + + let path = Path::new("/sys/block/") + .to_owned() + .join(trimmed) + .join("queue/rotational"); + // Normally, this file only contains '0' or '1' but just in case, we get 8 bytes... + match get_all_data(path, 8) + .unwrap_or_default() + .trim() + .parse() + .ok() + { + // The disk is marked as rotational so it's a HDD. + Some(1) => DiskType::HDD, + // The disk is marked as non-rotational so it's very likely a SSD. + Some(0) => DiskType::SSD, + // Normally it shouldn't happen but welcome to the wonderful world of IT! :D + Some(x) => DiskType::Unknown(x), + // The information isn't available... + None => DiskType::Unknown(-1), + } +} + +fn get_all_disks_inner(content: &str) -> Vec<Disk> { + // The goal of this array is to list all removable devices (the ones whose name starts with + // "usb-"). Then we check if + let removable_entries = match fs::read_dir("/dev/disk/by-id/") { + Ok(r) => r + .filter_map(|res| Some(res.ok()?.path())) + .filter_map(|e| { + if e.file_name() + .and_then(|x| Some(x.to_str()?.starts_with("usb-"))) + .unwrap_or_default() + { + e.canonicalize().ok() + } else { + None + } + }) + .collect::<Vec<PathBuf>>(), + _ => Vec::new(), + }; + + content + .lines() + .map(|line| { + let line = line.trim_start(); + // mounts format + // http://man7.org/linux/man-pages/man5/fstab.5.html + // fs_spec<tab>fs_file<tab>fs_vfstype<tab>other fields + let mut fields = line.split_whitespace(); + let fs_spec = fields.next().unwrap_or(""); + let fs_file = fields + .next() + .unwrap_or("") + .replace("\\134", "\\") + .replace("\\040", " ") + .replace("\\011", "\t") + .replace("\\012", "\n"); + let fs_vfstype = fields.next().unwrap_or(""); + (fs_spec, fs_file, fs_vfstype) + }) + .filter(|(fs_spec, fs_file, fs_vfstype)| { + // Check if fs_vfstype is one of our 'ignored' file systems. + let filtered = matches!( + *fs_vfstype, + "rootfs" | // https://www.kernel.org/doc/Documentation/filesystems/ramfs-rootfs-initramfs.txt + "sysfs" | // pseudo file system for kernel objects + "proc" | // another pseudo file system + "tmpfs" | + "devtmpfs" | + "cgroup" | + "cgroup2" | + "pstore" | // https://www.kernel.org/doc/Documentation/ABI/testing/pstore + "squashfs" | // squashfs is a compressed read-only file system (for snaps) + "rpc_pipefs" | // The pipefs pseudo file system service + "iso9660" // optical media + ); + + !(filtered || + fs_file.starts_with("/sys") || // check if fs_file is an 'ignored' mount point + fs_file.starts_with("/proc") || + (fs_file.starts_with("/run") && !fs_file.starts_with("/run/media")) || + fs_spec.starts_with("sunrpc")) + }) + .filter_map(|(fs_spec, fs_file, fs_vfstype)| { + new_disk( + fs_spec.as_ref(), + Path::new(&fs_file), + fs_vfstype.as_bytes(), + &removable_entries, + ) + }) + .collect() +} + +pub(crate) fn get_all_disks() -> Vec<Disk> { + get_all_disks_inner(&get_all_data("/proc/mounts", 16_385).unwrap_or_default()) +} + +// #[test] +// fn check_all_disks() { +// let disks = get_all_disks_inner( +// r#"tmpfs /proc tmpfs rw,seclabel,relatime 0 0 +// proc /proc proc rw,nosuid,nodev,noexec,relatime 0 0 +// systemd-1 /proc/sys/fs/binfmt_misc autofs rw,relatime,fd=29,pgrp=1,timeout=0,minproto=5,maxproto=5,direct,pipe_ino=17771 0 0 +// tmpfs /sys tmpfs rw,seclabel,relatime 0 0 +// sysfs /sys sysfs rw,seclabel,nosuid,nodev,noexec,relatime 0 0 +// securityfs /sys/kernel/security securityfs rw,nosuid,nodev,noexec,relatime 0 0 +// cgroup2 /sys/fs/cgroup cgroup2 rw,seclabel,nosuid,nodev,noexec,relatime,nsdelegate 0 0 +// pstore /sys/fs/pstore pstore rw,seclabel,nosuid,nodev,noexec,relatime 0 0 +// none /sys/fs/bpf bpf rw,nosuid,nodev,noexec,relatime,mode=700 0 0 +// configfs /sys/kernel/config configfs rw,nosuid,nodev,noexec,relatime 0 0 +// selinuxfs /sys/fs/selinux selinuxfs rw,relatime 0 0 +// debugfs /sys/kernel/debug debugfs rw,seclabel,nosuid,nodev,noexec,relatime 0 0 +// tmpfs /dev/shm tmpfs rw,seclabel,relatime 0 0 +// devpts /dev/pts devpts rw,seclabel,relatime,gid=5,mode=620,ptmxmode=666 0 0 +// tmpfs /sys/fs/selinux tmpfs rw,seclabel,relatime 0 0 +// /dev/vda2 /proc/filesystems xfs rw,seclabel,relatime,attr2,inode64,logbufs=8,logbsize=32k,noquota 0 0 +// "#, +// ); +// assert_eq!(disks.len(), 1); +// assert_eq!( +// disks[0], +// Disk { +// type_: DiskType::Unknown(-1), +// name: OsString::from("devpts"), +// file_system: vec![100, 101, 118, 112, 116, 115], +// mount_point: PathBuf::from("/dev/pts"), +// total_space: 0, +// available_space: 0, +// } +// ); +// } diff --git a/vendor/sysinfo/src/linux/mod.rs b/vendor/sysinfo/src/linux/mod.rs new file mode 100644 index 000000000..9cff98907 --- /dev/null +++ b/vendor/sysinfo/src/linux/mod.rs @@ -0,0 +1,16 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +pub mod component; +pub mod cpu; +pub mod disk; +pub mod network; +pub mod process; +pub mod system; +pub(crate) mod utils; + +pub use self::component::Component; +pub use self::cpu::Cpu; +pub use self::disk::Disk; +pub use self::network::{NetworkData, Networks}; +pub use self::process::Process; +pub use self::system::System; diff --git a/vendor/sysinfo/src/linux/network.rs b/vendor/sysinfo/src/linux/network.rs new file mode 100644 index 000000000..0153c151a --- /dev/null +++ b/vendor/sysinfo/src/linux/network.rs @@ -0,0 +1,314 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::fs::File; +use std::io::Read; +use std::path::Path; + +use crate::{NetworkExt, NetworksExt, NetworksIter}; +use std::collections::{hash_map, HashMap}; + +#[doc = include_str!("../../md_doc/networks.md")] +pub struct Networks { + interfaces: HashMap<String, NetworkData>, +} + +macro_rules! old_and_new { + ($ty_:expr, $name:ident, $old:ident) => {{ + $ty_.$old = $ty_.$name; + $ty_.$name = $name; + }}; + ($ty_:expr, $name:ident, $old:ident, $path:expr) => {{ + let _tmp = $path; + $ty_.$old = $ty_.$name; + $ty_.$name = _tmp; + }}; +} + +#[allow(clippy::ptr_arg)] +fn read<P: AsRef<Path>>(parent: P, path: &str, data: &mut Vec<u8>) -> u64 { + if let Ok(mut f) = File::open(parent.as_ref().join(path)) { + if let Ok(size) = f.read(data) { + let mut i = 0; + let mut ret = 0; + + while i < size && i < data.len() && data[i] >= b'0' && data[i] <= b'9' { + ret *= 10; + ret += (data[i] - b'0') as u64; + i += 1; + } + return ret; + } + } + 0 +} + +impl Networks { + pub(crate) fn new() -> Self { + Networks { + interfaces: HashMap::new(), + } + } +} + +fn refresh_networks_list_from_sysfs( + interfaces: &mut HashMap<String, NetworkData>, + sysfs_net: &Path, +) { + if let Ok(dir) = std::fs::read_dir(sysfs_net) { + let mut data = vec![0; 30]; + + for stats in interfaces.values_mut() { + stats.updated = false; + } + + for entry in dir.flatten() { + let parent = &entry.path().join("statistics"); + let entry = match entry.file_name().into_string() { + Ok(entry) => entry, + Err(_) => continue, + }; + let rx_bytes = read(parent, "rx_bytes", &mut data); + let tx_bytes = read(parent, "tx_bytes", &mut data); + let rx_packets = read(parent, "rx_packets", &mut data); + let tx_packets = read(parent, "tx_packets", &mut data); + let rx_errors = read(parent, "rx_errors", &mut data); + let tx_errors = read(parent, "tx_errors", &mut data); + // let rx_compressed = read(parent, "rx_compressed", &mut data); + // let tx_compressed = read(parent, "tx_compressed", &mut data); + match interfaces.entry(entry) { + hash_map::Entry::Occupied(mut e) => { + let mut interface = e.get_mut(); + old_and_new!(interface, rx_bytes, old_rx_bytes); + old_and_new!(interface, tx_bytes, old_tx_bytes); + old_and_new!(interface, rx_packets, old_rx_packets); + old_and_new!(interface, tx_packets, old_tx_packets); + old_and_new!(interface, rx_errors, old_rx_errors); + old_and_new!(interface, tx_errors, old_tx_errors); + // old_and_new!(e, rx_compressed, old_rx_compressed); + // old_and_new!(e, tx_compressed, old_tx_compressed); + interface.updated = true; + } + hash_map::Entry::Vacant(e) => { + e.insert(NetworkData { + rx_bytes, + old_rx_bytes: rx_bytes, + tx_bytes, + old_tx_bytes: tx_bytes, + rx_packets, + old_rx_packets: rx_packets, + tx_packets, + old_tx_packets: tx_packets, + rx_errors, + old_rx_errors: rx_errors, + tx_errors, + old_tx_errors: tx_errors, + // rx_compressed, + // old_rx_compressed: rx_compressed, + // tx_compressed, + // old_tx_compressed: tx_compressed, + updated: true, + }); + } + }; + } + + // Remove interfaces which are gone. + interfaces.retain(|_, d| d.updated); + } +} + +impl NetworksExt for Networks { + fn iter(&self) -> NetworksIter { + NetworksIter::new(self.interfaces.iter()) + } + + fn refresh(&mut self) { + let mut v = vec![0; 30]; + + for (interface_name, data) in self.interfaces.iter_mut() { + data.update(interface_name, &mut v); + } + } + + fn refresh_networks_list(&mut self) { + refresh_networks_list_from_sysfs(&mut self.interfaces, Path::new("/sys/class/net/")); + } +} + +#[doc = include_str!("../../md_doc/network_data.md")] +pub struct NetworkData { + /// Total number of bytes received over interface. + rx_bytes: u64, + old_rx_bytes: u64, + /// Total number of bytes transmitted over interface. + tx_bytes: u64, + old_tx_bytes: u64, + /// Total number of packets received. + rx_packets: u64, + old_rx_packets: u64, + /// Total number of packets transmitted. + tx_packets: u64, + old_tx_packets: u64, + /// Shows the total number of packets received with error. This includes + /// too-long-frames errors, ring-buffer overflow errors, CRC errors, + /// frame alignment errors, fifo overruns, and missed packets. + rx_errors: u64, + old_rx_errors: u64, + /// similar to `rx_errors` + tx_errors: u64, + old_tx_errors: u64, + // /// Indicates the number of compressed packets received by this + // /// network device. This value might only be relevant for interfaces + // /// that support packet compression (e.g: PPP). + // rx_compressed: usize, + // old_rx_compressed: usize, + // /// Indicates the number of transmitted compressed packets. Note + // /// this might only be relevant for devices that support + // /// compression (e.g: PPP). + // tx_compressed: usize, + // old_tx_compressed: usize, + /// Whether or not the above data has been updated during refresh + updated: bool, +} + +impl NetworkData { + fn update(&mut self, path: &str, data: &mut Vec<u8>) { + let path = &Path::new("/sys/class/net/").join(path).join("statistics"); + old_and_new!(self, rx_bytes, old_rx_bytes, read(path, "rx_bytes", data)); + old_and_new!(self, tx_bytes, old_tx_bytes, read(path, "tx_bytes", data)); + old_and_new!( + self, + rx_packets, + old_rx_packets, + read(path, "rx_packets", data) + ); + old_and_new!( + self, + tx_packets, + old_tx_packets, + read(path, "tx_packets", data) + ); + old_and_new!( + self, + rx_errors, + old_rx_errors, + read(path, "rx_errors", data) + ); + old_and_new!( + self, + tx_errors, + old_tx_errors, + read(path, "tx_errors", data) + ); + // old_and_new!( + // self, + // rx_compressed, + // old_rx_compressed, + // read(path, "rx_compressed", data) + // ); + // old_and_new!( + // self, + // tx_compressed, + // old_tx_compressed, + // read(path, "tx_compressed", data) + // ); + } +} + +impl NetworkExt for NetworkData { + fn received(&self) -> u64 { + self.rx_bytes.saturating_sub(self.old_rx_bytes) + } + + fn total_received(&self) -> u64 { + self.rx_bytes + } + + fn transmitted(&self) -> u64 { + self.tx_bytes.saturating_sub(self.old_tx_bytes) + } + + fn total_transmitted(&self) -> u64 { + self.tx_bytes + } + + fn packets_received(&self) -> u64 { + self.rx_packets.saturating_sub(self.old_rx_packets) + } + + fn total_packets_received(&self) -> u64 { + self.rx_packets + } + + fn packets_transmitted(&self) -> u64 { + self.tx_packets.saturating_sub(self.old_tx_packets) + } + + fn total_packets_transmitted(&self) -> u64 { + self.tx_packets + } + + fn errors_on_received(&self) -> u64 { + self.rx_errors.saturating_sub(self.old_rx_errors) + } + + fn total_errors_on_received(&self) -> u64 { + self.rx_errors + } + + fn errors_on_transmitted(&self) -> u64 { + self.tx_errors.saturating_sub(self.old_tx_errors) + } + + fn total_errors_on_transmitted(&self) -> u64 { + self.tx_errors + } +} + +#[cfg(test)] +mod test { + use super::refresh_networks_list_from_sysfs; + use std::collections::HashMap; + use std::fs; + + #[test] + fn refresh_networks_list_add_interface() { + let sys_net_dir = tempfile::tempdir().expect("failed to create temporary directory"); + + fs::create_dir(sys_net_dir.path().join("itf1")).expect("failed to create subdirectory"); + + let mut interfaces = HashMap::new(); + + refresh_networks_list_from_sysfs(&mut interfaces, sys_net_dir.path()); + assert_eq!(interfaces.keys().collect::<Vec<_>>(), ["itf1"]); + + fs::create_dir(sys_net_dir.path().join("itf2")).expect("failed to create subdirectory"); + + refresh_networks_list_from_sysfs(&mut interfaces, sys_net_dir.path()); + let mut itf_names: Vec<String> = interfaces.keys().map(|n| n.to_owned()).collect(); + itf_names.sort(); + assert_eq!(itf_names, ["itf1", "itf2"]); + } + + #[test] + fn refresh_networks_list_remove_interface() { + let sys_net_dir = tempfile::tempdir().expect("failed to create temporary directory"); + + 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"); + + let mut interfaces = HashMap::new(); + + refresh_networks_list_from_sysfs(&mut interfaces, sys_net_dir.path()); + let mut itf_names: Vec<String> = interfaces.keys().map(|n| n.to_owned()).collect(); + itf_names.sort(); + assert_eq!(itf_names, ["itf1", "itf2"]); + + fs::remove_dir(&itf1_dir).expect("failed to remove subdirectory"); + + refresh_networks_list_from_sysfs(&mut interfaces, sys_net_dir.path()); + assert_eq!(interfaces.keys().collect::<Vec<_>>(), ["itf2"]); + } +} diff --git a/vendor/sysinfo/src/linux/process.rs b/vendor/sysinfo/src/linux/process.rs new file mode 100644 index 000000000..0b06e26f1 --- /dev/null +++ b/vendor/sysinfo/src/linux/process.rs @@ -0,0 +1,700 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::cell::UnsafeCell; +use std::collections::HashMap; +use std::fmt; +use std::fs::{self, File}; +use std::io::Read; +use std::mem::MaybeUninit; +use std::path::{Path, PathBuf}; +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::utils::into_iter; +use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessRefreshKind, ProcessStatus, Signal, Uid}; + +#[doc(hidden)] +impl From<u32> for ProcessStatus { + fn from(status: u32) -> ProcessStatus { + match status { + 1 => ProcessStatus::Idle, + 2 => ProcessStatus::Run, + 3 => ProcessStatus::Sleep, + 4 => ProcessStatus::Stop, + 5 => ProcessStatus::Zombie, + x => ProcessStatus::Unknown(x), + } + } +} + +#[doc(hidden)] +impl From<char> for ProcessStatus { + fn from(status: char) -> ProcessStatus { + match status { + 'R' => ProcessStatus::Run, + 'S' => ProcessStatus::Sleep, + 'D' => ProcessStatus::Idle, + 'Z' => ProcessStatus::Zombie, + 'T' => ProcessStatus::Stop, + 't' => ProcessStatus::Tracing, + 'X' | 'x' => ProcessStatus::Dead, + 'K' => ProcessStatus::Wakekill, + 'W' => ProcessStatus::Waking, + 'P' => ProcessStatus::Parked, + x => ProcessStatus::Unknown(x as u32), + } + } +} + +impl fmt::Display for ProcessStatus { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(match *self { + ProcessStatus::Idle => "Idle", + ProcessStatus::Run => "Runnable", + ProcessStatus::Sleep => "Sleeping", + ProcessStatus::Stop => "Stopped", + ProcessStatus::Zombie => "Zombie", + ProcessStatus::Tracing => "Tracing", + ProcessStatus::Dead => "Dead", + ProcessStatus::Wakekill => "Wakekill", + ProcessStatus::Waking => "Waking", + ProcessStatus::Parked => "Parked", + _ => "Unknown", + }) + } +} + +#[doc = include_str!("../../md_doc/process.md")] +pub struct Process { + pub(crate) name: String, + pub(crate) cmd: Vec<String>, + pub(crate) exe: PathBuf, + pub(crate) pid: Pid, + parent: Option<Pid>, + pub(crate) environ: Vec<String>, + pub(crate) cwd: PathBuf, + pub(crate) root: PathBuf, + pub(crate) memory: u64, + pub(crate) virtual_memory: u64, + utime: u64, + stime: u64, + old_utime: u64, + old_stime: u64, + start_time_without_boot_time: u64, + start_time: u64, + run_time: u64, + pub(crate) updated: bool, + cpu_usage: f32, + user_id: Option<Uid>, + group_id: Option<Gid>, + pub(crate) status: ProcessStatus, + /// Tasks run by this process. + pub tasks: HashMap<Pid, Process>, + pub(crate) stat_file: Option<File>, + old_read_bytes: u64, + old_written_bytes: u64, + read_bytes: u64, + written_bytes: u64, +} + +impl Process { + pub(crate) fn new( + pid: Pid, + parent: Option<Pid>, + start_time_without_boot_time: u64, + info: &SystemInfo, + ) -> Process { + Process { + name: String::with_capacity(20), + pid, + parent, + cmd: Vec::with_capacity(2), + environ: Vec::with_capacity(10), + exe: PathBuf::new(), + cwd: PathBuf::new(), + root: PathBuf::new(), + memory: 0, + virtual_memory: 0, + cpu_usage: 0., + utime: 0, + stime: 0, + 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), + run_time: 0, + user_id: None, + group_id: None, + status: ProcessStatus::Unknown(0), + tasks: if pid.0 == 0 { + HashMap::with_capacity(1000) + } else { + HashMap::new() + }, + stat_file: None, + old_read_bytes: 0, + old_written_bytes: 0, + read_bytes: 0, + written_bytes: 0, + } + } +} + +impl ProcessExt for Process { + fn kill_with(&self, signal: Signal) -> Option<bool> { + let c_signal = super::system::convert_signal(signal)?; + unsafe { Some(kill(self.pid.0, c_signal) == 0) } + } + + fn name(&self) -> &str { + &self.name + } + + fn cmd(&self) -> &[String] { + &self.cmd + } + + fn exe(&self) -> &Path { + self.exe.as_path() + } + + fn pid(&self) -> Pid { + self.pid + } + + fn environ(&self) -> &[String] { + &self.environ + } + + fn cwd(&self) -> &Path { + self.cwd.as_path() + } + + fn root(&self) -> &Path { + self.root.as_path() + } + + fn memory(&self) -> u64 { + self.memory + } + + fn virtual_memory(&self) -> u64 { + self.virtual_memory + } + + fn parent(&self) -> Option<Pid> { + self.parent + } + + fn status(&self) -> ProcessStatus { + self.status + } + + fn start_time(&self) -> u64 { + self.start_time + } + + fn run_time(&self) -> u64 { + self.run_time + } + + fn cpu_usage(&self) -> f32 { + self.cpu_usage + } + + fn disk_usage(&self) -> DiskUsage { + DiskUsage { + written_bytes: self.written_bytes.saturating_sub(self.old_written_bytes), + total_written_bytes: self.written_bytes, + read_bytes: self.read_bytes.saturating_sub(self.old_read_bytes), + total_read_bytes: self.read_bytes, + } + } + + fn user_id(&self) -> Option<&Uid> { + self.user_id.as_ref() + } + + 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; + } + } + } + } +} + +pub(crate) fn compute_cpu_usage(p: &mut Process, total_time: f32, max_value: f32) { + // First time updating the values without reference, wait for a second cycle to update cpu_usage + if p.old_utime == 0 && p.old_stime == 0 { + return; + } + + // We use `max_value` to ensure that the process CPU usage will never get bigger than: + // `"number of CPUs" * 100.` + p.cpu_usage = ((p.utime.saturating_sub(p.old_utime) + p.stime.saturating_sub(p.old_stime)) + as f32 + / total_time + * 100.) + .min(max_value); +} + +pub(crate) fn set_time(p: &mut Process, utime: u64, stime: u64) { + p.old_utime = p.utime; + p.old_stime = p.stime; + p.utime = utime; + p.stime = stime; + p.updated = true; +} + +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) { + Ok(d) => d, + Err(_) => return, + }; + let mut done = 0; + for line in data.split('\n') { + let mut parts = line.split(": "); + match parts.next() { + Some("read_bytes") => { + p.old_read_bytes = p.read_bytes; + p.read_bytes = parts + .next() + .and_then(|x| x.parse::<u64>().ok()) + .unwrap_or(p.old_read_bytes); + } + Some("write_bytes") => { + p.old_written_bytes = p.written_bytes; + p.written_bytes = parts + .next() + .and_then(|x| x.parse::<u64>().ok()) + .unwrap_or(p.old_written_bytes); + } + _ => continue, + } + done += 1; + if done > 1 { + // No need to continue the reading. + break; + } + } +} + +struct Wrap<'a, T>(UnsafeCell<&'a mut T>); + +impl<'a, T> Wrap<'a, T> { + fn get(&self) -> &'a mut T { + unsafe { *(self.0.get()) } + } +} + +#[allow(clippy::non_send_fields_in_send_ty)] +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(()), + }; + + 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)); + } + + let mut tmp = PathBuf::from(path); + + 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)?; + let name = parts[1]; + + let parent_pid = if proc_list.pid.0 != 0 { + Some(proc_list.pid) + } else { + match Pid::from_str(parts[3]) { + Ok(p) if p.0 != 0 => Some(p), + _ => None, + } + }; + + // 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.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)); + } + } + + if proc_list.pid.0 != 0 { + // If we're getting information for a child, no need to get those info since we + // already have them... + p.cmd = proc_list.cmd.clone(); + p.name = proc_list.name.clone(); + p.environ = proc_list.environ.clone(); + p.exe = proc_list.exe.clone(); + p.cwd = proc_list.cwd.clone(); + 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() { + Ok(exe_path) => { + p.exe = exe_path; + } + Err(_) => { + p.exe = if let Some(cmd) = p.cmd.get(0) { + PathBuf::from(cmd) + } else { + 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); + } + + update_time_and_memory( + path, + &mut p, + &parts, + proc_list.memory, + proc_list.virtual_memory, + uptime, + info, + refresh_kind, + ); + if refresh_kind.disk_usage() { + update_process_disk_activity(&mut p, path); + } + Ok((Some(p), pid)) +} + +#[allow(clippy::too_many_arguments)] +fn update_time_and_memory( + path: &Path, + entry: &mut Process, + parts: &[&str], + parent_memory: u64, + parent_virtual_memory: u64, + uptime: u64, + info: &SystemInfo, + refresh_kind: ProcessRefreshKind, +) { + { + // rss + entry.memory = u64::from_str(parts[23]) + .unwrap_or(0) + .saturating_mul(info.page_size_kb); + 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. + // see: https://man7.org/linux/man-pages/man5/proc.5.html + entry.virtual_memory = u64::from_str(parts[22]).unwrap_or(0) / 1_000; + if entry.virtual_memory >= parent_virtual_memory { + entry.virtual_memory -= parent_virtual_memory; + } + set_time( + entry, + u64::from_str(parts[13]).unwrap_or(0), + u64::from_str(parts[14]).unwrap_or(0), + ); + entry.run_time = uptime.saturating_sub(entry.start_time_without_boot_time); + } + refresh_procs( + entry, + &path.join("task"), + entry.pid, + uptime, + info, + refresh_kind, + ); +} + +pub(crate) fn refresh_procs( + proc_list: &mut Process, + path: &Path, + pid: Pid, + uptime: u64, + 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 + } + }) + .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 + } else { + false + } +} + +fn copy_from_file(entry: &Path) -> Vec<String> { + match File::open(entry) { + Ok(mut f) => { + let mut data = vec![0; 16_384]; + + if let Ok(size) = f.read(&mut data) { + data.truncate(size); + let mut out = Vec::with_capacity(20); + let mut start = 0; + for (pos, x) in data.iter().enumerate() { + if *x == 0 { + if pos - start >= 1 { + if let Ok(s) = + std::str::from_utf8(&data[start..pos]).map(|x| x.trim().to_owned()) + { + out.push(s); + } + } + start = pos + 1; // to keeping prevent '\0' + } + } + out + } else { + Vec::new() + } + } + Err(_) => Vec::new(), + } +} + +fn get_uid_and_gid(file_path: &Path) -> Option<(uid_t, gid_t)> { + use std::os::unix::ffi::OsStrExt; + + unsafe { + let mut sstat: MaybeUninit<libc::stat> = MaybeUninit::uninit(); + + let mut file_path: Vec<u8> = file_path.as_os_str().as_bytes().to_vec(); + file_path.push(0); + if libc::stat(file_path.as_ptr() as *const _, sstat.as_mut_ptr()) == 0 { + let sstat = sstat.assume_init(); + + return Some((sstat.st_uid, sstat.st_gid)); + } + } + + 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 + // the effective u/gid. + + let f = |h: &str, n: &str| -> Option<uid_t> { + if h.starts_with(n) { + h.split_whitespace().nth(2).unwrap_or("0").parse().ok() + } else { + None + } + }; + let mut uid = None; + let mut gid = None; + for line in status_data.lines() { + if let Some(u) = f(line, "Uid:") { + assert!(uid.is_none()); + uid = Some(u); + } else if let Some(g) = f(line, "Gid:") { + assert!(gid.is_none()); + gid = Some(g); + } else { + continue; + } + if uid.is_some() && gid.is_some() { + break; + } + } + match (uid, gid) { + (Some(u), Some(g)) => Some((u, g)), + _ => None, + } +} + +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>, ()> { + // 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 + // parentheses are legal parts of the command, so parsing has to + // proceed like this: The first field is delimited by the first + // whitespace, the second field is everything until the last ')' + // in the entire string. All other fields are delimited by + // whitespace. + + 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.extend(data.split_whitespace()); + // Remove command name '(' + if let Some(name) = parts[1].strip_prefix('(') { + parts[1] = name; + } + Ok(parts) +} diff --git a/vendor/sysinfo/src/linux/system.rs b/vendor/sysinfo/src/linux/system.rs new file mode 100644 index 000000000..7a8d0a010 --- /dev/null +++ b/vendor/sysinfo/src/linux/system.rs @@ -0,0 +1,852 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +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::{ + CpuRefreshKind, Disk, LoadAvg, Networks, Pid, ProcessRefreshKind, RefreshKind, SystemExt, User, +}; + +use libc::{self, c_char, c_int, sysconf, _SC_CLK_TCK, _SC_HOST_NAME_MAX, _SC_PAGESIZE}; +use std::collections::HashMap; +use std::fs::File; +use std::io::{BufRead, BufReader, Read}; +use std::path::Path; +use std::str::FromStr; +use std::sync::{Arc, Mutex}; + +// This whole thing is to prevent having too many files open at once. It could be problematic +// for processes using a lot of files and using sysinfo at the same time. +#[allow(clippy::mutex_atomic)] +pub(crate) static mut REMAINING_FILES: once_cell::sync::Lazy<Arc<Mutex<isize>>> = + once_cell::sync::Lazy::new(|| { + unsafe { + let mut limits = libc::rlimit { + rlim_cur: 0, + rlim_max: 0, + }; + if libc::getrlimit(libc::RLIMIT_NOFILE, &mut limits) != 0 { + // Most linux system now defaults to 1024. + return Arc::new(Mutex::new(1024 / 2)); + } + // We save the value in case the update fails. + let current = limits.rlim_cur; + + // The set the soft limit to the hard one. + limits.rlim_cur = limits.rlim_max; + // In this part, we leave minimum 50% of the available file descriptors to the process + // using sysinfo. + Arc::new(Mutex::new( + if libc::setrlimit(libc::RLIMIT_NOFILE, &limits) == 0 { + limits.rlim_cur / 2 + } else { + current / 2 + } as _, + )) + } + }); + +pub(crate) fn get_max_nb_fds() -> isize { + unsafe { + let mut limits = libc::rlimit { + rlim_cur: 0, + rlim_max: 0, + }; + if libc::getrlimit(libc::RLIMIT_NOFILE, &mut limits) != 0 { + // Most linux system now defaults to 1024. + 1024 / 2 + } else { + limits.rlim_max as isize / 2 + } + } +} + +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); + let line = buf + .split(b'\n') + .filter_map(|r| r.ok()) + .find(|l| l.starts_with(b"btime")); + + if let Some(line) = line { + return line + .split(|x| *x == b' ') + .filter(|s| !s.is_empty()) + .nth(1) + .map(to_u64) + .unwrap_or(0); + } + } + // Either we didn't find "btime" or "/proc/stat" wasn't available for some reason... + let mut up = libc::timespec { + tv_sec: 0, + tv_nsec: 0, + }; + unsafe { + if libc::clock_gettime(libc::CLOCK_BOOTTIME, &mut up) == 0 { + up.tv_sec as u64 + } else { + sysinfo_debug!("clock_gettime failed: boot time cannot be retrieve..."); + 0 + } + } +} + +pub(crate) struct SystemInfo { + pub(crate) page_size_kb: u64, + pub(crate) clock_cycle: u64, + pub(crate) boot_time: u64, +} + +impl SystemInfo { + fn new() -> Self { + unsafe { + Self { + page_size_kb: (sysconf(_SC_PAGESIZE) / 1024) as _, + clock_cycle: sysconf(_SC_CLK_TCK) as _, + boot_time: boot_time(), + } + } + } +} + +declare_signals! { + c_int, + Signal::Hangup => libc::SIGHUP, + Signal::Interrupt => libc::SIGINT, + Signal::Quit => libc::SIGQUIT, + Signal::Illegal => libc::SIGILL, + Signal::Trap => libc::SIGTRAP, + Signal::Abort => libc::SIGABRT, + Signal::IOT => libc::SIGIOT, + Signal::Bus => libc::SIGBUS, + Signal::FloatingPointException => libc::SIGFPE, + Signal::Kill => libc::SIGKILL, + Signal::User1 => libc::SIGUSR1, + Signal::Segv => libc::SIGSEGV, + Signal::User2 => libc::SIGUSR2, + Signal::Pipe => libc::SIGPIPE, + Signal::Alarm => libc::SIGALRM, + Signal::Term => libc::SIGTERM, + Signal::Child => libc::SIGCHLD, + Signal::Continue => libc::SIGCONT, + Signal::Stop => libc::SIGSTOP, + Signal::TSTP => libc::SIGTSTP, + Signal::TTIN => libc::SIGTTIN, + Signal::TTOU => libc::SIGTTOU, + Signal::Urgent => libc::SIGURG, + Signal::XCPU => libc::SIGXCPU, + Signal::XFSZ => libc::SIGXFSZ, + Signal::VirtualAlarm => libc::SIGVTALRM, + Signal::Profiling => libc::SIGPROF, + Signal::Winch => libc::SIGWINCH, + Signal::IO => libc::SIGIO, + Signal::Poll => libc::SIGPOLL, + Signal::Power => libc::SIGPWR, + Signal::Sys => libc::SIGSYS, +} + +#[doc = include_str!("../../md_doc/system.md")] +pub struct System { + process_list: Process, + mem_total: u64, + mem_free: u64, + mem_available: u64, + mem_buffers: u64, + mem_page_cache: 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, +} + +impl System { + /// It is sometime possible that a CPU usage computation is bigger than + /// `"number of CPUs" * 100`. + /// + /// To prevent that, we compute ahead of time this maximum value and ensure that processes' + /// CPU usage don't go over it. + fn get_max_process_cpu_usage(&self) -> f32 { + self.cpus.len() as f32 * 100. + } + + 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()); + } + + 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 total_time = if old > new { 1 } else { new - old }; + ( + total_time as f32 / self.cpus.len() as f32, + true, + self.get_max_process_cpu_usage(), + ) + } + } else { + (0., false, 0.) + }; + + self.process_list.tasks.retain(|_, proc_| { + if !proc_.updated { + return false; + } + if compute_cpu { + compute_cpu_usage(proc_, total_time, max_value); + } + proc_.updated = false; + true + }); + } + + 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; + } + } + } +} + +impl SystemExt for System { + const IS_SUPPORTED: bool = true; + 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 mut s = System { + process_list, + mem_total: 0, + mem_free: 0, + mem_available: 0, + mem_buffers: 0, + mem_page_cache: 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), + components: Vec::new(), + disks: Vec::with_capacity(2), + networks: Networks::new(), + users: Vec::new(), + need_cpus_update: true, + info, + got_cpu_frequency: false, + }; + s.refresh_specifics(refreshes); + s + } + + fn refresh_components_list(&mut self) { + self.components = component::get_components(); + } + + fn refresh_memory(&mut self) { + if let Ok(data) = get_all_data("/proc/meminfo", 16_385) { + 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("Buffers") => &mut self.mem_buffers, + Some("Cached") => &mut self.mem_page_cache, + Some("SReclaimable") => &mut self.mem_slab_reclaimable, + Some("SwapTotal") => &mut self.swap_total, + Some("SwapFree") => &mut self.swap_free, + _ => continue, + }; + 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; + } + } + } + } + } + + fn refresh_cpu_specifics(&mut self, refresh_kind: CpuRefreshKind) { + self.refresh_cpus(false, refresh_kind); + } + + fn refresh_processes_specifics(&mut self, refresh_kind: ProcessRefreshKind) { + let uptime = self.uptime(); + refresh_procs( + &mut self.process_list, + Path::new("/proc"), + Pid(0), + uptime, + &self.info, + refresh_kind, + ); + self.clear_procs(refresh_kind); + self.need_cpus_update = true; + } + + fn refresh_process_specifics(&mut self, pid: Pid, refresh_kind: ProcessRefreshKind) -> bool { + let uptime = self.uptime(); + let found = match _get_process_data( + &Path::new("/proc/").join(pid.to_string()), + &mut self.process_list, + Pid(0), + uptime, + &self.info, + refresh_kind, + ) { + Ok((Some(p), pid)) => { + self.process_list.tasks.insert(pid, p); + true + } + Ok(_) => true, + Err(_) => false, + }; + if found { + if refresh_kind.cpu() { + self.refresh_cpus(true, CpuRefreshKind::new().with_cpu_usage()); + + if self.cpus.is_empty() { + sysinfo_debug!("Cannot compute process CPU usage: no cpus found..."); + return found; + } + let (new, old) = get_raw_times(&self.global_cpu); + let total_time = (if old >= new { 1 } else { new - old }) as f32; + + let max_cpu_usage = self.get_max_process_cpu_usage(); + if let Some(p) = self.process_list.tasks.get_mut(&pid) { + compute_cpu_usage(p, total_time / self.cpus.len() as f32, max_cpu_usage); + p.updated = false; + } + } else if let Some(p) = self.process_list.tasks.get_mut(&pid) { + p.updated = false; + } + } + found + } + + fn refresh_disks_list(&mut self) { + self.disks = disk::get_all_disks(); + } + + fn refresh_users_list(&mut self) { + self.users = crate::users::get_users_list(); + } + + // COMMON PART + // + // Need to be moved into a "common" file to avoid duplication. + + fn processes(&self) -> &HashMap<Pid, Process> { + &self.process_list.tasks + } + + fn process(&self, pid: Pid) -> Option<&Process> { + self.process_list.tasks.get(&pid) + } + + fn networks(&self) -> &Networks { + &self.networks + } + + fn networks_mut(&mut self) -> &mut Networks { + &mut self.networks + } + + fn global_cpu_info(&self) -> &Cpu { + &self.global_cpu + } + + fn cpus(&self) -> &[Cpu] { + &self.cpus + } + + fn physical_core_count(&self) -> Option<usize> { + get_physical_core_count() + } + + fn total_memory(&self) -> u64 { + self.mem_total + } + + fn free_memory(&self) -> u64 { + self.mem_free + } + + fn available_memory(&self) -> u64 { + self.mem_available + } + + fn used_memory(&self) -> u64 { + self.mem_total + - self.mem_free + - self.mem_buffers + - self.mem_page_cache + - self.mem_slab_reclaimable + } + + fn total_swap(&self) -> u64 { + self.swap_total + } + + fn free_swap(&self) -> u64 { + self.swap_free + } + + // need to be checked + fn used_swap(&self) -> u64 { + self.swap_total - self.swap_free + } + + fn components(&self) -> &[Component] { + &self.components + } + + fn components_mut(&mut self) -> &mut [Component] { + &mut self.components + } + + fn disks(&self) -> &[Disk] { + &self.disks + } + + fn disks_mut(&mut self) -> &mut [Disk] { + &mut self.disks + } + + fn uptime(&self) -> u64 { + let content = get_all_data("/proc/uptime", 50).unwrap_or_default(); + content + .split('.') + .next() + .and_then(|t| t.parse().ok()) + .unwrap_or_default() + } + + fn boot_time(&self) -> u64 { + self.info.boot_time + } + + fn load_average(&self) -> LoadAvg { + let mut s = String::new(); + if File::open("/proc/loadavg") + .and_then(|mut f| f.read_to_string(&mut s)) + .is_err() + { + return LoadAvg::default(); + } + let loads = s + .trim() + .split(' ') + .take(3) + .map(|val| val.parse::<f64>().unwrap()) + .collect::<Vec<f64>>(); + LoadAvg { + one: loads[0], + five: loads[1], + fifteen: loads[2], + } + } + + fn users(&self) -> &[User] { + &self.users + } + + #[cfg(not(target_os = "android"))] + fn name(&self) -> Option<String> { + get_system_info_linux( + InfoType::Name, + Path::new("/etc/os-release"), + Path::new("/etc/lsb-release"), + ) + } + + #[cfg(target_os = "android")] + fn name(&self) -> Option<String> { + get_system_info_android(InfoType::Name) + } + + fn long_os_version(&self) -> Option<String> { + #[cfg(target_os = "android")] + let system_name = "Android"; + + #[cfg(not(target_os = "android"))] + let system_name = "Linux"; + + Some(format!( + "{} {} {}", + system_name, + self.os_version().unwrap_or_default(), + self.name().unwrap_or_default() + )) + } + + fn host_name(&self) -> Option<String> { + unsafe { + let hostname_max = sysconf(_SC_HOST_NAME_MAX); + let mut buffer = vec![0_u8; hostname_max as usize]; + if libc::gethostname(buffer.as_mut_ptr() as *mut c_char, buffer.len()) == 0 { + if let Some(pos) = buffer.iter().position(|x| *x == 0) { + // Shrink buffer to terminate the null bytes + buffer.resize(pos, 0); + } + String::from_utf8(buffer).ok() + } else { + sysinfo_debug!("gethostname failed: hostname cannot be retrieved..."); + None + } + } + } + + fn kernel_version(&self) -> Option<String> { + let mut raw = std::mem::MaybeUninit::<libc::utsname>::zeroed(); + + unsafe { + if libc::uname(raw.as_mut_ptr()) == 0 { + let info = raw.assume_init(); + + let release = info + .release + .iter() + .filter(|c| **c != 0) + .map(|c| *c as u8 as char) + .collect::<String>(); + + Some(release) + } else { + None + } + } + } + + #[cfg(not(target_os = "android"))] + fn os_version(&self) -> Option<String> { + get_system_info_linux( + InfoType::OsVersion, + Path::new("/etc/os-release"), + Path::new("/etc/lsb-release"), + ) + } + + #[cfg(target_os = "android")] + fn os_version(&self) -> Option<String> { + get_system_info_android(InfoType::OsVersion) + } +} + +impl Default for System { + fn default() -> System { + System::new() + } +} + +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: + /// - Android: The device model + /// - Linux: The distributions name + Name, + OsVersion, +} + +#[cfg(not(target_os = "android"))] +fn get_system_info_linux(info: InfoType, path: &Path, fallback_path: &Path) -> Option<String> { + if let Ok(f) = File::open(path) { + let reader = BufReader::new(f); + + let info_str = match info { + InfoType::Name => "NAME=", + InfoType::OsVersion => "VERSION_ID=", + }; + + for line in reader.lines().flatten() { + if let Some(stripped) = line.strip_prefix(info_str) { + return Some(stripped.replace('"', "")); + } + } + } + + // Fallback to `/etc/lsb-release` file for systems where VERSION_ID is not included. + // VERSION_ID is not required in the `/etc/os-release` file + // per https://www.linux.org/docs/man5/os-release.html + // If this fails for some reason, fallback to None + let reader = BufReader::new(File::open(fallback_path).ok()?); + + let info_str = match info { + InfoType::OsVersion => "DISTRIB_RELEASE=", + InfoType::Name => "DISTRIB_ID=", + }; + for line in reader.lines().flatten() { + if let Some(stripped) = line.strip_prefix(info_str) { + return Some(stripped.replace('"', "")); + } + } + None +} + +#[cfg(target_os = "android")] +fn get_system_info_android(info: InfoType) -> Option<String> { + // https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/os/Build.java#58 + let name: &'static [u8] = match info { + InfoType::Name => b"ro.product.model\0", + InfoType::OsVersion => b"ro.build.version.release\0", + }; + + let mut value_buffer = vec![0u8; libc::PROP_VALUE_MAX as usize]; + unsafe { + let len = libc::__system_property_get( + name.as_ptr() as *const c_char, + value_buffer.as_mut_ptr() as *mut c_char, + ); + + if len != 0 { + if let Some(pos) = value_buffer.iter().position(|c| *c == 0) { + value_buffer.resize(pos, 0); + } + String::from_utf8(value_buffer).ok() + } else { + None + } + } +} + +#[cfg(test)] +mod test { + #[cfg(target_os = "android")] + use super::get_system_info_android; + #[cfg(not(target_os = "android"))] + use super::get_system_info_linux; + use super::InfoType; + + #[test] + #[cfg(target_os = "android")] + fn lsb_release_fallback_android() { + assert!(get_system_info_android(InfoType::OsVersion).is_some()); + assert!(get_system_info_android(InfoType::Name).is_some()); + } + + #[test] + #[cfg(not(target_os = "android"))] + fn lsb_release_fallback_not_android() { + use std::path::Path; + + let dir = tempfile::tempdir().expect("failed to create temporary directory"); + let tmp1 = dir.path().join("tmp1"); + let tmp2 = dir.path().join("tmp2"); + + // /etc/os-release + std::fs::write( + &tmp1, + r#"NAME="Ubuntu" +VERSION="20.10 (Groovy Gorilla)" +ID=ubuntu +ID_LIKE=debian +PRETTY_NAME="Ubuntu 20.10" +VERSION_ID="20.10" +VERSION_CODENAME=groovy +UBUNTU_CODENAME=groovy +"#, + ) + .expect("Failed to create tmp1"); + + // /etc/lsb-release + std::fs::write( + &tmp2, + r#"DISTRIB_ID=Ubuntu +DISTRIB_RELEASE=20.10 +DISTRIB_CODENAME=groovy +DISTRIB_DESCRIPTION="Ubuntu 20.10" +"#, + ) + .expect("Failed to create tmp2"); + + // Check for the "normal" path: "/etc/os-release" + assert_eq!( + get_system_info_linux(InfoType::OsVersion, &tmp1, Path::new("")), + Some("20.10".to_owned()) + ); + assert_eq!( + get_system_info_linux(InfoType::Name, &tmp1, Path::new("")), + Some("Ubuntu".to_owned()) + ); + + // Check for the "fallback" path: "/etc/lsb-release" + assert_eq!( + get_system_info_linux(InfoType::OsVersion, Path::new(""), &tmp2), + Some("20.10".to_owned()) + ); + assert_eq!( + get_system_info_linux(InfoType::Name, Path::new(""), &tmp2), + Some("Ubuntu".to_owned()) + ); + } +} diff --git a/vendor/sysinfo/src/linux/utils.rs b/vendor/sysinfo/src/linux/utils.rs new file mode 100644 index 000000000..cd881a3d1 --- /dev/null +++ b/vendor/sysinfo/src/linux/utils.rs @@ -0,0 +1,55 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::fs::File; +use std::io::{self, Read, Seek, SeekFrom}; +use std::path::Path; + +pub(crate) fn get_all_data_from_file(file: &mut File, size: usize) -> io::Result<String> { + let mut buf = String::with_capacity(size); + file.seek(SeekFrom::Start(0))?; + file.read_to_string(&mut buf)?; + Ok(buf) +} + +pub(crate) fn get_all_data<P: AsRef<Path>>(file_path: P, size: usize) -> io::Result<String> { + let mut file = File::open(file_path.as_ref())?; + get_all_data_from_file(&mut file, size) +} + +#[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 { + 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(), + } + } + } + } +} diff --git a/vendor/sysinfo/src/macros.rs b/vendor/sysinfo/src/macros.rs new file mode 100644 index 000000000..3bb4defa1 --- /dev/null +++ b/vendor/sysinfo/src/macros.rs @@ -0,0 +1,58 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#[cfg(feature = "debug")] +#[doc(hidden)] +#[allow(unused)] +macro_rules! sysinfo_debug { + ($($x:tt)*) => {{ + eprintln!($($x)*); + }} +} + +#[cfg(not(feature = "debug"))] +#[doc(hidden)] +#[allow(unused)] +macro_rules! sysinfo_debug { + ($($x:tt)*) => {{}}; +} + +macro_rules! declare_signals { + ($kind:ty, _ => None,) => ( + use crate::Signal; + + pub(crate) const fn supported_signals() -> &'static [Signal] { + &[] + } + ); + + ($kind:ty, $(Signal::$signal:ident => $map:expr,)+ _ => None,) => ( + use crate::Signal; + + pub(crate) const fn supported_signals() -> &'static [Signal] { + &[$(Signal::$signal,)*] + } + + #[inline] + pub(crate) fn convert_signal(s: Signal) -> Option<$kind> { + match s { + $(Signal::$signal => Some($map),)* + _ => None, + } + } + ); + + ($kind:ty, $(Signal::$signal:ident => $map:expr,)+) => ( + use crate::Signal; + + pub(crate) const fn supported_signals() -> &'static [Signal] { + &[$(Signal::$signal,)*] + } + + #[inline] + pub(crate) fn convert_signal(s: Signal) -> Option<$kind> { + match s { + $(Signal::$signal => Some($map),)* + } + } + ) +} diff --git a/vendor/sysinfo/src/sysinfo.h b/vendor/sysinfo/src/sysinfo.h new file mode 100644 index 000000000..13c039128 --- /dev/null +++ b/vendor/sysinfo/src/sysinfo.h @@ -0,0 +1,45 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#pragma once + +#include <sys/types.h> +#include <stdbool.h> + +typedef void* CSystem; +typedef const void* CProcess; +typedef const char* RString; + +CSystem *sysinfo_init(); +void sysinfo_destroy(CSystem system); +void sysinfo_refresh_system(CSystem system); +void sysinfo_refresh_all(CSystem system); +void sysinfo_refresh_processes(CSystem system); +#ifdef __linux__ +void sysinfo_refresh_process(CSystem system, pid_t pid); +#endif +void sysinfo_refresh_disks(CSystem system); +void sysinfo_refresh_disk_list(CSystem system); +size_t sysinfo_get_total_memory(CSystem system); +size_t sysinfo_get_free_memory(CSystem system); +size_t sysinfo_get_used_memory(CSystem system); +size_t sysinfo_get_total_swap(CSystem system); +size_t sysinfo_get_free_swap(CSystem system); +size_t sysinfo_get_used_swap(CSystem system); +size_t sysinfo_get_network_income(CSystem system); +size_t sysinfo_get_network_outcome(CSystem system); +void sysinfo_get_cpus_usage(CSystem system, unsigned int *length, float **cpus); +size_t sysinfo_get_processes(CSystem system, bool (*fn_pointer)(pid_t, CProcess, void*), + void *data); +#ifdef __linux__ +size_t sysinfo_process_get_tasks(CProcess process, bool (*fn_pointer)(pid_t, CProcess, void*), + void *data); +#endif +CProcess sysinfo_get_process_by_pid(CSystem system, pid_t pid); +pid_t sysinfo_process_get_pid(CProcess process); +pid_t sysinfo_process_get_parent_pid(CProcess process); +float sysinfo_process_get_cpu_usage(CProcess process); +size_t sysinfo_process_get_memory(CProcess process); +RString sysinfo_process_get_executable_path(CProcess process); +RString sysinfo_process_get_root_directory(CProcess process); +RString sysinfo_process_get_current_directory(CProcess process); +void sysinfo_rstring_free(RString str); diff --git a/vendor/sysinfo/src/system.rs b/vendor/sysinfo/src/system.rs new file mode 100644 index 000000000..63a70651f --- /dev/null +++ b/vendor/sysinfo/src/system.rs @@ -0,0 +1,117 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +// Once https://github.com/rust-lang/rfcs/blob/master/text/1422-pub-restricted.md +// feature gets stabilized, we can move common parts in here. + +#[cfg(test)] +mod tests { + use crate::{ProcessExt, System, SystemExt}; + + #[test] + fn test_refresh_system() { + let mut sys = System::new(); + sys.refresh_system(); + // We don't want to test on unsupported systems. + if System::IS_SUPPORTED { + assert!(sys.total_memory() != 0); + assert!(sys.free_memory() != 0); + } + assert!(sys.total_memory() >= sys.free_memory()); + assert!(sys.total_swap() >= sys.free_swap()); + } + + #[test] + fn test_refresh_process() { + let mut sys = System::new(); + assert!(sys.processes().is_empty(), "no process should be listed!"); + // We don't want to test on unsupported systems. + + #[cfg(not(feature = "apple-sandbox"))] + if System::IS_SUPPORTED { + assert!( + sys.refresh_process(crate::get_current_pid().expect("failed to get current pid")), + "process not listed", + ); + // Ensure that the process was really added to the list! + assert!(sys + .process(crate::get_current_pid().expect("failed to get current pid")) + .is_some()); + } + } + + #[test] + fn test_get_process() { + let mut sys = System::new(); + sys.refresh_processes(); + let current_pid = match crate::get_current_pid() { + Ok(pid) => pid, + _ => { + if !System::IS_SUPPORTED { + return; + } + panic!("get_current_pid should work!"); + } + }; + if let Some(p) = sys.process(current_pid) { + assert!(p.memory() > 0); + } else { + #[cfg(not(feature = "apple-sandbox"))] + assert!(!System::IS_SUPPORTED); + } + } + + #[test] + fn check_if_send_and_sync() { + trait Foo { + fn foo(&self) {} + } + impl<T> Foo for T where T: Send {} + + trait Bar { + fn bar(&self) {} + } + + impl<T> Bar for T where T: Sync {} + + let mut sys = System::new(); + sys.refresh_processes(); + let current_pid = match crate::get_current_pid() { + Ok(pid) => pid, + _ => { + if !System::IS_SUPPORTED { + return; + } + panic!("get_current_pid should work!"); + } + }; + if let Some(p) = sys.process(current_pid) { + p.foo(); // If this doesn't compile, it'll simply mean that the Process type + // doesn't implement the Send trait. + p.bar(); // If this doesn't compile, it'll simply mean that the Process type + // doesn't implement the Sync trait. + } else { + #[cfg(not(feature = "apple-sandbox"))] + assert!(!System::IS_SUPPORTED); + } + } + + #[test] + fn check_hostname_has_no_nuls() { + let sys = System::new(); + + if let Some(hostname) = sys.host_name() { + assert!(!hostname.contains('\u{0}')) + } + } + + #[test] + fn check_uptime() { + let sys = System::new(); + let uptime = sys.uptime(); + if System::IS_SUPPORTED { + std::thread::sleep(std::time::Duration::from_millis(1000)); + let new_uptime = sys.uptime(); + assert!(uptime < new_uptime); + } + } +} diff --git a/vendor/sysinfo/src/traits.rs b/vendor/sysinfo/src/traits.rs new file mode 100644 index 000000000..3d5eafaa8 --- /dev/null +++ b/vendor/sysinfo/src/traits.rs @@ -0,0 +1,1582 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{ + common::{Gid, Uid}, + sys::{Component, Cpu, Disk, Networks, Process}, +}; +use crate::{ + CpuRefreshKind, DiskType, DiskUsage, LoadAvg, NetworksIter, Pid, ProcessRefreshKind, + ProcessStatus, RefreshKind, Signal, User, +}; + +use std::collections::HashMap; +use std::ffi::OsStr; +use std::fmt::Debug; +use std::path::Path; + +/// Contains all the methods of the [`Disk`][crate::Disk] struct. +/// +/// ```no_run +/// use sysinfo::{DiskExt, System, SystemExt}; +/// +/// let s = System::new(); +/// for disk in s.disks() { +/// println!("{:?}: {:?}", disk.name(), disk.type_()); +/// } +/// ``` +pub trait DiskExt: Debug { + /// Returns the disk type. + /// + /// ```no_run + /// use sysinfo::{DiskExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for disk in s.disks() { + /// println!("{:?}", disk.type_()); + /// } + /// ``` + fn type_(&self) -> DiskType; + + /// Returns the disk name. + /// + /// ```no_run + /// use sysinfo::{DiskExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for disk in s.disks() { + /// println!("{:?}", disk.name()); + /// } + /// ``` + fn name(&self) -> &OsStr; + + /// Returns the file system used on this disk (so for example: `EXT4`, `NTFS`, etc...). + /// + /// ```no_run + /// use sysinfo::{DiskExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for disk in s.disks() { + /// println!("{:?}", disk.file_system()); + /// } + /// ``` + fn file_system(&self) -> &[u8]; + + /// Returns the mount point of the disk (`/` for example). + /// + /// ```no_run + /// use sysinfo::{DiskExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for disk in s.disks() { + /// println!("{:?}", disk.mount_point()); + /// } + /// ``` + fn mount_point(&self) -> &Path; + + /// Returns the total disk size, in bytes. + /// + /// ```no_run + /// use sysinfo::{DiskExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for disk in s.disks() { + /// println!("{}", disk.total_space()); + /// } + /// ``` + fn total_space(&self) -> u64; + + /// Returns the available disk size, in bytes. + /// + /// ```no_run + /// use sysinfo::{DiskExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for disk in s.disks() { + /// println!("{}", disk.available_space()); + /// } + /// ``` + fn available_space(&self) -> u64; + + /// Returns `true` if the disk is removable. + /// + /// ```no_run + /// use sysinfo::{DiskExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for disk in s.disks() { + /// println!("{}", disk.is_removable()); + /// } + /// ``` + fn is_removable(&self) -> bool; + + /// Updates the disk' information. + /// + /// ```no_run + /// use sysinfo::{DiskExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// for disk in s.disks_mut() { + /// disk.refresh(); + /// } + /// ``` + fn refresh(&mut self) -> bool; +} + +/// Contains all the methods of the [`Process`][crate::Process] struct. +pub trait ProcessExt: Debug { + /// Sends [`Signal::Kill`] to the process (which is the only signal supported on all supported + /// platforms by this crate). + /// + /// If you want to send another signal, take a look at [`ProcessExt::kill_with`]. + /// + /// To get the list of the supported signals on this system, use + /// [`SystemExt::SUPPORTED_SIGNALS`]. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// process.kill(); + /// } + /// ``` + fn kill(&self) -> bool { + self.kill_with(Signal::Kill).unwrap_or(false) + } + + /// Sends the given `signal` to the process. If the signal doesn't exist on this platform, + /// it'll do nothing and will return `None`. Otherwise it'll return if the signal was sent + /// successfully. + /// + /// If you just want to kill the process, use [`ProcessExt::kill`] directly. + /// + /// To get the list of the supported signals on this system, use + /// [`SystemExt::SUPPORTED_SIGNALS`]. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, Signal, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// if process.kill_with(Signal::Kill).is_none() { + /// eprintln!("This signal isn't supported on this platform"); + /// } + /// } + /// ``` + fn kill_with(&self, signal: Signal) -> Option<bool>; + + /// Returns the name of the process. + /// + /// **⚠️ 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. + /// + /// If you are looking for a specific process, unless you know what you are doing, in most + /// cases it's better to use [`ProcessExt::exe`] instead (which can be empty sometimes!). + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{}", process.name()); + /// } + /// ``` + fn name(&self) -> &str; + + /// Returns the command line. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{:?}", process.cmd()); + /// } + /// ``` + fn cmd(&self) -> &[String]; + + /// Returns the path to the process. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{}", process.exe().display()); + /// } + /// ``` + fn exe(&self) -> &Path; + + /// Returns the pid of the process. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{}", process.pid()); + /// } + /// ``` + fn pid(&self) -> Pid; + + /// Returns the environment variables of the process. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{:?}", process.environ()); + /// } + /// ``` + fn environ(&self) -> &[String]; + + /// Returns the current working directory. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{}", process.cwd().display()); + /// } + /// ``` + fn cwd(&self) -> &Path; + + /// Returns the path of the root directory. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{}", process.root().display()); + /// } + /// ``` + fn root(&self) -> &Path; + + /// Returns the memory usage (in KB). + /// + /// ```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()); + /// } + /// ``` + fn memory(&self) -> u64; + + /// Returns the virtual memory usage (in KB). + /// + /// ```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()); + /// } + /// ``` + fn virtual_memory(&self) -> u64; + + /// Returns the parent pid. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{:?}", process.parent()); + /// } + /// ``` + fn parent(&self) -> Option<Pid>; + + /// Returns the status of the processus. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{:?}", process.status()); + /// } + /// ``` + fn status(&self) -> ProcessStatus; + + /// Returns the time where the process was started (in seconds) from epoch. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("Started at {} seconds", process.start_time()); + /// } + /// ``` + fn start_time(&self) -> u64; + + /// Returns for how much time the process has been running (in seconds). + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("Running since {} seconds", process.run_time()); + /// } + /// ``` + fn run_time(&self) -> u64; + + /// Returns the total CPU usage (in %). Notice that it might be bigger than 100 if run on a + /// multicore machine. + /// + /// If you want a value between 0% and 100%, divide the returned value by the number of CPU + /// CPUs. + /// + /// **Warning**: If you want accurate CPU usage number, better leave a bit of time + /// between two calls of this method (200 ms for example). + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{}%", process.cpu_usage()); + /// } + /// ``` + fn cpu_usage(&self) -> f32; + + /// Returns number of bytes read and written to disk. + /// + /// ⚠️ On Windows and FreeBSD, this method actually returns **ALL** I/O read and written bytes. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// let disk_usage = process.disk_usage(); + /// println!("read bytes : new/total => {}/{}", + /// disk_usage.read_bytes, + /// disk_usage.total_read_bytes, + /// ); + /// println!("written bytes: new/total => {}/{}", + /// disk_usage.written_bytes, + /// disk_usage.total_written_bytes, + /// ); + /// } + /// ``` + fn disk_usage(&self) -> DiskUsage; + + /// Returns the ID of the owner user of this process or `None` if this information couldn't + /// be retrieved. If you want to get the [`User`] from it, take a look at + /// [`SystemExt::get_user_by_id`]. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// + /// if let Some(process) = s.process(Pid::from(1337)) { + /// eprintln!("User id for process 1337: {:?}", process.user_id()); + /// } + /// ``` + fn user_id(&self) -> Option<&Uid>; + + /// Returns the process group ID of the process. + /// + /// ⚠️ It always returns `None` on Windows. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// + /// if let Some(process) = s.process(Pid::from(1337)) { + /// eprintln!("Group id for process 1337: {:?}", process.group_id()); + /// } + /// ``` + fn group_id(&self) -> Option<Gid>; +} + +/// Contains all the methods of the [`Cpu`][crate::Cpu] struct. +pub trait CpuExt: Debug { + /// Returns this CPU's usage. + /// + /// Note: You'll need to refresh it at least twice (diff between the first and the second is + /// how CPU usage is computed) at first if you want to have a non-zero value. + /// + /// ```no_run + /// use sysinfo::{CpuExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for cpu in s.cpus() { + /// println!("{}%", cpu.cpu_usage()); + /// } + /// ``` + fn cpu_usage(&self) -> f32; + + /// Returns this CPU's name. + /// + /// ```no_run + /// use sysinfo::{CpuExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for cpu in s.cpus() { + /// println!("{}", cpu.name()); + /// } + /// ``` + fn name(&self) -> &str; + + /// Returns the CPU's vendor id. + /// + /// ```no_run + /// use sysinfo::{CpuExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for cpu in s.cpus() { + /// println!("{}", cpu.vendor_id()); + /// } + /// ``` + fn vendor_id(&self) -> &str; + + /// Returns the CPU's brand. + /// + /// ```no_run + /// use sysinfo::{CpuExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for cpu in s.cpus() { + /// println!("{}", cpu.brand()); + /// } + /// ``` + fn brand(&self) -> &str; + + /// Returns the CPU's frequency. + /// + /// ```no_run + /// use sysinfo::{CpuExt, System, SystemExt}; + /// + /// let s = System::new(); + /// for cpu in s.cpus() { + /// println!("{}", cpu.frequency()); + /// } + /// ``` + fn frequency(&self) -> u64; +} + +/// Contains all the methods of the [`System`][crate::System] type. +pub trait SystemExt: Sized + Debug + Default + Send + Sync { + /// Returns `true` if this OS is supported. Please refer to the + /// [crate-level documentation](index.html) to get the list of supported OSes. + /// + /// ``` + /// use sysinfo::{System, SystemExt}; + /// + /// if System::IS_SUPPORTED { + /// println!("This OS is supported!"); + /// } else { + /// println!("This OS isn't supported (yet?)."); + /// } + /// ``` + const IS_SUPPORTED: bool; + + /// Returns the list of the supported signals on this system (used by + /// [`ProcessExt::kill_with`]). + /// + /// ``` + /// use sysinfo::{System, SystemExt}; + /// + /// println!("supported signals: {:?}", System::SUPPORTED_SIGNALS); + /// ``` + const SUPPORTED_SIGNALS: &'static [Signal]; + + /// Creates a new [`System`] instance with nothing loaded except the cpus list. If you + /// want to load components, network interfaces or the disks, you'll have to use the + /// `refresh_*_list` methods. [`SystemExt::refresh_networks_list`] for example. + /// + /// Use the [`refresh_all`] method to update its internal information (or any of the `refresh_` + /// method). + /// + /// [`System`]: crate::System + /// [`refresh_all`]: #method.refresh_all + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new(); + /// ``` + fn new() -> Self { + Self::new_with_specifics(RefreshKind::new()) + } + + /// Creates a new [`System`] instance with everything loaded. + /// + /// It is an equivalent of [`SystemExt::new_with_specifics`]`(`[`RefreshKind::everything`]`())`. + /// + /// [`System`]: crate::System + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// ``` + fn new_all() -> Self { + Self::new_with_specifics(RefreshKind::everything()) + } + + /// Creates a new [`System`] instance and refresh the data corresponding to the + /// given [`RefreshKind`]. + /// + /// [`System`]: crate::System + /// + /// ``` + /// use sysinfo::{RefreshKind, System, SystemExt}; + /// + /// // We want everything except disks. + /// let mut system = System::new_with_specifics(RefreshKind::everything().without_disks_list()); + /// + /// assert_eq!(system.disks().len(), 0); + /// # if System::IS_SUPPORTED && !cfg!(feature = "apple-sandbox") { + /// assert!(system.processes().len() > 0); + /// # } + /// + /// // If you want the disks list afterwards, just call the corresponding + /// // "refresh_disks_list": + /// system.refresh_disks_list(); + /// let disks = system.disks(); + /// ``` + fn new_with_specifics(refreshes: RefreshKind) -> Self; + + /// Refreshes according to the given [`RefreshKind`]. It calls the corresponding + /// "refresh_" methods. + /// + /// ``` + /// use sysinfo::{ProcessRefreshKind, RefreshKind, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// + /// // Let's just update networks and processes: + /// s.refresh_specifics( + /// RefreshKind::new().with_networks().with_processes(ProcessRefreshKind::everything()), + /// ); + /// ``` + fn refresh_specifics(&mut self, refreshes: RefreshKind) { + if refreshes.memory() { + self.refresh_memory(); + } + if let Some(kind) = refreshes.cpu() { + self.refresh_cpu_specifics(kind); + } + if refreshes.components_list() { + self.refresh_components_list(); + } else if refreshes.components() { + self.refresh_components(); + } + if refreshes.networks_list() { + self.refresh_networks_list(); + } else if refreshes.networks() { + self.refresh_networks(); + } + if let Some(kind) = refreshes.processes() { + self.refresh_processes_specifics(kind); + } + if refreshes.disks_list() { + self.refresh_disks_list(); + } else if refreshes.disks() { + self.refresh_disks(); + } + if refreshes.users_list() { + self.refresh_users_list(); + } + } + + /// Refreshes all system, processes, disks and network interfaces information. + /// + /// Please note that it doesn't recompute disks list, components list, network interfaces + /// list nor users list. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_all(); + /// ``` + fn refresh_all(&mut self) { + self.refresh_system(); + self.refresh_processes(); + self.refresh_disks(); + self.refresh_networks(); + } + + /// Refreshes system information (RAM, swap, CPU usage and components' temperature). + /// + /// If you want some more specific refreshes, you might be interested into looking at + /// [`refresh_memory`], [`refresh_cpu`] and [`refresh_components`]. + /// + /// [`refresh_memory`]: SystemExt::refresh_memory + /// [`refresh_cpu`]: SystemExt::refresh_memory + /// [`refresh_components`]: SystemExt::refresh_components + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_system(); + /// ``` + fn refresh_system(&mut self) { + self.refresh_memory(); + self.refresh_cpu(); + self.refresh_components(); + } + + /// Refreshes RAM and SWAP usage. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_memory(); + /// ``` + fn refresh_memory(&mut self); + + /// Refreshes CPUs information. + /// + /// ⚠️ Please note that the result will very likely be inaccurate at the first call. + /// You need to call this method at least twice (with a bit of time between each call, like + /// 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())`. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_cpu(); + /// ``` + fn refresh_cpu(&mut self) { + self.refresh_cpu_specifics(CpuRefreshKind::everything()) + } + + /// Refreshes CPUs specific information. + /// + /// Please note that it doesn't recompute disks list, components list, network interfaces + /// list nor users list. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_all(); + /// ``` + fn refresh_cpu_specifics(&mut self, refresh_kind: CpuRefreshKind); + + /// Refreshes components' temperature. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_components(); + /// ``` + fn refresh_components(&mut self) { + for component in self.components_mut() { + component.refresh(); + } + } + + /// Refreshes components list. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new(); + /// s.refresh_components_list(); + /// ``` + fn refresh_components_list(&mut self); + + /// Gets all processes and updates their information. + /// + /// It does the same as `system.refresh_processes_specifics(ProcessRefreshKind::everything())`. + /// + /// ⚠️ On Linux, `sysinfo` keeps the `stat` files open by default. You can change this behaviour + /// by using [`set_open_files_limit`][crate::set_open_files_limit]. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_processes(); + /// ``` + fn refresh_processes(&mut self) { + self.refresh_processes_specifics(ProcessRefreshKind::everything()); + } + + /// Gets all processes and updates the specified information. + /// + /// ⚠️ On Linux, `sysinfo` keeps the `stat` files open by default. You can change this behaviour + /// by using [`set_open_files_limit`][crate::set_open_files_limit]. + /// + /// ```no_run + /// use sysinfo::{ProcessRefreshKind, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_processes_specifics(ProcessRefreshKind::new()); + /// ``` + fn refresh_processes_specifics(&mut self, refresh_kind: ProcessRefreshKind); + + /// Refreshes *only* the process corresponding to `pid`. Returns `false` if the process doesn't + /// exist (it will **NOT** be removed from the processes if it doesn't exist anymore). If it + /// isn't listed yet, it'll be added. + /// + /// It is the same as calling + /// `sys.refresh_process_specifics(pid, ProcessRefreshKind::everything())`. + /// + /// ```no_run + /// use sysinfo::{Pid, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_process(Pid::from(1337)); + /// ``` + fn refresh_process(&mut self, pid: Pid) -> bool { + self.refresh_process_specifics(pid, ProcessRefreshKind::everything()) + } + + /// Refreshes *only* the process corresponding to `pid`. Returns `false` if the process doesn't + /// exist (it will **NOT** be removed from the processes if it doesn't exist anymore). If it + /// isn't listed yet, it'll be added. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessRefreshKind, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_process_specifics(Pid::from(1337), ProcessRefreshKind::new()); + /// ``` + fn refresh_process_specifics(&mut self, pid: Pid, refresh_kind: ProcessRefreshKind) -> bool; + + /// Refreshes the listed disks' information. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_disks(); + /// ``` + fn refresh_disks(&mut self) { + for disk in self.disks_mut() { + disk.refresh(); + } + } + + /// The disk list will be emptied then completely recomputed. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_disks_list(); + /// ``` + fn refresh_disks_list(&mut self); + + /// Refreshes users list. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_users_list(); + /// ``` + fn refresh_users_list(&mut self); + + /// Refreshes networks data. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_networks(); + /// ``` + /// + /// It is a shortcut for: + /// + /// ```no_run + /// use sysinfo::{NetworksExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// let networks = s.networks_mut(); + /// networks.refresh(); + /// ``` + fn refresh_networks(&mut self) { + self.networks_mut().refresh(); + } + + /// The network list will be updated: removing not existing anymore interfaces and adding new + /// ones. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// s.refresh_networks_list(); + /// ``` + /// + /// This is a shortcut for: + /// + /// ```no_run + /// use sysinfo::{NetworksExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// let networks = s.networks_mut(); + /// networks.refresh_networks_list(); + /// ``` + fn refresh_networks_list(&mut self) { + self.networks_mut().refresh_networks_list(); + } + + /// Returns the process list. + /// + /// ```no_run + /// use sysinfo::{ProcessExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// for (pid, process) in s.processes() { + /// println!("{} {}", pid, process.name()); + /// } + /// ``` + fn processes(&self) -> &HashMap<Pid, Process>; + + /// Returns the process corresponding to the given pid or `None` if no such process exists. + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// if let Some(process) = s.process(Pid::from(1337)) { + /// println!("{}", process.name()); + /// } + /// ``` + fn process(&self, pid: Pid) -> Option<&Process>; + + /// Returns an iterator of process containing the given `name`. + /// + /// If you want only the processes with exactly the given `name`, take a look at + /// [`SystemExt::processes_by_exact_name`]. + /// + /// ```no_run + /// use sysinfo::{ProcessExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// for process in s.processes_by_name("htop") { + /// println!("{} {}", process.pid(), process.name()); + /// } + /// ``` + // FIXME: replace the returned type with `impl Iterator<Item = &Process>` when it's supported! + fn processes_by_name<'a>( + &'a self, + name: &'a str, + ) -> Box<dyn Iterator<Item = &'a Process> + 'a> { + Box::new( + self.processes() + .values() + .filter(move |val: &&Process| val.name().contains(name)), + ) + } + + /// Returns an iterator of processes with exactly the given `name`. + /// + /// If you instead want the processes containing `name`, take a look at + /// [`SystemExt::processes_by_name`]. + /// + /// ```no_run + /// use sysinfo::{ProcessExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// for process in s.processes_by_exact_name("htop") { + /// println!("{} {}", process.pid(), process.name()); + /// } + /// ``` + // FIXME: replace the returned type with `impl Iterator<Item = &Process>` when it's supported! + fn processes_by_exact_name<'a>( + &'a self, + name: &'a str, + ) -> Box<dyn Iterator<Item = &'a Process> + 'a> { + Box::new( + self.processes() + .values() + .filter(move |val: &&Process| val.name() == name), + ) + } + + /// Returns "global" cpus information (aka the addition of all the CPUs). + /// + /// To have up-to-date information, you need to call [`SystemExt::refresh_cpu`] or + /// [`SystemExt::refresh_specifics`] with `cpu` enabled. + /// + /// ```no_run + /// use sysinfo::{CpuRefreshKind, CpuExt, RefreshKind, System, SystemExt}; + /// + /// let s = System::new_with_specifics( + /// RefreshKind::new().with_cpu(CpuRefreshKind::everything()), + /// ); + /// println!("{}%", s.global_cpu_info().cpu_usage()); + /// ``` + fn global_cpu_info(&self) -> &Cpu; + + /// Returns the list of the CPUs. + /// + /// By default, the list of cpus is empty until you call [`SystemExt::refresh_cpu`] or + /// [`SystemExt::refresh_specifics`] with `cpu` enabled. + /// + /// ```no_run + /// use sysinfo::{CpuRefreshKind, CpuExt, RefreshKind, System, SystemExt}; + /// + /// let s = System::new_with_specifics( + /// RefreshKind::new().with_cpu(CpuRefreshKind::everything()), + /// ); + /// for cpu in s.cpus() { + /// println!("{}%", cpu.cpu_usage()); + /// } + /// ``` + fn cpus(&self) -> &[Cpu]; + + /// Returns the number of physical cores on the CPU or `None` if it couldn't get it. + /// + /// In case there are multiple CPUs, it will combine the physical core count of all the CPUs. + /// + /// **Important**: this information is computed every time this function is called. + /// + /// ```no_run + /// use sysinfo::{CpuExt, System, SystemExt}; + /// + /// let s = System::new(); + /// println!("{:?}", s.physical_core_count()); + /// ``` + fn physical_core_count(&self) -> Option<usize>; + + /// Returns the RAM size in KB. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// println!("{} KB", s.total_memory()); + /// ``` + fn total_memory(&self) -> u64; + + /// Returns the amount of free RAM in KB. + /// + /// Generally, "free" memory refers to unallocated memory whereas "available" memory refers to + /// memory that is available for (re)use. + /// + /// Side note: Windows doesn't report "free" memory so this method returns the same value + /// as [`get_available_memory`](#tymethod.available_memory). + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// println!("{} KB", s.free_memory()); + /// ``` + fn free_memory(&self) -> u64; + + /// Returns the amount of available RAM in KB. + /// + /// Generally, "free" memory refers to unallocated memory whereas "available" memory refers to + /// memory that is available for (re)use. + /// + /// ⚠️ Windows and FreeBSD don't report "available" memory so [`SystemExt::free_memory`] + /// returns the same value as this method. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// println!("{} KB", s.available_memory()); + /// ``` + fn available_memory(&self) -> u64; + + /// Returns the amount of used RAM in KB. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// println!("{} KB", s.used_memory()); + /// ``` + fn used_memory(&self) -> u64; + + /// Returns the SWAP size in KB. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// println!("{} KB", s.total_swap()); + /// ``` + fn total_swap(&self) -> u64; + + /// Returns the amount of free SWAP in KB. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// println!("{} KB", s.free_swap()); + /// ``` + fn free_swap(&self) -> u64; + + /// Returns the amount of used SWAP in KB. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// println!("{} KB", s.used_swap()); + /// ``` + fn used_swap(&self) -> u64; + + /// Returns the components list. + /// + /// ```no_run + /// use sysinfo::{ComponentExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// for component in s.components() { + /// println!("{}: {}°C", component.label(), component.temperature()); + /// } + /// ``` + fn components(&self) -> &[Component]; + + /// Returns a mutable components list. + /// + /// ```no_run + /// use sysinfo::{ComponentExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// for component in s.components_mut() { + /// component.refresh(); + /// } + /// ``` + 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 + /// use sysinfo::{System, SystemExt, UserExt}; + /// + /// let mut s = System::new_all(); + /// for user in s.users() { + /// println!("{} is in {} groups", user.name(), user.groups().len()); + /// } + /// ``` + fn users(&self) -> &[User]; + + /// 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(); + /// } + /// ``` + fn disks_mut(&mut self) -> &mut [Disk]; + + /// Returns the network interfaces object. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, data) in networks { + /// println!( + /// "[{}] in: {}, out: {}", + /// interface_name, + /// data.received(), + /// data.transmitted(), + /// ); + /// } + /// ``` + fn networks(&self) -> &Networks; + + /// Returns a mutable access to network interfaces. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// let networks = s.networks_mut(); + /// networks.refresh_networks_list(); + /// ``` + fn networks_mut(&mut self) -> &mut Networks; + + /// Returns system uptime (in seconds). + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// println!("System running since {} seconds", s.uptime()); + /// ``` + fn uptime(&self) -> u64; + + /// Returns the time (in seconds) when the system booted since UNIX epoch. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new(); + /// println!("System booted at {} seconds", s.boot_time()); + /// ``` + fn boot_time(&self) -> u64; + + /// Returns the system load average value. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new_all(); + /// let load_avg = s.load_average(); + /// println!( + /// "one minute: {}%, five minutes: {}%, fifteen minutes: {}%", + /// load_avg.one, + /// load_avg.five, + /// load_avg.fifteen, + /// ); + /// ``` + fn load_average(&self) -> LoadAvg; + + /// Returns the system name. + /// + /// **Important**: this information is computed every time this function is called. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new(); + /// println!("OS: {:?}", s.name()); + /// ``` + fn name(&self) -> Option<String>; + + /// Returns the system's kernel version. + /// + /// **Important**: this information is computed every time this function is called. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new(); + /// println!("kernel version: {:?}", s.kernel_version()); + /// ``` + fn kernel_version(&self) -> Option<String>; + + /// Returns the system version (e.g. for MacOS this will return 11.1 rather than the kernel version). + /// + /// **Important**: this information is computed every time this function is called. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new(); + /// println!("OS version: {:?}", s.os_version()); + /// ``` + fn os_version(&self) -> Option<String>; + + /// Returns the system long os version (e.g "MacOS 11.2 BigSur"). + /// + /// **Important**: this information is computed every time this function is called. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new(); + /// println!("Long OS Version: {:?}", s.long_os_version()); + /// ``` + fn long_os_version(&self) -> Option<String>; + + /// Returns the system hostname based off DNS + /// + /// **Important**: this information is computed every time this function is called. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt}; + /// + /// let s = System::new(); + /// println!("Hostname: {:?}", s.host_name()); + /// ``` + fn host_name(&self) -> Option<String>; + + /// Returns the [`User`] matching the given `user_id`. + /// + /// **Important**: The user list must be filled before using this method, otherwise it will + /// always return `None` (through the `refresh_*` methods). + /// + /// It is a shorthand for: + /// + /// ```ignore + /// let s = System::new_all(); + /// s.users().find(|user| user.id() == user_id); + /// ``` + /// + /// Full example: + /// + /// ```no_run + /// use sysinfo::{Pid, ProcessExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// + /// if let Some(process) = s.process(Pid::from(1337)) { + /// if let Some(user_id) = process.user_id() { + /// eprintln!("User for process 1337: {:?}", s.get_user_by_id(user_id)); + /// } + /// } + /// ``` + fn get_user_by_id(&self, user_id: &Uid) -> Option<&User> { + self.users().iter().find(|user| user.id() == user_id) + } +} + +/// Getting volume of received and transmitted data. +pub trait NetworkExt: Debug { + /// Returns the number of received bytes since the last refresh. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("in: {} B", network.received()); + /// } + /// ``` + fn received(&self) -> u64; + + /// Returns the total number of received bytes. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("in: {} B", network.total_received()); + /// } + /// ``` + fn total_received(&self) -> u64; + + /// Returns the number of transmitted bytes since the last refresh. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("out: {} B", network.transmitted()); + /// } + /// ``` + fn transmitted(&self) -> u64; + + /// Returns the total number of transmitted bytes. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("out: {} B", network.total_transmitted()); + /// } + /// ``` + fn total_transmitted(&self) -> u64; + + /// Returns the number of incoming packets since the last refresh. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("in: {}", network.packets_received()); + /// } + /// ``` + fn packets_received(&self) -> u64; + + /// Returns the total number of incoming packets. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("in: {}", network.total_packets_received()); + /// } + /// ``` + fn total_packets_received(&self) -> u64; + + /// Returns the number of outcoming packets since the last refresh. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("out: {}", network.packets_transmitted()); + /// } + /// ``` + fn packets_transmitted(&self) -> u64; + + /// Returns the total number of outcoming packets. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("out: {}", network.total_packets_transmitted()); + /// } + /// ``` + fn total_packets_transmitted(&self) -> u64; + + /// Returns the number of incoming errors since the last refresh. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("in: {}", network.errors_on_received()); + /// } + /// ``` + fn errors_on_received(&self) -> u64; + + /// Returns the total number of incoming errors. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("in: {}", network.total_errors_on_received()); + /// } + /// ``` + fn total_errors_on_received(&self) -> u64; + + /// Returns the number of outcoming errors since the last refresh. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("out: {}", network.errors_on_transmitted()); + /// } + /// ``` + fn errors_on_transmitted(&self) -> u64; + + /// Returns the total number of outcoming errors. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("out: {}", network.total_errors_on_transmitted()); + /// } + /// ``` + fn total_errors_on_transmitted(&self) -> u64; +} + +/// Interacting with network interfaces. +pub trait NetworksExt: Debug { + /// Returns an iterator over the network interfaces. + /// + /// ```no_run + /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// let networks = s.networks(); + /// for (interface_name, network) in networks { + /// println!("in: {} B", network.received()); + /// } + /// ``` + fn iter(&self) -> NetworksIter; + + /// Refreshes the network interfaces list. + /// + /// ```no_run + /// use sysinfo::{NetworksExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// let networks = s.networks_mut(); + /// networks.refresh_networks_list(); + /// ``` + fn refresh_networks_list(&mut self); + + /// Refreshes the network interfaces' content. + /// + /// ```no_run + /// use sysinfo::{NetworksExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// let networks = s.networks_mut(); + /// networks.refresh(); + /// ``` + fn refresh(&mut self); +} + +/// Getting a component temperature information. +pub trait ComponentExt: Debug { + /// Returns the temperature of the component (in celsius degree). + /// + /// ```no_run + /// use sysinfo::{ComponentExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// for component in s.components() { + /// println!("{}°C", component.temperature()); + /// } + /// ``` + fn temperature(&self) -> f32; + + /// Returns the maximum temperature of the component (in celsius degree). + /// + /// ```no_run + /// use sysinfo::{ComponentExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// for component in s.components() { + /// println!("{}°C", component.max()); + /// } + /// ``` + fn max(&self) -> f32; + + /// Returns the highest temperature before the component halts (in celsius degree). + /// + /// ```no_run + /// use sysinfo::{ComponentExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// for component in s.components() { + /// println!("{:?}°C", component.critical()); + /// } + /// ``` + fn critical(&self) -> Option<f32>; + + /// Returns the label of the component. + /// + /// ```no_run + /// use sysinfo::{ComponentExt, System, SystemExt}; + /// + /// let s = System::new_all(); + /// for component in s.components() { + /// println!("{}", component.label()); + /// } + /// ``` + fn label(&self) -> &str; + + /// Refreshes component. + /// + /// ```no_run + /// use sysinfo::{ComponentExt, System, SystemExt}; + /// + /// let mut s = System::new_all(); + /// for component in s.components_mut() { + /// component.refresh(); + /// } + /// ``` + fn refresh(&mut self); +} + +/// Getting information for a user. +/// +/// It is returned from [`SystemExt::users`]. +/// +/// ```no_run +/// use sysinfo::{System, SystemExt, UserExt}; +/// +/// let mut s = System::new_all(); +/// for user in s.users() { +/// println!("{} is in {} groups", user.name(), user.groups().len()); +/// } +/// ``` +pub trait UserExt: Debug { + /// Return the user id of the user. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt, UserExt}; + /// + /// let mut s = System::new_all(); + /// for user in s.users() { + /// println!("{:?}", *user.id()); + /// } + /// ``` + fn id(&self) -> &Uid; + + /// Return the group id of the user. + /// + /// *NOTE* - On Windows, this value defaults to 0. Windows doesn't have a `username` specific group assigned to the user. + /// They do however have unique [Security Identifiers](https://docs.microsoft.com/en-us/windows/win32/secauthz/security-identifiers) + /// made up of various [Components](https://docs.microsoft.com/en-us/windows/win32/secauthz/sid-components). + /// Pieces of the SID may be a candidate for this field, but it doesn't map well to a single group id. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt, UserExt}; + /// + /// let mut s = System::new_all(); + /// for user in s.users() { + /// println!("{}", *user.group_id()); + /// } + /// ``` + fn group_id(&self) -> Gid; + + /// Returns the name of the user. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt, UserExt}; + /// + /// let mut s = System::new_all(); + /// for user in s.users() { + /// println!("{}", user.name()); + /// } + /// ``` + fn name(&self) -> &str; + + /// Returns the groups of the user. + /// + /// ```no_run + /// use sysinfo::{System, SystemExt, UserExt}; + /// + /// let mut s = System::new_all(); + /// for user in s.users() { + /// println!("{} is in {:?}", user.name(), user.groups()); + /// } + /// ``` + fn groups(&self) -> &[String]; +} diff --git a/vendor/sysinfo/src/unknown/component.rs b/vendor/sysinfo/src/unknown/component.rs new file mode 100644 index 000000000..ec4a8e87a --- /dev/null +++ b/vendor/sysinfo/src/unknown/component.rs @@ -0,0 +1,26 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::ComponentExt; + +#[doc = include_str!("../../md_doc/component.md")] +pub struct Component {} + +impl ComponentExt for Component { + fn temperature(&self) -> f32 { + 0.0 + } + + fn max(&self) -> f32 { + 0.0 + } + + fn critical(&self) -> Option<f32> { + None + } + + fn label(&self) -> &str { + "" + } + + fn refresh(&mut self) {} +} diff --git a/vendor/sysinfo/src/unknown/cpu.rs b/vendor/sysinfo/src/unknown/cpu.rs new file mode 100644 index 000000000..72b9be447 --- /dev/null +++ b/vendor/sysinfo/src/unknown/cpu.rs @@ -0,0 +1,34 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::CpuExt; + +#[doc = include_str!("../../md_doc/cpu.md")] +pub struct Cpu {} + +impl Cpu { + pub(crate) fn new() -> Cpu { + Cpu {} + } +} + +impl CpuExt for Cpu { + fn cpu_usage(&self) -> f32 { + 0.0 + } + + fn name(&self) -> &str { + "" + } + + fn frequency(&self) -> u64 { + 0 + } + + fn vendor_id(&self) -> &str { + "" + } + + fn brand(&self) -> &str { + "" + } +} diff --git a/vendor/sysinfo/src/unknown/disk.rs b/vendor/sysinfo/src/unknown/disk.rs new file mode 100644 index 000000000..8956da9f5 --- /dev/null +++ b/vendor/sysinfo/src/unknown/disk.rs @@ -0,0 +1,42 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{DiskExt, DiskType}; + +use std::{ffi::OsStr, path::Path}; + +#[doc = include_str!("../../md_doc/disk.md")] +pub struct Disk {} + +impl DiskExt for Disk { + fn type_(&self) -> DiskType { + unreachable!() + } + + fn name(&self) -> &OsStr { + unreachable!() + } + + fn file_system(&self) -> &[u8] { + &[] + } + + fn mount_point(&self) -> &Path { + Path::new("") + } + + fn total_space(&self) -> u64 { + 0 + } + + fn available_space(&self) -> u64 { + 0 + } + + fn is_removable(&self) -> bool { + false + } + + fn refresh(&mut self) -> bool { + true + } +} diff --git a/vendor/sysinfo/src/unknown/mod.rs b/vendor/sysinfo/src/unknown/mod.rs new file mode 100644 index 000000000..e62712607 --- /dev/null +++ b/vendor/sysinfo/src/unknown/mod.rs @@ -0,0 +1,15 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +pub mod component; +pub mod cpu; +pub mod disk; +pub mod network; +pub mod process; +pub mod system; + +pub use self::component::Component; +pub use self::cpu::Cpu; +pub use self::disk::Disk; +pub use self::network::{NetworkData, Networks}; +pub use self::process::Process; +pub use self::system::System; diff --git a/vendor/sysinfo/src/unknown/network.rs b/vendor/sysinfo/src/unknown/network.rs new file mode 100644 index 000000000..4a8ff4831 --- /dev/null +++ b/vendor/sysinfo/src/unknown/network.rs @@ -0,0 +1,81 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::collections::HashMap; + +use crate::{NetworkExt, NetworksExt, NetworksIter}; + +#[doc = include_str!("../../md_doc/networks.md")] +pub struct Networks { + interfaces: HashMap<String, NetworkData>, +} + +impl Networks { + pub(crate) fn new() -> Networks { + Networks { + interfaces: HashMap::new(), + } + } +} + +impl NetworksExt for Networks { + fn iter(&self) -> NetworksIter { + NetworksIter::new(self.interfaces.iter()) + } + + fn refresh_networks_list(&mut self) {} + + fn refresh(&mut self) {} +} + +#[doc = include_str!("../../md_doc/network_data.md")] +pub struct NetworkData; + +impl NetworkExt for NetworkData { + fn received(&self) -> u64 { + 0 + } + + fn total_received(&self) -> u64 { + 0 + } + + fn transmitted(&self) -> u64 { + 0 + } + + fn total_transmitted(&self) -> u64 { + 0 + } + + fn packets_received(&self) -> u64 { + 0 + } + + fn total_packets_received(&self) -> u64 { + 0 + } + + fn packets_transmitted(&self) -> u64 { + 0 + } + + fn total_packets_transmitted(&self) -> u64 { + 0 + } + + fn errors_on_received(&self) -> u64 { + 0 + } + + fn total_errors_on_received(&self) -> u64 { + 0 + } + + fn errors_on_transmitted(&self) -> u64 { + 0 + } + + fn total_errors_on_transmitted(&self) -> u64 { + 0 + } +} diff --git a/vendor/sysinfo/src/unknown/process.rs b/vendor/sysinfo/src/unknown/process.rs new file mode 100644 index 000000000..c4656d3f5 --- /dev/null +++ b/vendor/sysinfo/src/unknown/process.rs @@ -0,0 +1,92 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessStatus, Signal, Uid}; + +use std::fmt; +use std::path::Path; + +impl fmt::Display for ProcessStatus { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str("Unknown") + } +} + +#[doc = include_str!("../../md_doc/process.md")] +pub struct Process { + pid: Pid, + parent: Option<Pid>, +} + +impl ProcessExt for Process { + fn kill_with(&self, _signal: Signal) -> Option<bool> { + None + } + + fn name(&self) -> &str { + "" + } + + fn cmd(&self) -> &[String] { + &[] + } + + fn exe(&self) -> &Path { + Path::new("") + } + + fn pid(&self) -> Pid { + self.pid + } + + fn environ(&self) -> &[String] { + &[] + } + + fn cwd(&self) -> &Path { + Path::new("") + } + + fn root(&self) -> &Path { + Path::new("") + } + + fn memory(&self) -> u64 { + 0 + } + + fn virtual_memory(&self) -> u64 { + 0 + } + + fn parent(&self) -> Option<Pid> { + self.parent + } + + fn status(&self) -> ProcessStatus { + ProcessStatus::Unknown(0) + } + + fn start_time(&self) -> u64 { + 0 + } + + fn run_time(&self) -> u64 { + 0 + } + + fn cpu_usage(&self) -> f32 { + 0.0 + } + + fn disk_usage(&self) -> DiskUsage { + DiskUsage::default() + } + + fn user_id(&self) -> Option<&Uid> { + None + } + + fn group_id(&self) -> Option<Gid> { + None + } +} diff --git a/vendor/sysinfo/src/unknown/system.rs b/vendor/sysinfo/src/unknown/system.rs new file mode 100644 index 000000000..4603ae737 --- /dev/null +++ b/vendor/sysinfo/src/unknown/system.rs @@ -0,0 +1,171 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{ + sys::{component::Component, Cpu, Disk, Networks, Process}, + CpuRefreshKind, LoadAvg, Pid, ProcessRefreshKind, RefreshKind, SystemExt, User, +}; + +use std::collections::HashMap; + +declare_signals! { + (), + _ => None, +} + +#[doc = include_str!("../../md_doc/system.md")] +pub struct System { + processes_list: HashMap<Pid, Process>, + networks: Networks, + global_cpu: Cpu, +} + +impl SystemExt for System { + const IS_SUPPORTED: bool = false; + const SUPPORTED_SIGNALS: &'static [Signal] = supported_signals(); + + fn new_with_specifics(_: RefreshKind) -> System { + System { + processes_list: Default::default(), + networks: Networks::new(), + global_cpu: Cpu::new(), + } + } + + fn refresh_memory(&mut self) {} + + fn refresh_cpu_specifics(&mut self, _refresh_kind: CpuRefreshKind) {} + + fn refresh_components_list(&mut self) {} + + fn refresh_processes_specifics(&mut self, _refresh_kind: ProcessRefreshKind) {} + + fn refresh_process_specifics(&mut self, _pid: Pid, _refresh_kind: ProcessRefreshKind) -> bool { + false + } + + fn refresh_disks_list(&mut self) {} + + fn refresh_users_list(&mut self) {} + + // COMMON PART + // + // Need to be moved into a "common" file to avoid duplication. + + fn processes(&self) -> &HashMap<Pid, Process> { + &self.processes_list + } + + fn process(&self, _pid: Pid) -> Option<&Process> { + None + } + + fn networks(&self) -> &Networks { + &self.networks + } + + fn networks_mut(&mut self) -> &mut Networks { + &mut self.networks + } + + fn global_cpu_info(&self) -> &Cpu { + &self.global_cpu + } + + fn cpus(&self) -> &[Cpu] { + &[] + } + + fn physical_core_count(&self) -> Option<usize> { + None + } + + fn total_memory(&self) -> u64 { + 0 + } + + fn free_memory(&self) -> u64 { + 0 + } + + fn available_memory(&self) -> u64 { + 0 + } + + fn used_memory(&self) -> u64 { + 0 + } + + fn total_swap(&self) -> u64 { + 0 + } + + fn free_swap(&self) -> u64 { + 0 + } + + fn used_swap(&self) -> u64 { + 0 + } + + fn components(&self) -> &[Component] { + &[] + } + + fn components_mut(&mut self) -> &mut [Component] { + &mut [] + } + + fn disks(&self) -> &[Disk] { + &[] + } + + fn disks_mut(&mut self) -> &mut [Disk] { + &mut [] + } + + fn uptime(&self) -> u64 { + 0 + } + + fn boot_time(&self) -> u64 { + 0 + } + + fn load_average(&self) -> LoadAvg { + LoadAvg { + one: 0., + five: 0., + fifteen: 0., + } + } + + fn users(&self) -> &[User] { + &[] + } + + fn name(&self) -> Option<String> { + None + } + + fn long_os_version(&self) -> Option<String> { + None + } + + fn kernel_version(&self) -> Option<String> { + None + } + + fn os_version(&self) -> Option<String> { + None + } + + fn host_name(&self) -> Option<String> { + None + } +} + +impl Default for System { + fn default() -> System { + System::new() + } +} diff --git a/vendor/sysinfo/src/users.rs b/vendor/sysinfo/src/users.rs new file mode 100644 index 000000000..1891ec7cc --- /dev/null +++ b/vendor/sysinfo/src/users.rs @@ -0,0 +1,97 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{ + common::{Gid, Uid}, + User, +}; + +use libc::{getgrgid, getgrouplist}; +use std::fs::File; +use std::io::Read; + +pub fn get_users_list() -> Vec<User> { + let mut s = String::new(); + let mut ngroups = 100; + let mut groups = vec![0; ngroups as usize]; + + let _ = File::open("/etc/passwd").and_then(|mut f| f.read_to_string(&mut s)); + s.lines() + .filter_map(|line| { + let mut parts = line.split(':'); + if let Some(username) = parts.next() { + let mut parts = parts.skip(1); + // Skip the user if the uid cannot be parsed correctly + if let Some(uid) = parts.next().and_then(parse_id) { + if let Some(group_id) = parts.next().and_then(parse_id) { + if let Some(command) = parts.last() { + if command.is_empty() + || command.ends_with("/false") + || command.ends_with("/nologin") + { + // We don't want "fake" users so in case the user command is "bad", we + // ignore this user. + return None; + } + let mut c_user = username.as_bytes().to_vec(); + c_user.push(0); + loop { + let mut current = ngroups; + + unsafe { + if getgrouplist( + c_user.as_ptr() as *const _, + group_id, + groups.as_mut_ptr(), + &mut current, + ) == -1 + { + if current > ngroups { + groups.resize(current as _, 0); + ngroups = current; + continue; + } + // It really failed, let's move on... + return None; + } + // Let's get all the group names! + return Some(User { + uid: Uid(uid), + gid: Gid(group_id), + name: username.to_owned(), + groups: groups[..current as usize] + .iter() + .filter_map(|id| { + let g = getgrgid(*id as _); + if g.is_null() { + return None; + } + let mut group_name = Vec::new(); + let c_group_name = (*g).gr_name; + let mut x = 0; + loop { + let c = *c_group_name.offset(x); + if c == 0 { + break; + } + group_name.push(c as u8); + x += 1; + } + String::from_utf8(group_name).ok() + }) + .collect(), + }); + } + } + } + } + } + } + None + }) + .collect() +} + +#[inline] +fn parse_id(id: &str) -> Option<u32> { + id.parse::<u32>().ok() +} diff --git a/vendor/sysinfo/src/utils.rs b/vendor/sysinfo/src/utils.rs new file mode 100644 index 000000000..578ab61c6 --- /dev/null +++ b/vendor/sysinfo/src/utils.rs @@ -0,0 +1,61 @@ +// 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( + all( + any( + target_os = "linux", + target_os = "android", + target_os = "macos", + target_os = "windows", + target_os = "freebsd", + ), + feature = "multithread" + ), + not(feature = "apple-sandbox"), + not(feature = "unknown-ci") +))] +pub(crate) fn into_iter<T>(val: T) -> T::Iter +where + T: rayon::iter::IntoParallelIterator, +{ + val.into_par_iter() +} + +/// Converts the value into a sequential iterator (if the multithread feature is disabled) +/// Uses the std::iter::IntoIterator trait +#[cfg(all( + all( + any( + target_os = "linux", + target_os = "android", + target_os = "macos", + target_os = "windows", + target_os = "freebsd", + ), + not(feature = "multithread") + ), + not(feature = "unknown-ci"), + not(feature = "apple-sandbox") +))] +pub(crate) fn into_iter<T>(val: T) -> T::IntoIter +where + T: IntoIterator, +{ + val.into_iter() +} diff --git a/vendor/sysinfo/src/windows/component.rs b/vendor/sysinfo/src/windows/component.rs new file mode 100644 index 000000000..502594e38 --- /dev/null +++ b/vendor/sysinfo/src/windows/component.rs @@ -0,0 +1,374 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::ComponentExt; + +use std::ptr::null_mut; + +use winapi::shared::rpcdce::{ + RPC_C_AUTHN_LEVEL_CALL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, + RPC_C_IMP_LEVEL_IMPERSONATE, +}; +use winapi::shared::winerror::{FAILED, SUCCEEDED, S_FALSE, S_OK}; +use winapi::shared::wtypesbase::CLSCTX_INPROC_SERVER; +use winapi::um::combaseapi::{ + CoCreateInstance, CoInitializeEx, CoInitializeSecurity, CoSetProxyBlanket, CoUninitialize, +}; +use winapi::um::oaidl::VARIANT; +use winapi::um::objidl::EOAC_NONE; +use winapi::um::oleauto::{SysAllocString, SysFreeString, VariantClear}; +use winapi::um::wbemcli::{ + CLSID_WbemLocator, IEnumWbemClassObject, IID_IWbemLocator, IWbemClassObject, IWbemLocator, + IWbemServices, WBEM_FLAG_FORWARD_ONLY, WBEM_FLAG_NONSYSTEM_ONLY, WBEM_FLAG_RETURN_IMMEDIATELY, +}; + +#[doc = include_str!("../../md_doc/component.md")] +pub struct Component { + temperature: f32, + max: f32, + critical: Option<f32>, + label: String, + connection: Option<Connection>, +} + +impl Component { + /// Creates a new `Component` with the given information. + fn new() -> Option<Component> { + let mut c = Connection::new() + .and_then(|x| x.initialize_security()) + .and_then(|x| x.create_instance()) + .and_then(|x| x.connect_server()) + .and_then(|x| x.set_proxy_blanket()) + .and_then(|x| x.exec_query())?; + + c.temperature(true) + .map(|(temperature, critical)| Component { + temperature, + label: "Computer".to_owned(), + max: temperature, + critical, + connection: Some(c), + }) + } +} + +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) { + if self.connection.is_none() { + self.connection = Connection::new() + .and_then(|x| x.initialize_security()) + .and_then(|x| x.create_instance()) + .and_then(|x| x.connect_server()) + .and_then(|x| x.set_proxy_blanket()); + } + self.connection = if let Some(x) = self.connection.take() { + x.exec_query() + } else { + None + }; + if let Some(ref mut connection) = self.connection { + if let Some((temperature, _)) = connection.temperature(false) { + self.temperature = temperature; + if self.temperature > self.max { + self.max = self.temperature; + } + } + } + } +} + +pub(crate) fn get_components() -> Vec<Component> { + match Component::new() { + Some(c) => vec![c], + None => Vec::new(), + } +} + +struct Instance(*mut IWbemLocator); + +impl Drop for Instance { + fn drop(&mut self) { + if !self.0.is_null() { + unsafe { + (*self.0).Release(); + } + } + } +} + +struct ServerConnection(*mut IWbemServices); + +impl Drop for ServerConnection { + fn drop(&mut self) { + if !self.0.is_null() { + unsafe { + (*self.0).Release(); + } + } + } +} + +struct Enumerator(*mut IEnumWbemClassObject); + +impl Drop for Enumerator { + fn drop(&mut self) { + if !self.0.is_null() { + unsafe { + (*self.0).Release(); + } + } + } +} + +macro_rules! bstr { + ($($x:expr),*) => {{ + let x: &[u16] = &[$($x as u16),*, 0]; + SysAllocString(x.as_ptr()) + }} +} + +struct Connection { + instance: Option<Instance>, + server_connection: Option<ServerConnection>, + enumerator: Option<Enumerator>, + initialized: bool, +} + +#[allow(clippy::non_send_fields_in_send_ty)] +unsafe impl Send for Connection {} +unsafe impl Sync for Connection {} + +impl Connection { + #[allow(clippy::unnecessary_wraps)] + fn new() -> Option<Connection> { + unsafe { + let val = CoInitializeEx(null_mut(), 0); + Some(Connection { + instance: None, + server_connection: None, + enumerator: None, + initialized: val == S_OK || val == S_FALSE, + }) + } + } + + fn initialize_security(self) -> Option<Connection> { + unsafe { + if FAILED(CoInitializeSecurity( + null_mut(), + -1, + null_mut(), + null_mut(), + RPC_C_AUTHN_LEVEL_DEFAULT, + RPC_C_IMP_LEVEL_IMPERSONATE, + null_mut(), + EOAC_NONE, + null_mut(), + )) { + None + } else { + Some(self) + } + } + } + + fn create_instance(mut self) -> Option<Connection> { + let mut p_loc = null_mut(); + + unsafe { + if FAILED(CoCreateInstance( + &CLSID_WbemLocator as *const _, + null_mut(), + CLSCTX_INPROC_SERVER, + &IID_IWbemLocator as *const _, + &mut p_loc as *mut _ as *mut _, + )) { + None + } else { + self.instance = Some(Instance(p_loc)); + Some(self) + } + } + } + + fn connect_server(mut self) -> Option<Connection> { + let mut p_svc = null_mut(); + + if let Some(ref instance) = self.instance { + unsafe { + // "root\WMI" + let s = bstr!('r', 'o', 'o', 't', '\\', 'W', 'M', 'I'); + let res = (*instance.0).ConnectServer( + s, + null_mut(), + null_mut(), + null_mut(), + 0, + null_mut(), + null_mut(), + &mut p_svc as *mut _, + ); + SysFreeString(s); + if FAILED(res) { + return None; + } + } + } else { + return None; + } + self.server_connection = Some(ServerConnection(p_svc)); + Some(self) + } + + fn set_proxy_blanket(self) -> Option<Connection> { + if let Some(ref server_connection) = self.server_connection { + unsafe { + if FAILED(CoSetProxyBlanket( + server_connection.0 as *mut _, + RPC_C_AUTHN_WINNT, + RPC_C_AUTHZ_NONE, + null_mut(), + RPC_C_AUTHN_LEVEL_CALL, + RPC_C_IMP_LEVEL_IMPERSONATE, + null_mut(), + EOAC_NONE, + )) { + return None; + } + } + } else { + return None; + } + Some(self) + } + + fn exec_query(mut self) -> Option<Connection> { + let mut p_enumerator = null_mut(); + + if let Some(ref server_connection) = self.server_connection { + unsafe { + // "WQL" + let s = bstr!('W', 'Q', 'L'); // query kind + // "SELECT * FROM MSAcpi_ThermalZoneTemperature" + let query = bstr!( + 'S', 'E', 'L', 'E', 'C', 'T', ' ', '*', ' ', 'F', 'R', 'O', 'M', ' ', 'M', 'S', + 'A', 'c', 'p', 'i', '_', 'T', 'h', 'e', 'r', 'm', 'a', 'l', 'Z', 'o', 'n', 'e', + 'T', 'e', 'm', 'p', 'e', 'r', 'a', 't', 'u', 'r', 'e' + ); + let hres = (*server_connection.0).ExecQuery( + s, + query, + (WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY) as _, + null_mut(), + &mut p_enumerator as *mut _, + ); + SysFreeString(s); + SysFreeString(query); + if FAILED(hres) { + return None; + } + } + } else { + return None; + } + self.enumerator = Some(Enumerator(p_enumerator)); + Some(self) + } + + fn temperature(&mut self, get_critical: bool) -> Option<(f32, Option<f32>)> { + use winapi::um::wbemcli::WBEM_INFINITE; + + let p_enum = match self.enumerator.take() { + Some(x) => x, + None => { + return None; + } + }; + let mut p_obj: *mut IWbemClassObject = null_mut(); + let mut nb_returned = 0; + + unsafe { + (*p_enum.0).Next( + WBEM_INFINITE as _, // Time out + 1, // One object + &mut p_obj as *mut _, + &mut nb_returned, + ); + + if nb_returned == 0 { + return None; // not enough rights I suppose... + } + + (*p_obj).BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY as _); + + let mut p_val = std::mem::MaybeUninit::<VARIANT>::uninit(); + // "CurrentTemperature" + let temp = bstr!( + 'C', 'u', 'r', 'r', 'e', 'n', 't', 'T', 'e', 'm', 'p', 'e', 'r', 'a', 't', 'u', + 'r', 'e' + ); + let res = (*p_obj).Get(temp, 0, p_val.as_mut_ptr(), null_mut(), null_mut()); + let mut p_val = p_val.assume_init(); + + SysFreeString(temp); + VariantClear(&mut p_val as *mut _ as *mut _); + + let temp = if SUCCEEDED(res) { + // temperature is given in tenth of degrees Kelvin + (p_val.n1.decVal().Lo64 / 10) as f32 - 273.15 + } else { + (*p_obj).Release(); + return None; + }; + + let mut critical = None; + if get_critical { + // "CriticalPoint" + let crit = bstr!( + 'C', 'r', 'i', 't', 'i', 'c', 'a', 'l', 'T', 'r', 'i', 'p', 'P', 'o', 'i', 'n', + 't' + ); + let res = (*p_obj).Get(crit, 0, &mut p_val, null_mut(), null_mut()); + + SysFreeString(crit); + VariantClear(&mut p_val as *mut _ as *mut _); + + if SUCCEEDED(res) { + // temperature is given in tenth of degrees Kelvin + critical = Some((p_val.n1.decVal().Lo64 / 10) as f32 - 273.15); + } + } + (*p_obj).Release(); + Some((temp, critical)) + } + } +} + +impl Drop for Connection { + fn drop(&mut self) { + // Those three calls are here to enforce that they get dropped in the good order. + self.enumerator.take(); + self.server_connection.take(); + self.instance.take(); + if self.initialized { + unsafe { + CoUninitialize(); + } + } + } +} diff --git a/vendor/sysinfo/src/windows/cpu.rs b/vendor/sysinfo/src/windows/cpu.rs new file mode 100644 index 000000000..bbaa27ad7 --- /dev/null +++ b/vendor/sysinfo/src/windows/cpu.rs @@ -0,0 +1,548 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::sys::tools::KeyHandler; +use crate::{CpuExt, CpuRefreshKind, LoadAvg}; + +use std::collections::HashMap; +use std::io::Error; +use std::mem; +use std::ops::DerefMut; +use std::ptr::null_mut; +use std::sync::Mutex; + +use ntapi::ntpoapi::PROCESSOR_POWER_INFORMATION; + +use winapi::shared::minwindef::FALSE; +use winapi::shared::winerror::{ERROR_INSUFFICIENT_BUFFER, ERROR_SUCCESS}; +use winapi::um::handleapi::CloseHandle; +use winapi::um::pdh::{ + PdhAddEnglishCounterA, PdhAddEnglishCounterW, PdhCloseQuery, PdhCollectQueryData, + PdhCollectQueryDataEx, PdhGetFormattedCounterValue, PdhOpenQueryA, PdhRemoveCounter, + PDH_FMT_COUNTERVALUE, PDH_FMT_DOUBLE, PDH_HCOUNTER, PDH_HQUERY, +}; +use winapi::um::powerbase::CallNtPowerInformation; +use winapi::um::synchapi::CreateEventA; +use winapi::um::sysinfoapi::GetLogicalProcessorInformationEx; +use winapi::um::sysinfoapi::SYSTEM_INFO; +use winapi::um::winbase::{RegisterWaitForSingleObject, INFINITE}; +use winapi::um::winnt::{ + ProcessorInformation, RelationAll, RelationProcessorCore, BOOLEAN, HANDLE, + PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PVOID, WT_EXECUTEDEFAULT, +}; + +// This formula comes from linux's include/linux/sched/loadavg.h +// https://github.com/torvalds/linux/blob/345671ea0f9258f410eb057b9ced9cefbbe5dc78/include/linux/sched/loadavg.h#L20-L23 +#[allow(clippy::excessive_precision)] +const LOADAVG_FACTOR_1F: f64 = 0.9200444146293232478931553241; +#[allow(clippy::excessive_precision)] +const LOADAVG_FACTOR_5F: f64 = 0.9834714538216174894737477501; +#[allow(clippy::excessive_precision)] +const LOADAVG_FACTOR_15F: f64 = 0.9944598480048967508795473394; +// The time interval in seconds between taking load counts, same as Linux +const SAMPLING_INTERVAL: usize = 5; + +// maybe use a read/write lock instead? +static LOAD_AVG: once_cell::sync::Lazy<Mutex<Option<LoadAvg>>> = + once_cell::sync::Lazy::new(|| unsafe { init_load_avg() }); + +pub(crate) fn get_load_average() -> LoadAvg { + if let Ok(avg) = LOAD_AVG.lock() { + if let Some(avg) = &*avg { + return avg.clone(); + } + } + LoadAvg::default() +} + +unsafe extern "system" fn load_avg_callback(counter: PVOID, _: BOOLEAN) { + let mut display_value = mem::MaybeUninit::<PDH_FMT_COUNTERVALUE>::uninit(); + + if PdhGetFormattedCounterValue( + counter as _, + PDH_FMT_DOUBLE, + null_mut(), + display_value.as_mut_ptr(), + ) != ERROR_SUCCESS as _ + { + return; + } + let display_value = display_value.assume_init(); + if let Ok(mut avg) = LOAD_AVG.lock() { + if let Some(avg) = avg.deref_mut() { + let current_load = display_value.u.doubleValue(); + + avg.one = avg.one * LOADAVG_FACTOR_1F + current_load * (1.0 - LOADAVG_FACTOR_1F); + avg.five = avg.five * LOADAVG_FACTOR_5F + current_load * (1.0 - LOADAVG_FACTOR_5F); + avg.fifteen = + avg.fifteen * LOADAVG_FACTOR_15F + current_load * (1.0 - LOADAVG_FACTOR_15F); + } + } +} + +unsafe fn init_load_avg() -> Mutex<Option<LoadAvg>> { + // You can see the original implementation here: https://github.com/giampaolo/psutil + let mut query = null_mut(); + + if PdhOpenQueryA(null_mut(), 0, &mut query) != ERROR_SUCCESS as _ { + sysinfo_debug!("init_load_avg: PdhOpenQueryA failed"); + return Mutex::new(None); + } + + let mut counter: PDH_HCOUNTER = mem::zeroed(); + if PdhAddEnglishCounterA( + query, + b"\\System\\Cpu Queue Length\0".as_ptr() as _, + 0, + &mut counter, + ) != ERROR_SUCCESS as _ + { + PdhCloseQuery(query); + sysinfo_debug!("init_load_avg: failed to get CPU queue length"); + return Mutex::new(None); + } + + let event = CreateEventA(null_mut(), FALSE, FALSE, b"LoadUpdateEvent\0".as_ptr() as _); + if event.is_null() { + PdhCloseQuery(query); + sysinfo_debug!("init_load_avg: failed to create event `LoadUpdateEvent`"); + return Mutex::new(None); + } + + if PdhCollectQueryDataEx(query, SAMPLING_INTERVAL as _, event) != ERROR_SUCCESS as _ { + PdhCloseQuery(query); + sysinfo_debug!("init_load_avg: PdhCollectQueryDataEx failed"); + return Mutex::new(None); + } + + let mut wait_handle = null_mut(); + if RegisterWaitForSingleObject( + &mut wait_handle, + event, + Some(load_avg_callback), + counter as _, + INFINITE, + WT_EXECUTEDEFAULT, + ) == 0 + { + PdhRemoveCounter(counter); + PdhCloseQuery(query); + sysinfo_debug!("init_load_avg: RegisterWaitForSingleObject failed"); + Mutex::new(None) + } else { + Mutex::new(Some(LoadAvg::default())) + } +} + +struct InternalQuery { + query: PDH_HQUERY, + event: HANDLE, + data: HashMap<String, PDH_HCOUNTER>, +} + +unsafe impl Send for InternalQuery {} +unsafe impl Sync for InternalQuery {} + +impl Drop for InternalQuery { + fn drop(&mut self) { + unsafe { + for (_, counter) in self.data.iter() { + PdhRemoveCounter(*counter); + } + + if !self.event.is_null() { + CloseHandle(self.event); + } + + if !self.query.is_null() { + PdhCloseQuery(self.query); + } + } + } +} + +pub(crate) struct Query { + internal: InternalQuery, +} + +impl Query { + pub fn new() -> Option<Query> { + let mut query = null_mut(); + unsafe { + if PdhOpenQueryA(null_mut(), 0, &mut query) == ERROR_SUCCESS as i32 { + let q = InternalQuery { + query, + event: null_mut(), + data: HashMap::new(), + }; + Some(Query { internal: q }) + } else { + sysinfo_debug!("Query::new: PdhOpenQueryA failed"); + None + } + } + } + + #[allow(clippy::ptr_arg)] + pub fn get(&self, name: &String) -> Option<f32> { + if let Some(counter) = self.internal.data.get(name) { + unsafe { + let mut display_value = mem::MaybeUninit::<PDH_FMT_COUNTERVALUE>::uninit(); + let counter: PDH_HCOUNTER = *counter; + + let ret = PdhGetFormattedCounterValue( + counter, + PDH_FMT_DOUBLE, + null_mut(), + display_value.as_mut_ptr(), + ) as u32; + let display_value = display_value.assume_init(); + return if ret == ERROR_SUCCESS as _ { + let data = *display_value.u.doubleValue(); + Some(data as f32) + } else { + sysinfo_debug!("Query::get: PdhGetFormattedCounterValue failed"); + Some(0.) + }; + } + } + None + } + + #[allow(clippy::ptr_arg)] + pub fn add_english_counter(&mut self, name: &String, getter: Vec<u16>) -> bool { + if self.internal.data.contains_key(name) { + sysinfo_debug!("Query::add_english_counter: doesn't have key `{:?}`", name); + return false; + } + unsafe { + let mut counter: PDH_HCOUNTER = std::mem::zeroed(); + let ret = PdhAddEnglishCounterW(self.internal.query, getter.as_ptr(), 0, &mut counter); + if ret == ERROR_SUCCESS as _ { + self.internal.data.insert(name.clone(), counter); + } else { + sysinfo_debug!( + "Query::add_english_counter: failed to add counter '{}': {:x}...", + name, + ret, + ); + return false; + } + } + true + } + + pub fn refresh(&self) { + unsafe { + if PdhCollectQueryData(self.internal.query) != ERROR_SUCCESS as _ { + sysinfo_debug!("failed to refresh CPU data"); + } + } + } +} + +pub(crate) struct CpusWrapper { + global: Cpu, + cpus: Vec<Cpu>, + got_cpu_frequency: bool, +} + +impl CpusWrapper { + pub fn new() -> Self { + Self { + global: Cpu::new_with_values("Total CPU".to_owned(), String::new(), String::new(), 0), + cpus: Vec::new(), + got_cpu_frequency: false, + } + } + + pub fn global_cpu(&self) -> &Cpu { + &self.global + } + + pub fn global_cpu_mut(&mut self) -> &mut Cpu { + &mut self.global + } + + pub fn cpus(&self) -> &[Cpu] { + &self.cpus + } + + fn init_if_needed(&mut self, refresh_kind: CpuRefreshKind) { + if self.cpus.is_empty() { + let (cpus, vendor_id, brand) = super::tools::init_cpus(refresh_kind); + self.cpus = cpus; + self.global.vendor_id = vendor_id; + self.global.brand = brand; + self.got_cpu_frequency = refresh_kind.frequency(); + } + } + + pub fn len(&mut self) -> usize { + self.init_if_needed(CpuRefreshKind::new()); + self.cpus.len() + } + + pub fn iter_mut(&mut self, refresh_kind: CpuRefreshKind) -> impl Iterator<Item = &mut Cpu> { + self.init_if_needed(refresh_kind); + self.cpus.iter_mut() + } + + pub fn get_frequencies(&mut self) { + if self.got_cpu_frequency { + return; + } + let frequencies = get_frequencies(self.cpus.len()); + + for (cpu, frequency) in self.cpus.iter_mut().zip(frequencies) { + cpu.set_frequency(frequency); + } + self.got_cpu_frequency = true; + } +} + +#[doc = include_str!("../../md_doc/cpu.md")] +pub struct Cpu { + name: String, + cpu_usage: f32, + key_used: Option<KeyHandler>, + vendor_id: String, + brand: String, + frequency: u64, +} + +impl CpuExt for Cpu { + fn cpu_usage(&self) -> f32 { + self.cpu_usage + } + + fn name(&self) -> &str { + &self.name + } + + fn frequency(&self) -> u64 { + self.frequency + } + + fn vendor_id(&self) -> &str { + &self.vendor_id + } + + fn brand(&self) -> &str { + &self.brand + } +} + +impl Cpu { + pub(crate) fn new_with_values( + name: String, + vendor_id: String, + brand: String, + frequency: u64, + ) -> Cpu { + Cpu { + name, + cpu_usage: 0f32, + key_used: None, + vendor_id, + brand, + frequency, + } + } + + pub(crate) fn set_cpu_usage(&mut self, value: f32) { + self.cpu_usage = value; + } + + pub(crate) fn set_frequency(&mut self, value: u64) { + self.frequency = value; + } +} + +fn get_vendor_id_not_great(info: &SYSTEM_INFO) -> String { + use winapi::um::winnt; + // https://docs.microsoft.com/fr-fr/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info + unsafe { + match info.u.s().wProcessorArchitecture { + winnt::PROCESSOR_ARCHITECTURE_INTEL => "Intel x86", + winnt::PROCESSOR_ARCHITECTURE_MIPS => "MIPS", + winnt::PROCESSOR_ARCHITECTURE_ALPHA => "RISC Alpha", + winnt::PROCESSOR_ARCHITECTURE_PPC => "PPC", + winnt::PROCESSOR_ARCHITECTURE_SHX => "SHX", + winnt::PROCESSOR_ARCHITECTURE_ARM => "ARM", + winnt::PROCESSOR_ARCHITECTURE_IA64 => "Intel Itanium-based x64", + winnt::PROCESSOR_ARCHITECTURE_ALPHA64 => "RISC Alpha x64", + winnt::PROCESSOR_ARCHITECTURE_MSIL => "MSIL", + winnt::PROCESSOR_ARCHITECTURE_AMD64 => "(Intel or AMD) x64", + winnt::PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 => "Intel Itanium-based x86", + winnt::PROCESSOR_ARCHITECTURE_NEUTRAL => "unknown", + winnt::PROCESSOR_ARCHITECTURE_ARM64 => "ARM x64", + winnt::PROCESSOR_ARCHITECTURE_ARM32_ON_WIN64 => "ARM", + winnt::PROCESSOR_ARCHITECTURE_IA32_ON_ARM64 => "Intel Itanium-based x86", + _ => "unknown", + } + .to_owned() + } +} + +#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] +pub(crate) fn get_vendor_id_and_brand(info: &SYSTEM_INFO) -> (String, String) { + #[cfg(target_arch = "x86")] + use std::arch::x86::__cpuid; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::__cpuid; + + unsafe fn add_u32(v: &mut Vec<u8>, i: u32) { + let i = &i as *const u32 as *const u8; + v.push(*i); + v.push(*i.offset(1)); + v.push(*i.offset(2)); + v.push(*i.offset(3)); + } + + unsafe { + // First, we try to get the complete name. + let res = __cpuid(0x80000000); + let n_ex_ids = res.eax; + let brand = if n_ex_ids >= 0x80000004 { + let mut extdata = Vec::with_capacity(5); + + for i in 0x80000000..=n_ex_ids { + extdata.push(__cpuid(i)); + } + + // 4 * u32 * nb_entries + let mut out = Vec::with_capacity(4 * std::mem::size_of::<u32>() * 3); + for data in extdata.iter().take(5).skip(2) { + add_u32(&mut out, data.eax); + add_u32(&mut out, data.ebx); + add_u32(&mut out, data.ecx); + add_u32(&mut out, data.edx); + } + let mut pos = 0; + for e in out.iter() { + if *e == 0 { + break; + } + pos += 1; + } + match std::str::from_utf8(&out[..pos]) { + Ok(s) => s.to_owned(), + _ => String::new(), + } + } else { + String::new() + }; + + // Failed to get full name, let's retry for the short version! + let res = __cpuid(0); + let mut x = Vec::with_capacity(3 * std::mem::size_of::<u32>()); + add_u32(&mut x, res.ebx); + add_u32(&mut x, res.edx); + add_u32(&mut x, res.ecx); + let mut pos = 0; + for e in x.iter() { + if *e == 0 { + break; + } + pos += 1; + } + let vendor_id = match std::str::from_utf8(&x[..pos]) { + Ok(s) => s.to_owned(), + Err(_) => get_vendor_id_not_great(info), + }; + (vendor_id, brand) + } +} + +#[cfg(all(not(target_arch = "x86_64"), not(target_arch = "x86")))] +pub(crate) fn get_vendor_id_and_brand(info: &SYSTEM_INFO) -> (String, String) { + (get_vendor_id_not_great(info), String::new()) +} + +pub(crate) fn get_key_used(p: &mut Cpu) -> &mut Option<KeyHandler> { + &mut p.key_used +} + +// From https://stackoverflow.com/a/43813138: +// +// If your PC has 64 or fewer logical cpus installed, the above code will work fine. However, +// if your PC has more than 64 logical cpus installed, use GetActiveCpuCount() or +// GetLogicalCpuInformation() to determine the total number of logical cpus installed. +pub(crate) fn get_frequencies(nb_cpus: usize) -> Vec<u64> { + let size = nb_cpus * mem::size_of::<PROCESSOR_POWER_INFORMATION>(); + let mut infos: Vec<PROCESSOR_POWER_INFORMATION> = Vec::with_capacity(nb_cpus); + + unsafe { + if CallNtPowerInformation( + ProcessorInformation, + null_mut(), + 0, + infos.as_mut_ptr() as _, + size as _, + ) == 0 + { + infos.set_len(nb_cpus); + // infos.Number + return infos + .into_iter() + .map(|i| i.CurrentMhz as u64) + .collect::<Vec<_>>(); + } + } + sysinfo_debug!("get_frequencies: CallNtPowerInformation failed"); + vec![0; nb_cpus] +} + +pub(crate) fn get_physical_core_count() -> Option<usize> { + // we cannot use the number of cpus here to pre calculate the buf size + // GetLogicalCpuInformationEx with RelationProcessorCore passed to it not only returns + // the logical cores but also numa nodes + // + // GetLogicalCpuInformationEx: https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getlogicalprocessorinformationex + + let mut needed_size = 0; + unsafe { + GetLogicalProcessorInformationEx(RelationAll, null_mut(), &mut needed_size); + + let mut buf: Vec<u8> = Vec::with_capacity(needed_size as _); + + loop { + if GetLogicalProcessorInformationEx( + RelationAll, + buf.as_mut_ptr() as *mut _, + &mut needed_size, + ) == FALSE + { + let e = Error::last_os_error(); + // For some reasons, the function might return a size not big enough... + match e.raw_os_error() { + Some(value) if value == ERROR_INSUFFICIENT_BUFFER as _ => {} + _ => { + sysinfo_debug!( + "get_physical_core_count: GetLogicalCpuInformationEx failed" + ); + return None; + } + } + } else { + break; + } + buf.reserve(needed_size as usize - buf.capacity()); + } + + buf.set_len(needed_size as _); + + let mut i = 0; + let raw_buf = buf.as_ptr(); + let mut count = 0; + while i < buf.len() { + let p = &*(raw_buf.add(i) as PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX); + i += p.Size as usize; + if p.Relationship == RelationProcessorCore { + // Only count the physical cores. + count += 1; + } + } + Some(count) + } +} diff --git a/vendor/sysinfo/src/windows/disk.rs b/vendor/sysinfo/src/windows/disk.rs new file mode 100644 index 000000000..ae393afb2 --- /dev/null +++ b/vendor/sysinfo/src/windows/disk.rs @@ -0,0 +1,249 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{DiskExt, DiskType}; + +use std::ffi::{OsStr, OsString}; +use std::mem::size_of; +use std::path::Path; + +use winapi::ctypes::c_void; +use winapi::shared::minwindef::{DWORD, MAX_PATH}; +use winapi::um::fileapi::{ + CreateFileW, GetDiskFreeSpaceExW, GetDriveTypeW, GetLogicalDrives, GetVolumeInformationW, + OPEN_EXISTING, +}; +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, +}; +use winapi::um::winnt::{FILE_SHARE_READ, FILE_SHARE_WRITE, HANDLE, ULARGE_INTEGER}; + +#[doc = include_str!("../../md_doc/disk.md")] +pub struct Disk { + type_: DiskType, + name: OsString, + file_system: Vec<u8>, + mount_point: Vec<u16>, + s_mount_point: String, + total_space: u64, + available_space: u64, + is_removable: bool, +} + +impl DiskExt for Disk { + fn type_(&self) -> DiskType { + self.type_ + } + + fn name(&self) -> &OsStr { + &self.name + } + + fn file_system(&self) -> &[u8] { + &self.file_system + } + + fn mount_point(&self) -> &Path { + Path::new(&self.s_mount_point) + } + + fn total_space(&self) -> u64 { + self.total_space + } + + fn available_space(&self) -> u64 { + self.available_space + } + + fn is_removable(&self) -> bool { + self.is_removable + } + + fn refresh(&mut self) -> bool { + if self.total_space != 0 { + unsafe { + let mut tmp: ULARGE_INTEGER = std::mem::zeroed(); + if GetDiskFreeSpaceExW( + self.mount_point.as_ptr(), + std::ptr::null_mut(), + std::ptr::null_mut(), + &mut tmp, + ) != 0 + { + self.available_space = *tmp.QuadPart(); + return true; + } + } + } + false + } +} + +struct HandleWrapper(HANDLE); + +impl HandleWrapper { + unsafe fn new(drive_name: &[u16], open_rights: DWORD) -> Option<Self> { + let handle = CreateFileW( + drive_name.as_ptr(), + open_rights, + FILE_SHARE_READ | FILE_SHARE_WRITE, + std::ptr::null_mut(), + OPEN_EXISTING, + 0, + std::ptr::null_mut(), + ); + if handle == INVALID_HANDLE_VALUE { + CloseHandle(handle); + None + } else { + Some(Self(handle)) + } + } +} + +impl Drop for HandleWrapper { + fn drop(&mut self) { + unsafe { + CloseHandle(self.0); + } + } +} + +unsafe fn get_drive_size(mount_point: &[u16]) -> Option<(u64, u64)> { + let mut total_size: ULARGE_INTEGER = std::mem::zeroed(); + let mut available_space: ULARGE_INTEGER = std::mem::zeroed(); + if GetDiskFreeSpaceExW( + mount_point.as_ptr(), + std::ptr::null_mut(), + &mut total_size, + &mut available_space, + ) != 0 + { + Some(( + *total_size.QuadPart() as u64, + *available_space.QuadPart() as u64, + )) + } else { + None + } +} + +pub(crate) unsafe fn get_disks() -> Vec<Disk> { + let drives = GetLogicalDrives(); + if drives == 0 { + return Vec::new(); + } + + #[cfg(feature = "multithread")] + use rayon::iter::ParallelIterator; + + crate::utils::into_iter(0..DWORD::BITS) + .filter_map(|x| { + if (drives >> x) & 1 == 0 { + return None; + } + let mount_point = [b'A' as u16 + x as u16, b':' as u16, b'\\' as u16, 0]; + + let drive_type = GetDriveTypeW(mount_point.as_ptr()); + + let is_removable = drive_type == DRIVE_REMOVABLE; + + if drive_type != DRIVE_FIXED && drive_type != DRIVE_REMOVABLE { + return None; + } + let mut name = [0u16; MAX_PATH + 1]; + let mut file_system = [0u16; 32]; + if GetVolumeInformationW( + mount_point.as_ptr(), + name.as_mut_ptr(), + name.len() as DWORD, + std::ptr::null_mut(), + std::ptr::null_mut(), + std::ptr::null_mut(), + file_system.as_mut_ptr(), + file_system.len() as DWORD, + ) == 0 + { + return None; + } + let mut pos = 0; + for x in name.iter() { + if *x == 0 { + break; + } + pos += 1; + } + let name = String::from_utf16_lossy(&name[..pos]); + let name = OsStr::new(&name); + + pos = 0; + for x in file_system.iter() { + if *x == 0 { + break; + } + pos += 1; + } + let file_system: Vec<u8> = file_system[..pos].iter().map(|x| *x as u8).collect(); + + let drive_name = [ + b'\\' as u16, + b'\\' as u16, + b'.' as u16, + b'\\' as u16, + b'A' as u16 + x as u16, + b':' as u16, + 0, + ]; + let handle = HandleWrapper::new(&drive_name, 0)?; + let (total_space, available_space) = get_drive_size(&mount_point)?; + 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, + AdditionalParameters: [0], + }; + let mut dtd: DEVICE_TRIM_DESCRIPTOR = std::mem::zeroed(); + + let mut dw_size = 0; + let type_ = if DeviceIoControl( + handle.0, + 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 dw_size, + std::ptr::null_mut(), + ) == 0 + || dw_size != size_of::<DEVICE_TRIM_DESCRIPTOR>() as DWORD + { + DiskType::Unknown(-1) + } else { + let is_ssd = dtd.TrimEnabled != 0; + if is_ssd { + DiskType::SSD + } else { + DiskType::HDD + } + }; + Some(Disk { + type_, + name: name.to_owned(), + file_system: file_system.to_vec(), + mount_point: mount_point.to_vec(), + s_mount_point: String::from_utf16_lossy(&mount_point[..mount_point.len() - 1]), + total_space, + available_space, + is_removable, + }) + }) + .collect::<Vec<_>>() +} diff --git a/vendor/sysinfo/src/windows/macros.rs b/vendor/sysinfo/src/windows/macros.rs new file mode 100644 index 000000000..b0c024c7c --- /dev/null +++ b/vendor/sysinfo/src/windows/macros.rs @@ -0,0 +1,16 @@ +// 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 new file mode 100644 index 000000000..fa5d66beb --- /dev/null +++ b/vendor/sysinfo/src/windows/mod.rs @@ -0,0 +1,20 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +mod component; +mod cpu; +mod disk; +#[macro_use] +mod macros; +mod network; +mod process; +mod system; +mod tools; +mod users; +mod utils; + +pub use self::component::Component; +pub use self::cpu::Cpu; +pub use self::disk::Disk; +pub use self::network::{NetworkData, Networks}; +pub use self::process::Process; +pub use self::system::System; diff --git a/vendor/sysinfo/src/windows/network.rs b/vendor/sysinfo/src/windows/network.rs new file mode 100644 index 000000000..6a09a0490 --- /dev/null +++ b/vendor/sysinfo/src/windows/network.rs @@ -0,0 +1,249 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{NetworkExt, NetworksExt, NetworksIter}; + +use std::collections::{hash_map, HashMap}; + +use winapi::shared::ifdef::{MediaConnectStateDisconnected, NET_LUID}; +use winapi::shared::netioapi::{ + FreeMibTable, GetIfEntry2, GetIfTable2, MIB_IF_ROW2, PMIB_IF_TABLE2, +}; +use winapi::shared::winerror::NO_ERROR; + +macro_rules! old_and_new { + ($ty_:expr, $name:ident, $old:ident, $new_val:expr) => {{ + $ty_.$old = $ty_.$name; + $ty_.$name = $new_val; + }}; +} + +#[doc = include_str!("../../md_doc/networks.md")] +pub struct Networks { + interfaces: HashMap<String, NetworkData>, +} + +impl Networks { + pub(crate) fn new() -> Networks { + Networks { + interfaces: HashMap::new(), + } + } +} + +impl NetworksExt for Networks { + #[allow(clippy::needless_lifetimes)] + fn iter<'a>(&'a self) -> NetworksIter<'a> { + NetworksIter::new(self.interfaces.iter()) + } + + fn refresh_networks_list(&mut self) { + let mut table: PMIB_IF_TABLE2 = std::ptr::null_mut(); + + unsafe { + if GetIfTable2(&mut table) != NO_ERROR { + return; + } + + for (_, data) in self.interfaces.iter_mut() { + data.updated = false; + } + + // In here, this is tricky: we have to filter out the software interfaces to only keep + // the hardware ones. To do so, we first check the connection potential speed (if 0, not + // interesting), then we check its state: if not open, not interesting either. And finally, + // we count the members of a same group: if there is more than 1, then it's software level. + let mut groups = HashMap::new(); + let mut indexes = Vec::new(); + let ptr = (*table).Table.as_ptr(); + for i in 0..(*table).NumEntries { + let ptr = &*ptr.offset(i as _); + if (ptr.TransmitLinkSpeed == 0 && ptr.ReceiveLinkSpeed == 0) + || ptr.MediaConnectState == MediaConnectStateDisconnected + || ptr.PhysicalAddressLength == 0 + { + continue; + } + let id = vec![ + ptr.InterfaceGuid.Data2, + ptr.InterfaceGuid.Data3, + ptr.InterfaceGuid.Data4[0] as _, + ptr.InterfaceGuid.Data4[1] as _, + ptr.InterfaceGuid.Data4[2] as _, + ptr.InterfaceGuid.Data4[3] as _, + ptr.InterfaceGuid.Data4[4] as _, + ptr.InterfaceGuid.Data4[5] as _, + ptr.InterfaceGuid.Data4[6] as _, + ptr.InterfaceGuid.Data4[7] as _, + ]; + let entry = groups.entry(id.clone()).or_insert(0); + *entry += 1; + if *entry > 1 { + continue; + } + indexes.push((i, id)); + } + for (i, id) in indexes { + let ptr = &*ptr.offset(i as _); + if *groups.get(&id).unwrap_or(&0) > 1 { + continue; + } + let mut pos = 0; + for x in ptr.Alias.iter() { + if *x == 0 { + break; + } + pos += 1; + } + let interface_name = match String::from_utf16(&ptr.Alias[..pos]) { + Ok(s) => s, + _ => continue, + }; + match self.interfaces.entry(interface_name) { + hash_map::Entry::Occupied(mut e) => { + let mut interface = e.get_mut(); + old_and_new!(interface, current_out, old_out, ptr.OutOctets); + old_and_new!(interface, current_in, old_in, ptr.InOctets); + old_and_new!( + interface, + packets_in, + old_packets_in, + ptr.InUcastPkts.saturating_add(ptr.InNUcastPkts) + ); + old_and_new!( + interface, + packets_out, + old_packets_out, + ptr.OutUcastPkts.saturating_add(ptr.OutNUcastPkts) + ); + old_and_new!(interface, errors_in, old_errors_in, ptr.InErrors); + old_and_new!(interface, errors_out, old_errors_out, ptr.OutErrors); + interface.updated = true; + } + hash_map::Entry::Vacant(e) => { + let packets_in = ptr.InUcastPkts.saturating_add(ptr.InNUcastPkts); + let packets_out = ptr.OutUcastPkts.saturating_add(ptr.OutNUcastPkts); + + e.insert(NetworkData { + id: ptr.InterfaceLuid, + current_out: ptr.OutOctets, + old_out: ptr.OutOctets, + current_in: ptr.InOctets, + old_in: ptr.InOctets, + packets_in, + old_packets_in: packets_in, + packets_out, + old_packets_out: packets_out, + errors_in: ptr.InErrors, + old_errors_in: ptr.InErrors, + errors_out: ptr.OutErrors, + old_errors_out: ptr.OutErrors, + updated: true, + }); + } + } + } + FreeMibTable(table as _); + } + // Remove interfaces which are gone. + self.interfaces.retain(|_, d| d.updated); + } + + fn refresh(&mut self) { + let entry = std::mem::MaybeUninit::<MIB_IF_ROW2>::zeroed(); + + unsafe { + let mut entry = entry.assume_init(); + for (_, interface) in self.interfaces.iter_mut() { + entry.InterfaceLuid = interface.id; + entry.InterfaceIndex = 0; // to prevent the function to pick this one as index + if GetIfEntry2(&mut entry) != NO_ERROR { + continue; + } + old_and_new!(interface, current_out, old_out, entry.OutOctets); + old_and_new!(interface, current_in, old_in, entry.InOctets); + old_and_new!( + interface, + packets_in, + old_packets_in, + entry.InUcastPkts.saturating_add(entry.InNUcastPkts) + ); + old_and_new!( + interface, + packets_out, + old_packets_out, + entry.OutUcastPkts.saturating_add(entry.OutNUcastPkts) + ); + old_and_new!(interface, errors_in, old_errors_in, entry.InErrors); + old_and_new!(interface, errors_out, old_errors_out, entry.OutErrors); + } + } + } +} + +#[doc = include_str!("../../md_doc/network_data.md")] +pub struct NetworkData { + id: NET_LUID, + current_out: u64, + old_out: u64, + current_in: u64, + old_in: u64, + packets_in: u64, + old_packets_in: u64, + packets_out: u64, + old_packets_out: u64, + errors_in: u64, + old_errors_in: u64, + errors_out: u64, + old_errors_out: u64, + updated: bool, +} + +impl NetworkExt for NetworkData { + fn received(&self) -> u64 { + self.current_in.saturating_sub(self.old_in) + } + + fn total_received(&self) -> u64 { + self.current_in + } + + fn transmitted(&self) -> u64 { + self.current_out.saturating_sub(self.old_out) + } + + fn total_transmitted(&self) -> u64 { + self.current_out + } + + fn packets_received(&self) -> u64 { + self.packets_in.saturating_sub(self.old_packets_in) + } + + fn total_packets_received(&self) -> u64 { + self.packets_in + } + + fn packets_transmitted(&self) -> u64 { + self.packets_out.saturating_sub(self.old_packets_out) + } + + fn total_packets_transmitted(&self) -> u64 { + self.packets_out + } + + fn errors_on_received(&self) -> u64 { + self.errors_in.saturating_sub(self.old_errors_in) + } + + fn total_errors_on_received(&self) -> u64 { + self.errors_in + } + + fn errors_on_transmitted(&self) -> u64 { + self.errors_out.saturating_sub(self.old_errors_out) + } + + fn total_errors_on_transmitted(&self) -> u64 { + self.errors_out + } +} diff --git a/vendor/sysinfo/src/windows/process.rs b/vendor/sysinfo/src/windows/process.rs new file mode 100644 index 000000000..bdc35c53e --- /dev/null +++ b/vendor/sysinfo/src/windows/process.rs @@ -0,0 +1,1019 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::sys::utils::to_str; +use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessRefreshKind, ProcessStatus, Signal, Uid}; + +use std::ffi::OsString; +use std::fmt; +use std::mem::{size_of, zeroed, MaybeUninit}; +use std::ops::Deref; +use std::os::windows::ffi::OsStringExt; +use std::os::windows::process::CommandExt; +use std::path::{Path, PathBuf}; +use std::process; +use std::ptr::null_mut; +use std::str; +use std::sync::Arc; + +use libc::{c_void, memcpy}; + +use ntapi::ntpebteb::PEB; +use ntapi::ntwow64::{PEB32, PRTL_USER_PROCESS_PARAMETERS32, RTL_USER_PROCESS_PARAMETERS32}; +use once_cell::sync::Lazy; + +use ntapi::ntpsapi::{ + NtQueryInformationProcess, ProcessBasicInformation, ProcessCommandLineInformation, + ProcessWow64Information, PROCESSINFOCLASS, PROCESS_BASIC_INFORMATION, +}; +use ntapi::ntrtl::{RtlGetVersion, PRTL_USER_PROCESS_PARAMETERS, RTL_USER_PROCESS_PARAMETERS}; +use winapi::shared::basetsd::SIZE_T; +use winapi::shared::minwindef::{DWORD, FALSE, FILETIME, LPVOID, MAX_PATH, TRUE, ULONG}; +use winapi::shared::ntdef::{NT_SUCCESS, UNICODE_STRING}; +use winapi::shared::ntstatus::{ + STATUS_BUFFER_OVERFLOW, STATUS_BUFFER_TOO_SMALL, STATUS_INFO_LENGTH_MISMATCH, +}; +use winapi::shared::winerror::ERROR_INSUFFICIENT_BUFFER; +use winapi::um::errhandlingapi::GetLastError; +use winapi::um::handleapi::CloseHandle; +use winapi::um::heapapi::{GetProcessHeap, HeapAlloc, HeapFree}; +use winapi::um::memoryapi::{ReadProcessMemory, VirtualQueryEx}; +use winapi::um::processthreadsapi::{ + GetProcessTimes, GetSystemTimes, OpenProcess, OpenProcessToken, +}; +use winapi::um::psapi::{ + EnumProcessModulesEx, GetModuleBaseNameW, GetModuleFileNameExW, GetProcessMemoryInfo, + LIST_MODULES_ALL, PROCESS_MEMORY_COUNTERS, PROCESS_MEMORY_COUNTERS_EX, +}; +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, +}; + +impl fmt::Display for ProcessStatus { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(match *self { + ProcessStatus::Run => "Runnable", + _ => "Unknown", + }) + } +} + +fn get_process_handler(pid: Pid) -> Option<HandleWrapper> { + if pid.0 == 0 { + return None; + } + let options = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ; + + unsafe { HandleWrapper::new(OpenProcess(options, FALSE, pid.0 as DWORD)) } +} + +unsafe fn get_process_user_id( + handle: &HandleWrapper, + refresh_kind: ProcessRefreshKind, +) -> Option<Uid> { + struct HeapWrap<T>(*mut T); + + impl<T> HeapWrap<T> { + unsafe fn new(size: DWORD) -> Option<Self> { + let ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size as _) as *mut T; + if ptr.is_null() { + sysinfo_debug!("HeapAlloc failed"); + None + } else { + Some(Self(ptr)) + } + } + } + + impl<T> Drop for HeapWrap<T> { + fn drop(&mut self) { + if !self.0.is_null() { + unsafe { + HeapFree(GetProcessHeap(), 0, self.0 as *mut _); + } + } + } + } + + if !refresh_kind.user() { + return None; + } + + let mut token = null_mut(); + + if OpenProcessToken(**handle, TOKEN_QUERY, &mut token) == 0 { + sysinfo_debug!("OpenProcessToken failed"); + return None; + } + + let token = HandleWrapper::new(token)?; + + let mut size = 0; + + if GetTokenInformation(*token, TokenUser, null_mut(), 0, &mut size) == 0 { + let err = GetLastError(); + if err != ERROR_INSUFFICIENT_BUFFER { + sysinfo_debug!("GetTokenInformation failed, error: {:?}", err); + return None; + } + } + + let ptu: HeapWrap<TOKEN_USER> = HeapWrap::new(size)?; + + if GetTokenInformation(*token, TokenUser, ptu.0 as *mut _, size, &mut size) == 0 { + sysinfo_debug!("GetTokenInformation failed, error: {:?}", GetLastError()); + return None; + } + + let mut name_use = 0; + let mut name = [0u16; 256]; + let mut domain_name = [0u16; 256]; + let mut size = 256; + + if winapi::um::winbase::LookupAccountSidW( + std::ptr::null_mut(), + (*ptu.0).User.Sid, + name.as_mut_ptr(), + &mut size, + domain_name.as_mut_ptr(), + &mut size, + &mut name_use, + ) == 0 + { + sysinfo_debug!( + "LookupAccountSidW failed: {:?}", + winapi::um::errhandlingapi::GetLastError(), + ); + None + } else { + Some(Uid(to_str(name.as_mut_ptr()).into_boxed_str())) + } +} + +struct HandleWrapper(HANDLE); + +impl HandleWrapper { + fn new(handle: HANDLE) -> Option<Self> { + if handle.is_null() { + None + } else { + Some(Self(handle)) + } + } +} + +impl Deref for HandleWrapper { + type Target = HANDLE; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl Drop for HandleWrapper { + fn drop(&mut self) { + unsafe { + CloseHandle(self.0); + } + } +} + +#[allow(clippy::non_send_fields_in_send_ty)] +unsafe impl Send for HandleWrapper {} +unsafe impl Sync for HandleWrapper {} + +#[doc = include_str!("../../md_doc/process.md")] +pub struct Process { + name: String, + cmd: Vec<String>, + exe: PathBuf, + pid: Pid, + user_id: Option<Uid>, + environ: Vec<String>, + cwd: PathBuf, + root: PathBuf, + pub(crate) memory: u64, + pub(crate) virtual_memory: u64, + parent: Option<Pid>, + status: ProcessStatus, + handle: Option<Arc<HandleWrapper>>, + cpu_calc_values: CPUsageCalculationValues, + start_time: u64, + pub(crate) run_time: u64, + cpu_usage: f32, + pub(crate) updated: bool, + old_read_bytes: u64, + old_written_bytes: u64, + read_bytes: u64, + written_bytes: u64, +} + +struct CPUsageCalculationValues { + old_process_sys_cpu: u64, + old_process_user_cpu: u64, + old_system_sys_cpu: u64, + old_system_user_cpu: u64, +} + +impl CPUsageCalculationValues { + fn new() -> Self { + CPUsageCalculationValues { + old_process_sys_cpu: 0, + old_process_user_cpu: 0, + old_system_sys_cpu: 0, + old_system_user_cpu: 0, + } + } +} +static WINDOWS_8_1_OR_NEWER: Lazy<bool> = Lazy::new(|| unsafe { + let mut version_info: RTL_OSVERSIONINFOEXW = MaybeUninit::zeroed().assume_init(); + + version_info.dwOSVersionInfoSize = std::mem::size_of::<RTL_OSVERSIONINFOEXW>() as u32; + if !NT_SUCCESS(RtlGetVersion( + &mut version_info as *mut RTL_OSVERSIONINFOEXW as *mut _, + )) { + return true; + } + + // Windows 8.1 is 6.3 + version_info.dwMajorVersion > 6 + || version_info.dwMajorVersion == 6 && version_info.dwMinorVersion >= 3 +}); + +unsafe fn get_process_name(process_handler: &HandleWrapper, h_mod: *mut c_void) -> String { + let mut process_name = [0u16; MAX_PATH + 1]; + + GetModuleBaseNameW( + **process_handler, + h_mod as _, + process_name.as_mut_ptr(), + MAX_PATH as DWORD + 1, + ); + null_terminated_wchar_to_string(&process_name) +} + +unsafe fn get_h_mod(process_handler: &HandleWrapper, h_mod: &mut *mut c_void) -> bool { + let mut cb_needed = 0; + EnumProcessModulesEx( + **process_handler, + h_mod as *mut *mut c_void as _, + size_of::<DWORD>() as DWORD, + &mut cb_needed, + LIST_MODULES_ALL, + ) != 0 +} + +unsafe fn get_exe(process_handler: &HandleWrapper, h_mod: *mut c_void) -> PathBuf { + let mut exe_buf = [0u16; MAX_PATH + 1]; + GetModuleFileNameExW( + **process_handler, + h_mod as _, + exe_buf.as_mut_ptr(), + MAX_PATH as DWORD + 1, + ); + + PathBuf::from(null_terminated_wchar_to_string(&exe_buf)) +} + +impl Process { + pub(crate) fn new_from_pid( + pid: Pid, + now: u64, + refresh_kind: ProcessRefreshKind, + ) -> Option<Process> { + unsafe { + let process_handler = get_process_handler(pid)?; + let mut info: MaybeUninit<PROCESS_BASIC_INFORMATION> = MaybeUninit::uninit(); + if NtQueryInformationProcess( + *process_handler, + ProcessBasicInformation, + info.as_mut_ptr() as *mut _, + size_of::<PROCESS_BASIC_INFORMATION>() as _, + null_mut(), + ) != 0 + { + return None; + } + let info = info.assume_init(); + let mut h_mod = null_mut(); + + let name = if get_h_mod(&process_handler, &mut h_mod) { + get_process_name(&process_handler, h_mod) + } else { + String::new() + }; + + let exe = get_exe(&process_handler, h_mod); + let mut root = exe.clone(); + root.pop(); + let (cmd, environ, cwd) = match get_process_params(&process_handler) { + Ok(args) => args, + Err(_e) => { + sysinfo_debug!("Failed to get process parameters: {}", _e); + (Vec::new(), Vec::new(), PathBuf::new()) + } + }; + 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 { + None + }; + let user_id = get_process_user_id(&process_handler, refresh_kind); + Some(Process { + handle: Some(Arc::new(process_handler)), + name, + pid, + parent, + user_id, + cmd, + environ, + exe, + cwd, + root, + status: ProcessStatus::Run, + memory: 0, + virtual_memory: 0, + cpu_usage: 0., + cpu_calc_values: CPUsageCalculationValues::new(), + start_time, + run_time, + updated: true, + old_read_bytes: 0, + old_written_bytes: 0, + read_bytes: 0, + written_bytes: 0, + }) + } + } + + pub(crate) fn new_full( + pid: Pid, + parent: Option<Pid>, + memory: u64, + virtual_memory: u64, + name: String, + now: u64, + 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 mut root = exe.clone(); + root.pop(); + let (cmd, environ, cwd) = match get_process_params(&handle) { + Ok(args) => args, + Err(_e) => { + sysinfo_debug!("Failed to get process parameters: {}", _e); + (Vec::new(), Vec::new(), PathBuf::new()) + } + }; + 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)), + name, + pid, + user_id, + parent, + cmd, + environ, + exe, + cwd, + root, + status: ProcessStatus::Run, + memory, + virtual_memory, + cpu_usage: 0., + cpu_calc_values: CPUsageCalculationValues::new(), + start_time, + run_time, + updated: true, + old_read_bytes: 0, + old_written_bytes: 0, + read_bytes: 0, + written_bytes: 0, + } + } + } else { + Process { + handle: None, + name, + pid, + user_id: None, + parent, + cmd: Vec::new(), + environ: Vec::new(), + exe: get_executable_path(pid), + cwd: PathBuf::new(), + root: PathBuf::new(), + status: ProcessStatus::Run, + memory, + virtual_memory, + cpu_usage: 0., + cpu_calc_values: CPUsageCalculationValues::new(), + start_time: 0, + run_time: 0, + updated: true, + old_read_bytes: 0, + old_written_bytes: 0, + read_bytes: 0, + written_bytes: 0, + } + } + } + + pub(crate) fn update( + &mut self, + refresh_kind: crate::ProcessRefreshKind, + nb_cpus: u64, + now: u64, + ) { + if refresh_kind.cpu() { + compute_cpu_usage(self, nb_cpus); + } + if refresh_kind.disk_usage() { + update_disk_usage(self); + } + self.run_time = now.saturating_sub(self.start_time()); + self.updated = true; + } + + pub(crate) fn get_handle(&self) -> Option<HANDLE> { + self.handle.as_ref().map(|h| ***h) + } +} + +impl ProcessExt for Process { + fn kill_with(&self, signal: Signal) -> Option<bool> { + super::system::convert_signal(signal)?; + let mut kill = process::Command::new("taskkill.exe"); + kill.arg("/PID").arg(self.pid.to_string()).arg("/F"); + kill.creation_flags(CREATE_NO_WINDOW); + match kill.output() { + Ok(o) => Some(o.status.success()), + Err(_) => Some(false), + } + } + + fn name(&self) -> &str { + &self.name + } + + fn cmd(&self) -> &[String] { + &self.cmd + } + + fn exe(&self) -> &Path { + self.exe.as_path() + } + + fn pid(&self) -> Pid { + self.pid + } + + fn environ(&self) -> &[String] { + &self.environ + } + + fn cwd(&self) -> &Path { + self.cwd.as_path() + } + + fn root(&self) -> &Path { + self.root.as_path() + } + + fn memory(&self) -> u64 { + self.memory + } + + fn virtual_memory(&self) -> u64 { + self.virtual_memory + } + + fn parent(&self) -> Option<Pid> { + self.parent + } + + fn status(&self) -> ProcessStatus { + self.status + } + + fn start_time(&self) -> u64 { + self.start_time + } + + fn run_time(&self) -> u64 { + self.run_time + } + + fn cpu_usage(&self) -> f32 { + self.cpu_usage + } + + fn disk_usage(&self) -> DiskUsage { + DiskUsage { + written_bytes: self.written_bytes - self.old_written_bytes, + total_written_bytes: self.written_bytes, + read_bytes: self.read_bytes - self.old_read_bytes, + total_read_bytes: self.read_bytes, + } + } + + fn user_id(&self) -> Option<&Uid> { + self.user_id.as_ref() + } + + fn group_id(&self) -> Option<Gid> { + None + } +} + +unsafe fn get_start_and_run_time(handle: &HandleWrapper, now: u64) -> (u64, u64) { + let mut fstart: FILETIME = zeroed(); + let mut x = zeroed(); + + GetProcessTimes( + **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); + // 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) +} + +#[allow(clippy::uninit_vec)] +unsafe fn ph_query_process_variable_size( + process_handle: &HandleWrapper, + process_information_class: PROCESSINFOCLASS, +) -> Option<Vec<u16>> { + let mut return_length = MaybeUninit::<ULONG>::uninit(); + + let mut status = NtQueryInformationProcess( + **process_handle, + process_information_class, + null_mut(), + 0, + return_length.as_mut_ptr() as *mut _, + ); + + if status != STATUS_BUFFER_OVERFLOW + && status != STATUS_BUFFER_TOO_SMALL + && status != STATUS_INFO_LENGTH_MISMATCH + { + return None; + } + + let mut return_length = return_length.assume_init(); + let buf_len = (return_length as usize) / 2; + let mut buffer: Vec<u16> = Vec::with_capacity(buf_len + 1); + buffer.set_len(buf_len); + + status = NtQueryInformationProcess( + **process_handle, + process_information_class, + buffer.as_mut_ptr() as *mut _, + return_length, + &mut return_length as *mut _, + ); + if !NT_SUCCESS(status) { + return None; + } + buffer.push(0); + Some(buffer) +} + +unsafe fn get_cmdline_from_buffer(buffer: *const u16) -> Vec<String> { + // Get argc and argv from the command line + let mut argc = MaybeUninit::<i32>::uninit(); + let argv_p = winapi::um::shellapi::CommandLineToArgvW(buffer, argc.as_mut_ptr()); + if argv_p.is_null() { + return Vec::new(); + } + let argc = argc.assume_init(); + let argv = std::slice::from_raw_parts(argv_p, argc as usize); + + let mut res = Vec::new(); + for arg in argv { + let len = libc::wcslen(*arg); + let str_slice = std::slice::from_raw_parts(*arg, len); + res.push(String::from_utf16_lossy(str_slice)); + } + + winapi::um::winbase::LocalFree(argv_p as *mut _); + + res +} + +unsafe fn get_region_size(handle: &HandleWrapper, ptr: LPVOID) -> Result<usize, &'static str> { + let mut meminfo = MaybeUninit::<MEMORY_BASIC_INFORMATION>::uninit(); + if VirtualQueryEx( + **handle, + ptr, + meminfo.as_mut_ptr() as *mut _, + size_of::<MEMORY_BASIC_INFORMATION>(), + ) == 0 + { + return Err("Unable to read process memory information"); + } + let meminfo = meminfo.assume_init(); + Ok((meminfo.RegionSize as isize - ptr.offset_from(meminfo.BaseAddress)) as usize) +} + +#[allow(clippy::uninit_vec)] +unsafe fn get_process_data( + handle: &HandleWrapper, + ptr: LPVOID, + size: usize, +) -> Result<Vec<u16>, &'static str> { + let mut buffer: Vec<u16> = Vec::with_capacity(size / 2 + 1); + buffer.set_len(size / 2); + if ReadProcessMemory( + **handle, + ptr as *mut _, + buffer.as_mut_ptr() as *mut _, + size, + null_mut(), + ) != TRUE + { + return Err("Unable to read process data"); + } + Ok(buffer) +} + +trait RtlUserProcessParameters { + fn get_cmdline(&self, handle: &HandleWrapper) -> Result<Vec<u16>, &'static str>; + fn get_cwd(&self, handle: &HandleWrapper) -> Result<Vec<u16>, &'static str>; + fn get_environ(&self, handle: &HandleWrapper) -> Result<Vec<u16>, &'static str>; +} + +macro_rules! impl_RtlUserProcessParameters { + ($t:ty) => { + impl RtlUserProcessParameters for $t { + fn get_cmdline(&self, handle: &HandleWrapper) -> Result<Vec<u16>, &'static str> { + let ptr = self.CommandLine.Buffer; + let size = self.CommandLine.Length; + unsafe { get_process_data(handle, ptr as _, size as _) } + } + fn get_cwd(&self, handle: &HandleWrapper) -> Result<Vec<u16>, &'static str> { + let ptr = self.CurrentDirectory.DosPath.Buffer; + let size = self.CurrentDirectory.DosPath.Length; + unsafe { get_process_data(handle, ptr as _, size as _) } + } + fn get_environ(&self, handle: &HandleWrapper) -> Result<Vec<u16>, &'static str> { + let ptr = self.Environment; + unsafe { + let size = get_region_size(handle, ptr as LPVOID)?; + get_process_data(handle, ptr as _, size as _) + } + } + } + }; +} + +impl_RtlUserProcessParameters!(RTL_USER_PROCESS_PARAMETERS32); +impl_RtlUserProcessParameters!(RTL_USER_PROCESS_PARAMETERS); + +unsafe fn get_process_params( + handle: &HandleWrapper, +) -> Result<(Vec<String>, Vec<String>, PathBuf), &'static str> { + if !cfg!(target_pointer_width = "64") { + return Err("Non 64 bit targets are not supported"); + } + + // First check if target process is running in wow64 compatibility emulator + let mut pwow32info = MaybeUninit::<LPVOID>::uninit(); + let result = NtQueryInformationProcess( + **handle, + ProcessWow64Information, + pwow32info.as_mut_ptr() as *mut _, + size_of::<LPVOID>() as u32, + null_mut(), + ); + if !NT_SUCCESS(result) { + return Err("Unable to check WOW64 information about the process"); + } + let pwow32info = pwow32info.assume_init(); + + if pwow32info.is_null() { + // target is a 64 bit process + + let mut pbasicinfo = MaybeUninit::<PROCESS_BASIC_INFORMATION>::uninit(); + let result = NtQueryInformationProcess( + **handle, + ProcessBasicInformation, + pbasicinfo.as_mut_ptr() as *mut _, + size_of::<PROCESS_BASIC_INFORMATION>() as u32, + null_mut(), + ); + if !NT_SUCCESS(result) { + return Err("Unable to get basic process information"); + } + let pinfo = pbasicinfo.assume_init(); + + let mut peb = MaybeUninit::<PEB>::uninit(); + if ReadProcessMemory( + **handle, + pinfo.PebBaseAddress as *mut _, + peb.as_mut_ptr() as *mut _, + size_of::<PEB>() as SIZE_T, + null_mut(), + ) != TRUE + { + return Err("Unable to read process PEB"); + } + + let peb = peb.assume_init(); + + let mut proc_params = MaybeUninit::<RTL_USER_PROCESS_PARAMETERS>::uninit(); + if ReadProcessMemory( + **handle, + peb.ProcessParameters as *mut PRTL_USER_PROCESS_PARAMETERS as *mut _, + proc_params.as_mut_ptr() as *mut _, + size_of::<RTL_USER_PROCESS_PARAMETERS>() as SIZE_T, + null_mut(), + ) != TRUE + { + return Err("Unable to read process parameters"); + } + + let proc_params = proc_params.assume_init(); + return Ok(( + get_cmd_line(&proc_params, handle), + get_proc_env(&proc_params, handle), + get_cwd(&proc_params, handle), + )); + } + // target is a 32 bit process in wow64 mode + + let mut peb32 = MaybeUninit::<PEB32>::uninit(); + if ReadProcessMemory( + **handle, + pwow32info, + peb32.as_mut_ptr() as *mut _, + size_of::<PEB32>() as SIZE_T, + null_mut(), + ) != TRUE + { + return Err("Unable to read PEB32"); + } + let peb32 = peb32.assume_init(); + + let mut proc_params = MaybeUninit::<RTL_USER_PROCESS_PARAMETERS32>::uninit(); + if ReadProcessMemory( + **handle, + peb32.ProcessParameters as *mut PRTL_USER_PROCESS_PARAMETERS32 as *mut _, + proc_params.as_mut_ptr() as *mut _, + size_of::<RTL_USER_PROCESS_PARAMETERS32>() as SIZE_T, + null_mut(), + ) != TRUE + { + return Err("Unable to read 32 bit process parameters"); + } + let proc_params = proc_params.assume_init(); + Ok(( + get_cmd_line(&proc_params, handle), + get_proc_env(&proc_params, handle), + get_cwd(&proc_params, handle), + )) +} + +fn get_cwd<T: RtlUserProcessParameters>(params: &T, handle: &HandleWrapper) -> PathBuf { + match params.get_cwd(handle) { + Ok(buffer) => unsafe { PathBuf::from(null_terminated_wchar_to_string(buffer.as_slice())) }, + Err(_e) => { + sysinfo_debug!("get_cwd failed to get data: {}", _e); + PathBuf::new() + } + } +} + +unsafe fn null_terminated_wchar_to_string(slice: &[u16]) -> String { + match slice.iter().position(|&x| x == 0) { + Some(pos) => OsString::from_wide(&slice[..pos]) + .to_string_lossy() + .into_owned(), + None => OsString::from_wide(slice).to_string_lossy().into_owned(), + } +} + +fn get_cmd_line_old<T: RtlUserProcessParameters>( + params: &T, + handle: &HandleWrapper, +) -> Vec<String> { + match params.get_cmdline(handle) { + Ok(buffer) => unsafe { get_cmdline_from_buffer(buffer.as_ptr()) }, + Err(_e) => { + sysinfo_debug!("get_cmd_line_old failed to get data: {}", _e); + Vec::new() + } + } +} + +#[allow(clippy::cast_ptr_alignment)] +fn get_cmd_line_new(handle: &HandleWrapper) -> Vec<String> { + unsafe { + if let Some(buffer) = ph_query_process_variable_size(handle, ProcessCommandLineInformation) + { + let buffer = (*(buffer.as_ptr() as *const UNICODE_STRING)).Buffer; + + get_cmdline_from_buffer(buffer) + } else { + vec![] + } + } +} + +fn get_cmd_line<T: RtlUserProcessParameters>(params: &T, handle: &HandleWrapper) -> Vec<String> { + if *WINDOWS_8_1_OR_NEWER { + get_cmd_line_new(handle) + } else { + get_cmd_line_old(params, handle) + } +} + +fn get_proc_env<T: RtlUserProcessParameters>(params: &T, handle: &HandleWrapper) -> Vec<String> { + match params.get_environ(handle) { + Ok(buffer) => { + let equals = "=".encode_utf16().next().unwrap(); + let raw_env = buffer; + let mut result = Vec::new(); + let mut begin = 0; + while let Some(offset) = raw_env[begin..].iter().position(|&c| c == 0) { + let end = begin + offset; + if raw_env[begin..end].iter().any(|&c| c == equals) { + result.push( + OsString::from_wide(&raw_env[begin..end]) + .to_string_lossy() + .into_owned(), + ); + begin = end + 1; + } else { + break; + } + } + result + } + Err(_e) => { + sysinfo_debug!("get_proc_env failed to get data: {}", _e); + Vec::new() + } + } +} + +pub(crate) fn get_executable_path(_pid: Pid) -> PathBuf { + /*let where_req = format!("ProcessId={}", pid); + + if let Some(ret) = run_wmi(&["process", "where", &where_req, "get", "ExecutablePath"]) { + for line in ret.lines() { + if line.is_empty() || line == "ExecutablePath" { + continue + } + return line.to_owned(); + } + }*/ + PathBuf::new() +} + +#[inline] +fn check_sub(a: u64, b: u64) -> u64 { + if a < b { + a + } else { + a - b + } +} + +/// Before changing this function, you must consider the following: +/// https://github.com/GuillaumeGomez/sysinfo/issues/459 +pub(crate) fn compute_cpu_usage(p: &mut Process, nb_cpus: u64) { + unsafe { + let mut ftime: FILETIME = zeroed(); + let mut fsys: FILETIME = zeroed(); + let mut fuser: FILETIME = zeroed(); + let mut fglobal_idle_time: FILETIME = zeroed(); + let mut fglobal_kernel_time: FILETIME = zeroed(); // notice that it includes idle time + let mut fglobal_user_time: FILETIME = zeroed(); + + if let Some(handle) = p.get_handle() { + GetProcessTimes( + handle, + &mut ftime as *mut FILETIME, + &mut ftime as *mut FILETIME, + &mut fsys as *mut FILETIME, + &mut fuser as *mut FILETIME, + ); + } + GetSystemTimes( + &mut fglobal_idle_time as *mut FILETIME, + &mut fglobal_kernel_time as *mut FILETIME, + &mut fglobal_user_time as *mut FILETIME, + ); + + let mut sys: ULARGE_INTEGER = std::mem::zeroed(); + memcpy( + &mut sys as *mut ULARGE_INTEGER as *mut c_void, + &mut fsys as *mut FILETIME as *mut c_void, + size_of::<FILETIME>(), + ); + let mut user: ULARGE_INTEGER = std::mem::zeroed(); + memcpy( + &mut user as *mut ULARGE_INTEGER as *mut c_void, + &mut fuser as *mut FILETIME as *mut c_void, + size_of::<FILETIME>(), + ); + let mut global_kernel_time: ULARGE_INTEGER = std::mem::zeroed(); + memcpy( + &mut global_kernel_time as *mut ULARGE_INTEGER as *mut c_void, + &mut fglobal_kernel_time as *mut FILETIME as *mut c_void, + size_of::<FILETIME>(), + ); + let mut global_user_time: ULARGE_INTEGER = std::mem::zeroed(); + memcpy( + &mut global_user_time as *mut ULARGE_INTEGER as *mut c_void, + &mut fglobal_user_time as *mut FILETIME as *mut c_void, + size_of::<FILETIME>(), + ); + + let sys = *sys.QuadPart(); + let user = *user.QuadPart(); + let global_kernel_time = *global_kernel_time.QuadPart(); + let global_user_time = *global_user_time.QuadPart(); + + let delta_global_kernel_time = + check_sub(global_kernel_time, p.cpu_calc_values.old_system_sys_cpu); + let delta_global_user_time = + check_sub(global_user_time, p.cpu_calc_values.old_system_user_cpu); + let delta_user_time = check_sub(user, p.cpu_calc_values.old_process_user_cpu); + let delta_sys_time = check_sub(sys, p.cpu_calc_values.old_process_sys_cpu); + + p.cpu_calc_values.old_process_user_cpu = user; + p.cpu_calc_values.old_process_sys_cpu = sys; + p.cpu_calc_values.old_system_user_cpu = global_user_time; + p.cpu_calc_values.old_system_sys_cpu = global_kernel_time; + + let denominator = delta_global_user_time.saturating_add(delta_global_kernel_time) as f32; + + if denominator < 0.00001 { + p.cpu_usage = 0.; + return; + } + + p.cpu_usage = 100.0 + * (delta_user_time.saturating_add(delta_sys_time) as f32 / denominator as f32) + * nb_cpus as f32; + } +} + +pub(crate) fn update_disk_usage(p: &mut Process) { + let mut counters = MaybeUninit::<IO_COUNTERS>::uninit(); + + if let Some(handle) = p.get_handle() { + unsafe { + let ret = GetProcessIoCounters(handle, counters.as_mut_ptr()); + if ret == 0 { + sysinfo_debug!("GetProcessIoCounters call failed on process {}", p.pid()); + } else { + let counters = counters.assume_init(); + p.old_read_bytes = p.read_bytes; + p.old_written_bytes = p.written_bytes; + p.read_bytes = counters.ReadTransferCount; + p.written_bytes = counters.WriteTransferCount; + } + } + } +} + +pub(crate) fn update_memory(p: &mut Process) { + if let Some(handle) = p.get_handle() { + unsafe { + let mut pmc: PROCESS_MEMORY_COUNTERS_EX = zeroed(); + if GetProcessMemoryInfo( + handle, + &mut pmc as *mut PROCESS_MEMORY_COUNTERS_EX as *mut c_void + as *mut PROCESS_MEMORY_COUNTERS, + 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; + } + } + } +} diff --git a/vendor/sysinfo/src/windows/system.rs b/vendor/sysinfo/src/windows/system.rs new file mode 100644 index 000000000..6abd30db5 --- /dev/null +++ b/vendor/sysinfo/src/windows/system.rs @@ -0,0 +1,623 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{ + CpuRefreshKind, LoadAvg, Networks, Pid, ProcessExt, ProcessRefreshKind, RefreshKind, SystemExt, + User, +}; +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::tools::*; +use crate::sys::users::get_users; +use crate::sys::utils::get_now; + +use crate::utils::into_iter; + +use std::cell::UnsafeCell; +use std::collections::HashMap; +use std::ffi::OsStr; +use std::mem::{size_of, zeroed}; +use std::os::windows::ffi::OsStrExt; +use std::slice::from_raw_parts; +use std::time::SystemTime; + +use ntapi::ntexapi::{ + NtQuerySystemInformation, SystemProcessInformation, SYSTEM_PROCESS_INFORMATION, +}; +use winapi::ctypes::wchar_t; +use winapi::shared::minwindef::{DWORD, FALSE, HKEY, LPBYTE, TRUE}; +use winapi::shared::ntdef::{PVOID, ULONG}; +use winapi::shared::ntstatus::STATUS_INFO_LENGTH_MISMATCH; +use winapi::shared::winerror; +use winapi::um::minwinbase::STILL_ACTIVE; +use winapi::um::processthreadsapi::GetExitCodeProcess; +use winapi::um::psapi::{GetPerformanceInfo, PERFORMANCE_INFORMATION}; +use winapi::um::sysinfoapi::{ + ComputerNamePhysicalDnsHostname, GetComputerNameExW, GetTickCount64, GlobalMemoryStatusEx, + MEMORYSTATUSEX, +}; +use winapi::um::winnt::{HANDLE, KEY_READ}; +use winapi::um::winreg::{RegOpenKeyExW, RegQueryValueExW}; + +declare_signals! { + (), + Signal::Kill => (), + _ => None, +} + +#[doc = include_str!("../../md_doc/system.md")] +pub struct System { + process_list: HashMap<Pid, Process>, + mem_total: u64, + mem_available: u64, + swap_total: u64, + swap_used: u64, + cpus: CpusWrapper, + components: Vec<Component>, + disks: Vec<Disk>, + query: Option<Query>, + networks: Networks, + boot_time: u64, + users: Vec<User>, +} + +// Useful for parallel iterations. +struct Wrap<T>(T); + +#[allow(clippy::non_send_fields_in_send_ty)] +unsafe impl<T> Send for Wrap<T> {} +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, + Err(_e) => { + sysinfo_debug!("Failed to compute boot time: {:?}", _e); + 0 + } + } +} + +impl SystemExt for System { + const IS_SUPPORTED: bool = true; + const SUPPORTED_SIGNALS: &'static [Signal] = supported_signals(); + + #[allow(non_snake_case)] + fn new_with_specifics(refreshes: RefreshKind) -> System { + let mut s = System { + process_list: HashMap::with_capacity(500), + mem_total: 0, + mem_available: 0, + swap_total: 0, + swap_used: 0, + cpus: CpusWrapper::new(), + components: Vec::new(), + disks: Vec::with_capacity(2), + query: None, + networks: Networks::new(), + boot_time: unsafe { boot_time() }, + users: Vec::new(), + }; + s.refresh_specifics(refreshes); + s + } + + fn refresh_cpu_specifics(&mut self, refresh_kind: CpuRefreshKind) { + if self.query.is_none() { + self.query = Query::new(); + if let Some(ref mut query) = self.query { + add_english_counter( + r"\Processor(_Total)\% Processor Time".to_string(), + query, + get_key_used(self.cpus.global_cpu_mut()), + "tot_0".to_owned(), + ); + for (pos, proc_) in self.cpus.iter_mut(refresh_kind).enumerate() { + add_english_counter( + format!(r"\Processor({})\% Processor Time", pos), + query, + get_key_used(proc_), + format!("{}_0", pos), + ); + } + } + } + if let Some(ref mut query) = self.query { + query.refresh(); + let mut used_time = None; + if let Some(ref key_used) = *get_key_used(self.cpus.global_cpu_mut()) { + used_time = Some( + query + .get(&key_used.unique_id) + .expect("global_key_idle disappeared"), + ); + } + if let Some(used_time) = used_time { + self.cpus.global_cpu_mut().set_cpu_usage(used_time); + } + for p in self.cpus.iter_mut(refresh_kind) { + let mut used_time = None; + if let Some(ref key_used) = *get_key_used(p) { + used_time = Some( + query + .get(&key_used.unique_id) + .expect("key_used disappeared"), + ); + } + if let Some(used_time) = used_time { + p.set_cpu_usage(used_time); + } + } + if refresh_kind.frequency() { + self.cpus.get_frequencies(); + } + } + } + + fn refresh_memory(&mut self) { + unsafe { + 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; + let mut perf_info: PERFORMANCE_INFORMATION = zeroed(); + if GetPerformanceInfo(&mut perf_info, size_of::<PERFORMANCE_INFORMATION>() as u32) + == TRUE + { + let swap_total = perf_info.PageSize.saturating_mul( + perf_info + .CommitLimit + .saturating_sub(perf_info.PhysicalTotal), + ); + let swap_used = perf_info.PageSize.saturating_mul( + perf_info + .CommitTotal + .saturating_sub(perf_info.PhysicalTotal), + ); + self.swap_total = (swap_total / 1000) as u64; + self.swap_used = (swap_used / 1000) as u64; + } + } + } + + fn refresh_components_list(&mut self) { + self.components = component::get_components(); + } + + #[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(); + if let Some(mut p) = Process::new_from_pid(pid, now, refresh_kind) { + p.update(refresh_kind, self.cpus.len() as u64, now); + p.updated = false; + self.process_list.insert(pid, p); + true + } else { + false + } + } + + #[allow(clippy::cast_ptr_alignment)] + fn refresh_processes_specifics(&mut self, refresh_kind: ProcessRefreshKind) { + // Windows 10 notebook requires at least 512KiB of memory to make it in one go + let mut buffer_size: usize = 512 * 1024; + let now = get_now(); + + loop { + let mut process_information: Vec<u8> = Vec::with_capacity(buffer_size); + let mut cb_needed = 0; + + unsafe { + process_information.set_len(buffer_size); + let ntstatus = NtQuerySystemInformation( + SystemProcessInformation, + process_information.as_mut_ptr() as PVOID, + buffer_size as ULONG, + &mut cb_needed, + ); + + if ntstatus != STATUS_INFO_LENGTH_MISMATCH { + if ntstatus < 0 { + sysinfo_debug!( + "Couldn't get process infos: NtQuerySystemInformation returned {}", + ntstatus + ); + } + + // Parse the data block to get process information + let mut process_ids = Vec::with_capacity(500); + let mut process_information_offset = 0; + loop { + let p = process_information + .as_ptr() + .offset(process_information_offset) + as *const SYSTEM_PROCESS_INFORMATION; + let pi = &*p; + + process_ids.push(Wrap(p)); + + if pi.NextEntryOffset == 0 { + break; + } + + process_information_offset += pi.NextEntryOffset as isize; + } + let process_list = Wrap(UnsafeCell::new(&mut self.process_list)); + let nb_cpus = if refresh_kind.cpu() { + self.cpus.len() as u64 + } else { + 0 + }; + + #[cfg(feature = "multithread")] + use rayon::iter::ParallelIterator; + + // TODO: instead of using parallel iterator only here, would be better to be + // able to run it over `process_information` directly! + let processes = into_iter(process_ids) + .filter_map(|pi| { + 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; + } + let name = get_process_name(&pi, pid); + let mut p = Process::new_full( + pid, + if pi.InheritedFromUniqueProcessId as usize != 0 { + Some(Pid(pi.InheritedFromUniqueProcessId as _)) + } else { + None + }, + (pi.WorkingSetSize as u64) / 1_000, + (pi.VirtualSize as u64) / 1_000, + name, + now, + refresh_kind, + ); + p.update(refresh_kind, nb_cpus, now); + Some(p) + }) + .collect::<Vec<_>>(); + for p in processes.into_iter() { + self.process_list.insert(p.pid(), p); + } + self.process_list.retain(|_, v| { + let x = v.updated; + v.updated = false; + x + }); + + break; + } + + // GetNewBufferSize + if cb_needed == 0 { + buffer_size *= 2; + continue; + } + // allocating a few more kilo bytes just in case there are some new process + // kicked in since new call to NtQuerySystemInformation + buffer_size = (cb_needed + (1024 * 10)) as usize; + } + } + } + + fn refresh_disks_list(&mut self) { + self.disks = unsafe { get_disks() }; + } + + fn refresh_users_list(&mut self) { + self.users = unsafe { get_users() }; + } + + fn processes(&self) -> &HashMap<Pid, Process> { + &self.process_list + } + + fn process(&self, pid: Pid) -> Option<&Process> { + self.process_list.get(&pid) + } + + fn global_cpu_info(&self) -> &Cpu { + self.cpus.global_cpu() + } + + fn cpus(&self) -> &[Cpu] { + self.cpus.cpus() + } + + fn physical_core_count(&self) -> Option<usize> { + get_physical_core_count() + } + + fn total_memory(&self) -> u64 { + self.mem_total + } + + fn free_memory(&self) -> u64 { + // MEMORYSTATUSEX doesn't report free memory + self.mem_available + } + + fn available_memory(&self) -> u64 { + self.mem_available + } + + fn used_memory(&self) -> u64 { + self.mem_total - self.mem_available + } + + fn total_swap(&self) -> u64 { + self.swap_total + } + + fn free_swap(&self) -> u64 { + self.swap_total - self.swap_used + } + + fn used_swap(&self) -> u64 { + self.swap_used + } + + fn components(&self) -> &[Component] { + &self.components + } + + fn components_mut(&mut self) -> &mut [Component] { + &mut self.components + } + + fn disks(&self) -> &[Disk] { + &self.disks + } + + fn disks_mut(&mut self) -> &mut [Disk] { + &mut self.disks + } + + fn users(&self) -> &[User] { + &self.users + } + + fn networks(&self) -> &Networks { + &self.networks + } + + fn networks_mut(&mut self) -> &mut Networks { + &mut self.networks + } + + fn uptime(&self) -> u64 { + unsafe { GetTickCount64() / 1000 } + } + + fn boot_time(&self) -> u64 { + self.boot_time + } + + fn load_average(&self) -> LoadAvg { + get_load_average() + } + + fn name(&self) -> Option<String> { + Some("Windows".to_owned()) + } + + fn long_os_version(&self) -> Option<String> { + get_reg_string_value( + HKEY_LOCAL_MACHINE, + "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", + "ProductName", + ) + } + + fn host_name(&self) -> Option<String> { + get_dns_hostname() + } + + fn kernel_version(&self) -> Option<String> { + get_reg_string_value( + HKEY_LOCAL_MACHINE, + "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", + "CurrentBuildNumber", + ) + } + + 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", + ); + + Some(format!( + "{} ({})", + u32::from_le_bytes(major.unwrap_or_default()), + build_number.unwrap_or_default() + )) + } +} + +impl Default for System { + fn default() -> System { + System::new() + } +} + +fn is_proc_running(handle: HANDLE) -> bool { + let mut exit_code = 0; + unsafe { + let ret = GetExitCodeProcess(handle, &mut exit_code); + !(ret == FALSE || exit_code != STILL_ACTIVE) + } +} + +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; + } + update_memory(entry); + entry.update(refresh_kind, s.cpus.len() as u64, get_now()); + entry.updated = false; + true + } else { + false + } +} + +#[allow(clippy::size_of_in_element_count)] +//^ needed for "name.Length as usize / std::mem::size_of::<u16>()" +pub(crate) fn get_process_name(process: &SYSTEM_PROCESS_INFORMATION, process_id: Pid) -> String { + let name = &process.ImageName; + if name.Buffer.is_null() { + match process_id.0 { + 0 => "Idle".to_owned(), + 4 => "System".to_owned(), + _ => format!("<no name> Process {}", process_id), + } + } else { + unsafe { + let slice = std::slice::from_raw_parts( + name.Buffer, + // The length is in bytes, not the length of string + name.Length as usize / std::mem::size_of::<u16>(), + ); + + String::from_utf16_lossy(slice) + } + } +} + +fn utf16_str<S: AsRef<OsStr> + ?Sized>(text: &S) -> Vec<u16> { + OsStr::new(text) + .encode_wide() + .chain(Some(0).into_iter()) + .collect::<Vec<_>>() +} + +fn get_reg_string_value(hkey: HKEY, path: &str, field_name: &str) -> Option<String> { + let c_path = utf16_str(path); + let c_field_name = utf16_str(field_name); + + let mut new_hkey: HKEY = std::ptr::null_mut(); + unsafe { + if RegOpenKeyExW(hkey, c_path.as_ptr(), 0, KEY_READ, &mut new_hkey) != 0 { + return None; + } + + let mut buf_len: DWORD = 2048; + let mut buf_type: DWORD = 0; + let mut buf: Vec<u8> = Vec::with_capacity(buf_len as usize); + loop { + match RegQueryValueExW( + new_hkey, + c_field_name.as_ptr(), + std::ptr::null_mut(), + &mut buf_type, + buf.as_mut_ptr() as LPBYTE, + &mut buf_len, + ) as DWORD + { + 0 => break, + winerror::ERROR_MORE_DATA => { + buf.reserve(buf_len as _); + } + _ => return None, + } + } + + buf.set_len(buf_len as _); + + let words = from_raw_parts(buf.as_ptr() as *const u16, buf.len() / 2); + let mut s = String::from_utf16_lossy(words); + while s.ends_with('\u{0}') { + s.pop(); + } + Some(s) + } +} + +fn get_reg_value_u32(hkey: HKEY, path: &str, field_name: &str) -> Option<[u8; 4]> { + let c_path = utf16_str(path); + let c_field_name = utf16_str(field_name); + + let mut new_hkey: HKEY = std::ptr::null_mut(); + unsafe { + if RegOpenKeyExW(hkey, c_path.as_ptr(), 0, KEY_READ, &mut new_hkey) != 0 { + return None; + } + + let mut buf_len: DWORD = 4; + let mut buf_type: DWORD = 0; + let mut buf = [0u8; 4]; + + match RegQueryValueExW( + new_hkey, + c_field_name.as_ptr(), + std::ptr::null_mut(), + &mut buf_type, + buf.as_mut_ptr() as LPBYTE, + &mut buf_len, + ) as DWORD + { + 0 => Some(buf), + _ => None, + } + } +} + +fn get_dns_hostname() -> Option<String> { + let mut buffer_size = 0; + // Running this first to get the buffer size since the DNS name can be longer than MAX_COMPUTERNAME_LENGTH + // setting the `lpBuffer` to null will return the buffer size + // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getcomputernameexw + unsafe { + GetComputerNameExW( + ComputerNamePhysicalDnsHostname, + std::ptr::null_mut(), + &mut buffer_size, + ); + + // Setting the buffer with the new length + let mut buffer = vec![0_u16; buffer_size as usize]; + + // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/ne-sysinfoapi-computer_name_format + if GetComputerNameExW( + ComputerNamePhysicalDnsHostname, + buffer.as_mut_ptr() as *mut wchar_t, + &mut buffer_size, + ) == TRUE + { + if let Some(pos) = buffer.iter().position(|c| *c == 0) { + buffer.resize(pos, 0); + } + + return String::from_utf16(&buffer).ok(); + } + } + + sysinfo_debug!("Failed to get computer hostname"); + None +} diff --git a/vendor/sysinfo/src/windows/tools.rs b/vendor/sysinfo/src/windows/tools.rs new file mode 100644 index 000000000..a0c334010 --- /dev/null +++ b/vendor/sysinfo/src/windows/tools.rs @@ -0,0 +1,55 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::sys::cpu::{self, Cpu, Query}; +use crate::CpuRefreshKind; + +use std::mem::zeroed; + +use winapi::um::sysinfoapi::{GetSystemInfo, SYSTEM_INFO}; + +pub(crate) struct KeyHandler { + pub unique_id: String, +} + +impl KeyHandler { + pub fn new(unique_id: String) -> KeyHandler { + KeyHandler { unique_id } + } +} + +pub(crate) fn init_cpus(refresh_kind: CpuRefreshKind) -> (Vec<Cpu>, String, String) { + unsafe { + let mut sys_info: SYSTEM_INFO = zeroed(); + GetSystemInfo(&mut sys_info); + let (vendor_id, brand) = cpu::get_vendor_id_and_brand(&sys_info); + let nb_cpus = sys_info.dwNumberOfProcessors as usize; + let frequencies = if refresh_kind.frequency() { + cpu::get_frequencies(nb_cpus) + } else { + vec![0; nb_cpus] + }; + let mut ret = Vec::with_capacity(nb_cpus + 1); + for (nb, frequency) in frequencies.iter().enumerate() { + ret.push(Cpu::new_with_values( + format!("CPU {}", nb + 1), + vendor_id.clone(), + brand.clone(), + *frequency, + )); + } + (ret, vendor_id, brand) + } +} + +pub(crate) fn add_english_counter( + s: String, + query: &mut Query, + keys: &mut Option<KeyHandler>, + counter_name: String, +) { + let mut full = s.encode_utf16().collect::<Vec<_>>(); + full.push(0); + if query.add_english_counter(&counter_name, full) { + *keys = Some(KeyHandler::new(counter_name)); + } +} diff --git a/vendor/sysinfo/src/windows/users.rs b/vendor/sysinfo/src/windows/users.rs new file mode 100644 index 000000000..2fef05c3f --- /dev/null +++ b/vendor/sysinfo/src/windows/users.rs @@ -0,0 +1,181 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::sys::utils::to_str; +use crate::{ + common::{Gid, Uid}, + User, +}; + +use std::ptr::null_mut; +use winapi::shared::lmcons::{MAX_PREFERRED_LENGTH, NET_API_STATUS}; +use winapi::shared::minwindef::DWORD; +use winapi::shared::ntstatus::STATUS_SUCCESS; +use winapi::shared::winerror::ERROR_MORE_DATA; +use winapi::um::lmaccess::{NetUserEnum, NetUserGetLocalGroups}; +use winapi::um::lmaccess::{ + FILTER_NORMAL_ACCOUNT, LG_INCLUDE_INDIRECT, LPLOCALGROUP_USERS_INFO_0, USER_INFO_0, +}; +use winapi::um::lmapibuf::NetApiBufferFree; +use winapi::um::ntlsa::{ + LsaEnumerateLogonSessions, LsaFreeReturnBuffer, LsaGetLogonSessionData, + PSECURITY_LOGON_SESSION_DATA, +}; +use winapi::um::winnt::{LPWSTR, PLUID}; + +// FIXME: once this is mreged in winapi, it can be removed. +#[allow(non_upper_case_globals)] +const NERR_Success: NET_API_STATUS = 0; + +unsafe fn get_groups_for_user(username: LPWSTR) -> Vec<String> { + let mut buf: LPLOCALGROUP_USERS_INFO_0 = null_mut(); + let mut nb_entries = 0; + let mut total_entries = 0; + let mut groups; + + let status = NetUserGetLocalGroups( + [0u16].as_ptr(), + username, + 0, + LG_INCLUDE_INDIRECT, + &mut buf as *mut _ as _, + MAX_PREFERRED_LENGTH, + &mut nb_entries, + &mut total_entries, + ); + + if status == NERR_Success { + groups = Vec::with_capacity(nb_entries as _); + + if !buf.is_null() { + for i in 0..nb_entries { + let tmp = buf.offset(i as _); + if tmp.is_null() { + break; + } + groups.push(to_str((*tmp).lgrui0_name)); + } + } + } else { + groups = Vec::new(); + sysinfo_debug!("NetUserGetLocalGroups failed with ret code {}", status); + } + if !buf.is_null() { + NetApiBufferFree(buf as *mut _); + } + + groups +} + +// FIXME: For now, the Uid is the user name, which is quite bad. Normally, there is `PSID` for +// that. But when getting the `PSID` from the processes, it doesn't match the ones we have for +// the users (`EqualSid`). Anyway, until I have time and motivation to fix this. It'll remain +// like that... +pub unsafe fn get_users() -> Vec<User> { + let mut users = Vec::new(); + let mut buffer: *mut USER_INFO_0 = null_mut(); + let mut nb_read = 0; + let mut total = 0; + let mut resume_handle: DWORD = 0; + + loop { + let status = NetUserEnum( + null_mut(), + 0, + FILTER_NORMAL_ACCOUNT, + &mut buffer as *mut _ as *mut _, + MAX_PREFERRED_LENGTH, + &mut nb_read, + &mut total, + &mut resume_handle as *mut _ as *mut _, + ); + if status == NERR_Success || status == ERROR_MORE_DATA { + let entries: &[USER_INFO_0] = std::slice::from_raw_parts(buffer, nb_read as _); + for entry in entries { + if entry.usri0_name.is_null() { + continue; + } + // let mut user: *mut USER_INFO_23 = null_mut(); + + // if NetUserGetInfo( + // null_mut(), + // entry.usri0_name, + // 23, + // &mut user as *mut _ as *mut _, + // ) == NERR_Success + // { + // let groups = get_groups_for_user((*user).usri23_name); + // users.push(User { + // uid: Uid(name.clone().into_boxed_str()), + // gid: Gid(0), + // name: to_str((*user).usri23_name), + // groups, + // }); + // } + // if !user.is_null() { + // NetApiBufferFree(user as *mut _); + // } + let groups = get_groups_for_user(entry.usri0_name); + let name = to_str(entry.usri0_name); + users.push(User { + uid: Uid(name.clone().into_boxed_str()), + gid: Gid(0), + name, + groups, + }); + } + } else { + sysinfo_debug!( + "NetUserEnum error: {}", + if status == winapi::shared::winerror::ERROR_ACCESS_DENIED { + "access denied" + } else if status == winapi::shared::winerror::ERROR_INVALID_LEVEL { + "invalid level" + } else { + "unknown error" + } + ); + } + if !buffer.is_null() { + NetApiBufferFree(buffer as *mut _); + buffer = null_mut(); + } + if status != ERROR_MORE_DATA { + break; + } + } + + // First part done. Second part now! + let mut nb_sessions = 0; + let mut uids: PLUID = null_mut(); + if LsaEnumerateLogonSessions(&mut nb_sessions, &mut uids) != STATUS_SUCCESS { + sysinfo_debug!("LsaEnumerateLogonSessions failed"); + } else { + for offset in 0..nb_sessions { + let entry = uids.add(offset as _); + let mut data: PSECURITY_LOGON_SESSION_DATA = null_mut(); + + if LsaGetLogonSessionData(entry, &mut data) == STATUS_SUCCESS && !data.is_null() { + let data = *data; + if data.LogonType == winapi::um::ntlsa::Network { + continue; + } + let name = to_str(data.UserName.Buffer); + if users.iter().any(|u| u.name == name) { + continue; + } + users.push(User { + uid: Uid(name.clone().into_boxed_str()), + gid: Gid(0), + name, + // There is no local groups for a non-local user. + groups: Vec::new(), + }); + } + if !data.is_null() { + LsaFreeReturnBuffer(data as *mut _); + } + } + } + + users +} diff --git a/vendor/sysinfo/src/windows/utils.rs b/vendor/sysinfo/src/windows/utils.rs new file mode 100644 index 000000000..419ee195c --- /dev/null +++ b/vendor/sysinfo/src/windows/utils.rs @@ -0,0 +1,36 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use winapi::shared::minwindef::FILETIME; +use winapi::um::winnt::LPWSTR; + +use std::time::SystemTime; + +#[inline] +pub(crate) fn filetime_to_u64(f: FILETIME) -> u64 { + (f.dwHighDateTime as u64) << 32 | (f.dwLowDateTime as u64) +} + +#[inline] +pub(crate) fn get_now() -> u64 { + SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .map(|n| n.as_secs()) + .unwrap_or(0) +} + +pub(crate) unsafe fn to_str(p: LPWSTR) -> String { + let mut i = 0; + + loop { + let c = *p.offset(i); + if c == 0 { + break; + } + i += 1; + } + let s = std::slice::from_raw_parts(p, i as _); + String::from_utf16(s).unwrap_or_else(|_e| { + sysinfo_debug!("Failed to convert to UTF-16 string: {}", _e); + String::new() + }) +} diff --git a/vendor/sysinfo/tests/code_checkers/docs.rs b/vendor/sysinfo/tests/code_checkers/docs.rs new file mode 100644 index 000000000..918e64bb0 --- /dev/null +++ b/vendor/sysinfo/tests/code_checkers/docs.rs @@ -0,0 +1,135 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use super::utils::{show_error, TestResult}; +use std::ffi::OsStr; +use std::path::Path; + +fn to_correct_name(s: &str) -> String { + let mut out = String::with_capacity(s.len()); + + for c in s.chars() { + if c.is_uppercase() { + if !out.is_empty() { + out.push('_'); + } + out.push_str(c.to_lowercase().to_string().as_str()); + } else { + out.push(c); + } + } + out +} + +fn check_md_doc_path(p: &Path, md_line: &str, ty_line: &str) -> bool { + 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) = name + .split('<') + .next() + .and_then(|n| n.split('{').next()) + .and_then(|n| n.split('(').next()) + .and_then(|n| n.split(';').next()) + { + let correct = to_correct_name(name); + if correct.as_str() == md_name { + return true; + } + show_error( + p, + &format!( + "Invalid markdown file name `{}`, should have been `{}`", + md_name, correct + ), + ); + return false; + } + } + show_error(p, &format!("Cannot extract type name from `{}`", ty_line)); + } else { + show_error(p, &format!("Cannot extract md name from `{}`", md_line)); + } + return false; +} + +fn check_doc_comments_before(p: &Path, lines: &[&str], start: usize) -> bool { + let mut found_docs = false; + + for pos in (0..start).rev() { + let trimmed = lines[pos].trim(); + if trimmed.starts_with("///") { + if !lines[start].trim().starts_with("pub enum ThreadStatus {") { + show_error( + p, + &format!( + "Types should use common documentation by using `#[doc = include_str!(` \ + and by putting the markdown file in the `md_doc` folder instead of `{}`", + &lines[pos], + ), + ); + return false; + } + return true; + } else if trimmed.starts_with("#[doc = include_str!(") { + found_docs = true; + if !check_md_doc_path(p, trimmed, lines[start]) { + return false; + } + } else if !trimmed.starts_with("#[") && !trimmed.starts_with("//") { + break; + } + } + if !found_docs { + show_error( + p, + &format!( + "Missing documentation for public item: `{}` (if it's not supposed to be a public \ + item, use `pub(crate)` instead)", + lines[start], + ), + ); + return false; + } + true +} + +pub fn check_docs(content: &str, p: &Path) -> TestResult { + let mut res = TestResult { + nb_tests: 0, + nb_errors: 0, + }; + + // No need to check if we are in the `src` folder or if we are in a `ffi.rs` file. + if p.parent().unwrap().file_name().unwrap() == OsStr::new("src") + || p.file_name().unwrap() == OsStr::new("ffi.rs") + { + return res; + } + let lines = content.lines().collect::<Vec<_>>(); + + for pos in 1..lines.len() { + let line = lines[pos]; + let trimmed = line.trim(); + if trimmed.starts_with("//!") { + show_error(p, "There shouln't be inner doc comments (`//!`)"); + res.nb_tests += 1; + res.nb_errors += 1; + continue; + } else if !line.starts_with("pub fn ") + && !trimmed.starts_with("pub struct ") + && !trimmed.starts_with("pub enum ") + { + continue; + } + res.nb_tests += 1; + if !check_doc_comments_before(p, &lines, pos) { + res.nb_errors += 1; + } + } + res +} diff --git a/vendor/sysinfo/tests/code_checkers/headers.rs b/vendor/sysinfo/tests/code_checkers/headers.rs new file mode 100644 index 000000000..ac7a34ddb --- /dev/null +++ b/vendor/sysinfo/tests/code_checkers/headers.rs @@ -0,0 +1,59 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use super::utils::{show_error, TestResult}; +use std::path::Path; + +pub fn check_license_header(content: &str, p: &Path) -> TestResult { + let mut lines = content.lines(); + let next = lines.next(); + let header = "// Take a look at the license at the top of the repository in the LICENSE file."; + + match next { + Some(s) if s == header => { + let next = lines.next(); + match next { + Some("") => TestResult { + nb_tests: 1, + nb_errors: 0, + }, + Some(s) => { + show_error( + p, + &format!("Expected empty line after license header, found `{}`", s), + ); + TestResult { + nb_tests: 1, + nb_errors: 1, + } + } + None => { + show_error(p, "This file should very likely not exist..."); + TestResult { + nb_tests: 1, + nb_errors: 1, + } + } + } + } + Some(s) => { + show_error( + p, + &format!( + "Expected license header at the top of the file (`{}`), found: `{}`", + header, s + ), + ); + TestResult { + nb_tests: 1, + nb_errors: 1, + } + } + None => { + show_error(p, "This (empty?) file should very likely not exist..."); + TestResult { + nb_tests: 1, + nb_errors: 1, + } + } + } +} diff --git a/vendor/sysinfo/tests/code_checkers/mod.rs b/vendor/sysinfo/tests/code_checkers/mod.rs new file mode 100644 index 000000000..f6012da95 --- /dev/null +++ b/vendor/sysinfo/tests/code_checkers/mod.rs @@ -0,0 +1,49 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +mod docs; +mod headers; +mod signals; +mod utils; + +use std::path::Path; +use utils::TestResult; + +const CHECKS: &[(fn(&str, &Path) -> TestResult, &[&str])] = &[ + (headers::check_license_header, &["src", "tests", "examples"]), + (signals::check_signals, &["src"]), + (docs::check_docs, &["src"]), +]; + +fn handle_tests(res: &mut [TestResult]) { + utils::read_dirs( + &["benches", "examples", "src", "tests"], + &mut |p: &Path, c: &str| { + if let Some(first) = p.iter().next().and_then(|first| first.to_str()) { + for (pos, (check, filter)) in CHECKS.iter().enumerate() { + if filter.contains(&first) { + res[pos] += check(c, p); + } + } + } + }, + ); +} + +#[test] +fn code_checks() { + let mut res = Vec::new(); + + for _ in CHECKS { + res.push(TestResult { + nb_tests: 0, + nb_errors: 0, + }); + } + + handle_tests(&mut res); + + for r in res { + assert_eq!(r.nb_errors, 0); + assert_ne!(r.nb_tests, 0); + } +} diff --git a/vendor/sysinfo/tests/code_checkers/signals.rs b/vendor/sysinfo/tests/code_checkers/signals.rs new file mode 100644 index 000000000..68e47f76e --- /dev/null +++ b/vendor/sysinfo/tests/code_checkers/signals.rs @@ -0,0 +1,64 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use super::utils::{show_error, TestResult}; +use std::path::Path; + +fn check_supported_signals_decl<'a>(lines: &mut impl Iterator<Item = &'a str>, p: &Path) -> usize { + for line in lines { + let trimmed = line.trim(); + if trimmed.starts_with("const SUPPORTED_SIGNALS: &'static [Signal]") { + if trimmed != "const SUPPORTED_SIGNALS: &'static [Signal] = supported_signals();" { + show_error( + p, + "SystemExt::SUPPORTED_SIGNALS should be declared using `supported_signals()`", + ); + return 1; + } + break; + } + } + 0 +} + +fn check_kill_decl<'a>(lines: &mut impl Iterator<Item = &'a str>, p: &Path) -> usize { + let mut errors = 0; + + while let Some(line) = lines.next() { + let trimmed = line.trim(); + if trimmed.starts_with("fn kill(") { + show_error(p, "`ProcessExt::kill` should not be reimplemented!"); + errors += 1; + } else if trimmed.starts_with("fn kill_with(") { + if let Some(line) = lines.next() { + let trimmed = line.trim(); + if trimmed.ends_with("::system::convert_signal(signal)?;") || trimmed == "None" { + continue; + } else { + show_error(p, "`ProcessExt::kill_with` should use `convert_signal`"); + errors += 1; + } + } + } + } + errors +} + +pub fn check_signals(content: &str, p: &Path) -> TestResult { + let mut lines = content.lines(); + let mut res = TestResult { + nb_tests: 0, + nb_errors: 0, + }; + + while let Some(line) = lines.next() { + let trimmed = line.trim(); + if trimmed.starts_with("impl SystemExt for System {") { + res.nb_tests += 1; + res.nb_errors += check_supported_signals_decl(&mut lines, p); + } else if trimmed.starts_with("impl ProcessExt for Process {") { + res.nb_tests += 1; + res.nb_errors += check_kill_decl(&mut lines, p); + } + } + res +} diff --git a/vendor/sysinfo/tests/code_checkers/utils.rs b/vendor/sysinfo/tests/code_checkers/utils.rs new file mode 100644 index 000000000..dadbc0a54 --- /dev/null +++ b/vendor/sysinfo/tests/code_checkers/utils.rs @@ -0,0 +1,49 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use std::fs::{self, File}; +use std::io::Read; +use std::path::Path; + +pub struct TestResult { + pub nb_tests: usize, + pub nb_errors: usize, +} + +impl std::ops::AddAssign for TestResult { + fn add_assign(&mut self, other: Self) { + self.nb_tests += other.nb_tests; + self.nb_errors += other.nb_errors; + } +} + +pub fn read_dirs<P: AsRef<Path>, F: FnMut(&Path, &str)>(dirs: &[P], callback: &mut F) { + for dir in dirs { + read_dir(dir, callback); + } +} + +fn read_dir<P: AsRef<Path>, F: FnMut(&Path, &str)>(dir: P, callback: &mut F) { + for entry in fs::read_dir(dir).expect("read_dir failed") { + let entry = entry.expect("entry failed"); + let path = entry.path(); + if path.is_dir() { + read_dir(path, callback); + } else { + let content = read_file(&path); + callback(&path, &content); + } + } +} + +fn read_file<P: AsRef<Path>>(p: P) -> String { + let mut f = File::open(p).expect("read_file::open failed"); + let mut content = + String::with_capacity(f.metadata().map(|m| m.len() as usize + 1).unwrap_or(0)); + f.read_to_string(&mut content) + .expect("read_file::read_to_end failed"); + content +} + +pub fn show_error(p: &Path, err: &str) { + eprintln!("=> [{}]: {}", p.display(), err); +} diff --git a/vendor/sysinfo/tests/cpu.rs b/vendor/sysinfo/tests/cpu.rs new file mode 100644 index 000000000..fbeb65b81 --- /dev/null +++ b/vendor/sysinfo/tests/cpu.rs @@ -0,0 +1,32 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +// This test is used to ensure that the CPUs are not loaded by default. + +#[test] +fn test_cpu() { + use sysinfo::{CpuExt, SystemExt}; + + if sysinfo::System::IS_SUPPORTED { + let mut s = sysinfo::System::new(); + assert!(s.cpus().is_empty()); + s.refresh_cpu(); + assert!(!s.cpus().is_empty()); + + let s = sysinfo::System::new_all(); + assert!(!s.cpus().is_empty()); + + assert!(!s.cpus()[0].brand().chars().any(|c| c == '\0')); + } +} + +#[test] +fn test_physical_core_numbers() { + use sysinfo::SystemExt; + + if sysinfo::System::IS_SUPPORTED { + let s = sysinfo::System::new(); + let count = s.physical_core_count(); + assert_ne!(count, None); + assert!(count.unwrap() > 0); + } +} diff --git a/vendor/sysinfo/tests/disk_list.rs b/vendor/sysinfo/tests/disk_list.rs new file mode 100644 index 000000000..164d5b931 --- /dev/null +++ b/vendor/sysinfo/tests/disk_list.rs @@ -0,0 +1,14 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#[test] +fn test_disks() { + use sysinfo::SystemExt; + + if sysinfo::System::IS_SUPPORTED { + let s = sysinfo::System::new_all(); + // If we don't have any physical core present, it's very likely that we're inside a VM... + if s.physical_core_count().unwrap_or_default() > 0 { + assert!(!s.disks().is_empty()); + } + } +} diff --git a/vendor/sysinfo/tests/extras.rs b/vendor/sysinfo/tests/extras.rs new file mode 100644 index 000000000..140dd1131 --- /dev/null +++ b/vendor/sysinfo/tests/extras.rs @@ -0,0 +1,3 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +mod code_checkers; diff --git a/vendor/sysinfo/tests/network.rs b/vendor/sysinfo/tests/network.rs new file mode 100644 index 000000000..6925cb3c8 --- /dev/null +++ b/vendor/sysinfo/tests/network.rs @@ -0,0 +1,15 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +// This test is used to ensure that the networks are not loaded by default. + +#[test] +fn test_networks() { + use sysinfo::{NetworksExt, SystemExt}; + + if sysinfo::System::IS_SUPPORTED { + let s = sysinfo::System::new(); + assert_eq!(s.networks().iter().count(), 0); + let s = sysinfo::System::new_all(); + assert!(s.networks().iter().count() > 0); + } +} diff --git a/vendor/sysinfo/tests/process.rs b/vendor/sysinfo/tests/process.rs new file mode 100644 index 000000000..6745fc444 --- /dev/null +++ b/vendor/sysinfo/tests/process.rs @@ -0,0 +1,381 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use sysinfo::{Pid, PidExt, ProcessExt, SystemExt}; + +#[test] +fn test_process() { + let mut s = sysinfo::System::new(); + assert_eq!(s.processes().len(), 0); + s.refresh_processes(); + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + assert!(!s.processes().is_empty()); + #[cfg(not(windows))] + assert!(s + .processes() + .values() + .any(|p| !p.exe().to_str().unwrap_or("").is_empty())); +} + +#[test] +fn test_cwd() { + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + let mut p = if cfg!(target_os = "windows") { + std::process::Command::new("waitfor") + .arg("/t") + .arg("3") + .arg("CwdSignal") + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap() + } else { + std::process::Command::new("sleep") + .arg("3") + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap() + }; + + let pid = Pid::from_u32(p.id() as u32); + std::thread::sleep(std::time::Duration::from_secs(1)); + let mut s = sysinfo::System::new(); + s.refresh_processes(); + p.kill().expect("Unable to kill process."); + + let processes = s.processes(); + let p = processes.get(&pid); + + if let Some(p) = p { + assert_eq!(p.pid(), pid); + assert_eq!(p.cwd(), std::env::current_dir().unwrap()); + } else { + panic!("Process not found!"); + } +} + +#[test] +fn test_cmd() { + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + let mut p = if cfg!(target_os = "windows") { + std::process::Command::new("waitfor") + .arg("/t") + .arg("3") + .arg("CmdSignal") + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap() + } else { + std::process::Command::new("sleep") + .arg("3") + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap() + }; + std::thread::sleep(std::time::Duration::from_millis(500)); + let mut s = sysinfo::System::new(); + assert!(s.processes().is_empty()); + 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 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. + assert!(process.cmd()[0].contains("waitfor")); + assert_eq!(&process.cmd()[1..], &["/t", "3", "CmdSignal"]); + } else { + assert_eq!(process.cmd(), &["sleep", "3"]); + } + } else { + panic!("Process not found!"); + } +} + +#[test] +fn test_environ() { + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + let mut p = if cfg!(target_os = "windows") { + std::process::Command::new("waitfor") + .arg("/t") + .arg("3") + .arg("EnvironSignal") + .stdout(std::process::Stdio::null()) + .env("FOO", "BAR") + .env("OTHER", "VALUE") + .spawn() + .unwrap() + } else { + std::process::Command::new("sleep") + .arg("3") + .stdout(std::process::Stdio::null()) + .env("FOO", "BAR") + .env("OTHER", "VALUE") + .spawn() + .unwrap() + }; + + let pid = Pid::from_u32(p.id() as u32); + std::thread::sleep(std::time::Duration::from_secs(1)); + let mut s = sysinfo::System::new(); + s.refresh_processes(); + p.kill().expect("Unable to kill process."); + + let processes = s.processes(); + let p = processes.get(&pid); + + if let Some(p) = p { + assert_eq!(p.pid(), pid); + // FIXME: instead of ignoring the test on CI, try to find out what's wrong... + if std::env::var("APPLE_CI").is_err() { + assert!(p.environ().iter().any(|e| e == "FOO=BAR")); + assert!(p.environ().iter().any(|e| e == "OTHER=VALUE")); + } + } else { + panic!("Process not found!"); + } +} + +#[test] +fn test_process_refresh() { + let mut s = sysinfo::System::new(); + assert_eq!(s.processes().len(), 0); + + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + s.refresh_process(sysinfo::get_current_pid().expect("failed to get current pid")); + assert!(s + .process(sysinfo::get_current_pid().expect("failed to get current pid")) + .is_some(),); +} + +#[test] +fn test_process_disk_usage() { + use std::fs; + use std::fs::File; + use std::io::prelude::*; + use sysinfo::{get_current_pid, ProcessExt, SystemExt}; + + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + if std::env::var("FREEBSD_CI").is_ok() { + // For an unknown reason, when running this test on Cirrus CI, it fails. It works perfectly + // locally though... Dark magic... + return; + } + + fn inner() -> sysinfo::System { + { + let mut file = File::create("test.txt").expect("failed to create file"); + file.write_all(b"This is a test file\nwith test data.\n") + .expect("failed to write to file"); + } + fs::remove_file("test.txt").expect("failed to remove file"); + // Waiting a bit just in case... + std::thread::sleep(std::time::Duration::from_millis(250)); + let mut system = sysinfo::System::new(); + assert!(system.processes().is_empty()); + system.refresh_processes(); + assert!(!system.processes().is_empty()); + system + } + + let mut system = inner(); + let mut p = system + .process(get_current_pid().expect("Failed retrieving current pid.")) + .expect("failed to get process"); + + if cfg!(any(target_os = "macos", target_os = "ios")) && p.disk_usage().total_written_bytes == 0 + { + // For whatever reason, sometimes, mac doesn't work on the first time when running + // `cargo test`. Two solutions, either run with "cargo test -- --test-threads 1", or + // check twice... + system = inner(); + p = system + .process(get_current_pid().expect("Failed retrieving current pid.")) + .expect("failed to get process"); + } + + assert!( + p.disk_usage().total_written_bytes > 0, + "found {} total written bytes...", + p.disk_usage().total_written_bytes + ); + assert!( + p.disk_usage().written_bytes > 0, + "found {} written bytes...", + p.disk_usage().written_bytes + ); +} + +#[test] +fn cpu_usage_is_not_nan() { + let mut system = sysinfo::System::new(); + system.refresh_processes(); + + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + + let first_pids = system + .processes() + .iter() + .take(10) + .map(|(&pid, _)| pid) + .collect::<Vec<_>>(); + let mut checked = 0; + + first_pids.into_iter().for_each(|pid| { + system.refresh_process(pid); + if let Some(p) = system.process(pid) { + assert!(!p.cpu_usage().is_nan()); + checked += 1; + } + }); + assert!(checked > 0); +} + +#[test] +fn test_process_times() { + use std::time::{SystemTime, UNIX_EPOCH}; + + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + let mut p = if cfg!(target_os = "windows") { + std::process::Command::new("waitfor") + .arg("/t") + .arg("3") + .arg("ProcessTimes") + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap() + } else { + std::process::Command::new("sleep") + .arg("3") + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap() + }; + + let pid = Pid::from_u32(p.id() as u32); + std::thread::sleep(std::time::Duration::from_secs(1)); + let mut s = sysinfo::System::new(); + s.refresh_processes(); + p.kill().expect("Unable to kill process."); + + if let Some(p) = s.process(pid) { + assert_eq!(p.pid(), pid); + assert!(p.run_time() >= 1); + assert!(p.run_time() <= 2); + assert!(p.start_time() > p.run_time()); + // On linux, for whatever reason, the uptime seems to be older than the boot time, leading + // to this weird `+ 3` to ensure the test is passing as it should... + assert!( + p.start_time() + 3 + > SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_secs(), + ); + assert!(p.start_time() >= s.boot_time()); + } else { + panic!("Process not found!"); + } +} + +// Checks that `refresh_processes` is removing dead processes. +#[test] +fn test_refresh_processes() { + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + let mut p = if cfg!(target_os = "windows") { + std::process::Command::new("waitfor") + .arg("/t") + .arg("300") + .arg("RefreshProcesses") + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap() + } else { + std::process::Command::new("sleep") + .arg("300") + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap() + }; + + let pid = Pid::from_u32(p.id() as u32); + std::thread::sleep(std::time::Duration::from_secs(1)); + + // Checks that the process is listed as it should. + let mut s = sysinfo::System::new(); + s.refresh_processes(); + assert!(s.process(pid).is_some()); + + // Check that the process name is not empty. + assert!(!s.process(pid).unwrap().name().is_empty()); + + p.kill().expect("Unable to kill process."); + // We need this, otherwise the process will still be around as a zombie on linux. + let _ = p.wait(); + // Let's give some time to the system to clean up... + std::thread::sleep(std::time::Duration::from_secs(1)); + + s.refresh_processes(); + // Checks that the process isn't listed anymore. + assert!(s.process(pid).is_none()); +} + +// Checks that `refresh_process` is NOT removing dead processes. +#[test] +fn test_refresh_process() { + if !sysinfo::System::IS_SUPPORTED || cfg!(feature = "apple-sandbox") { + return; + } + let mut 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 pid = Pid::from_u32(p.id() as u32); + std::thread::sleep(std::time::Duration::from_secs(1)); + + // Checks that the process is listed as it should. + let mut s = sysinfo::System::new(); + s.refresh_process(pid); + assert!(s.process(pid).is_some()); + + // Check that the process name is not empty. + assert!(!s.process(pid).unwrap().name().is_empty()); + + p.kill().expect("Unable to kill process."); + // We need this, otherwise the process will still be around as a zombie on linux. + let _ = p.wait(); + // Let's give some time to the system to clean up... + std::thread::sleep(std::time::Duration::from_secs(1)); + + assert!(!s.refresh_process(pid)); + // Checks that the process is still listed. + assert!(s.process(pid).is_some()); +} diff --git a/vendor/sysinfo/tests/send_sync.rs b/vendor/sysinfo/tests/send_sync.rs new file mode 100644 index 000000000..1f8cc192c --- /dev/null +++ b/vendor/sysinfo/tests/send_sync.rs @@ -0,0 +1,10 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#[test] +fn test_send_sync() { + fn is_send<T: Send>() {} + fn is_sync<T: Sync>() {} + + is_send::<sysinfo::System>(); + is_sync::<sysinfo::System>(); +} diff --git a/vendor/sysinfo/tests/uptime.rs b/vendor/sysinfo/tests/uptime.rs new file mode 100644 index 000000000..d5eae7323 --- /dev/null +++ b/vendor/sysinfo/tests/uptime.rs @@ -0,0 +1,12 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +#[test] +fn test_uptime() { + use sysinfo::SystemExt; + + if sysinfo::System::IS_SUPPORTED { + let mut s = sysinfo::System::new(); + s.refresh_all(); + assert!(s.uptime() != 0); + } +} |