process_iterator_linux.cc revision 6e8cce623b6e4fe0c9e4af605d675dd9d0338c38 
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/files/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
13namespace base {
14
15namespace {
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.
21std::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.
41bool 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
57ProcessIterator::ProcessIterator(const ProcessFilter* filter)
58    : filter_(filter) {
59  procfs_dir_ = opendir(internal::kProcDir);
60}
61
62ProcessIterator::~ProcessIterator() {
63  if (procfs_dir_) {
64    closedir(procfs_dir_);
65    procfs_dir_ = NULL;
66  }
67}
68
69bool 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
131bool NamedProcessIterator::IncludeEntry() {
132  if (executable_name_ != entry().exe_file())
133    return false;
134  return ProcessIterator::IncludeEntry();
135}
136
137}  // namespace base
138