1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/process/process_iterator.h"
6
7 #include "base/file_util.h"
8 #include "base/logging.h"
9 #include "base/process/internal_linux.h"
10 #include "base/strings/string_util.h"
11 #include "base/threading/thread_restrictions.h"
12
13 namespace base {
14
15 namespace {
16
17 // Reads the |field_num|th field from |proc_stats|.
18 // Returns an empty string on failure.
19 // This version only handles VM_COMM and VM_STATE, which are the only fields
20 // that are strings.
GetProcStatsFieldAsString(const std::vector<std::string> & proc_stats,internal::ProcStatsFields field_num)21 std::string GetProcStatsFieldAsString(
22 const std::vector<std::string>& proc_stats,
23 internal::ProcStatsFields field_num) {
24 if (field_num < internal::VM_COMM || field_num > internal::VM_STATE) {
25 NOTREACHED();
26 return std::string();
27 }
28
29 if (proc_stats.size() > static_cast<size_t>(field_num))
30 return proc_stats[field_num];
31
32 NOTREACHED();
33 return 0;
34 }
35
36 // Reads /proc/<pid>/cmdline and populates |proc_cmd_line_args| with the command
37 // line arguments. Returns true if successful.
38 // Note: /proc/<pid>/cmdline contains command line arguments separated by single
39 // null characters. We tokenize it into a vector of strings using '\0' as a
40 // delimiter.
GetProcCmdline(pid_t pid,std::vector<std::string> * proc_cmd_line_args)41 bool GetProcCmdline(pid_t pid, std::vector<std::string>* proc_cmd_line_args) {
42 // Synchronously reading files in /proc is safe.
43 ThreadRestrictions::ScopedAllowIO allow_io;
44
45 FilePath cmd_line_file = internal::GetProcPidDir(pid).Append("cmdline");
46 std::string cmd_line;
47 if (!ReadFileToString(cmd_line_file, &cmd_line))
48 return false;
49 std::string delimiters;
50 delimiters.push_back('\0');
51 Tokenize(cmd_line, delimiters, proc_cmd_line_args);
52 return true;
53 }
54
55 } // namespace
56
ProcessIterator(const ProcessFilter * filter)57 ProcessIterator::ProcessIterator(const ProcessFilter* filter)
58 : filter_(filter) {
59 procfs_dir_ = opendir(internal::kProcDir);
60 }
61
~ProcessIterator()62 ProcessIterator::~ProcessIterator() {
63 if (procfs_dir_) {
64 closedir(procfs_dir_);
65 procfs_dir_ = NULL;
66 }
67 }
68
CheckForNextProcess()69 bool ProcessIterator::CheckForNextProcess() {
70 // TODO(port): skip processes owned by different UID
71
72 pid_t pid = kNullProcessId;
73 std::vector<std::string> cmd_line_args;
74 std::string stats_data;
75 std::vector<std::string> proc_stats;
76
77 // Arbitrarily guess that there will never be more than 200 non-process
78 // files in /proc. Hardy has 53 and Lucid has 61.
79 int skipped = 0;
80 const int kSkipLimit = 200;
81 while (skipped < kSkipLimit) {
82 dirent* slot = readdir(procfs_dir_);
83 // all done looking through /proc?
84 if (!slot)
85 return false;
86
87 // If not a process, keep looking for one.
88 pid = internal::ProcDirSlotToPid(slot->d_name);
89 if (!pid) {
90 skipped++;
91 continue;
92 }
93
94 if (!GetProcCmdline(pid, &cmd_line_args))
95 continue;
96
97 if (!internal::ReadProcStats(pid, &stats_data))
98 continue;
99 if (!internal::ParseProcStats(stats_data, &proc_stats))
100 continue;
101
102 std::string runstate =
103 GetProcStatsFieldAsString(proc_stats, internal::VM_STATE);
104 if (runstate.size() != 1) {
105 NOTREACHED();
106 continue;
107 }
108
109 // Is the process in 'Zombie' state, i.e. dead but waiting to be reaped?
110 // Allowed values: D R S T Z
111 if (runstate[0] != 'Z')
112 break;
113
114 // Nope, it's a zombie; somebody isn't cleaning up after their children.
115 // (e.g. WaitForProcessesToExit doesn't clean up after dead children yet.)
116 // There could be a lot of zombies, can't really decrement i here.
117 }
118 if (skipped >= kSkipLimit) {
119 NOTREACHED();
120 return false;
121 }
122
123 entry_.pid_ = pid;
124 entry_.ppid_ = GetProcStatsFieldAsInt64(proc_stats, internal::VM_PPID);
125 entry_.gid_ = GetProcStatsFieldAsInt64(proc_stats, internal::VM_PGRP);
126 entry_.cmd_line_args_.assign(cmd_line_args.begin(), cmd_line_args.end());
127 entry_.exe_file_ = GetProcessExecutablePath(pid).BaseName().value();
128 return true;
129 }
130
IncludeEntry()131 bool NamedProcessIterator::IncludeEntry() {
132 if (executable_name_ != entry().exe_file())
133 return false;
134 return ProcessIterator::IncludeEntry();
135 }
136
137 } // namespace base
138