Debian Codegraph @

os/exec/+linux/process.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 use errors;
5 use fmt;
6 use rt;
7 use time;
8 use unix;
9 use unix::signal;
10
11 // Stores information about a child process.
12 export type process = unix::pid;
13
14 // Returns the currently running [[process]].
15 export fn self() process = {
16 return unix::getpid();
17 };
18
19 // Stores information about an exited process.
20 export type status = struct {
21 status: int,
22 // Not all of these members are supported on all operating systems.
23 // Only utime and stime are guaranteed to be available.
24 rusage: struct {
25 utime: time::instant,
26 stime: time::instant,
27 maxrss: u64,
28 minflt: u64,
29 majflt: u64,
30 inblock: u64,
31 oublock: u64,
32 nvcsw: u64,
33 nivcsw: u64,
34 },
35 };
36
37 fn rusage(st: *status, ru: *rt::rusage) void = {
38 st.rusage.utime = time::instant {
39 sec = ru.ru_utime.tv_sec,
40 nsec = ru.ru_utime.tv_usec * time::MICROSECOND: i64,
41 };
42 st.rusage.stime = time::instant {
43 sec = ru.ru_stime.tv_sec,
44 nsec = ru.ru_stime.tv_usec * time::MICROSECOND: i64,
45 };
46 st.rusage.maxrss = ru.ru_maxrss;
47 st.rusage.minflt = ru.ru_minflt;
48 st.rusage.majflt = ru.ru_majflt;
49 st.rusage.inblock = ru.ru_inblock;
50 st.rusage.oublock = ru.ru_oublock;
51 st.rusage.nvcsw = ru.ru_nvcsw;
52 st.rusage.nivcsw = ru.ru_nivcsw;
53 };
54
55 // Flags accepted by the [[wait]] family of functions.
56 export type wait_flag = enum int {
57 NONE = 0,
58 CONTINUED = rt::WCONTINUED,
59 UNTRACED = rt::WUNTRACED,
60 };
61
62 // Waits for a process to complete, then returns its status information.
63 export fn wait(
64 proc: *process,
65 flags: wait_flag = wait_flag::NONE,
66 ) (status | error) = {
67 let ru: rt::rusage = rt::rusage { ... };
68 let st: status = status { ... };
69 match (rt::wait4(*proc, &st.status, flags, &ru)) {
70 case let err: rt::errno =>
71 return errors::errno(err);
72 case let pid: rt::pid_t =>
73 assert(pid == *proc: rt::pid_t);
74 };
75 rusage(&st, &ru);
76 return st;
77 };
78
79 // Waits for the first child process to complete, then returns its process info
80 // and status
81 export fn waitany(
82 flags: wait_flag = wait_flag::NONE,
83 ) ((process, status) | error) = {
84 let ru: rt::rusage = rt::rusage { ... };
85 let st: status = status { ... };
86 match (rt::wait4(-1, &st.status, flags, &ru)) {
87 case let err: rt::errno =>
88 return errors::errno(err);
89 case let pid: rt::pid_t =>
90 rusage(&st, &ru);
91 return (pid, st);
92 };
93 };
94
95 // Waits for all children to terminate succesfully. If a child process exits
96 // with a nonzero status, returns its process info and exit status immediately,
97 // not waiting for the remaining children.
98 export fn waitall() (uint | error | !(process, exit_status)) = {
99 let st: status = status { ... };
100 let ru: rt::rusage = rt::rusage { ... };
101 for (let i = 0u; true; i += 1) match (rt::wait4(-1, &st.status, 0, &ru)) {
102 case let err: rt::errno =>
103 if (err == rt::ECHILD) {
104 return i;
105 };
106 return errors::errno(err);
107 case let pid: rt::pid_t =>
108 match (check(&st)) {
109 case void => void;
110 case let es: !exit_status =>
111 return (pid, es);
112 };
113 };
114 };
115
116 // Checks for process completion, returning its status information on
117 // completion, or void if it is still running.
118 export fn peek(
119 proc: *process,
120 flags: wait_flag = wait_flag::NONE,
121 ) (status | void | error) = {
122 let ru: rt::rusage = rt::rusage { ... };
123 let st: status = status { ... };
124 match (rt::wait4(*proc, &st.status, rt::WNOHANG | flags, &ru)) {
125 case let err: rt::errno =>
126 return errors::errno(err);
127 case let pid: rt::pid_t =>
128 switch (pid) {
129 case 0 =>
130 return;
131 case =>
132 assert(pid == *proc: rt::pid_t);
133 };
134 };
135 rusage(&st, &ru);
136 return st;
137 };
138
139 // Checks if any child process has completed, returning its process info and
140 // status if so.
141 export fn peekany(
142 flags: wait_flag = wait_flag::NONE,
143 ) ((process, status) | void | error) = {
144 let ru: rt::rusage = rt::rusage { ... };
145 let st: status = status { ... };
146 match (rt::wait4(-1, &st.status, rt::WNOHANG | flags, &ru)) {
147 case let err: rt::errno =>
148 return errors::errno(err);
149 case let pid: rt::pid_t =>
150 switch (pid) {
151 case 0 =>
152 return;
153 case =>
154 return (pid, st);
155 };
156 };
157 };
158
159 // The exit status code of a process.
160 export type exited = int;
161
162 // The signal number which caused a process to terminate.
163 export type signaled = signal::sig;
164
165 // A process was stopped.
166 export type stopped = void;
167
168 // A process was continued.
169 export type continued = void;
170
171 // The exit status of a process.
172 export type exit_status = (exited | signaled | stopped | continued);
173
174 // Returns a human friendly string describing the exit status. The string is
175 // statically allocated; use [[strings::dup]] to extend its lifetime.
176 export fn exitstr(status: exit_status) const str = {
177 static let buf: [1024]u8 = [0...];
178 match (status) {
179 case let i: exited =>
180 switch (i) {
181 case 0 =>
182 return "exited normally";
183 case =>
184 return fmt::bsprintf(buf, "exited with status {}",
185 i: int)!;
186 };
187 case let s: signaled =>
188 return fmt::bsprintf(buf, "exited with signal {}",
189 signal::signame(s))!;
190 case stopped =>
191 return "Stopped";
192 case continued =>
193 return "Continued";
194 };
195 };
196
197 // Returns the exit status of a completed process.
198 export fn exit(stat: *status) exit_status = {
199 if (rt::wifexited(stat.status)) {
200 return rt::wexitstatus(stat.status): exited;
201 };
202 if (rt::wifsignaled(stat.status)) {
203 return rt::wtermsig(stat.status): signaled;
204 };
205 if (rt::wifstopped(stat.status)) {
206 return stopped;
207 };
208 if (rt::wifcontinued(stat.status)) {
209 return continued;
210 };
211 abort("Unexpected exit status");
212 };
213
214 // Checks the exit status of a completed process, returning void if successful,
215 // or its status code as an error type if not.
216 export fn check(stat: *status) (void | !exit_status) = {
217 if (rt::wifexited(stat.status)) {
218 switch (rt::wexitstatus(stat.status)) {
219 case 0 =>
220 return void;
221 case =>
222 return exit(stat);
223 };
224 };
225 return exit(stat);
226 };
227
228 // Terminates a process. On Linux, this sends [[unix::signal::sig::TERM]] to the
229 // process.
230 export fn kill(proc: process) (void | errors::error) = {
231 return sig(proc, signal::sig::TERM);
232 };
233
234 // Sends a signal to a child process. This function is only supported on
235 // Unix-like systems.
236 export fn sig(proc: process, sig: signal::sig) (void | errors::error) = {
237 match (rt::kill(proc, sig)) {
238 case let errno: rt::errno =>
239 return errors::errno(errno);
240 case void =>
241 return;
242 };
243 };