2023-01-02 16:00:42 -05:00
|
|
|
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
|
2020-09-05 20:34:02 -04:00
|
|
|
|
2021-04-06 04:33:43 -04:00
|
|
|
use super::utils::into_string;
|
2023-01-07 11:25:34 -05:00
|
|
|
use crate::permissions::PermissionsContainer;
|
2022-06-08 11:45:38 -04:00
|
|
|
use crate::worker::ExitCode;
|
2021-04-06 04:33:43 -04:00
|
|
|
use deno_core::error::{type_error, AnyError};
|
2022-12-17 17:25:51 -05:00
|
|
|
use deno_core::op;
|
2020-09-16 14:28:07 -04:00
|
|
|
use deno_core::url::Url;
|
2022-12-17 17:25:51 -05:00
|
|
|
use deno_core::v8;
|
2021-05-02 19:22:57 -04:00
|
|
|
use deno_core::Extension;
|
2022-12-17 17:25:51 -05:00
|
|
|
use deno_core::ExtensionBuilder;
|
2020-09-10 09:57:45 -04:00
|
|
|
use deno_core::OpState;
|
2022-09-14 11:59:20 -04:00
|
|
|
use deno_node::NODE_ENV_VAR_ALLOWLIST;
|
2022-12-17 17:25:51 -05:00
|
|
|
use serde::Serialize;
|
2019-08-23 01:30:14 -04:00
|
|
|
use std::collections::HashMap;
|
|
|
|
use std::env;
|
2019-08-14 11:03:02 -04:00
|
|
|
|
2022-11-02 03:17:00 -04:00
|
|
|
mod sys_info;
|
|
|
|
|
2022-06-13 17:53:04 -04:00
|
|
|
fn init_ops(builder: &mut ExtensionBuilder) -> &mut ExtensionBuilder {
|
|
|
|
builder.ops(vec![
|
|
|
|
op_env::decl(),
|
|
|
|
op_exec_path::decl(),
|
|
|
|
op_exit::decl(),
|
|
|
|
op_delete_env::decl(),
|
|
|
|
op_get_env::decl(),
|
2022-10-26 16:37:48 -04:00
|
|
|
op_gid::decl(),
|
2022-06-13 17:53:04 -04:00
|
|
|
op_hostname::decl(),
|
|
|
|
op_loadavg::decl(),
|
|
|
|
op_network_interfaces::decl(),
|
|
|
|
op_os_release::decl(),
|
2022-12-26 18:16:12 -05:00
|
|
|
op_os_uptime::decl(),
|
2022-12-28 08:56:05 -05:00
|
|
|
op_node_unstable_os_uptime::decl(),
|
2022-06-13 17:53:04 -04:00
|
|
|
op_set_env::decl(),
|
|
|
|
op_set_exit_code::decl(),
|
|
|
|
op_system_memory_info::decl(),
|
2022-10-26 16:37:48 -04:00
|
|
|
op_uid::decl(),
|
2022-12-17 17:25:51 -05:00
|
|
|
op_runtime_memory_usage::decl(),
|
2022-06-13 17:53:04 -04:00
|
|
|
])
|
|
|
|
}
|
|
|
|
|
2022-06-08 11:45:38 -04:00
|
|
|
pub fn init(exit_code: ExitCode) -> Extension {
|
2023-01-08 17:48:46 -05:00
|
|
|
let mut builder = Extension::builder("deno_os");
|
2022-06-13 17:53:04 -04:00
|
|
|
init_ops(&mut builder)
|
2021-12-11 09:56:45 -05:00
|
|
|
.state(move |state| {
|
2022-06-08 11:45:38 -04:00
|
|
|
state.put::<ExitCode>(exit_code.clone());
|
2021-12-11 09:56:45 -05:00
|
|
|
Ok(())
|
|
|
|
})
|
2021-05-02 19:22:57 -04:00
|
|
|
.build()
|
2019-08-14 11:03:02 -04:00
|
|
|
}
|
|
|
|
|
2022-06-13 17:53:04 -04:00
|
|
|
pub fn init_for_worker() -> Extension {
|
2023-01-08 17:48:46 -05:00
|
|
|
let mut builder = Extension::builder("deno_os_worker");
|
2022-06-13 17:53:04 -04:00
|
|
|
init_ops(&mut builder)
|
|
|
|
.middleware(|op| match op.name {
|
|
|
|
"op_exit" => noop_op::decl(),
|
|
|
|
"op_set_exit_code" => noop_op::decl(),
|
|
|
|
_ => op,
|
|
|
|
})
|
|
|
|
.build()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[op]
|
2022-07-26 13:34:08 -04:00
|
|
|
fn noop_op() -> Result<(), AnyError> {
|
2022-06-13 17:53:04 -04:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-03-14 18:38:53 -04:00
|
|
|
fn op_exec_path(state: &mut OpState) -> Result<String, AnyError> {
|
2019-08-23 01:30:14 -04:00
|
|
|
let current_exe = env::current_exe().unwrap();
|
2023-01-07 11:25:34 -05:00
|
|
|
state
|
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_read_blind(¤t_exe, "exec_path", "Deno.execPath()")?;
|
2019-08-23 01:30:14 -04:00
|
|
|
// Now apply URL parser to current exe to get fully resolved path, otherwise
|
|
|
|
// we might get `./` and `../` bits in `exec_path`
|
2019-08-14 11:03:02 -04:00
|
|
|
let exe_url = Url::from_file_path(current_exe).unwrap();
|
2019-08-23 01:30:14 -04:00
|
|
|
let path = exe_url.to_file_path().unwrap();
|
2021-04-05 12:40:24 -04:00
|
|
|
|
|
|
|
into_string(path.into_os_string())
|
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2019-10-11 14:41:54 -04:00
|
|
|
fn op_set_env(
|
2020-09-10 09:57:45 -04:00
|
|
|
state: &mut OpState,
|
2022-12-15 10:26:10 -05:00
|
|
|
key: String,
|
|
|
|
value: String,
|
2021-04-05 12:40:24 -04:00
|
|
|
) -> Result<(), AnyError> {
|
2023-01-07 11:25:34 -05:00
|
|
|
state.borrow_mut::<PermissionsContainer>().check_env(&key)?;
|
2022-09-21 02:18:58 -04:00
|
|
|
if key.is_empty() {
|
|
|
|
return Err(type_error("Key is an empty string."));
|
|
|
|
}
|
|
|
|
if key.contains(&['=', '\0'] as &[char]) {
|
|
|
|
return Err(type_error(format!(
|
|
|
|
"Key contains invalid characters: {:?}",
|
|
|
|
key
|
|
|
|
)));
|
|
|
|
}
|
|
|
|
if value.contains('\0') {
|
|
|
|
return Err(type_error(format!(
|
|
|
|
"Value contains invalid characters: {:?}",
|
|
|
|
value
|
|
|
|
)));
|
2021-02-23 04:24:59 -05:00
|
|
|
}
|
2021-10-05 16:38:27 -04:00
|
|
|
env::set_var(key, value);
|
2021-04-05 12:40:24 -04:00
|
|
|
Ok(())
|
2019-08-14 11:03:02 -04:00
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-03-14 18:38:53 -04:00
|
|
|
fn op_env(state: &mut OpState) -> Result<HashMap<String, String>, AnyError> {
|
2023-01-07 11:25:34 -05:00
|
|
|
state.borrow_mut::<PermissionsContainer>().check_env_all()?;
|
2021-04-05 12:40:24 -04:00
|
|
|
Ok(env::vars().collect())
|
2019-10-02 11:55:28 -04:00
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2019-10-11 14:41:54 -04:00
|
|
|
fn op_get_env(
|
2020-09-10 09:57:45 -04:00
|
|
|
state: &mut OpState,
|
2021-04-05 12:40:24 -04:00
|
|
|
key: String,
|
|
|
|
) -> Result<Option<String>, AnyError> {
|
2022-11-11 11:04:57 -05:00
|
|
|
let skip_permission_check = NODE_ENV_VAR_ALLOWLIST.contains(&key);
|
2022-09-14 11:59:20 -04:00
|
|
|
|
|
|
|
if !skip_permission_check {
|
2023-01-07 11:25:34 -05:00
|
|
|
state.borrow_mut::<PermissionsContainer>().check_env(&key)?;
|
2022-09-14 11:59:20 -04:00
|
|
|
}
|
|
|
|
|
2022-09-21 02:18:58 -04:00
|
|
|
if key.is_empty() {
|
|
|
|
return Err(type_error("Key is an empty string."));
|
2021-02-23 04:24:59 -05:00
|
|
|
}
|
2022-09-21 02:18:58 -04:00
|
|
|
|
|
|
|
if key.contains(&['=', '\0'] as &[char]) {
|
|
|
|
return Err(type_error(format!(
|
|
|
|
"Key contains invalid characters: {:?}",
|
|
|
|
key
|
|
|
|
)));
|
|
|
|
}
|
|
|
|
|
2021-04-05 12:40:24 -04:00
|
|
|
let r = match env::var(key) {
|
|
|
|
Err(env::VarError::NotPresent) => None,
|
|
|
|
v => Some(v?),
|
2019-10-02 11:55:28 -04:00
|
|
|
};
|
2020-08-28 11:08:24 -04:00
|
|
|
Ok(r)
|
2019-10-02 11:55:28 -04:00
|
|
|
}
|
2021-04-13 07:25:21 -04:00
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-03-14 18:38:53 -04:00
|
|
|
fn op_delete_env(state: &mut OpState, key: String) -> Result<(), AnyError> {
|
2023-01-07 11:25:34 -05:00
|
|
|
state.borrow_mut::<PermissionsContainer>().check_env(&key)?;
|
2021-04-05 12:40:24 -04:00
|
|
|
if key.is_empty() || key.contains(&['=', '\0'] as &[char]) {
|
2021-02-23 04:24:59 -05:00
|
|
|
return Err(type_error("Key contains invalid characters."));
|
|
|
|
}
|
2021-04-05 12:40:24 -04:00
|
|
|
env::remove_var(key);
|
|
|
|
Ok(())
|
2019-08-14 11:03:02 -04:00
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-05-13 04:36:31 -04:00
|
|
|
fn op_set_exit_code(state: &mut OpState, code: i32) {
|
2022-06-08 11:45:38 -04:00
|
|
|
state.borrow_mut::<ExitCode>().set(code);
|
2021-11-27 18:45:38 -05:00
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-05-13 04:36:31 -04:00
|
|
|
fn op_exit(state: &mut OpState) {
|
2022-06-08 11:45:38 -04:00
|
|
|
let code = state.borrow::<ExitCode>().get();
|
2021-04-05 12:40:24 -04:00
|
|
|
std::process::exit(code)
|
2019-08-14 11:03:02 -04:00
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-03-14 18:38:53 -04:00
|
|
|
fn op_loadavg(state: &mut OpState) -> Result<(f64, f64, f64), AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("loadavg", "Deno.loadavg()")?;
|
2022-11-02 03:17:00 -04:00
|
|
|
Ok(sys_info::loadavg())
|
2020-02-22 18:46:52 -05:00
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-03-14 18:38:53 -04:00
|
|
|
fn op_hostname(state: &mut OpState) -> Result<String, AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("hostname", "Deno.hostname()")?;
|
2022-11-02 03:17:00 -04:00
|
|
|
Ok(sys_info::hostname())
|
2019-09-27 19:09:42 -04:00
|
|
|
}
|
2020-02-24 08:35:45 -05:00
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-03-14 18:38:53 -04:00
|
|
|
fn op_os_release(state: &mut OpState) -> Result<String, AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("osRelease", "Deno.osRelease()")?;
|
2022-11-02 03:17:00 -04:00
|
|
|
Ok(sys_info::os_release())
|
2021-04-05 12:40:24 -04:00
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2021-12-22 18:00:43 -05:00
|
|
|
fn op_network_interfaces(
|
|
|
|
state: &mut OpState,
|
|
|
|
) -> Result<Vec<NetworkInterface>, AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("networkInterfaces", "Deno.networkInterfaces()")?;
|
2021-12-22 18:00:43 -05:00
|
|
|
Ok(netif::up()?.map(NetworkInterface::from).collect())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(serde::Serialize)]
|
|
|
|
struct NetworkInterface {
|
|
|
|
family: &'static str,
|
|
|
|
name: String,
|
|
|
|
address: String,
|
|
|
|
netmask: String,
|
|
|
|
scopeid: Option<u32>,
|
|
|
|
cidr: String,
|
|
|
|
mac: String,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<netif::Interface> for NetworkInterface {
|
|
|
|
fn from(ifa: netif::Interface) -> Self {
|
|
|
|
let family = match ifa.address() {
|
|
|
|
std::net::IpAddr::V4(_) => "IPv4",
|
|
|
|
std::net::IpAddr::V6(_) => "IPv6",
|
|
|
|
};
|
|
|
|
|
|
|
|
let (address, range) = ifa.cidr();
|
|
|
|
let cidr = format!("{:?}/{}", address, range);
|
|
|
|
|
|
|
|
let name = ifa.name().to_owned();
|
|
|
|
let address = format!("{:?}", ifa.address());
|
|
|
|
let netmask = format!("{:?}", ifa.netmask());
|
|
|
|
let scopeid = ifa.scope_id();
|
|
|
|
|
|
|
|
let [b0, b1, b2, b3, b4, b5] = ifa.mac();
|
|
|
|
let mac = format!(
|
|
|
|
"{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
|
|
|
|
b0, b1, b2, b3, b4, b5
|
|
|
|
);
|
|
|
|
|
|
|
|
Self {
|
|
|
|
family,
|
|
|
|
name,
|
|
|
|
address,
|
|
|
|
netmask,
|
|
|
|
scopeid,
|
|
|
|
cidr,
|
|
|
|
mac,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2020-09-10 04:38:17 -04:00
|
|
|
fn op_system_memory_info(
|
2020-09-10 09:57:45 -04:00
|
|
|
state: &mut OpState,
|
2022-11-02 03:17:00 -04:00
|
|
|
) -> Result<Option<sys_info::MemInfo>, AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("systemMemoryInfo", "Deno.systemMemoryInfo()")?;
|
2022-11-02 03:17:00 -04:00
|
|
|
Ok(sys_info::mem_info())
|
2020-09-10 04:38:17 -04:00
|
|
|
}
|
2022-01-31 00:44:19 -05:00
|
|
|
|
2022-05-31 04:42:44 -04:00
|
|
|
#[cfg(not(windows))]
|
|
|
|
#[op]
|
2022-10-26 16:37:48 -04:00
|
|
|
fn op_gid(state: &mut OpState) -> Result<Option<u32>, AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("gid", "Deno.gid()")?;
|
2022-06-25 18:13:24 -04:00
|
|
|
// TODO(bartlomieju):
|
|
|
|
#[allow(clippy::undocumented_unsafe_blocks)]
|
|
|
|
unsafe {
|
|
|
|
Ok(Some(libc::getgid()))
|
|
|
|
}
|
2022-05-31 04:42:44 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(windows)]
|
|
|
|
#[op]
|
2022-10-26 16:37:48 -04:00
|
|
|
fn op_gid(state: &mut OpState) -> Result<Option<u32>, AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("gid", "Deno.gid()")?;
|
2022-05-31 04:42:44 -04:00
|
|
|
Ok(None)
|
|
|
|
}
|
|
|
|
|
2022-01-31 00:44:19 -05:00
|
|
|
#[cfg(not(windows))]
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-10-26 16:37:48 -04:00
|
|
|
fn op_uid(state: &mut OpState) -> Result<Option<u32>, AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("uid", "Deno.uid()")?;
|
2022-06-25 18:13:24 -04:00
|
|
|
// TODO(bartlomieju):
|
|
|
|
#[allow(clippy::undocumented_unsafe_blocks)]
|
|
|
|
unsafe {
|
|
|
|
Ok(Some(libc::getuid()))
|
|
|
|
}
|
2022-01-31 00:44:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(windows)]
|
2022-03-14 13:44:15 -04:00
|
|
|
#[op]
|
2022-10-26 16:37:48 -04:00
|
|
|
fn op_uid(state: &mut OpState) -> Result<Option<u32>, AnyError> {
|
2022-09-28 08:46:50 -04:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("uid", "Deno.uid()")?;
|
2022-01-31 00:44:19 -05:00
|
|
|
Ok(None)
|
|
|
|
}
|
2022-12-17 17:25:51 -05:00
|
|
|
|
|
|
|
// HeapStats stores values from a isolate.get_heap_statistics() call
|
|
|
|
#[derive(Serialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
struct MemoryUsage {
|
|
|
|
rss: usize,
|
|
|
|
heap_total: usize,
|
|
|
|
heap_used: usize,
|
|
|
|
external: usize,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[op(v8)]
|
|
|
|
fn op_runtime_memory_usage(scope: &mut v8::HandleScope) -> MemoryUsage {
|
|
|
|
let mut s = v8::HeapStatistics::default();
|
|
|
|
scope.get_heap_statistics(&mut s);
|
|
|
|
MemoryUsage {
|
|
|
|
rss: rss(),
|
|
|
|
heap_total: s.total_heap_size(),
|
|
|
|
heap_used: s.used_heap_size(),
|
|
|
|
external: s.external_memory(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(target_os = "linux")]
|
|
|
|
fn rss() -> usize {
|
|
|
|
// Inspired by https://github.com/Arc-blroth/memory-stats/blob/5364d0d09143de2a470d33161b2330914228fde9/src/linux.rs
|
|
|
|
|
|
|
|
// Extracts a positive integer from a string that
|
|
|
|
// may contain leading spaces and trailing chars.
|
|
|
|
// Returns the extracted number and the index of
|
|
|
|
// the next character in the string.
|
|
|
|
fn scan_int(string: &str) -> (usize, usize) {
|
|
|
|
let mut out = 0;
|
|
|
|
let mut idx = 0;
|
|
|
|
let mut chars = string.chars().peekable();
|
|
|
|
while let Some(' ') = chars.next_if_eq(&' ') {
|
|
|
|
idx += 1;
|
|
|
|
}
|
|
|
|
for n in chars {
|
|
|
|
idx += 1;
|
|
|
|
if ('0'..='9').contains(&n) {
|
|
|
|
out *= 10;
|
|
|
|
out += n as usize - '0' as usize;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
(out, idx)
|
|
|
|
}
|
|
|
|
|
|
|
|
let statm_content = if let Ok(c) = std::fs::read_to_string("/proc/self/statm")
|
|
|
|
{
|
|
|
|
c
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
// statm returns the virtual size and rss, in
|
|
|
|
// multiples of the page size, as the first
|
|
|
|
// two columns of output.
|
|
|
|
// SAFETY: libc call
|
|
|
|
let page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) };
|
|
|
|
|
|
|
|
if page_size < 0 {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
let (_total_size_pages, idx) = scan_int(&statm_content);
|
|
|
|
let (total_rss_pages, _) = scan_int(&statm_content[idx..]);
|
|
|
|
|
|
|
|
total_rss_pages * page_size as usize
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(target_os = "macos")]
|
|
|
|
fn rss() -> usize {
|
|
|
|
// Inspired by https://github.com/Arc-blroth/memory-stats/blob/5364d0d09143de2a470d33161b2330914228fde9/src/darwin.rs
|
|
|
|
|
|
|
|
let mut task_info =
|
|
|
|
std::mem::MaybeUninit::<libc::mach_task_basic_info_data_t>::uninit();
|
|
|
|
let mut count = libc::MACH_TASK_BASIC_INFO_COUNT;
|
|
|
|
// SAFETY: libc calls
|
|
|
|
let r = unsafe {
|
|
|
|
libc::task_info(
|
|
|
|
libc::mach_task_self(),
|
|
|
|
libc::MACH_TASK_BASIC_INFO,
|
|
|
|
task_info.as_mut_ptr() as libc::task_info_t,
|
|
|
|
&mut count as *mut libc::mach_msg_type_number_t,
|
|
|
|
)
|
|
|
|
};
|
|
|
|
// According to libuv this should never fail
|
|
|
|
assert_eq!(r, libc::KERN_SUCCESS);
|
|
|
|
// SAFETY: we just asserted that it was success
|
|
|
|
let task_info = unsafe { task_info.assume_init() };
|
|
|
|
task_info.resident_size as usize
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(windows)]
|
|
|
|
fn rss() -> usize {
|
|
|
|
use winapi::shared::minwindef::DWORD;
|
|
|
|
use winapi::shared::minwindef::FALSE;
|
|
|
|
use winapi::um::processthreadsapi::GetCurrentProcess;
|
|
|
|
use winapi::um::psapi::GetProcessMemoryInfo;
|
|
|
|
use winapi::um::psapi::PROCESS_MEMORY_COUNTERS;
|
|
|
|
|
|
|
|
// SAFETY: winapi calls
|
|
|
|
unsafe {
|
|
|
|
// this handle is a constant—no need to close it
|
|
|
|
let current_process = GetCurrentProcess();
|
|
|
|
let mut pmc: PROCESS_MEMORY_COUNTERS = std::mem::zeroed();
|
|
|
|
|
|
|
|
if GetProcessMemoryInfo(
|
|
|
|
current_process,
|
|
|
|
&mut pmc,
|
|
|
|
std::mem::size_of::<PROCESS_MEMORY_COUNTERS>() as DWORD,
|
|
|
|
) != FALSE
|
|
|
|
{
|
|
|
|
pmc.WorkingSetSize
|
|
|
|
} else {
|
|
|
|
0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-12-26 18:16:12 -05:00
|
|
|
|
2022-12-28 08:56:05 -05:00
|
|
|
fn os_uptime(state: &mut OpState) -> Result<u64, AnyError> {
|
2022-12-26 18:16:12 -05:00
|
|
|
state
|
2023-01-07 11:25:34 -05:00
|
|
|
.borrow_mut::<PermissionsContainer>()
|
|
|
|
.check_sys("osUptime", "Deno.osUptime()")?;
|
2022-12-26 18:16:12 -05:00
|
|
|
Ok(sys_info::os_uptime())
|
|
|
|
}
|
2022-12-28 08:56:05 -05:00
|
|
|
|
|
|
|
#[op]
|
|
|
|
fn op_os_uptime(state: &mut OpState) -> Result<u64, AnyError> {
|
|
|
|
super::check_unstable(state, "Deno.osUptime");
|
|
|
|
os_uptime(state)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[op]
|
|
|
|
fn op_node_unstable_os_uptime(state: &mut OpState) -> Result<u64, AnyError> {
|
|
|
|
os_uptime(state)
|
|
|
|
}
|