blob: a52a5823a9b6a669efc1b445a687377b50e7306c [file] [log] [blame] [raw]
/*
htop - haiku/Platform.c
(C) 2014 Hisham H. Muhammad
(C) 2015 David C. Hunt
Copyright 2015-2022 Rivoreo
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
#include "Platform.h"
#include "CPUMeter.h"
#include "MemoryMeter.h"
#include "SwapMeter.h"
#include "TasksMeter.h"
#include "LoadAverageMeter.h"
#include "ClockMeter.h"
#include "HostnameMeter.h"
#include "UptimeMeter.h"
#include "HaikuProcess.h"
#include "HaikuProcessList.h"
#include <OS.h>
#include <unistd.h>
#include <signal.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
/*{
#include "config.h"
#include "Action.h"
#include "BatteryMeter.h"
#include "SignalsPanel.h"
#include <stdint.h>
#include <dlfcn.h>
#define PLATFORM_SUPPORT_PROCESS_O_STATE
#ifndef PRIO_PROCESS
#define PRIO_PROCESS 0
#endif
#if !defined HAVE_SYSTEM_INFO_CACHED_PAGES || !defined HAVE_SYSTEM_INFO_MAX_SWAP_PAGES
#ifndef B_MEMORY_INFO
#define B_MEMORY_INFO 0x6d656d6f
#endif
struct vm_stat {
uint64_t max_memory;
uint64_t free_memory;
uint64_t needed_memory;
uint64_t max_swap_space;
uint64_t free_swap_space;
uint64_t block_cache_memory;
uint32_t page_faults;
};
#endif
static inline void *get_libroot() {
static void *libroot;
if(!libroot) libroot = dlopen("libroot.so", RTLD_LAZY);
return libroot;
}
}*/
const SignalItem Platform_signals[] = {
{ .name = "Cancel", .number = 0 },
#define SIG(NAME) { .name = #NAME, .number = SIG##NAME }
SIG(HUP),
SIG(INT),
SIG(QUIT),
SIG(ILL),
SIG(CHLD),
SIG(PIPE),
SIG(FPE),
SIG(KILL),
SIG(STOP),
SIG(SEGV),
SIG(CONT),
SIG(TSTP),
SIG(ALRM),
SIG(TERM),
SIG(TTIN),
SIG(TTOU),
SIG(USR1),
SIG(USR2),
SIG(WINCH),
SIG(KILLTHR),
SIG(TRAP),
SIG(POLL),
SIG(PROF),
SIG(SYS),
SIG(URG),
SIG(VTALRM),
SIG(XCPU),
SIG(XFSZ),
SIG(BUS),
#undef SIG
};
const unsigned int Platform_numberOfSignals = sizeof(Platform_signals)/sizeof(SignalItem);
ProcessField Platform_defaultFields[] = { HTOP_PID_FIELD, HTOP_EFFECTIVE_USER_FIELD, HTOP_PRIORITY_FIELD, HTOP_NICE_FIELD, HTOP_M_SIZE_FIELD, HTOP_M_RESIDENT_FIELD, HTOP_STATE_FIELD, HTOP_PERCENT_CPU_FIELD, HTOP_PERCENT_MEM_FIELD, HTOP_TIME_FIELD, HTOP_NAME_FIELD, HTOP_COMM_FIELD, 0 };
const unsigned int Platform_numberOfFields = HTOP_LAST_PROCESSFIELD;
MeterClass* Platform_meterTypes[] = {
&CPUMeter_class,
&ClockMeter_class,
&LoadAverageMeter_class,
&LoadMeter_class,
&MemoryMeter_class,
&SwapMeter_class,
&TasksMeter_class,
&BatteryMeter_class,
&HostnameMeter_class,
&UptimeMeter_class,
&AllCPUsMeter_class,
&AllCPUs2Meter_class,
&LeftCPUsMeter_class,
&RightCPUsMeter_class,
&LeftCPUs2Meter_class,
&RightCPUs2Meter_class,
&BlankMeter_class,
NULL
};
#if !defined HAVE_SYSTEM_INFO_CACHED_PAGES || !defined HAVE_SYSTEM_INFO_MAX_SWAP_PAGES
bool Platform_getVMStat(struct vm_stat *buffer, size_t size) {
static bool is_available = true;
if(!is_available) return false;
static status_t (*get_system_info_etc)(uint32_t, void *, size_t);
if(!get_system_info_etc) {
void *libroot = get_libroot();
if(!libroot) {
is_available = false;
return false;
}
*(void **)&get_system_info_etc = dlsym(libroot, "_kern_get_system_info_etc");
if(!get_system_info_etc) {
is_available = false;
return false;
}
}
return get_system_info_etc(B_MEMORY_INFO, buffer, size) == B_OK;
}
#endif
void Platform_setBindings(Htop_Action* keys) {
(void) keys;
}
int Platform_getUptime() {
return system_time() / 1000000;
}
void Platform_getLoadAverage(double* one, double* five, double* fifteen) {
*one = 0;
*five = 0;
*fifteen = 0;
}
int Platform_getMaxPid() {
return INT32_MAX;
}
double Platform_updateCPUValues(Meter *meter, int cpu) {
const HaikuProcessList *pl = (const HaikuProcessList *)meter->pl;
if(cpu || pl->super.cpuCount == 1) {
const struct cpu_data *data = pl->cpu_data + (cpu ? cpu - 1 : 0);
meter->values[CPU_METER_NORMAL] = data->period / (double)pl->interval * 100;
} else {
double total_cpu_time = 0;
for(int i = 0; i < pl->super.cpuCount; i++) {
total_cpu_time += pl->cpu_data[i].period;
}
meter->values[CPU_METER_NORMAL] =
total_cpu_time / (double)pl->super.cpuCount / (double)pl->interval * 100;
}
return meter->values[CPU_METER_NORMAL];
}
void Platform_updateMemoryValues(Meter *meter) {
meter->total = meter->pl->totalMem;
meter->values[0] = meter->pl->usedMem;
meter->values[1] = meter->pl->buffersMem;
meter->values[2] = meter->pl->cachedMem;
}
void Platform_updateSwapValues(Meter *meter) {
meter->total = meter->pl->totalSwap;
meter->values[0] = meter->pl->usedSwap;
}
char **Platform_getProcessArgv(const Process *proc) {
return NULL;
}
char **Platform_getProcessEnvv(const Process *proc) {
return NULL;
}
bool Platform_haveSwap() {
#ifdef HAVE_SYSTEM_INFO_MAX_SWAP_PAGES
system_info si;
get_system_info(&si);
return si.max_swap_pages > 0;
#else
struct vm_stat st;
if(!Platform_getVMStat(&st, sizeof st)) return false;
return st.max_swap_space > 0;
#endif
}
#ifndef HAVE_GETPRIORITY
int getpriority(int which, int who) {
if(which != PRIO_PROCESS) {
errno = EINVAL;
return -1;
}
thread_info info;
status_t status = get_thread_info(who, &info);
if(status != B_OK) {
errno = status;
return -1;
}
return B_NORMAL_PRIORITY - info.priority;
}
#endif
#ifndef HAVE_SETPRIORITY
int setpriority(int which, int who, int value) {
if(which != PRIO_PROCESS) {
errno = EINVAL;
return -1;
}
status_t status = set_thread_priority(who, B_NORMAL_PRIORITY - value);
if(status != B_OK) {
errno = status;
return -1;
}
return 0;
}
#endif