QNX下获取系统信息的方法(cpu,内存,进程等等)

QNX 专栏收录该内容
11 篇文章 3 订阅

有不少朋友问在qnx下如何获取内存及cpu占有率等等,想到两年前自己做过一个类似windows里的任务管理器的东东,里面有一部分就是获取内存,cpu,磁盘及进程信息的GUI程序,记得也美其名曰xxxTaskMan。把里面的关键代码写下来供兄弟们参考。界面部分就不公布了,无非是一些窗口,按钮,list等等。

 

一、ProcInfo.h

 

  1. // ProcInfo.h: interface for the CProcInfo class.
  2. //
  3. //
  4. #if !defined(AFX_PROCINFO_H__E3782DFC_59DE_45FC_BF1F_D8C8BF0181C1__INCLUDED_)
  5. #define AFX_PROCINFO_H__E3782DFC_59DE_45FC_BF1F_D8C8BF0181C1__INCLUDED_
  6. #if _MSC_VER > 1000
  7. #pragma once
  8. #endif // _MSC_VER > 1000
  9. class CProcInfo  
  10. {
  11. public:
  12.     CProcInfo();
  13.     virtual ~CProcInfo();
  14. public:
  15.     static void InitSysInfo();
  16.     static void ClearSysInfo();
  17.     static int GetFreeMem();
  18.     static int GetTotalMem();
  19.     static int GetFreeMemPercent();
  20.     static void GetSysInfo(int &TotalMem,int &CpuSpeed,int &BootTime,char *pszCpuName);
  21.     static void GetDiskInfo(int &Total,int &Free);
  22.     static int  GetFreeDiskPercent();
  23.     static int normalize_data_size(int &size);
  24.     
  25.     static bool GetProcName(const int iPid,char *pszProcName,int &fd);
  26.     static bool GetSingleProcInfo(const int fd,long &StartTsp,int &CpuTime,int &MemSize);
  27. private:
  28.     static int s_iTotalMem;
  29.     static int s_iCpuSpeed;
  30.     static int s_iBootTime;
  31.     static char s_strCpuName[32];
  32.     static int s_hSysProc;
  33.     static int s_hRootFile;
  34. };
  35. #endif // !defined(AFX_PROCINFO_H__E3782DFC_59DE_45FC_BF1F_D8C8BF0181C1__INCLUDED_)

使用方法,启动后先调用一次InitSysInfo(),结束后调用一次ClearSysInfo()进行清理。

 

