xref: /freebsd/contrib/kyua/utils/process/status.cpp (revision b0d29bc47dba79f6f38e67eabadfb4b32ffd9390)
1 // Copyright 2010 The Kyua Authors.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 //   notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 //   notice, this list of conditions and the following disclaimer in the
12 //   documentation and/or other materials provided with the distribution.
13 // * Neither the name of Google Inc. nor the names of its contributors
14 //   may be used to endorse or promote products derived from this software
15 //   without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 
29 #include "utils/process/status.hpp"
30 
31 extern "C" {
32 #include <sys/wait.h>
33 }
34 
35 #include "utils/format/macros.hpp"
36 #include "utils/optional.ipp"
37 #include "utils/sanity.hpp"
38 
39 namespace process = utils::process;
40 
41 using utils::none;
42 using utils::optional;
43 
44 #if !defined(WCOREDUMP)
45 #   define WCOREDUMP(x) false
46 #endif
47 
48 
49 /// Constructs a new status object based on the status value of waitpid(2).
50 ///
51 /// \param dead_pid_ The PID of the process this status belonged to.
52 /// \param stat_loc The status value returnd by waitpid(2).
status(const int dead_pid_,int stat_loc)53 process::status::status(const int dead_pid_, int stat_loc) :
54     _dead_pid(dead_pid_),
55     _exited(WIFEXITED(stat_loc) ?
56             optional< int >(WEXITSTATUS(stat_loc)) : none),
57     _signaled(WIFSIGNALED(stat_loc) ?
58               optional< std::pair< int, bool > >(
59                   std::make_pair(WTERMSIG(stat_loc), WCOREDUMP(stat_loc))) :
60                   none)
61 {
62 }
63 
64 
65 /// Constructs a new status object based on fake values.
66 ///
67 /// \param exited_ If not none, specifies the exit status of the program.
68 /// \param signaled_ If not none, specifies the termination signal and whether
69 ///     the process dumped core or not.
status(const optional<int> & exited_,const optional<std::pair<int,bool>> & signaled_)70 process::status::status(const optional< int >& exited_,
71                         const optional< std::pair< int, bool > >& signaled_) :
72     _dead_pid(-1),
73     _exited(exited_),
74     _signaled(signaled_)
75 {
76 }
77 
78 
79 /// Constructs a new status object based on a fake exit status.
80 ///
81 /// \param exitstatus_ The exit code of the process.
82 ///
83 /// \return A status object with fake data.
84 process::status
fake_exited(const int exitstatus_)85 process::status::fake_exited(const int exitstatus_)
86 {
87     return status(utils::make_optional(exitstatus_), none);
88 }
89 
90 
91 /// Constructs a new status object based on a fake exit status.
92 ///
93 /// \param termsig_ The termination signal of the process.
94 /// \param coredump_ Whether the process dumped core or not.
95 ///
96 /// \return A status object with fake data.
97 process::status
fake_signaled(const int termsig_,const bool coredump_)98 process::status::fake_signaled(const int termsig_, const bool coredump_)
99 {
100     return status(none, utils::make_optional(std::make_pair(termsig_,
101                                                             coredump_)));
102 }
103 
104 
105 /// Returns the PID of the process this status was taken from.
106 ///
107 /// Please note that the process is already dead and gone from the system.  This
108 /// PID can only be used for informational reasons and not to address the
109 /// process in any way.
110 ///
111 /// \return The PID of the original process.
112 int
dead_pid(void) const113 process::status::dead_pid(void) const
114 {
115     return _dead_pid;
116 }
117 
118 
119 /// Returns whether the process exited cleanly or not.
120 ///
121 /// \return True if the process exited cleanly, false otherwise.
122 bool
exited(void) const123 process::status::exited(void) const
124 {
125     return _exited;
126 }
127 
128 
129 /// Returns the exit code of the process.
130 ///
131 /// \pre The process must have exited cleanly (i.e. exited() must be true).
132 ///
133 /// \return The exit code.
134 int
exitstatus(void) const135 process::status::exitstatus(void) const
136 {
137     PRE(exited());
138     return _exited.get();
139 }
140 
141 
142 /// Returns whether the process terminated due to a signal or not.
143 ///
144 /// \return True if the process terminated due to a signal, false otherwise.
145 bool
signaled(void) const146 process::status::signaled(void) const
147 {
148     return _signaled;
149 }
150 
151 
152 /// Returns the signal that terminated the process.
153 ///
154 /// \pre The process must have terminated by a signal (i.e. signaled() must be
155 ///     true.
156 ///
157 /// \return The signal number.
158 int
termsig(void) const159 process::status::termsig(void) const
160 {
161     PRE(signaled());
162     return _signaled.get().first;
163 }
164 
165 
166 /// Returns whether the process core dumped or not.
167 ///
168 /// This functionality may be unsupported in some platforms.  In such cases,
169 /// this method returns false unconditionally.
170 ///
171 /// \pre The process must have terminated by a signal (i.e. signaled() must be
172 ///     true.
173 ///
174 /// \return True if the process dumped core, false otherwise.
175 bool
coredump(void) const176 process::status::coredump(void) const
177 {
178     PRE(signaled());
179     return _signaled.get().second;
180 }
181 
182 
183 /// Injects the object into a stream.
184 ///
185 /// \param output The stream into which to inject the object.
186 /// \param status The object to format.
187 ///
188 /// \return The output stream.
189 std::ostream&
operator <<(std::ostream & output,const status & status)190 process::operator<<(std::ostream& output, const status& status)
191 {
192     if (status.exited()) {
193         output << F("status{exitstatus=%s}") % status.exitstatus();
194     } else {
195         INV(status.signaled());
196         output << F("status{termsig=%s, coredump=%s}") % status.termsig() %
197             status.coredump();
198     }
199     return output;
200 }
201