Debian Codegraph @

os/exec/+freebsd/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 = rt::rusage { ... };
82 let st: status = 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: int =>
87 assert(pid == *proc: int);
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 = rt::rusage { ... };
99 let st: status = status { ... };
100 match (rt::wait4(-1, &st.status, flags, &ru)) {
101 case let err: rt::errno =>
102 return errors::errno(err);
103 case let pid: int =>
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 = status { ... };
114 let ru: rt::rusage = rt::rusage { ... };
115 for (let i = 0u; true; i += 1) match (rt::wait4(-1, &st.status, 0, &ru)) {
116 case let err: rt::errno =>
117 if (err == rt::ECHILD) {
118 return i;
119 } else {
120 return errors::errno(err);
121 };
122 case let pid: int =>
123 match (check(&st)) {
124 case void => void;
125 case let es: !exit_status =>
126 return (pid: process, es);
127 };
128 };
129 };
130
131 // Checks for process completion, returning its status information on
132 // completion, or void if it is still running.
133 export fn peek(
134 proc: *process,
135 flags: wait_flag = wait_flag::NONE,
136 ) (status | void | error) = {
137 let ru: rt::rusage = rt::rusage { ... };
138 let st: status = status { ... };
139 match (rt::wait4(*proc, &st.status, rt::WNOHANG | flags, &ru)) {
140 case let err: rt::errno =>
141 return errors::errno(err);
142 case let pid: int =>
143 switch (pid) {
144 case 0 =>
145 return;
146 case =>
147 assert(pid == *proc: int);
148 };
149 };
150 rusage(&st, &ru);
151 return st;
152 };
153
154 // Checks if any child process has completed, returning its process info and
155 // status if so.
156 export fn peekany(
157 flags: wait_flag = wait_flag::NONE,
158 ) ((process, status) | void | error) = {
159 let ru: rt::rusage = rt::rusage { ... };
160 let st: status = status { ... };
161 match (rt::wait4(-1, &st.status, rt::WNOHANG | flags, &ru)) {
162 case let err: rt::errno =>
163 return errors::errno(err);
164 case let pid: int =>
165 switch (pid) {
166 case 0 =>
167 return;
168 case =>
169 return (pid: process, st);
170 };
171 };
172 };
173
174 // The exit status code of a process.
175 export type exited = int;
176
177 // The signal number which caused a process to terminate.
178 export type signaled = signal::sig;
179
180 // The exit status of a process.
181 export type exit_status = (exited | signaled);
182
183 // Returns a human friendly string describing the exit status. The string is
184 // statically allocated; use [[strings::dup]] to extend its lifetime.
185 export fn exitstr(status: exit_status) const str = {
186 static let buf: [1024]u8 = [0...];
187 match (status) {
188 case let i: exited =>
189 switch (i) {
190 case 0 =>
191 return "exited normally";
192 case =>
193 return fmt::bsprintf(buf,
194 "exited with status {}", i: int)!;
195 };
196 case let s: signaled =>
197 return fmt::bsprintf(buf, "exited with signal {}",
198 signal::signame(s))!;
199 };
200 };
201
202 // Returns the exit status of a completed process.
203 export fn exit(stat: *status) exit_status = {
204 if (rt::wifexited(stat.status)) {
205 return rt::wexitstatus(stat.status): exited;
206 };
207 if (rt::wifsignaled(stat.status)) {
208 return rt::wtermsig(stat.status): signaled;
209 };
210 abort("Unexpected exit status");
211 };
212
213 // Checks the exit status of a completed process, returning void if successful,
214 // or its status code as an error type if not.
215 export fn check(stat: *status) (void | !exit_status) = {
216 if (rt::wifexited(stat.status)) {
217 switch (rt::wexitstatus(stat.status)) {
218 case 0 =>
219 return void;
220 case =>
221 return exit(stat);
222 };
223 };
224 return exit(stat);
225 };
226
227 // Terminates a process. On FreeBSD, this sends [[unix::signal::sig::TERM]] to
228 // the process.
229 export fn kill(proc: process) (void | errors::error) = {
230 return sig(proc, signal::sig::TERM);
231 };
232
233 // Sends a signal to a child process. This function is only supported on
234 // Unix-like systems.
235 export fn sig(proc: process, sig: signal::sig) (void | errors::error) = {
236 match (rt::kill(proc, sig)) {
237 case let errno: rt::errno =>
238 return errors::errno(errno);
239 case void =>
240 return;
241 };
242 };