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);
}
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;
}
//-------------------------------------------------------------------------------------
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;
}
