base/process/process_posix.cc

   1 // Copyright (c) 2011 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.h"
   6
   7 #include <sys/resource.h>
   8 #include <sys/time.h>
   9 #include <sys/types.h>
  10
  11 #include "base/logging.h"
  12 #include "base/process/kill.h"
  13
  14 namespace base {
  15
  16 Process::Process(ProcessHandle handle) : process_(handle) {
  17 }
  18
  19 Process::Process(RValue other)
  20     : process_(other.object->process_) {
  21   other.object->Close();
  22 }
  23
  24 Process& Process::operator=(RValue other) {
  25   if (this != other.object) {
  26     process_ = other.object->process_;
  27     other.object->Close();
  28   }
  29   return *this;
  30 }
  31
  32 // static
  33 Process Process::Current() {
  34   return Process(GetCurrentProcessHandle());
  35 }
  36
  37 // static
  38 Process Process::Open(ProcessId pid) {
  39   if (pid == GetCurrentProcId())
  40     return Current();
  41
  42   // On POSIX process handles are the same as PIDs.
  43   return Process(pid);
  44 }
  45
  46 // static
  47 Process Process::OpenWithExtraPriviles(ProcessId pid) {
  48   // On POSIX there are no privileges to set.
  49   return Open(pid);
  50 }
  51
  52 // static
  53 Process Process::DeprecatedGetProcessFromHandle(ProcessHandle handle) {
  54   DCHECK_NE(handle, GetCurrentProcessHandle());
  55   return Process(handle);
  56 }
  57
  58 #if !defined(OS_LINUX)
  59 // static
  60 bool Process::CanBackgroundProcesses() {
  61   return false;
  62 }
  63 #endif  // !defined(OS_LINUX)
  64
  65 bool Process::IsValid() const {
  66   return process_ != kNullProcessHandle;
  67 }
  68
  69 ProcessHandle Process::Handle() const {
  70   return process_;
  71 }
  72
  73 Process Process::Duplicate() const {
  74   if (is_current())
  75     return Current();
  76
  77   return Process(process_);
  78 }
  79
  80 ProcessId Process::Pid() const {
  81   DCHECK(IsValid());
  82   return GetProcId(process_);
  83 }
  84
  85 bool Process::is_current() const {
  86   return process_ == GetCurrentProcessHandle();
  87 }
  88
  89 void Process::Close() {
  90   process_ = kNullProcessHandle;
  91   // if the process wasn't terminated (so we waited) or the state
  92   // wasn't already collected w/ a wait from process_utils, we're gonna
  93   // end up w/ a zombie when it does finally exit.
  94 }
  95
  96 void Process::Terminate(int result_code) {
  97   // result_code isn't supportable.
  98   DCHECK(IsValid());
  99   // We don't wait here. It's the responsibility of other code to reap the
 100   // child.
 101   KillProcess(process_, result_code, false);
 102 }
 103
 104 bool Process::WaitForExit(int* exit_code) {
 105   // TODO(rvargas) crbug.com/417532: Remove this constant.
 106   const int kNoTimeout = -1;
 107   return WaitForExitWithTimeout(TimeDelta::FromMilliseconds(kNoTimeout),
 108                                 exit_code);
 109 }
 110
 111 bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) {
 112   // TODO(rvargas) crbug.com/417532: Move the implementation here.
 113   return base::WaitForExitCodeWithTimeout(Handle(), exit_code, timeout);
 114 }
 115
 116 #if !defined(OS_LINUX)
 117 bool Process::IsProcessBackgrounded() const {
 118   // See SetProcessBackgrounded().
 119   DCHECK(IsValid());
 120   return false;
 121 }
 122
 123 bool Process::SetProcessBackgrounded(bool value) {
 124   // POSIX only allows lowering the priority of a process, so if we
 125   // were to lower it we wouldn't be able to raise it back to its initial
 126   // priority.
 127   DCHECK(IsValid());
 128   return false;
 129 }
 130 #endif  // !defined(OS_LINUX)
 131
 132 int Process::GetPriority() const {
 133   DCHECK(IsValid());
 134   return getpriority(PRIO_PROCESS, process_);
 135 }
 136
 137 }  // namspace base