Debian Codegraph @

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