1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
// processinfo_linux2.cpp
/* Copyright 2009 10gen Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "processinfo.h"
#include <iostream>
#include <stdio.h>
using namespace std;
#define KLONG long
#define KLF "l"
namespace mongo {
class LinuxProc {
public:
LinuxProc( pid_t pid = getpid() ){
char name[128];
sprintf( name , "/proc/%d/stat" , pid );
FILE * f = fopen( name , "r");
int found = fscanf(f,
"%d %s %c "
"%d %d %d %d %d "
"%lu %lu %lu %lu %lu "
"%lu %lu %ld %ld " /* utime stime cutime cstime */
"%ld %ld "
"%ld "
"%ld "
"%lu " /* start_time */
"%lu "
"%ld " // rss
"%lu %"KLF"u %"KLF"u %"KLF"u %"KLF"u %"KLF"u "
/*
"%*s %*s %*s %*s "
"%"KLF"u %*lu %*lu "
"%d %d "
"%lu %lu"
*/
,
&_pid,
_comm,
&_state,
&_ppid, &_pgrp, &_session, &_tty, &_tpgid,
&_flags, &_min_flt, &_cmin_flt, &_maj_flt, &_cmaj_flt,
&_utime, &_stime, &_cutime, &_cstime,
&_priority, &_nice,
&_alarm,
&_nlwp,
&_start_time,
&_vsize,
&_rss,
&_rss_rlim, &_start_code, &_end_code, &_start_stack, &_kstk_esp, &_kstk_eip
/*
&_wchan,
&_exit_signal, &_processor,
&_rtprio, &_sched
*/
);
if ( found == 0 ){
cout << "system error: reading proc info" << endl;
}
fclose( f );
}
unsigned long getVirtualMemorySize(){
return _vsize;
}
unsigned long getResidentSize(){
return (unsigned long)_rss * 4 * 1024;
}
private:
int _pid;
// The process ID.
char _comm[128];
// The filename of the executable, in parentheses. This is visible whether or not the executable is swapped out.
char _state;
//One character from the string "RSDZTW" where R is running, S is sleeping in an interruptible wait, D is waiting in uninterruptible
// disk sleep, Z is zombie, T is traced or stopped (on a signal), and W is paging.
int _ppid;
// The PID of the parent.
int _pgrp;
// The process group ID of the process.
int _session;
// The session ID of the process.
int _tty;
// The tty the process uses.
int _tpgid;
// The process group ID of the process which currently owns the tty that the process is connected to.
unsigned long _flags; // %lu
// The kernel flags word of the process. For bit meanings, see the PF_* defines in <linux/sched.h>. Details depend on the kernel version.
unsigned long _min_flt; // %lu
// The number of minor faults the process has made which have not required loading a memory page from disk.
unsigned long _cmin_flt; // %lu
// The number of minor faults that the process
unsigned long _maj_flt; // %lu
// The number of major faults the process has made which have required loading a memory page from disk.
unsigned long _cmaj_flt; // %lu
// The number of major faults that the process
unsigned long _utime; // %lu
// The number of jiffies that this process has been scheduled in user mode.
unsigned long _stime; // %lu
// The number of jiffies that this process has been scheduled in kernel mode.
long _cutime; // %ld
// The number of jiffies that this removed field.
long _cstime; // %ld
long _priority;
long _nice;
long _nlwp; // %ld
// The time in jiffies before the next SIGALRM is sent to the process due to an interval timer.
unsigned long _alarm;
unsigned long _start_time; // %lu
// The time in jiffies the process started after system boot.
unsigned long _vsize; // %lu
// Virtual memory size in bytes.
long _rss; // %ld
// Resident Set Size: number of pages the process has in real memory, minus 3 for administrative purposes. This is just the pages which
// count towards text, data, or stack space. This does not include pages which have not been demand-loaded in, or which are swapped out
unsigned long _rss_rlim; // %lu
// Current limit in bytes on the rss of the process (usually 4294967295 on i386).
unsigned long _start_code; // %lu
// The address above which program text can run.
unsigned long _end_code; // %lu
// The address below which program text can run.
unsigned long _start_stack; // %lu
// The address of the start of the stack.
unsigned long _kstk_esp; // %lu
// The current value of esp (stack pointer), as found in the kernel stack page for the process.
unsigned long _kstk_eip; // %lu
// The current EIP (instruction pointer).
};
ProcessInfo::ProcessInfo( pid_t pid ) : _pid( pid ){
}
ProcessInfo::~ProcessInfo(){
}
bool ProcessInfo::supported(){
return true;
}
int ProcessInfo::getVirtualMemorySize(){
LinuxProc p(_pid);
return (int)( p.getVirtualMemorySize() / ( 1024.0 * 1024 ) );
}
int ProcessInfo::getResidentSize(){
LinuxProc p(_pid);
return (int)( p.getResidentSize() / ( 1024.0 * 1024 ) );
}
}
|
