Uptime::Uptime() {
QString cpu;
int status;
char b[256];
sigar_t *sigar;
sigar_uptime_t uptime;
sigar_open(&sigar);
status = sigar_uptime_get(sigar, &uptime);
status = sigar_uptime_string(sigar, &uptime, b, sizeof(b));
if (status != SIGAR_OK) {
printf("get uptime error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
this->time = cpu.setNum(uptime.uptime, 'g');
//this->time = uptime.uptime;
this->days = b;
qDebug() << "uptime.uptime : " << uptime.uptime;
qDebug() << "time : " << this->time;
//printf("uptime time %f\n", uptime.uptime);
//printf("uptime days = %s time %f\n", b, uptime.uptime);
sigar_close(sigar);
}
SysInfo::SysInfo()
{
int status;
sigar_t *sigar;
sigar_sys_info_t sysinfo;
sigar_open(&sigar);
status = sigar_sys_info_get(sigar, &sysinfo);
if (status != SIGAR_OK) {
printf("get sys info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
name = sysinfo.name;
version = sysinfo.version;
arch = sysinfo.arch;
machine = sysinfo.machine;
description = sysinfo.description;
patch_level = sysinfo.patch_level;
vendor = sysinfo.vendor;
vendor_version = sysinfo.vendor_version;
vendor_name = sysinfo.vendor_name;
vendor_code_name = sysinfo.vendor_code_name;
sigar_close(sigar);
}
//-------------------------------------------------------------------------------------
uint32 SystemInfo::countCPU()
{
static uint32 count = 0;
if(count == 0)
{
int status = SIGAR_OK;
sigar_t *sigarcpulist;
sigar_cpu_list_t cpulist;
sigar_open(&sigarcpulist);
status = sigar_cpu_list_get(sigarcpulist, &cpulist);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("error: {} ({}) cpu_list_get\n",
status, sigar_strerror(sigarcpulist, status)));
count = 1;
}
else
{
count = cpulist.number;
sigar_cpu_list_destroy(sigarcpulist, &cpulist);
}
sigar_close(sigarcpulist);
}
return count;
}
NetRouteInfo::NetRouteInfo()
{
sigar_t *sigar_route;
sigar_net_route_list_t route_list;
sigar_open(&sigar_route);
int status = sigar_net_route_list_get(sigar_route,&route_list);
if(status != SIGAR_OK)
cout<<"Net Route Error: "<<status<<sigar_strerror(sigar_route,status);
for(int i=0; i<route_list.number; i++)
{
sigar_net_route_t route = route_list.data[i];
cout<<route.mask.addr.in<<endl;
}
sigar_net_route_list_destroy(sigar_route,&route_list);
sigar_close(sigar_route);
}
Mem::Mem()
{
int status;
sigar_t *sigar;
sigar_mem_t mem;
sigar_open(&sigar);
status = sigar_mem_get(sigar, &mem);
if (status != SIGAR_OK) {
printf("get mem info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
ram.setNum(mem.ram);
total.setNum(mem.total / MiB, 'g');
used.setNum(mem.used / MiB, 'g');
free.setNum(mem.free / MiB, 'g');
actual_free.setNum(mem.actual_free / MiB, 'g');
actual_used.setNum(mem.actual_used / MiB, 'g');
actual_free_percent.setNum(mem.free_percent, 'g');
actual_used_percent.setNum(mem.used_percent, 'g');
qDebug() << "mem.actual_used : " << mem.actual_used;
qDebug() << "mem.used_percent : " << mem.used_percent;
qDebug() << "actual_used_percent : " << actual_used_percent;
sigar_close(sigar);
}
CpuStat::CpuStat()
{
int status, i;
sigar_t *sigar;
sigar_cpu_t _prev_cpu, cpu;
sigar_cpu_perc_t cpu_perc;
sigar_open(&sigar);
status = sigar_cpu_get(sigar, &_prev_cpu);
if (status != SIGAR_OK) {
printf("cpu stat error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
QTest::qSleep(1000);
status = sigar_cpu_get(sigar, &cpu);
if (status != SIGAR_OK) {
printf("cpu stat error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
sigar_cpu_perc_calculate(&_prev_cpu, &cpu, &cpu_perc);
user.setNum(cpu_perc.user * 100.);
sys.setNum(cpu_perc.sys * 100.);
nice.setNum(cpu_perc.nice * 100.);
idle.setNum(cpu_perc.idle * 100.);
wait.setNum(cpu_perc.wait * 100.);
irq.setNum(cpu_perc.irq * 100.);
soft_irq.setNum(cpu_perc.soft_irq * 100.);
stolen.setNum(cpu_perc.stolen * 100.);
combined.setNum(cpu_perc.combined * 100.);
total.setNum(cpu.total);
sigar_close(sigar);
}
NetInfo::NetInfo()
{
int status;
sigar_t *sigar;
sigar_net_info_t ni;
sigar_net_interface_config_t ifc;
char addrbuf[SIGAR_INET6_ADDRSTRLEN];
sigar_open(&sigar);
status = sigar_net_info_get(sigar, &ni);
if (status != SIGAR_OK) {
printf("get net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
hostname = ni.host_name;
default_gateway = ni.default_gateway;
domain_name = ni.domain_name;
primary_dns = ni.primary_dns;
secondary_dns = ni.secondary_dns;
status = sigar_net_interface_config_primary_get(sigar, &ifc);
if (status != SIGAR_OK) {
printf("get net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
if (sigar_net_interface_config_primary_get(sigar, &ifc) == SIGAR_OK) {
primary_interface = ifc.name;
sigar_net_address_to_string(sigar, &ifc.address, addrbuf);
primary_addr = addrbuf;
}
if (primary_addr.isEmpty() )
primary_addr = "127.0.0.1";
qDebug () << ifc.name << " " << ifc.type << " " << primary_addr;
sigar_close(sigar);
}
static void sigar_throw_error(JNIEnv *env, jni_sigar_t *jsigar, int err)
{
jclass errorClass;
int err_type = err;
/*
* support:
* #define SIGAR_EPERM_KMEM (SIGAR_OS_START_ERROR+EACCES)
* this allows for os impl specific message
* (e.g. Failed to open /dev/kmem) but still map to the proper
* Sigar*Exception
*/
if (err_type > SIGAR_OS_START_ERROR) {
err_type -= SIGAR_OS_START_ERROR;
}
switch (err_type) {
case SIGAR_ENOENT:
errorClass = SIGAR_FIND_CLASS("SigarFileNotFoundException");
break;
case SIGAR_EACCES:
errorClass = SIGAR_FIND_CLASS("SigarPermissionDeniedException");
break;
case SIGAR_ENOTIMPL:
if (jsigar->not_impl == NULL) {
jfieldID id;
jthrowable not_impl;
errorClass = SIGAR_FIND_CLASS(SIGAR_NOTIMPL_EX);
id = JENV->GetStaticFieldID(env, errorClass,
"INSTANCE",
SIGAR_CLASS_SIG(SIGAR_NOTIMPL_EX));
not_impl = JENV->GetStaticObjectField(env, errorClass, id);
jsigar->not_impl = JENV->NewGlobalRef(env, not_impl);
}
JENV->Throw(env, jsigar->not_impl);
return;
default:
errorClass = SIGAR_FIND_CLASS("SigarException");
break;
}
JENV->ThrowNew(env, errorClass,
sigar_strerror(jsigar->sigar, err));
}
FileSystem::FileSystem()
{
int status;
sigar_t *sigar;
sigar_file_system_list_t fslist;
sigar_open(&sigar);
status = sigar_file_system_list_get(sigar, &fslist);
if (status != SIGAR_OK) {
printf("get net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
}
static sigar_pid_t rb_sigar_pid_get(rb_sigar_t *rbsigar, VALUE obj)
{
SIGAR;
if (TYPE(obj) == T_STRING) {
char *pid = StringValuePtr(obj);
if (sigar_isdigit(*pid)) {
obj = rb_str2inum(obj, 10);
/* fallthru */
}
else if ((RSTRING_LEN(obj) == 2) &&
(*pid == '$') && (*(pid + 1) == '$'))
{
return sigar_pid_get(sigar);
}
else {
/* XXX cache queries */
sigar_ptql_query_t *query;
sigar_ptql_error_t error;
int status =
sigar_ptql_query_create(&query, (char *)pid, &error);
if (status == SIGAR_OK) {
sigar_pid_t qpid;
sigar_ptql_re_impl_set(sigar, NULL, rbsigar_ptql_re_impl);
status = sigar_ptql_query_find_process(sigar, query, &qpid);
sigar_ptql_re_impl_set(sigar, NULL, NULL);
sigar_ptql_query_destroy(query);
if (status == SIGAR_OK) {
return qpid;
}
else {
RB_SIGAR_RAISE(sigar_strerror(sigar, status));
}
}
else {
RB_SIGAR_RAISE(error.message);
}
}
}
return NUM2UINT(obj);
}
LoadAvg::LoadAvg()
{
// loadavg doest not exist on windows. Test to not segfault
if (system.os_name.indexOf("windows", 0, Qt::CaseInsensitive) == -1) {
QString load;
int status;
sigar_t *sigar;
sigar_loadavg_t loadavg;
sigar_open(&sigar);
status = sigar_loadavg_get(sigar, &loadavg);
if (status != SIGAR_OK) {
printf("get load avg : %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
qDebug() << "loadavg.loadavg[0] : " << loadavg.loadavg[0];
qDebug() << "loadavg.loadavg[1] : " << loadavg.loadavg[1];
qDebug() << "loadavg.loadavg[2] : " << loadavg.loadavg[2];
/*
int i_loadavg0 = loadavg.loadavg[0] * 100.00 + 0.5;
int i_loadavg1 = loadavg.loadavg[1] * 100.00 + 0.5;
int i_loadavg2 = loadavg.loadavg[2] * 100.00 + 0.5;
loadavg0 = load.setNum(i_loadavg0);
loadavg1 = load.setNum(i_loadavg1);
loadavg2 = load.setNum(i_loadavg2);
*/
loadavg0 = load.setNum(loadavg.loadavg[0], 'g');
loadavg1 = load.setNum(loadavg.loadavg[1], 'g');
loadavg2 = load.setNum(loadavg.loadavg[2], 'g');
sigar_close(sigar);
}
}
static VALUE rb_sigar_proc_list(int argc, VALUE *argv, VALUE obj)
{
SIGAR_GET;
int status;
sigar_proc_list_t list;
VALUE RETVAL;
VALUE vptql;
rb_scan_args(argc, argv, "01", &vptql);
if (NIL_P(vptql)) {
status = sigar_proc_list_get(sigar, &list);
if (status != SIGAR_OK) {
RB_SIGAR_CROAK;
}
}
else {
sigar_ptql_query_t *query;
sigar_ptql_error_t error;
char *ptql = StringValuePtr(vptql);
status = sigar_ptql_query_create(&query, ptql, &error);
if (status != SIGAR_OK) {
RB_SIGAR_RAISE(error.message);
}
sigar_ptql_re_impl_set(sigar, NULL, rbsigar_ptql_re_impl);
status = sigar_ptql_query_find(sigar, query, &list);
sigar_ptql_re_impl_set(sigar, NULL, NULL);
sigar_ptql_query_destroy(query);
if (status != SIGAR_OK) {
RB_SIGAR_RAISE(sigar_strerror(sigar, status));
}
}
RETVAL = rb_sigar_new_intlist(&list.data[0],
list.number);
sigar_proc_list_destroy(sigar, &list);
return RETVAL;
}
//-------------------------------------------------------------------------------------
bool SystemInfo::_autocreate()
{
if(_g_sigarproclist == NULL)
{
sigar_open(&_g_sigarproclist);
int status = sigar_proc_list_get(_g_sigarproclist, &_g_proclist);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("SystemInfo::autocreate:error: {} ({}) sigar_proc_list_get\n",
status, sigar_strerror(_g_sigarproclist, status)));
sigar_close(_g_sigarproclist);
_g_sigarproclist = NULL;
return false;
}
}
return true;
}
Cpu::Cpu() {
int status, i;
sigar_t *sigar;
sigar_cpu_info_list_t cpulist;
sigar_open(&sigar);
status = sigar_cpu_info_list_get(sigar, &cpulist);
if (status != SIGAR_OK) {
printf("cpu_list error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
/*
for (i=0; i<cpulist.number; i++) {
sigar_cpu_info_t cpu = cpulist.data[i];
cpus << cpu.vendor;
cpus << cpu.model;
cpus << cpu.mhz;
cpus << cpu.cache_size;
}*/
sigar_cpu_info_t cpu = cpulist.data[0];
vendor = cpu.vendor;
model = cpu.model;
mhz.setNum(cpu.mhz);
cache_size.setNum(cpu.cache_size);
number.setNum(cpulist.number);
total_cores.setNum(cpu.total_cores);
total_sockets.setNum(cpu.total_sockets);
cores_per_socket.setNum(cpu.cores_per_socket);
sigar_cpu_info_list_destroy(sigar, &cpulist);
sigar_close(sigar);
}
Swap::Swap()
{
int status;
sigar_t *sigar;
sigar_swap_t swap;
sigar_open(&sigar);
status = sigar_swap_get(sigar, &swap);
if (status != SIGAR_OK) {
printf("get swap info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
total.setNum(swap.total / MiB, 'g');
used.setNum(swap.used / MiB, 'g');
free.setNum(swap.free / MiB, 'g');
page_in.setNum(swap.page_in);
page_out.setNum(swap.page_out);
sigar_close(sigar);
}
NetConnectionInfo::NetConnectionInfo()
{
sigar_t *sigar_conn;
sigar_net_connection_list_t conn_list;
sigar_open(&sigar_conn);
int flags = SIGAR_NETCONN_SERVER | SIGAR_NETCONN_CLIENT | SIGAR_NETCONN_TCP | SIGAR_NETCONN_UDP ;
int status = sigar_net_connection_list_get(sigar_conn,&conn_list,flags);
if(status != SIGAR_OK)
cout<<"Net Connection Error: "<<status<<sigar_strerror(sigar_conn,status);
for(int i=0; i<conn_list.number; i++)
{
sigar_net_connection_t conn = conn_list.data[i];
}
sigar_net_connection_list_destroy(sigar_conn,&conn_list);
sigar_close(sigar_conn);
}
static void get_pid_metrics(apr_int32_t pid, apr_int32_t tmid, apr_int32_t ssid, apr_int32_t ccnt)
{
apr_int32_t status;
sigar_proc_cpu_t cpu;
sigar_proc_mem_t mem;
sigar_proc_fd_t fd;
pidrec_t* rec;
apr_pool_t* pool = apr_hash_pool_get(gx.pidtab);
rec = apr_hash_get(gx.pidtab, &pid, sizeof(pid));
if (rec && rec->updated_tick == gx.tick)
return; /* updated in current cycle */
memset(&cpu, 0, sizeof(cpu));
memset(&mem, 0, sizeof(mem));
memset(&fd, 0, sizeof(fd));
TR2(("--------------------- starting %d\n", pid));
if (!rec)
{
sigar_proc_exe_t exe;
/* There might be cases where the pid no longer exist, so we'll just
* zero out the memory first before doing anything */
rec = apr_pcalloc(pool, sizeof(*rec));
CHECKMEM(rec);
rec->pid = pid;
rec->query_key.tmid = tmid;
rec->query_key.ssid = ssid;
rec->query_key.ccnt = ccnt;
rec->pname = rec->cwd = 0;
if (0 == sigar_proc_exe_get(gx.sigar, pid, &exe))
{
rec->pname = apr_pstrdup(pool, exe.name);
rec->cwd = apr_pstrdup(pool, exe.root);
}
if (!rec->pname)
rec->pname = "unknown";
if (!rec->cwd)
rec->cwd = "unknown";
apr_hash_set(gx.pidtab, &rec->pid, sizeof(rec->pid), rec);
}
status = sigar_proc_mem_get(gx.sigar, pid, &mem);
/* ESRCH is error 3: (No such process) */
if (status != SIGAR_OK)
{
if (status != ESRCH) {
TR2(("[WARNING] %s. PID: %d\n", sigar_strerror(gx.sigar, status), pid));
}
return;
}
status = sigar_proc_cpu_get(gx.sigar, pid, &cpu);
if (status != SIGAR_OK)
{
if (status != ESRCH) {
TR2(("[WARNING] %s. PID: %d\n", sigar_strerror(gx.sigar, status), pid));
}
return;
}
status = sigar_proc_fd_get(gx.sigar, pid, &fd);
if (status != SIGAR_OK)
{
if (status != ESRCH) {
TR2(("[WARNING] %s. PID: %d\n", sigar_strerror(gx.sigar, status), pid));
}
return;
}
rec->updated_tick = gx.tick;
rec->p_metrics.fd_cnt = (apr_uint32_t) fd.total;
rec->p_metrics.cpu_pct = (float) (cpu.percent * cpu_cores_utilization_multiplier);
rec->p_metrics.mem.size = mem.size;
rec->p_metrics.mem.resident = mem.resident;
#ifdef __linux__
rec->p_metrics.mem.share = mem.share;
#else
rec->p_metrics.mem.share = 0;
#endif
rec->cpu_elapsed = cpu.total;
}
static int sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
{
kstat_ctl_t *kc = sigar->kc;
kstat_t *ksp;
uint_t cpuinfo[CPU_STATES];
unsigned int i;
int is_debug = SIGAR_LOG_IS_DEBUG(sigar);
sigar_cache_t *chips;
if (sigar_kstat_update(sigar) == -1) {
return errno;
}
if (cpulist == &sigar->cpulist) {
if (sigar->cpulist.size == 0) {
/* create once */
sigar_cpu_list_create(cpulist);
}
else {
/* reset, re-using cpulist.data */
sigar->cpulist.number = 0;
}
}
else {
sigar_cpu_list_create(cpulist);
}
if (is_debug) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[cpu_list] OS reports %d CPUs",
sigar->ncpu);
}
chips = sigar_cache_new(16);
chips->free_value = free_chip_id;
for (i=0; i<sigar->ncpu; i++) {
sigar_cpu_t *cpu;
char *buf;
int chip_id;
sigar_cache_entry_t *ent;
if (!CPU_ONLINE(sigar->ks.cpuid[i])) {
sigar_log_printf(sigar, SIGAR_LOG_INFO,
"cpu %d (id=%d) is offline",
i, sigar->ks.cpuid[i]);
continue;
}
if (!(ksp = sigar->ks.cpu[i])) {
sigar_log_printf(sigar, SIGAR_LOG_ERROR,
"NULL ksp for cpu %d (id=%d)",
i, sigar->ks.cpuid[i]);
continue; /* shouldnot happen */
}
if (kstat_read(kc, ksp, NULL) < 0) {
sigar_log_printf(sigar, SIGAR_LOG_ERROR,
"kstat_read failed for cpu %d (id=%d): %s",
i, sigar->ks.cpuid[i],
sigar_strerror(sigar, errno));
continue; /* shouldnot happen */
}
/*
* cpu_stat_t is not binary compatible between solaris versions.
* since cpu_stat is a 'raw' kstat and not 'named' we cannot
* use name based lookups as we do for others.
* the start of the cpu_stat_t structure is binary compatible,
* which looks like so:
* typedef struct cpu_stat {
* kmutex_t cpu_stat_lock;
* cpu_sysinfo_t cpu_sysinfo;
* ...
* typedef struct cpu_sysinfo {
* ulong cpu[CPU_STATES];
* ...
* we just copy the piece we need below:
*/
buf = ksp->ks_data;
buf += sizeof(kmutex_t);
memcpy(&cpuinfo[0], buf, sizeof(cpuinfo));
chip_id = sigar->cpu_list_cores ? -1 : get_chip_id(sigar, i);
if (chip_id == -1) {
SIGAR_CPU_LIST_GROW(cpulist);
cpu = &cpulist->data[cpulist->number++];
SIGAR_ZERO(cpu);
}
else {
/* merge times of logical processors */
ent = sigar_cache_get(chips, chip_id);
if (ent->value) {
cpu = &cpulist->data[(long)ent->value-1];
}
else {
SIGAR_CPU_LIST_GROW(cpulist);
cpu = &cpulist->data[cpulist->number++];
ent->value = (void *)(long)cpulist->number;
SIGAR_ZERO(cpu);
if (is_debug) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[cpu_list] Merging times of"
" logical processors for chip_id=%d",
chip_id);
}
}
}
cpu->user += SIGAR_TICK2MSEC(cpuinfo[CPU_USER]);
cpu->sys += SIGAR_TICK2MSEC(cpuinfo[CPU_KERNEL]);
cpu->idle += SIGAR_TICK2MSEC(cpuinfo[CPU_IDLE]);
cpu->wait += SIGAR_TICK2MSEC(cpuinfo[CPU_WAIT]);
cpu->nice += 0; /* no cpu->nice */
cpu->total = cpu->user + cpu->sys + cpu->idle + cpu->wait;
}
sigar_cache_destroy(chips);
return SIGAR_OK;
}
//-------------------------------------------------------------------------------------
float SystemInfo::getCPUPerByPID(uint32 pid)
{
if(pid == 0)
{
pid = (uint32)getProcessPID();
}
float percent = 0.f;
bool tryed = false;
_TRYGET:
if(!hasPID(pid, &_g_proclist))
{
DEBUG_MSG(fmt::format("SystemInfo::getCPUPerByPID: error: not found pid({})\n", pid));
if(!tryed)
{
clear();
tryed = true;
if(_autocreate())
goto _TRYGET;
}
return 0.f;
}
/*
int status = SIGAR_OK;
// for (size_t i = 0; i < proclist.number; i++)
{
sigar_proc_cpu_t cpu;
status = sigar_proc_cpu_get(_g_sigarproclist, pid, &cpu);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("error: {} ({}) proc_cpu_get({})\n",
status, sigar_strerror(_g_sigarproclist, status), pid));
return 0.f;
}
}
*/
// sleep(1000);
// for (size_t i = 0; i < proclist.number; i++)
{
sigar_proc_cpu_t cpu;
int status = sigar_proc_cpu_get(_g_sigarproclist, pid, &cpu);
if (status == SIGAR_OK)
{
/*
sigar_proc_state_t procstate;
status = sigar_proc_state_get(sigarproclist, pid, &procstate);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("error: {} ({}) proc_state({})\n",
status, sigar_strerror(sigarproclist, status), pid));
return 0.f;
}
*/
percent = float(cpu.percent) * 100.f;
#if KBE_PLATFORM == PLATFORM_WIN32
percent /= float(countCPU());
#endif
}
else
{
DEBUG_MSG(fmt::format("error: {} ({}) proc_cpu_get({})\n",
status, sigar_strerror(_g_sigarproclist, status), pid));
return 0.f;
}
}
return percent;
}
ProcList::ProcList()
{
int status;
sigar_t *sigar;
sigar_proc_list_t proclist;
unsigned long i;
sigar_open(&sigar);
status = sigar_proc_list_get(sigar, &proclist);
if (status != SIGAR_OK) {
printf("get proc list error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
for (i=0; i<proclist.number; i++) {
sigar_pid_t pid = proclist.data[i];
sigar_proc_mem_t proc_mem;
sigar_proc_time_t proc_time;
sigar_proc_state_t proc_state;
status = sigar_proc_mem_get(sigar, pid, &proc_mem);
if (status != SIGAR_OK) {
#ifdef DEBUG
printf("error: %d (%s) proc_mem(%d)\n",
status, sigar_strerror(sigar, status), pid);
#endif
continue;
}
status = sigar_proc_state_get(sigar, pid, &proc_state);
if (status != SIGAR_OK) {
#ifdef DEBUG
printf("error: %d (%s) proc_state(%d)\n",
status, sigar_strerror(sigar, status), pid);
#endif
continue;
}
status = sigar_proc_time_get(sigar, pid, &proc_time);
if (status != SIGAR_OK) {
#ifdef DEBUG
printf("error: %d (%s) proc_time(%d)\n",
status, sigar_strerror(sigar, status), pid);
#endif
continue;
}
// printf("%d %s\n", (long)pid, pstate.name);
//qDebug() << "name " << pstate.name << " processor " << pstate.processor;
//qDebug() << lpid.setNum((long)pid);
// datas << QString("PID : %1 , %2").arg(lpid.setNum((long)pid), pstate.name);
Process proc;
//proc = new(Process);
proc.pid.setNum((long)pid);
proc.state_name = proc_state.name;
proc.state_state = proc_state.state;
proc.state_ppid.setNum(proc_state.ppid);
//proc.state_tty = proc_state.tty;
proc.state_priority.setNum(proc_state.priority);
proc.state_nice.setNum(proc_state.nice);
proc.state_processor.setNum(proc_state.processor);
proc.state_threads.setNum(proc_state.threads);
proc.mem_size.setNum(proc_mem.size);
proc.mem_resident.setNum(proc_mem.resident);
proc.mem_share.setNum(proc_mem.share);
proc.mem_minor_faults.setNum(proc_mem.minor_faults);
proc.mem_major_faults.setNum(proc_mem.major_faults);
proc.mem_page_faults.setNum(proc_mem.page_faults);
proc.time_start_time.setNum(proc_time.start_time);
qDebug() << "proc_state.name : " << proc_state.name << " : proc_time.start_time : " << proc_time.start_time;
proc.time_user.setNum(proc_time.user);
proc.time_sys.setNum(proc_time.sys);
proc.time_total.setNum(proc_time.total);
stack.push(proc);
//delete(proc);
}
/* TEST OK
while (!stack.isEmpty())
{
qDebug() << "stack length : " << stack.count();
ok = .pop();
qDebug() << "name : " << ok->state_name << " " << " pid : " << ok->pid;
delete(ok);
}
*/
sigar_proc_list_destroy(sigar, &proclist);
sigar_close(sigar);
}
//-------------------------------------------------------------------------------------
uint64 SystemInfo::getMemUsedByPID(uint32 pid)
{
if(pid == 0)
{
pid = (uint32)getProcessPID();
}
int status;
sigar_uint64_t total = 0;
bool tryed = false;
_TRYGET:
if(!hasPID(pid, &_g_proclist))
{
DEBUG_MSG(fmt::format("SystemInfo::getMemUsedByPID: error: not found pid({})\n", pid));
if(!tryed)
{
clear();
tryed = true;
if(_autocreate())
goto _TRYGET;
}
return 0;
}
//for (i=0; i<(int)proclist.number; i++)
{
sigar_proc_state_t pstate;
sigar_proc_time_t ptime;
status = sigar_proc_state_get(_g_sigarproclist, pid, &pstate);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("error: {} ({}) proc_state({})\n",
status, sigar_strerror(_g_sigarproclist, status), pid));
goto _END;
}
status = sigar_proc_time_get(_g_sigarproclist, pid, &ptime);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("error: {} ({}) proc_time({})\n",
status, sigar_strerror(_g_sigarproclist, status), pid));
goto _END;
}
sigar_proc_mem_t proc_mem;
status = sigar_proc_mem_get(_g_sigarproclist, pid, &proc_mem);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("error: {} ({}) sigar_proc_mem_get({})\n",
status, sigar_strerror(_g_sigarproclist, status), pid));
goto _END;
}
total = proc_mem.resident;
}
_END:
return total;
}
NetStat::NetStat(QString ifname)
{
int status;
QString tmp;
sigar_t *sigar;
sigar_net_stat_t s;
sigar_net_interface_stat_t curr, curr2;
sigar_open(&sigar);
status = sigar_net_stat_get(sigar, &s, DEFAULT_NET_STAT_FLAGS);
if (status != SIGAR_OK) {
printf("get net start info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
/*
s.all_inbound_total;
s.all_outbound_total;
s.tcp_inbound_total;
s.tcp_outbound_total;
s.tcp_states;*/
tcp_established = s.tcp_states[SIGAR_TCP_ESTABLISHED];
tcp_listen = s.tcp_states[SIGAR_TCP_LISTEN];
tcp_time_wait = s.tcp_states[SIGAR_TCP_TIME_WAIT];
tcp_close_wait = s.tcp_states[SIGAR_TCP_CLOSE_WAIT];
tcp_idle = s.tcp_states[SIGAR_TCP_IDLE];
status = sigar_net_interface_stat_get(sigar, ifname.toAscii(), &curr);
if (status != SIGAR_OK) {
printf("get stat net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
// printf("curr_net_stat: rx_bytes=%llu, tx_bytes=%llu \n", (Llu)curr.rx_bytes, (Llu)curr.tx_bytes);
m_time.start();
//poll(0, 0, DEFAULT_PAUSE);
QTest::qSleep(1000);
status = sigar_net_interface_stat_get(sigar, ifname.toAscii(), &curr2);
if (status != SIGAR_OK) {
printf("get stat net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
int elapsed = m_time.elapsed();
//rx_bytes.setNum(curr.rx_bytes, 10);
//tx_bytes.setNum(curr.tx_bytes, 10);
//double tmp = (curr2.rx_bytes - curr.rx_bytes) / KiB;
//qDebug() << "rx tmp " << tmp;
rx_rate.setNum(((curr2.rx_bytes - curr.rx_bytes) / KiB), 'g');
//rx_rate = (curr2.rx_bytes - curr.rx_bytes) / KiB;
//tmp = "";
//tmp = (curr2.tx_bytes - curr.tx_bytes) / KiB;
//qDebug() << "tx tmp " << tmp;
tx_rate.setNum(((curr2.tx_bytes - curr.tx_bytes) / KiB), 'g');
//tx_rate = (curr2.tx_bytes - curr.tx_bytes) / KiB;
//tmp = "";
qDebug() << "tx2 rate : " << curr2.tx_bytes << " tx rate : " << curr.tx_bytes << " rate : " << (curr2.tx_bytes - curr.tx_bytes) / KiB;
sigar_close(sigar);
}
