2015-07-12 18:47:43 +00:00
|
|
|
/*
|
|
|
|
htop - darwin/Platform.c
|
|
|
|
(C) 2014 Hisham H. Muhammad
|
|
|
|
(C) 2015 David C. Hunt
|
2020-10-05 07:51:32 +00:00
|
|
|
Released under the GNU GPLv2, see the COPYING file
|
2015-07-12 18:47:43 +00:00
|
|
|
in the source distribution for its full text.
|
|
|
|
*/
|
|
|
|
|
2020-12-12 19:43:08 +00:00
|
|
|
#include "config.h" // IWYU pragma: keep
|
|
|
|
|
2015-07-12 18:47:43 +00:00
|
|
|
#include "Platform.h"
|
2020-12-12 19:41:19 +00:00
|
|
|
|
|
|
|
#include <math.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
|
|
#include <CoreFoundation/CFString.h>
|
|
|
|
#include <IOKit/ps/IOPowerSources.h>
|
|
|
|
#include <IOKit/ps/IOPSKeys.h>
|
|
|
|
|
2015-07-12 18:47:43 +00:00
|
|
|
#include "ClockMeter.h"
|
2020-12-12 19:41:19 +00:00
|
|
|
#include "CPUMeter.h"
|
|
|
|
#include "DarwinProcessList.h"
|
2020-10-05 11:52:58 +00:00
|
|
|
#include "DateMeter.h"
|
|
|
|
#include "DateTimeMeter.h"
|
2015-07-12 18:47:43 +00:00
|
|
|
#include "HostnameMeter.h"
|
2020-12-12 19:41:19 +00:00
|
|
|
#include "LoadAverageMeter.h"
|
|
|
|
#include "Macros.h"
|
|
|
|
#include "MemoryMeter.h"
|
2020-11-11 21:15:35 +00:00
|
|
|
#include "ProcessLocksScreen.h"
|
2020-12-12 19:41:19 +00:00
|
|
|
#include "SwapMeter.h"
|
|
|
|
#include "TasksMeter.h"
|
2015-07-12 18:47:43 +00:00
|
|
|
#include "UptimeMeter.h"
|
2019-07-07 21:30:37 +00:00
|
|
|
#include "zfs/ZfsArcMeter.h"
|
2019-09-03 18:26:02 +00:00
|
|
|
#include "zfs/ZfsCompressedArcMeter.h"
|
2015-07-12 18:47:43 +00:00
|
|
|
|
2020-12-12 19:43:08 +00:00
|
|
|
#ifdef HAVE_MACH_MACH_TIME_H
|
|
|
|
#include <mach/mach_time.h>
|
|
|
|
#endif
|
2015-07-13 06:17:14 +00:00
|
|
|
|
2015-07-12 18:47:43 +00:00
|
|
|
|
2020-11-20 16:09:34 +00:00
|
|
|
ProcessField Platform_defaultFields[] = { PID, USER, PRIORITY, NICE, M_VIRT, M_RESIDENT, STATE, PERCENT_CPU, PERCENT_MEM, TIME, COMM, 0 };
|
2015-07-12 18:47:43 +00:00
|
|
|
|
2016-08-30 12:41:17 +00:00
|
|
|
const SignalItem Platform_signals[] = {
|
2015-10-06 16:03:47 +00:00
|
|
|
{ .name = " 0 Cancel", .number = 0 },
|
|
|
|
{ .name = " 1 SIGHUP", .number = 1 },
|
|
|
|
{ .name = " 2 SIGINT", .number = 2 },
|
|
|
|
{ .name = " 3 SIGQUIT", .number = 3 },
|
|
|
|
{ .name = " 4 SIGILL", .number = 4 },
|
|
|
|
{ .name = " 5 SIGTRAP", .number = 5 },
|
|
|
|
{ .name = " 6 SIGABRT", .number = 6 },
|
|
|
|
{ .name = " 6 SIGIOT", .number = 6 },
|
|
|
|
{ .name = " 7 SIGEMT", .number = 7 },
|
|
|
|
{ .name = " 8 SIGFPE", .number = 8 },
|
|
|
|
{ .name = " 9 SIGKILL", .number = 9 },
|
|
|
|
{ .name = "10 SIGBUS", .number = 10 },
|
|
|
|
{ .name = "11 SIGSEGV", .number = 11 },
|
|
|
|
{ .name = "12 SIGSYS", .number = 12 },
|
|
|
|
{ .name = "13 SIGPIPE", .number = 13 },
|
|
|
|
{ .name = "14 SIGALRM", .number = 14 },
|
|
|
|
{ .name = "15 SIGTERM", .number = 15 },
|
|
|
|
{ .name = "16 SIGURG", .number = 16 },
|
|
|
|
{ .name = "17 SIGSTOP", .number = 17 },
|
|
|
|
{ .name = "18 SIGTSTP", .number = 18 },
|
|
|
|
{ .name = "19 SIGCONT", .number = 19 },
|
|
|
|
{ .name = "20 SIGCHLD", .number = 20 },
|
|
|
|
{ .name = "21 SIGTTIN", .number = 21 },
|
|
|
|
{ .name = "22 SIGTTOU", .number = 22 },
|
|
|
|
{ .name = "23 SIGIO", .number = 23 },
|
|
|
|
{ .name = "24 SIGXCPU", .number = 24 },
|
|
|
|
{ .name = "25 SIGXFSZ", .number = 25 },
|
|
|
|
{ .name = "26 SIGVTALRM", .number = 26 },
|
|
|
|
{ .name = "27 SIGPROF", .number = 27 },
|
|
|
|
{ .name = "28 SIGWINCH", .number = 28 },
|
|
|
|
{ .name = "29 SIGINFO", .number = 29 },
|
|
|
|
{ .name = "30 SIGUSR1", .number = 30 },
|
|
|
|
{ .name = "31 SIGUSR2", .number = 31 },
|
|
|
|
};
|
|
|
|
|
2020-10-03 20:00:27 +00:00
|
|
|
const unsigned int Platform_numberOfSignals = ARRAYSIZE(Platform_signals);
|
2015-10-06 16:03:47 +00:00
|
|
|
|
2020-10-05 11:19:50 +00:00
|
|
|
const MeterClass* const Platform_meterTypes[] = {
|
2015-07-12 18:47:43 +00:00
|
|
|
&CPUMeter_class,
|
|
|
|
&ClockMeter_class,
|
2020-10-05 11:52:58 +00:00
|
|
|
&DateMeter_class,
|
|
|
|
&DateTimeMeter_class,
|
2015-07-12 18:47:43 +00:00
|
|
|
&LoadAverageMeter_class,
|
|
|
|
&LoadMeter_class,
|
|
|
|
&MemoryMeter_class,
|
2015-11-16 17:32:22 +00:00
|
|
|
&SwapMeter_class,
|
2015-07-12 18:47:43 +00:00
|
|
|
&TasksMeter_class,
|
|
|
|
&BatteryMeter_class,
|
|
|
|
&HostnameMeter_class,
|
|
|
|
&UptimeMeter_class,
|
|
|
|
&AllCPUsMeter_class,
|
|
|
|
&AllCPUs2Meter_class,
|
2020-09-24 19:50:29 +00:00
|
|
|
&AllCPUs4Meter_class,
|
2020-09-24 19:56:40 +00:00
|
|
|
&AllCPUs8Meter_class,
|
2015-07-12 18:47:43 +00:00
|
|
|
&LeftCPUsMeter_class,
|
|
|
|
&RightCPUsMeter_class,
|
|
|
|
&LeftCPUs2Meter_class,
|
|
|
|
&RightCPUs2Meter_class,
|
2020-09-24 19:50:29 +00:00
|
|
|
&LeftCPUs4Meter_class,
|
|
|
|
&RightCPUs4Meter_class,
|
2020-09-24 19:56:40 +00:00
|
|
|
&LeftCPUs8Meter_class,
|
|
|
|
&RightCPUs8Meter_class,
|
2019-07-07 21:30:37 +00:00
|
|
|
&ZfsArcMeter_class,
|
2019-09-03 18:26:02 +00:00
|
|
|
&ZfsCompressedArcMeter_class,
|
2015-07-12 18:47:43 +00:00
|
|
|
&BlankMeter_class,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2020-12-12 19:43:08 +00:00
|
|
|
double Platform_timebaseToNS = 1.0;
|
|
|
|
|
2020-11-19 01:32:07 +00:00
|
|
|
void Platform_init(void) {
|
2020-12-12 19:43:08 +00:00
|
|
|
// Check if we can determine the timebase used on this system.
|
|
|
|
// If the API is unavailable assume we get our timebase in nanoseconds.
|
|
|
|
#ifdef HAVE_MACH_TIMEBASE_INFO
|
|
|
|
mach_timebase_info_data_t info;
|
|
|
|
mach_timebase_info(&info);
|
|
|
|
Platform_timebaseToNS = (double)info.numer / (double)info.denom;
|
|
|
|
#else
|
|
|
|
Platform_timebaseToNS = 1.0;
|
|
|
|
#endif
|
2020-11-19 01:32:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Platform_done(void) {
|
|
|
|
/* no platform-specific cleanup needed */
|
|
|
|
}
|
|
|
|
|
2015-07-12 18:47:43 +00:00
|
|
|
void Platform_setBindings(Htop_Action* keys) {
|
2020-11-19 01:32:07 +00:00
|
|
|
/* no platform-specific key bindings */
|
2015-07-12 18:47:43 +00:00
|
|
|
(void) keys;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Platform_getUptime() {
|
2015-08-19 16:56:46 +00:00
|
|
|
struct timeval bootTime, currTime;
|
|
|
|
int mib[2] = { CTL_KERN, KERN_BOOTTIME };
|
|
|
|
size_t size = sizeof(bootTime);
|
2015-07-14 02:02:40 +00:00
|
|
|
|
2015-08-19 16:56:46 +00:00
|
|
|
int err = sysctl(mib, 2, &bootTime, &size, NULL, 0);
|
|
|
|
if (err) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
gettimeofday(&currTime, NULL);
|
2015-07-14 02:02:40 +00:00
|
|
|
|
2015-08-19 16:56:46 +00:00
|
|
|
return (int) difftime(currTime.tv_sec, bootTime.tv_sec);
|
2015-07-12 18:47:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Platform_getLoadAverage(double* one, double* five, double* fifteen) {
|
2015-07-13 06:17:14 +00:00
|
|
|
double results[3];
|
|
|
|
|
2020-10-31 19:52:20 +00:00
|
|
|
if (3 == getloadavg(results, 3)) {
|
2015-07-13 06:17:14 +00:00
|
|
|
*one = results[0];
|
|
|
|
*five = results[1];
|
|
|
|
*fifteen = results[2];
|
|
|
|
} else {
|
|
|
|
*one = 0;
|
|
|
|
*five = 0;
|
|
|
|
*fifteen = 0;
|
|
|
|
}
|
2015-07-12 18:47:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int Platform_getMaxPid() {
|
2015-07-13 06:17:14 +00:00
|
|
|
/* http://opensource.apple.com/source/xnu/xnu-2782.1.97/bsd/sys/proc_internal.hh */
|
|
|
|
return 99999;
|
2015-07-12 18:47:43 +00:00
|
|
|
}
|
|
|
|
|
2015-08-20 03:32:47 +00:00
|
|
|
ProcessPidColumn Process_pidColumns[] = {
|
|
|
|
{ .id = PID, .label = "PID" },
|
|
|
|
{ .id = PPID, .label = "PPID" },
|
|
|
|
{ .id = TPGID, .label = "TPGID" },
|
|
|
|
{ .id = TGID, .label = "TGID" },
|
|
|
|
{ .id = PGRP, .label = "PGRP" },
|
2017-01-31 23:03:55 +00:00
|
|
|
{ .id = SESSION, .label = "SID" },
|
2015-08-20 03:32:47 +00:00
|
|
|
{ .id = 0, .label = NULL },
|
|
|
|
};
|
2015-07-12 18:47:43 +00:00
|
|
|
|
2015-10-23 15:46:21 +00:00
|
|
|
static double Platform_setCPUAverageValues(Meter* mtr) {
|
2020-10-31 22:28:02 +00:00
|
|
|
const ProcessList* dpl = mtr->pl;
|
2020-10-21 19:25:50 +00:00
|
|
|
int cpus = dpl->cpuCount;
|
2015-10-25 03:28:29 +00:00
|
|
|
double sumNice = 0.0;
|
|
|
|
double sumNormal = 0.0;
|
|
|
|
double sumKernel = 0.0;
|
|
|
|
double sumPercent = 0.0;
|
2015-10-23 15:46:21 +00:00
|
|
|
for (int i = 1; i <= cpus; i++) {
|
|
|
|
sumPercent += Platform_setCPUValues(mtr, i);
|
|
|
|
sumNice += mtr->values[CPU_METER_NICE];
|
|
|
|
sumNormal += mtr->values[CPU_METER_NORMAL];
|
|
|
|
sumKernel += mtr->values[CPU_METER_KERNEL];
|
|
|
|
}
|
|
|
|
mtr->values[CPU_METER_NICE] = sumNice / cpus;
|
|
|
|
mtr->values[CPU_METER_NORMAL] = sumNormal / cpus;
|
|
|
|
mtr->values[CPU_METER_KERNEL] = sumKernel / cpus;
|
|
|
|
return sumPercent / cpus;
|
|
|
|
}
|
|
|
|
|
2015-07-13 21:53:46 +00:00
|
|
|
double Platform_setCPUValues(Meter* mtr, int cpu) {
|
2015-10-23 15:46:21 +00:00
|
|
|
|
|
|
|
if (cpu == 0) {
|
|
|
|
return Platform_setCPUAverageValues(mtr);
|
|
|
|
}
|
2015-08-19 16:56:46 +00:00
|
|
|
|
2020-10-31 22:28:02 +00:00
|
|
|
const DarwinProcessList* dpl = (const DarwinProcessList*)mtr->pl;
|
|
|
|
const processor_cpu_load_info_t prev = &dpl->prev_load[cpu - 1];
|
|
|
|
const processor_cpu_load_info_t curr = &dpl->curr_load[cpu - 1];
|
2015-08-19 16:56:46 +00:00
|
|
|
double total = 0;
|
|
|
|
|
|
|
|
/* Take the sums */
|
2020-10-31 19:55:36 +00:00
|
|
|
for (size_t i = 0; i < CPU_STATE_MAX; ++i) {
|
2015-08-19 16:56:46 +00:00
|
|
|
total += (double)curr->cpu_ticks[i] - (double)prev->cpu_ticks[i];
|
|
|
|
}
|
2015-07-12 18:47:43 +00:00
|
|
|
|
2015-08-19 16:56:46 +00:00
|
|
|
mtr->values[CPU_METER_NICE]
|
2020-10-31 21:14:27 +00:00
|
|
|
= ((double)curr->cpu_ticks[CPU_STATE_NICE] - (double)prev->cpu_ticks[CPU_STATE_NICE]) * 100.0 / total;
|
2015-08-19 16:56:46 +00:00
|
|
|
mtr->values[CPU_METER_NORMAL]
|
2020-10-31 21:14:27 +00:00
|
|
|
= ((double)curr->cpu_ticks[CPU_STATE_USER] - (double)prev->cpu_ticks[CPU_STATE_USER]) * 100.0 / total;
|
2015-08-19 16:56:46 +00:00
|
|
|
mtr->values[CPU_METER_KERNEL]
|
2020-10-31 21:14:27 +00:00
|
|
|
= ((double)curr->cpu_ticks[CPU_STATE_SYSTEM] - (double)prev->cpu_ticks[CPU_STATE_SYSTEM]) * 100.0 / total;
|
2015-07-14 02:02:40 +00:00
|
|
|
|
2020-10-04 15:55:08 +00:00
|
|
|
mtr->curItems = 3;
|
2015-07-14 02:02:40 +00:00
|
|
|
|
2015-08-19 16:56:46 +00:00
|
|
|
/* Convert to percent and return */
|
|
|
|
total = mtr->values[CPU_METER_NICE] + mtr->values[CPU_METER_NORMAL] + mtr->values[CPU_METER_KERNEL];
|
|
|
|
|
2020-09-07 10:24:32 +00:00
|
|
|
mtr->values[CPU_METER_FREQUENCY] = NAN;
|
2020-09-10 17:56:33 +00:00
|
|
|
mtr->values[CPU_METER_TEMPERATURE] = NAN;
|
2019-08-11 00:17:45 +00:00
|
|
|
|
Introduce CLAMP macro. Unify all MIN(MAX(a,b),c) uses.
With the CLAMP macro replacing the combination of MIN and MAX, we will
have at least two advantages:
1. It's more obvious semantically.
2. There are no more mixes of confusing uses like MIN(MAX(a,b),c) and
MAX(MIN(a,b),c) and MIN(a,MAX(b,c)) appearing everywhere. We unify
the 'clamping' with a single macro.
Note that the behavior of this CLAMP macro is different from
the combination `MAX(low,MIN(x,high))`.
* This CLAMP macro expands to two comparisons instead of three from
MAX and MIN combination. In theory, this makes the code slightly
smaller, in case that (low) or (high) or both are computed at
runtime, so that compilers cannot optimize them. (The third
comparison will matter if (low)>(high); see below.)
* CLAMP has a side effect, that if (low)>(high) it will produce weird
results. Unlike MIN & MAX which will force either (low) or (high) to
win. No assertion of ((low)<=(high)) is done in this macro, for now.
This CLAMP macro is implemented like described in glib
<http://developer.gnome.org/glib/stable/glib-Standard-Macros.html>
and does not handle weird uses like CLAMP(a++, low++, high--) .
2016-01-15 12:26:01 +00:00
|
|
|
return CLAMP(total, 0.0, 100.0);
|
2015-08-19 16:56:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Platform_setMemoryValues(Meter* mtr) {
|
2020-10-31 22:28:02 +00:00
|
|
|
const DarwinProcessList* dpl = (const DarwinProcessList*)mtr->pl;
|
2020-10-21 19:25:50 +00:00
|
|
|
const struct vm_statistics* vm = &dpl->vm_stats;
|
2015-08-19 16:56:46 +00:00
|
|
|
double page_K = (double)vm_page_size / (double)1024;
|
|
|
|
|
|
|
|
mtr->total = dpl->host_info.max_mem / 1024;
|
|
|
|
mtr->values[0] = (double)(vm->active_count + vm->wire_count) * page_K;
|
|
|
|
mtr->values[1] = (double)vm->purgeable_count * page_K;
|
|
|
|
mtr->values[2] = (double)vm->inactive_count * page_K;
|
2015-07-12 18:47:43 +00:00
|
|
|
}
|
|
|
|
|
2015-11-16 17:32:22 +00:00
|
|
|
void Platform_setSwapValues(Meter* mtr) {
|
2020-10-31 21:14:27 +00:00
|
|
|
int mib[2] = {CTL_VM, VM_SWAPUSAGE};
|
|
|
|
struct xsw_usage swapused;
|
|
|
|
size_t swlen = sizeof(swapused);
|
|
|
|
sysctl(mib, 2, &swapused, &swlen, NULL, 0);
|
2015-07-12 18:47:43 +00:00
|
|
|
|
2020-10-31 21:14:27 +00:00
|
|
|
mtr->total = swapused.xsu_total / 1024;
|
|
|
|
mtr->values[0] = swapused.xsu_used / 1024;
|
2015-11-16 17:32:22 +00:00
|
|
|
}
|
2015-12-03 21:16:10 +00:00
|
|
|
|
2019-07-07 21:30:37 +00:00
|
|
|
void Platform_setZfsArcValues(Meter* this) {
|
2020-10-21 19:25:50 +00:00
|
|
|
const DarwinProcessList* dpl = (const DarwinProcessList*) this->pl;
|
2019-07-07 21:30:37 +00:00
|
|
|
|
2019-09-03 18:21:33 +00:00
|
|
|
ZfsArcMeter_readStats(this, &(dpl->zfs));
|
2019-07-07 21:30:37 +00:00
|
|
|
}
|
|
|
|
|
2019-09-03 18:26:02 +00:00
|
|
|
void Platform_setZfsCompressedArcValues(Meter* this) {
|
2020-10-21 19:25:50 +00:00
|
|
|
const DarwinProcessList* dpl = (const DarwinProcessList*) this->pl;
|
2019-09-03 18:26:02 +00:00
|
|
|
|
|
|
|
ZfsCompressedArcMeter_readStats(this, &(dpl->zfs));
|
|
|
|
}
|
|
|
|
|
2015-12-03 21:16:10 +00:00
|
|
|
char* Platform_getProcessEnv(pid_t pid) {
|
|
|
|
char* env = NULL;
|
|
|
|
|
|
|
|
int argmax;
|
|
|
|
size_t bufsz = sizeof(argmax);
|
|
|
|
|
|
|
|
int mib[3];
|
|
|
|
mib[0] = CTL_KERN;
|
|
|
|
mib[1] = KERN_ARGMAX;
|
|
|
|
if (sysctl(mib, 2, &argmax, &bufsz, 0, 0) == 0) {
|
2016-02-02 14:53:02 +00:00
|
|
|
char* buf = xMalloc(argmax);
|
2015-12-03 21:16:10 +00:00
|
|
|
if (buf) {
|
|
|
|
mib[0] = CTL_KERN;
|
|
|
|
mib[1] = KERN_PROCARGS2;
|
|
|
|
mib[2] = pid;
|
2020-09-08 14:17:31 +00:00
|
|
|
bufsz = argmax;
|
2015-12-03 21:16:10 +00:00
|
|
|
if (sysctl(mib, 3, buf, &bufsz, 0, 0) == 0) {
|
|
|
|
if (bufsz > sizeof(int)) {
|
|
|
|
char *p = buf, *endp = buf + bufsz;
|
2020-09-08 14:17:31 +00:00
|
|
|
int argc = *(int*)(void*)p;
|
2015-12-03 21:16:10 +00:00
|
|
|
p += sizeof(int);
|
|
|
|
|
|
|
|
// skip exe
|
2020-10-31 22:28:02 +00:00
|
|
|
p = strchr(p, 0) + 1;
|
2015-12-03 21:16:10 +00:00
|
|
|
|
|
|
|
// skip padding
|
2020-10-31 19:39:01 +00:00
|
|
|
while (!*p && p < endp)
|
2015-12-03 21:16:10 +00:00
|
|
|
++p;
|
|
|
|
|
|
|
|
// skip argv
|
2020-10-31 22:28:02 +00:00
|
|
|
for (; argc-- && p < endp; p = strrchr(p, 0) + 1)
|
2015-12-03 21:16:10 +00:00
|
|
|
;
|
|
|
|
|
|
|
|
// skip padding
|
2020-10-31 19:39:01 +00:00
|
|
|
while (!*p && p < endp)
|
2015-12-03 21:16:10 +00:00
|
|
|
++p;
|
|
|
|
|
|
|
|
size_t size = endp - p;
|
2020-10-31 22:28:02 +00:00
|
|
|
env = xMalloc(size + 2);
|
2016-04-30 01:10:05 +00:00
|
|
|
memcpy(env, p, size);
|
|
|
|
env[size] = 0;
|
2020-10-31 22:28:02 +00:00
|
|
|
env[size + 1] = 0;
|
2015-12-03 21:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return env;
|
|
|
|
}
|
2020-09-13 17:46:34 +00:00
|
|
|
|
2020-11-11 21:15:35 +00:00
|
|
|
char* Platform_getInodeFilename(pid_t pid, ino_t inode) {
|
|
|
|
(void)pid;
|
|
|
|
(void)inode;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
FileLocks_ProcessData* Platform_getProcessLocks(pid_t pid) {
|
|
|
|
(void)pid;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-10-21 15:06:32 +00:00
|
|
|
bool Platform_getDiskIO(DiskIOData* data) {
|
2020-09-13 17:46:34 +00:00
|
|
|
// TODO
|
2020-10-21 15:06:32 +00:00
|
|
|
(void)data;
|
2020-10-20 19:40:51 +00:00
|
|
|
return false;
|
2020-09-13 17:46:34 +00:00
|
|
|
}
|
2020-10-08 14:34:54 +00:00
|
|
|
|
2020-10-31 22:28:02 +00:00
|
|
|
bool Platform_getNetworkIO(unsigned long int* bytesReceived,
|
|
|
|
unsigned long int* packetsReceived,
|
|
|
|
unsigned long int* bytesTransmitted,
|
|
|
|
unsigned long int* packetsTransmitted) {
|
2020-10-08 14:34:54 +00:00
|
|
|
// TODO
|
|
|
|
*bytesReceived = 0;
|
|
|
|
*packetsReceived = 0;
|
|
|
|
*bytesTransmitted = 0;
|
|
|
|
*packetsTransmitted = 0;
|
2020-10-20 19:40:51 +00:00
|
|
|
return false;
|
2020-10-08 14:34:54 +00:00
|
|
|
}
|
2020-11-17 07:12:38 +00:00
|
|
|
|
2020-11-25 11:46:00 +00:00
|
|
|
void Platform_getBattery(double* percent, ACPresence* isOnAC) {
|
2020-11-17 07:12:38 +00:00
|
|
|
CFTypeRef power_sources = IOPSCopyPowerSourcesInfo();
|
|
|
|
|
2020-11-25 11:46:00 +00:00
|
|
|
*percent = NAN;
|
2020-11-17 07:12:38 +00:00
|
|
|
*isOnAC = AC_ERROR;
|
|
|
|
|
|
|
|
if (NULL == power_sources)
|
|
|
|
return;
|
|
|
|
|
|
|
|
CFArrayRef list = IOPSCopyPowerSourcesList(power_sources);
|
|
|
|
CFDictionaryRef battery = NULL;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (NULL == list) {
|
|
|
|
CFRelease(power_sources);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = CFArrayGetCount(list);
|
|
|
|
|
|
|
|
/* Get the battery */
|
|
|
|
for (int i = 0; i < len && battery == NULL; ++i) {
|
|
|
|
CFDictionaryRef candidate = IOPSGetPowerSourceDescription(power_sources,
|
|
|
|
CFArrayGetValueAtIndex(list, i)); /* GET rule */
|
|
|
|
CFStringRef type;
|
|
|
|
|
|
|
|
if (NULL != candidate) {
|
|
|
|
type = (CFStringRef) CFDictionaryGetValue(candidate,
|
|
|
|
CFSTR(kIOPSTransportTypeKey)); /* GET rule */
|
|
|
|
|
|
|
|
if (kCFCompareEqualTo == CFStringCompare(type, CFSTR(kIOPSInternalType), 0)) {
|
|
|
|
CFRetain(candidate);
|
|
|
|
battery = candidate;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NULL != battery) {
|
|
|
|
/* Determine the AC state */
|
|
|
|
CFStringRef power_state = CFDictionaryGetValue(battery, CFSTR(kIOPSPowerSourceStateKey));
|
|
|
|
|
|
|
|
*isOnAC = (kCFCompareEqualTo == CFStringCompare(power_state, CFSTR(kIOPSACPowerValue), 0))
|
|
|
|
? AC_PRESENT
|
|
|
|
: AC_ABSENT;
|
|
|
|
|
|
|
|
/* Get the percentage remaining */
|
|
|
|
double current;
|
|
|
|
double max;
|
|
|
|
|
|
|
|
CFNumberGetValue(CFDictionaryGetValue(battery, CFSTR(kIOPSCurrentCapacityKey)),
|
|
|
|
kCFNumberDoubleType, ¤t);
|
|
|
|
CFNumberGetValue(CFDictionaryGetValue(battery, CFSTR(kIOPSMaxCapacityKey)),
|
|
|
|
kCFNumberDoubleType, &max);
|
|
|
|
|
2020-11-25 11:46:00 +00:00
|
|
|
*percent = (current * 100.0) / max;
|
2020-11-17 07:12:38 +00:00
|
|
|
|
|
|
|
CFRelease(battery);
|
|
|
|
}
|
|
|
|
|
|
|
|
CFRelease(list);
|
|
|
|
CFRelease(power_sources);
|
|
|
|
}
|