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
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/process/internal_aix.h"
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/procfs.h>
#include <unistd.h>
#include <map>
#include <string>
#include <vector>
#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/threading/thread_restrictions.h"
#include "base/time/time.h"
// Not defined on AIX by default.
#define NAME_MAX 255
namespace base {
namespace internalAIX {
const char kProcDir[] = "/proc";
const char kStatFile[] = "psinfo"; // AIX specific
FilePath GetProcPidDir(pid_t pid) {
return FilePath(kProcDir).Append(NumberToString(pid));
}
pid_t ProcDirSlotToPid(const char* d_name) {
int i;
for (i = 0; i < NAME_MAX && d_name[i]; ++i) {
if (!IsAsciiDigit(d_name[i])) {
return 0;
}
}
if (i == NAME_MAX) {
return 0;
}
// Read the process's command line.
pid_t pid;
std::string pid_string(d_name);
if (!StringToInt(pid_string, &pid)) {
NOTREACHED();
}
return pid;
}
bool ReadProcFile(const FilePath& file, struct psinfo* info) {
// Synchronously reading files in /proc is safe.
ScopedAllowBlocking scoped_allow_blocking;
int fileId;
if ((fileId = open(file.value().c_str(), O_RDONLY)) < 0) {
DPLOG(WARNING) << "Failed to open " << file.MaybeAsASCII();
return false;
}
if (read(fileId, info, sizeof(*info)) < 0) {
DPLOG(WARNING) << "Failed to read " << file.MaybeAsASCII();
return false;
}
return true;
}
bool ReadProcStats(pid_t pid, struct psinfo* info) {
FilePath stat_file = internalAIX::GetProcPidDir(pid).Append(kStatFile);
return ReadProcFile(stat_file, info);
}
bool ParseProcStats(struct psinfo& stats_data,
std::vector<std::string>* proc_stats) {
// The stat file is formatted as:
// struct psinfo
// see -
// https://www.ibm.com/support/knowledgecenter/ssw_aix_71/com.ibm.aix.files/proc.htm
proc_stats->clear();
// PID.
proc_stats->push_back(NumberToString(stats_data.pr_pid));
// Process name without parentheses. // 1
proc_stats->push_back(stats_data.pr_fname);
// Process State (Not available) // 2
proc_stats->push_back("0");
// Process id of parent // 3
proc_stats->push_back(NumberToString(stats_data.pr_ppid));
// Process group id // 4
proc_stats->push_back(NumberToString(stats_data.pr_pgid));
return true;
}
typedef std::map<std::string, std::string> ProcStatMap;
void ParseProcStat(const std::string& contents, ProcStatMap* output) {
StringPairs key_value_pairs;
SplitStringIntoKeyValuePairs(contents, ' ', '\n', &key_value_pairs);
for (size_t i = 0; i < key_value_pairs.size(); ++i) {
output->insert(key_value_pairs[i]);
}
}
int64_t GetProcStatsFieldAsInt64(const std::vector<std::string>& proc_stats,
ProcStatsFields field_num) {
DCHECK_GE(field_num, VM_PPID);
CHECK_LT(static_cast<size_t>(field_num), proc_stats.size());
int64_t value;
return StringToInt64(proc_stats[field_num], &value) ? value : 0;
}
size_t GetProcStatsFieldAsSizeT(const std::vector<std::string>& proc_stats,
ProcStatsFields field_num) {
DCHECK_GE(field_num, VM_PPID);
CHECK_LT(static_cast<size_t>(field_num), proc_stats.size());
size_t value;
return StringToSizeT(proc_stats[field_num], &value) ? value : 0;
}
int64_t ReadProcStatsAndGetFieldAsInt64(pid_t pid, ProcStatsFields field_num) {
struct psinfo stats_data;
if (!ReadProcStats(pid, &stats_data)) {
return 0;
}
std::vector<std::string> proc_stats;
if (!ParseProcStats(stats_data, &proc_stats)) {
return 0;
}
return GetProcStatsFieldAsInt64(proc_stats, field_num);
}
size_t ReadProcStatsAndGetFieldAsSizeT(pid_t pid, ProcStatsFields field_num) {
struct psinfo stats_data;
if (!ReadProcStats(pid, &stats_data)) {
return 0;
}
std::vector<std::string> proc_stats;
if (!ParseProcStats(stats_data, &proc_stats)) {
return 0;
}
return GetProcStatsFieldAsSizeT(proc_stats, field_num);
}
} // namespace internalAIX
} // namespace base
|