2、ProcInfo.cpp代码

 

 

 

  1. // ProcInfo.cpp: implementation of the CProcInfo class.
  2. //
  3. //
  4. #include <errno.h>
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <fcntl.h>
  8. #include <string.h>
  9. #include <unistd.h>
  10. #include <sys/iofunc.h>
  11. #include <sys/dispatch.h>
  12. #include <sys/neutrino.h>
  13. #include <sys/procfs.h>
  14. #include <sys/stat.h>
  15. #include "ProcInfo.h"
  16. #include <libgen.h>
  17. //
  18. // Construction/Destruction
  19. //
  20. int CProcInfo::s_iTotalMem;
  21. int CProcInfo::s_iCpuSpeed;
  22. int CProcInfo::s_iBootTime;
  23. char CProcInfo::s_strCpuName[32]={'/0'};
  24.     
  25. int CProcInfo::s_hSysProc=-1;
  26. int CProcInfo::s_hRootFile=-1;
  27. CProcInfo::CProcInfo()
  28. {
  29. }
  30. CProcInfo::~CProcInfo()
  31. {
  32. }
  33. void CProcInfo::InitSysInfo()
  34. {
  35.     char                    buffer[50];
  36.     procfs_sysinfo          *sysinfo;
  37.     struct cpuinfo_entry    *cpu;
  38.     int                     i;
  39.     sprintf(buffer, "/proc");
  40.     
  41.     if ((s_hSysProc = open(buffer, O_RDONLY)) == -1)
  42.         printf( "couldn't open %s: %s/n", buffer, strerror(errno));
  43.     sysinfo = (procfs_sysinfo *)buffer;
  44.     if (devctl(s_hSysProc, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
  45.         printf( "couldn't get info for %s: %s/n", buffer, strerror(errno));
  46.     i = sysinfo->total_size;
  47.     if(!(sysinfo = (procfs_sysinfo *)alloca(i)))
  48.         printf( "couldn't get memory for %s: %s/n", buffer, strerror(errno));
  49.     if (devctl(s_hSysProc, DCMD_PROC_SYSINFO, sysinfo, i, 0) != EOK)
  50.         printf( "couldn't get info for %s: %s/n", buffer, strerror(errno));
  51.     s_iTotalMem = _SYSPAGE_ENTRY(sysinfo, system_private)->ramsize;
  52.     s_iBootTime = _SYSPAGE_ENTRY(sysinfo, qtime)->boot_time;
  53.     cpu = _SYSPAGE_ENTRY(sysinfo, cpuinfo);
  54. //  printf("%s ", &_SYSPAGE_ENTRY(sysinfo, strings)->data[cpu->name]); //实际name
  55.     strcpy(s_strCpuName,"Cyrix X86");
  56.     s_iCpuSpeed=cpu->speed;
  57. }
  58. void CProcInfo::ClearSysInfo()
  59. {
  60.     close(s_hSysProc);
  61.     s_hSysProc=-1;
  62.     close(s_hRootFile);
  63.     s_hRootFile=-1;
  64. }
  65. void CProcInfo::GetSysInfo(int &TotalMem,int &CpuSpeed,int &BootTime,char *pszCpuName)
  66. {
  67.     TotalMem=s_iTotalMem;
  68.     CpuSpeed=s_iCpuSpeed;
  69.     BootTime=s_iBootTime;
  70.     if (pszCpuName)
  71.     {
  72.         strcpy(pszCpuName,s_strCpuName);
  73.     }
  74. }
  75. int CProcInfo::GetFreeMem()
  76. {
  77.     if (s_hSysProc==-1)
  78.     {
  79.         s_hSysProc=open("/proc", O_RDONLY);
  80.     }
  81.     struct stat             st;
  82.     if (fstat(s_hSysProc, &st) == -1)
  83.         printf( "couldn't get stat info for %s: %s/n""/proc", strerror(errno));
  84.     return st.st_size;
  85. }
  86. int CProcInfo::GetTotalMem()
  87. {
  88.     return s_iTotalMem;
  89. }
  90.     
  91. int CProcInfo::GetFreeMemPercent()
  92. {
  93.     int freemem=GetFreeMem();
  94.     return ( (int)( freemem*100.0/s_iTotalMem ) );
  95. }
  96. int CProcInfo::GetFreeDiskPercent()
  97. {
  98.     int iTotal,iFree;
  99.     GetDiskInfo(iTotal,iFree);
  100.     return ( (int)( iFree*100.0/iTotal ) );
  101. }
  102. int CProcInfo::normalize_data_size(int &size) {
  103.     char sym = 0;
  104.     if (size > 8192) {
  105.         size /= 1024;
  106.         sym = 'K';
  107.         if (size > 8192) {
  108.             size /= 1024;
  109.             sym = 'M';
  110.         } 
  111.         if (size > 8192) {
  112.             size /= 1024;
  113.             sym = 'G';
  114.         }
  115.         if (size > 8192) {
  116.             size /= 1024;
  117.             sym = 'T';
  118.         }
  119.     }
  120.     return sym;
  121. }
  122. void CProcInfo::GetDiskInfo(int &Total,int &Free)
  123. {
  124.     if (-1==s_hRootFile)
  125.     {
  126.         s_hRootFile = open("/",O_RDONLY);
  127.     }
  128.     if (-1==s_hRootFile)
  129.     {
  130.         Total=-1;
  131.         Free=-1;
  132.         return;
  133.     }
  134.     struct statvfs FileBuff;
  135.     int tmpret=0;
  136.     
  137.     if (-1==(tmpret=fstatvfs(s_hRootFile,&FileBuff)))
  138.     {
  139.         printf("fstatvfs ret=%d/n",tmpret);
  140.         printf("fstatvfs is:%s/n",strerror(tmpret)); 
  141.         close(s_hRootFile);
  142.         Total=-1;
  143.         Free=-1;
  144.         return ;
  145.     }
  146.     
  147. //  printf("f_blocks=%d,bfree=%d,f_bsize=%ld/n",FileBuff.f_blocks,FileBuff.f_bfree,FileBuff.f_bsize);
  148. //  printf("DT=%ld,DF=%ld/n",FileBuff.f_blocks*FileBuff.f_bsize,FileBuff.f_bfree*FileBuff.f_bsize);
  149.     Total=FileBuff.f_blocks*FileBuff.f_bsize;
  150.     Free=FileBuff.f_bfree*FileBuff.f_bsize; 
  151. }
  152.     
  153. bool CProcInfo::GetProcName(const int iPid,char *pszProcName,int &fd)
  154. {
  155.     if (!pszProcName)
  156.     {
  157.         return false;
  158.     }
  159.     char            buf[PATH_MAX + 1];
  160.     struct dinfo_s {
  161.         procfs_debuginfo    info;
  162.         char                pathbuffer[PATH_MAX]; /* 1st byte is info.path[0] */
  163.     }dinfo;
  164.     
  165.     sprintf(buf, "/proc/%d/as", iPid);
  166.     
  167.     if ((fd = open(buf, O_RDONLY|O_NONBLOCK)) == -1){
  168.         return false;
  169.     }
  170.     if (devctl(fd, DCMD_PROC_MAPDEBUG_BASE, &dinfo, sizeof(dinfo), NULL) != EOK) {
  171.         close(fd);
  172.         return false;
  173.     }
  174.     strcpy(pszProcName,basename(dinfo.info.path));
  175.     return true;
  176. }
  177. //StartTsp:单位:秒
  178. //CpuTime:单位:毫秒
  179. //MemSize:单位:字节
  180. bool CProcInfo::GetSingleProcInfo(const int fd,long &StartTsp,int &CpuTime,int &MemSize)
  181. {
  182.     procfs_info     infos;
  183.     if (-1==fd)
  184.     {
  185.         return false;
  186.     }
  187.        
  188.     if (devctl(fd, DCMD_PROC_INFO, &infos, sizeof infos, 0) != EOK) {
  189.         return false;
  190.     }
  191.     
  192.     StartTsp=infos.start_time/1000000000;       
  193.     CpuTime=(infos.stime + infos.utime)/1000000;
  194.     //MemSize
  195.     MemSize=0;//
  196.     procfs_mapinfo      *mapinfos = NULL;
  197.     static int      num_mapinfos = 0;
  198.     procfs_mapinfo      *mapinfo_p;
  199.     int             flags = ~0, err, num, i;
  200.     // Get the number of map entrys
  201.     if((err = devctl(fd, DCMD_PROC_MAPINFO, NULL, 0, &num )) != EOK)
  202.     {
  203.         printf("failed devctl num mapinfos - %d (%s)/n", err, strerror(err));
  204.         return false;
  205.     }
  206.     // malloc enough memory for all of them
  207.     if ( (mapinfos = (procfs_mapinfo*)malloc( num*sizeof(procfs_mapinfo) )) == NULL )
  208.     {
  209.         printf("failed malloc - %d (%s)/n", err, strerror(err));
  210.         return false;
  211.     }
  212.     num_mapinfos = num;
  213.     mapinfo_p = mapinfos;
  214.     // fill the map entrys  
  215.     if((err = devctl(fd, DCMD_PROC_MAPINFO, mapinfo_p, num*sizeof(procfs_mapinfo), &num)) != EOK)
  216.     {
  217.         printf("failed devctl mapinfos - %d (%s)/n", err, strerror(err));
  218.         free(mapinfos);
  219.         return false;
  220.     }
  221.     if (num>num_mapinfos)
  222.     {
  223.         num=num_mapinfos;
  224.     }
  225.     //
  226.     // Run through the list of mapinfo's, and store the data and text info
  227.     // so we can print it at the bottom of the loop.
  228.     //
  229.     for ( mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++ )
  230.     {
  231.         if ( !(mapinfo_p->flags & flags) )
  232.             mapinfo_p->ino = 0;
  233.         if ( mapinfo_p->ino == 0 ) /* already visited */
  234.             continue;
  235.         MemSize+=mapinfo_p->size;
  236.     }
  237.     free(mapinfos);
  238.     return true;
  239. }

3、CpuUsed.h

 

 

 

  1. // CpuUsed.h: interface for the CCpuUsed class.
  2. //
  3. //
  4. #if !defined(AFX_CPUUSED_H__DA812B5A_099E_43F0_9C27_E84A9F0A8E78__INCLUDED_)
  5. #define AFX_CPUUSED_H__DA812B5A_099E_43F0_9C27_E84A9F0A8E78__INCLUDED_
  6. #if _MSC_VER > 1000
  7. #pragma once
  8. #endif // _MSC_VER > 1000
  9. #include "QnxHardTimer.h"
  10. class CCpuUsed : public CQnxHardTimer  
  11. {
  12. public:
  13.     CCpuUsed();
  14.     virtual ~CCpuUsed();
  15.     virtual void  RepeatTimerThread();
  16.     int GetCpuUsed();
  17. public:
  18.     static CCpuUsed s_CpuUsed;
  19. protected:
  20.     int m_iCpuUsed;
  21.     clockid_t m_iClockID;
  22.     uint64_t  m_ut_old;
  23.     struct timespec m_tt_old;
  24. };
  25. #endif // !defined(AFX_CPUUSED_H__DA812B5A_099E_43F0_9C27_E84A9F0A8E78__INCLUDED_)

4、CpuUsed.cpp

 

 

 

 

  1. // CpuUsed.cpp: implementation of the CCpuUsed class.
  2. //
  3. //
  4. #include <stdint.h>
  5. #include <stdio.h>
  6. #include "CpuUsed.h"
  7. //
  8. // Construction/Destruction
  9. //
  10. CCpuUsed CCpuUsed::s_CpuUsed;
  11. CCpuUsed::CCpuUsed()
  12. {
  13.     m_iClockID=ClockId(1, 1); //取空闲线程;
  14.     m_ut_old=0;
  15. }
  16. CCpuUsed::~CCpuUsed()
  17. {
  18. }
  19. void  CCpuUsed::RepeatTimerThread()
  20. {
  21.     uint64_t  ut_now=0;
  22.     struct timespec tt_now;
  23.     uint64_t  ut_sub; //时间差
  24.     uint64_t  ut_tmp; 
  25.     ClockTime(m_iClockID, NULL, &ut_now);
  26.     clock_gettime( CLOCK_REALTIME, &tt_now);
  27.     ut_tmp=tt_now.tv_sec-m_tt_old.tv_sec;
  28.     ut_sub=ut_tmp*1000000000+tt_now.tv_nsec-m_tt_old.tv_nsec;
  29.     m_iCpuUsed=(int)( ((float)(ut_sub-(ut_now-m_ut_old))/(float)ut_sub)*100 );
  30.     m_ut_old=ut_now;
  31.     m_tt_old=tt_now;
  32. //  printf("m_iCpuUsed=%d%%/n",m_iCpuUsed);
  33. }
  34. int CCpuUsed::GetCpuUsed()
  35. {
  36.     if (m_iCpuUsed>100)
  37.     {
  38.         return 100;
  39.     }else if (m_iCpuUsed<0)
  40.     {
  41.         return 0;
  42.     }else
  43.         return m_iCpuUsed;
  44. }

注意,CCpuUsed类继承了我自己封装的一个CQnxHardTimer,其实也就是一个定时器,改定时器会重复调用RepeatTimerThread(),在这里面就可以进行系统cpu占用率的计算。用户只需要调用GetCpuUsed()就可以了。

 

5、参考资料

 

pidin的源码。在qnx已公开的源码里就有。

 

  • 0
    点赞
  • 0
    评论
  • 4
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值