QNX下获取系统信息的方法（cpu，内存，进程等等）

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

 

一、ProcInfo.h

 

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

3、CpuUsed.h

 

 

 

1. // CpuUsed.h: interface for the CCpuUsed class.
2. //
3. //////////////////////////////////////////////////////////////////////
5. #if !defined(AFX_CPUUSED_H__DA812B5A_099E_43F0_9C27_E84A9F0A8E78__INCLUDED_)
6. #define AFX_CPUUSED_H__DA812B5A_099E_43F0_9C27_E84A9F0A8E78__INCLUDED_
8. #if _MSC_VER > 1000
9. #pragma once
10. #endif // _MSC_VER > 1000
12. #include "QnxHardTimer.h"
14. class CCpuUsed : public CQnxHardTimer  
15. {
16. public:
17.     CCpuUsed();
18.     virtual ~CCpuUsed();
20.     virtual void  RepeatTimerThread();
22.     int GetCpuUsed();
24. public:
25.     static CCpuUsed s_CpuUsed;
27. protected:
28.     int m_iCpuUsed;
30.     clockid_t m_iClockID;
31.     uint64_t  m_ut_old;
32.     struct timespec m_tt_old;
33. };
35. #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 
5. #include 
6. #include "CpuUsed.h"
8. //////////////////////////////////////////////////////////////////////
9. // Construction/Destruction
10. //////////////////////////////////////////////////////////////////////
11. CCpuUsed CCpuUsed::s_CpuUsed;
13. CCpuUsed::CCpuUsed()
14. {
15.     m_iClockID=ClockId(1, 1); //取空闲线程;
16.     m_ut_old=0;
17. }
19. CCpuUsed::~CCpuUsed()
20. {
22. }
24. void  CCpuUsed::RepeatTimerThread()
25. {
26.     uint64_t  ut_now=0;
27.     struct timespec tt_now;
28.     uint64_t  ut_sub; //时间差
29.     uint64_t  ut_tmp; 
30.     ClockTime(m_iClockID, NULL, &ut_now);
31.     clock_gettime( CLOCK_REALTIME, &tt_now);
32.     ut_tmp=tt_now.tv_sec-m_tt_old.tv_sec;
33.     ut_sub=ut_tmp*1000000000+tt_now.tv_nsec-m_tt_old.tv_nsec;
34.     m_iCpuUsed=(int)( ((float)(ut_sub-(ut_now-m_ut_old))/(float)ut_sub)*100 );
35.     m_ut_old=ut_now;
36.     m_tt_old=tt_now;
37. //  printf("m_iCpuUsed=%d%%/n",m_iCpuUsed);
38. }
40. int CCpuUsed::GetCpuUsed()
41. {
42.     if (m_iCpuUsed>100)
43.     {
44.         return 100;
45.     }else if (m_iCpuUsed<0)
46.     {
47.         return 0;
48.     }else
49.         return m_iCpuUsed;
50. }

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

 

5、参考资料

 

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