//------------------------------------------------------------------------------------- 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; }
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); }
//------------------------------------------------------------------------------------- float SystemInfo::getCPUPer() { sigar_cpu_t current; if(_g_sigar_cpu == NULL) sigar_open(&_g_sigar_cpu); // sigar_cpu_get(_g_sigar_cpu, &_g_old_cpu); sigar_cpu_perc_t perc; // while(1) { sigar_cpu_get(_g_sigar_cpu, ¤t); sigar_cpu_perc_calculate(&_g_old_cpu, ¤t, &perc); // std::cout << "CPU " << perc.combined * 100 << "%\n"; _g_old_cpu = current; // sleep(1000); } float ret = float(perc.combined) * 100.f; //sigar_close(sigar_cpu); // DEBUG_MSG(fmt::format("SystemInfo::getCPUPer(): {}\n", ret)); return ret; }
static VALUE rb_sigar_new(VALUE module) { rb_sigar_t *rbsigar; rbsigar = ALLOC(rb_sigar_t); sigar_open(&(rbsigar->sigar)); return Data_Wrap_Struct(module, rb_sigar_mark, rb_sigar_close, rbsigar); }
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); }
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); }
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); }
void test_cpu_info(void) { //int status, i; sigar_t *sigar; //sigar_cpu_list_t cpulist; sigar_open(&sigar); sigar_cpu_info_list_t cpu_info_list; sigar_cpu_info_list_get(sigar, &cpu_info_list); //sigar_cpu_info_t cpu_info = cup_info_list; printf("vendor......%s\n", cpu_info_list.data->vendor); printf("model......%s\n", cpu_info_list.data->model); printf("mhz......%d\n", cpu_info_list.data->mhz); printf("total cores......%d\n", cpu_info_list.data->total_cores); //printf("Vendor......%s\n", cpu_info->vendor); sigar_cpu_info_list_destroy(sigar, &cpu_info_list); sigar_cpu_t cpu_old; sigar_cpu_t cpu_cur; sigar_cpu_get(sigar, &cpu_old); sigar_cpu_perc_t perc; sleep(1); sigar_cpu_get(sigar, &cpu_cur); sigar_cpu_perc_calculate(&cpu_old, &cpu_cur, &perc); printf("user......%3.2f%%\n", perc.user * 100); printf("sys......%3.2f%%\n", perc.sys * 100); printf("wait......%3.2f%%\n", perc.wait * 100); printf("nice......%3.2f%%\n", perc.nice * 100); printf("irq time......%f\n", perc.irq); printf("total used rate......%3.2f%%\n", perc.combined * 100); printf("total idle rate......%3.2f%%\n", perc.idle * 100); cpu_old = cpu_cur; /* status = sigar_cpu_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_t cpu = cpulist.data[i]; printf("cpu user: %ld, sys: %ld, nice: %ld, idle: %ld, wait: %ld, irq: %ld, soft_irq: %ld, stolen: %ld, total: %ld.\n", cpu.user, cpu.sys, cpu.nice, cpu.idle, cpu.wait, cpu.irq, cpu.soft_irq, cpu.stolen, cpu.total); } sigar_cpu_list_destroy(sigar, &cpulist); */ sigar_close(sigar); }
ulong MemInfo::_runCommand() { sigar_t *s = NULL; if (sigar_open(&s) != SIGAR_OK) { return 0; } char line[MAX_BUF] = {0}; #define MEM_FORMAT_DOUBLE(field) \ sprintf(line, "%12s: %.1lf %%\n", #field, memInfo.field); \ mMyStream<<line; \ #define MEM_FORMAT_INT64(field) \ sprintf(line, "%12s: %s B\n", #field, formatInteger(memInfo.field)); \ mMyStream<<line; \ if (mbPrintSwap) { sigar_swap_t memInfo; if (sigar_swap_get(s, &memInfo) != SIGAR_OK) { sigar_close(s); return 0; } MEM_FORMAT_INT64(total); MEM_FORMAT_INT64(used); MEM_FORMAT_INT64(free); MEM_FORMAT_INT64(page_in); MEM_FORMAT_INT64(page_out); } else { sigar_mem_t memInfo; if (sigar_mem_get(s, &memInfo) != SIGAR_OK) { sigar_close(s); return 0; } MEM_FORMAT_INT64(ram); MEM_FORMAT_INT64(total); MEM_FORMAT_INT64(used); MEM_FORMAT_INT64(free); MEM_FORMAT_INT64(actual_used); MEM_FORMAT_INT64(actual_free); MEM_FORMAT_DOUBLE(used_percent); MEM_FORMAT_DOUBLE(free_percent); } sigar_close(s); return mInterval; }
int main() { sigar_t *t; assert(SIGAR_OK == sigar_open(&t)); test_sigar_pid_get(t); sigar_close(t); return 0; }
int main() { sigar_t *t; int err = 0; assert(SIGAR_OK == sigar_open(&t)); test_sigar_mem_get(t); sigar_close(t); return err ? -1 : 0; }
ulong CpuInfo::_runCommand() { sigar_t *s = NULL; if (sigar_open(&s) != SIGAR_OK) { return 0; } sigar_cpu_info_list_t cpuinfo; if (sigar_cpu_info_list_get(s, &cpuinfo) != SIGAR_OK) { sigar_close(s); return 0; } char line[MAX_BUF] = {0}; for (int i = 0; i < cpuinfo.number; ++i) { sigar_cpu_info_t *info = &cpuinfo.data[i]; sprintf(line, "CPU %d:\n", i+1); mMyStream<<line; #define CPU_FORMAT_STR(field) \ sprintf(line, "%16s: %s\n", #field, info->field); \ mMyStream<<line; \ #define CPU_FORMAT_INT(field) \ sprintf(line, "%16s: %d\n", #field, info->field); \ mMyStream<<line; \ #define CPU_FORMAT_INT64(field) \ sprintf(line, "%16s: %llu\n", #field, info->field); \ mMyStream<<line; \ CPU_FORMAT_STR(vendor); CPU_FORMAT_STR(model); CPU_FORMAT_INT(mhz); CPU_FORMAT_INT(mhz_max); CPU_FORMAT_INT(mhz_min); CPU_FORMAT_INT64(cache_size); CPU_FORMAT_INT(total_sockets); CPU_FORMAT_INT(total_cores); CPU_FORMAT_INT(cores_per_socket); mMyStream<<"\n"; } sigar_cpu_info_list_destroy(s, &cpuinfo); sigar_close(s); return 0; }
static int lua_sigar_new(lua_State *L) { sigar_t **_s; sigar_t *s; if (SIGAR_OK != sigar_open(&s)) { luaL_error(L, "sigar_open() failed"); return 0; } _s = lua_newuserdata(L, sizeof(sigar_t *)); *_s = s; if (0 != luaL_newmetatable(L, "sigar")) { lua_newtable(L); lua_pushcfunction(L, lua_sigar_cpus_get); lua_setfield(L, -2, "cpus"); lua_pushcfunction(L, lua_sigar_procs_get); lua_setfield(L, -2, "procs"); lua_pushcfunction(L, lua_sigar_fses_get); lua_setfield(L, -2, "filesystems"); lua_pushcfunction(L, lua_sigar_disks_get); lua_setfield(L, -2, "disks"); lua_pushcfunction(L, lua_sigar_disk_get); lua_setfield(L, -2, "disk"); lua_pushcfunction(L, lua_sigar_who_get); lua_setfield(L, -2, "who"); lua_pushcfunction(L, lua_sigar_netifs_get); lua_setfield(L, -2, "netifs"); lua_pushcfunction(L, lua_sigar_proc_get); lua_setfield(L, -2, "proc"); lua_pushcfunction(L, lua_sigar_pid_get); lua_setfield(L, -2, "pid"); lua_pushcfunction(L, lua_sigar_mem_get); lua_setfield(L, -2, "mem"); lua_pushcfunction(L, lua_sigar_swap_get); lua_setfield(L, -2, "swap"); lua_pushcfunction(L, lua_sigar_version_get); lua_setfield(L, -2, "version"); lua_pushcfunction(L, lua_sigar_sysinfo_get); lua_setfield(L, -2, "sysinfo"); lua_setfield(L, -2, "__index"); lua_pushcfunction(L, lua_sigar_free); lua_setfield(L, -2, "__gc"); } lua_setmetatable(L, -2); return 1; }
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); } }
//------------------------------------------------------------------------------------- SystemInfo::MEM_INFOS SystemInfo::getMemInfos() { MEM_INFOS infos; sigar_t *sigar; sigar_open(&sigar); sigar_mem_t sigar_mem; sigar_mem_get(sigar, &sigar_mem); infos.total = sigar_mem.total; infos.free = sigar_mem.actual_free; infos.used = sigar_mem.actual_used; sigar_close(sigar); return infos; }
void ZSystemInfo::init(){ sigar_open(&_sigar); if(_sigar){ _modules << new ZCPUInfo(_sigar, this); _modules << new ZDiskInfo(_sigar, this); _modules << new ZNetworkInfo(_sigar, this); _modules << new ZMemoryInfo(_sigar, this); } zEvent->registerSignal(this, SIGNAL(refreshed())); zEvent->registerSlot(this, SLOT(refresh())); foreach(ZSigarModule *module, _modules){ zEvent->registerSignal(module, SIGNAL(refreshed())); zEvent->registerSlot(module, SLOT(refresh())); }
JNIEXPORT void SIGAR_JNIx(open) (JNIEnv *env, jobject obj) { jni_sigar_t *jsigar = malloc(sizeof(*jsigar)); memset(jsigar, '\0', sizeof(*jsigar)); sigar_set_pointer(env, obj, jsigar); /* this method is called by the constructor. * if != SIGAR_OK save status and throw exception * when methods are invoked (see sigar_get_pointer). */ if ((jsigar->open_status = sigar_open(&jsigar->sigar)) != SIGAR_OK) { sigar_throw_error(env, jsigar, jsigar->open_status); return; } }
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); }
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); }
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); } }
//------------------------------------------------------------------------------------- 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; }
Json::Value DiskSensor::GetMetaData() const { Json::Value metaData; sigar_t *fileSystem; sigar_open(&fileSystem); sigar_file_system_list_t fsList; sigar_file_system_list_get(fileSystem, &fsList); std::set<std::string> devices; for(int i=0;i<fsList.number;i++) { if(boost::starts_with(fsList.data[i].dev_name, "/dev/sd") || boost::starts_with(fsList.data[i].dev_name, "/dev/hd")) { devices.insert(fsList.data[i].dev_name); } } sigar_close(fileSystem); for(auto it=devices.begin();it!= devices.end();it++) { std::cout << *it << " " << std::endl; } return metaData; }
CPUInfo* cpu_info_create(char* client_id) { CPUInfo* info = (CPUInfo*)malloc(sizeof(CPUInfo)); if(NULL == info) return NULL; sigar_t* sigar; sigar_open(&sigar); sigar_cpu_info_list_t cpu_info_list; sigar_cpu_info_list_get(sigar, &cpu_info_list); info->sigar = sigar; info->cpu_info_list = &cpu_info_list; info->vendor = cpu_info_list.data->vendor; info->model = cpu_info_list.data->model; info->mhz = cpu_info_list.data->mhz; info->cores = cpu_info_list.data->total_cores; //设计json数据格式 cJSON* root; cJSON* clt; cJSON* body; root = cJSON_CreateObject(); cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("cpu")); cJSON_AddItemToObject(root, "clt", clt = cJSON_CreateObject()); cJSON_AddStringToObject(clt, "clt_id", client_id); cJSON_AddItemToObject(root, "body", body = cJSON_CreateObject()); cJSON_AddStringToObject(body, "vendor", info->vendor); cJSON_AddStringToObject(body, "model", info->model); cJSON_AddNumberToObject(body, "mhz", info->mhz); cJSON_AddNumberToObject(body, "cores", info->cores); cJSON_AddNumberToObject(body, "user", 0); cJSON_AddNumberToObject(body, "sys", 0); cJSON_AddNumberToObject(body, "wait", 0); cJSON_AddNumberToObject(body, "nice", 0); cJSON_AddNumberToObject(body, "irq", 0); cJSON_AddNumberToObject(body, "combined", 0); cJSON_AddNumberToObject(body, "idle", 0); info->json = root; return info; }
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 setup_sigar(void) { sigar_file_system_list_t sigar_fslist; sigar_net_interface_list_t sigar_netlist; int i, e, cnt; int do_destroy = 0; /* initialize sigar */ if (0 != (e = sigar_open(&gx.sigar))) { gpsmon_fatalx(FLINE, e, "sigar_open failed"); } TR2(("sigar initialized\n")); do_destroy = 1; if (0 != sigar_net_interface_list_get(gx.sigar, &sigar_netlist)) { memset(&sigar_netlist, 0, sizeof(sigar_netlist)); do_destroy = 0; } gx.netlist = apr_pcalloc(gx.pool, sizeof(const char*) * (1 + sigar_netlist.number)); CHECKMEM(gx.netlist); for (i = 0; i < sigar_netlist.number; i++) { gx.netlist[i] = apr_pstrdup(gx.pool, sigar_netlist.data[i]); CHECKMEM(gx.netlist[i]); TR2(("sigar net %d: %s\n", i, gx.netlist[i])); } if (do_destroy) sigar_net_interface_list_destroy(gx.sigar, &sigar_netlist); do_destroy = 1; if (0 != sigar_file_system_list_get(gx.sigar, &sigar_fslist)) { memset(&sigar_fslist, 0, sizeof(sigar_fslist)); do_destroy = 0; } cnt = 0; TR2(("sigar fsnumber: %d\n", sigar_fslist.number)); for (i = 0; i < sigar_fslist.number; i++) { if (sigar_fslist.data[i].type == SIGAR_FSTYPE_LOCAL_DISK) { TR2(("sigar cnt: %d\n", cnt + 1)); cnt++; } } gx.fslist = apr_pcalloc(gx.pool, sizeof(const char*) * (cnt + 1)); CHECKMEM(gx.fslist); gx.devlist = apr_pcalloc(gx.pool, sizeof(const char*) * (cnt + 1)); CHECKMEM(gx.devlist); cnt = 0; for (i = 0; i < sigar_fslist.number; i++) { if (sigar_fslist.data[i].type == SIGAR_FSTYPE_LOCAL_DISK) { gx.fslist[cnt] = apr_pstrdup(gx.pool, sigar_fslist.data[i].dir_name); CHECKMEM(gx.fslist[cnt]); TR2(("fs: %s\n", gx.fslist[cnt])); gx.devlist[cnt] = apr_pstrdup(gx.pool, sigar_fslist.data[i].dev_name); CHECKMEM(gx.devlist[cnt]); cnt++; } } cnt = 0; for (i = 0; i < sigar_fslist.number; i++) { if (sigar_fslist.data[i].type == SIGAR_FSTYPE_LOCAL_DISK || sigar_fslist.data[i].type == SIGAR_FSTYPE_NETWORK) { TR2(("sigar cnt: %d\n", cnt + 1)); cnt++; } } gx.allfslist = apr_pcalloc(gx.pool, sizeof(const char*) * (cnt + 1)); CHECKMEM(gx.allfslist); cnt = 0; for (i = 0; i < sigar_fslist.number; i++) { if (sigar_fslist.data[i].type == SIGAR_FSTYPE_LOCAL_DISK || sigar_fslist.data[i].type == SIGAR_FSTYPE_NETWORK) { gx.allfslist[cnt] = apr_pstrdup(gx.pool, sigar_fslist.data[i].dir_name); CHECKMEM(gx.allfslist[cnt]); TR2(("allfs: %s\n", gx.allfslist[cnt])); cnt++; } } if (do_destroy) sigar_file_system_list_destroy(gx.sigar, &sigar_fslist); }
static VALUE rb_sigar_new(VALUE module) { sigar_t *sigar; sigar_open(&sigar); return Data_Wrap_Struct(module, 0, rb_sigar_close, sigar); }
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); }
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); }