hare

process.ha (5618B)

---

 // SPDX-License-Identifier: MPL-2.0
 // (c) Hare authors <https://harelang.org>
 
 use errors;
 use fmt;
 use rt;
 use time;
 use unix;
 use unix::signal;
 
 // Stores information about a child process.
 export type process = unix::pid;
 
 // Returns the currently running [[process]].
 export fn self() process = {
 	return unix::getpid();
 };
 
 // Stores information about an exited process.
 export type status = struct {
 	status: int,
 	// Not all of these members are supported on all operating systems.
 	// Only utime and stime are guaranteed to be available.
 	rusage: struct {
 		utime: time::instant,
 		stime: time::instant,
 		maxrss: u64,
 		minflt: u64,
 		majflt: u64,
 		inblock: u64,
 		oublock: u64,
 		nvcsw: u64,
 		nivcsw: u64,
 	},
 };
 
 fn rusage(st: *status, ru: *rt::rusage) void = {
 	st.rusage.utime = time::instant {
 		sec = ru.ru_utime.tv_sec,
 		nsec = ru.ru_utime.tv_usec * time::MICROSECOND: i64,
 	};
 	st.rusage.stime = time::instant {
 		sec = ru.ru_stime.tv_sec,
 		nsec = ru.ru_stime.tv_usec * time::MICROSECOND: i64,
 	};
 	st.rusage.maxrss = ru.ru_maxrss;
 	st.rusage.minflt = ru.ru_minflt;
 	st.rusage.majflt = ru.ru_majflt;
 	st.rusage.inblock = ru.ru_inblock;
 	st.rusage.oublock = ru.ru_oublock;
 	st.rusage.nvcsw = ru.ru_nvcsw;
 	st.rusage.nivcsw = ru.ru_nivcsw;
 };
 
 // Waits for a process to complete, then returns its status information.
 export fn wait(proc: *process) (status | error) = {
 	let ru: rt::rusage = rt::rusage { ... };
 	let st: status = status { ... };
 	match (rt::wait4(*proc, &st.status, 0, &ru)) {
 	case let err: rt::errno =>
 		return errors::errno(err);
 	case let pid: rt::pid_t =>
 		assert(pid == *proc: rt::pid_t);
 	};
 	rusage(&st, &ru);
 	return st;
 };
 
 // Waits for the first child process to complete, then returns its process info
 // and status
 export fn waitany() ((process, status) | error) = {
 	let ru: rt::rusage = rt::rusage { ... };
 	let st: status = status { ... };
 	match (rt::wait4(-1, &st.status, 0, &ru)) {
 	case let err: rt::errno =>
 		return errors::errno(err);
 	case let pid: rt::pid_t =>
 		rusage(&st, &ru);
 		return (pid, st);
 	};
 };
 
 // Waits for all children to terminate succesfully. If a child process exits
 // with a nonzero status, returns its process info and exit status immediately,
 // not waiting for the remaining children.
 export fn waitall() (uint | error | !(process, exit_status)) = {
 	let st: status = status { ... };
 	let ru: rt::rusage = rt::rusage { ... };
 	for (let i = 0u; true; i += 1) match (rt::wait4(-1, &st.status, 0, &ru)) {
 	case let err: rt::errno =>
 		if (err == rt::ECHILD) {
 			return i;
 		};
 		return errors::errno(err);
 	case let pid: rt::pid_t =>
 		match (check(&st)) {
 		case void => void;
 		case let es: !exit_status =>
 			return (pid, es);
 		};
 	};
 };
 
 // Checks for process completion, returning its status information on
 // completion, or void if it is still running.
 export fn peek(proc: *process) (status | void | error) = {
 	let ru: rt::rusage = rt::rusage { ... };
 	let st: status = status { ... };
 	match (rt::wait4(*proc, &st.status, rt::WNOHANG, &ru)) {
 	case let err: rt::errno =>
 		return errors::errno(err);
 	case let pid: rt::pid_t =>
 		switch (pid) {
 		case 0 =>
 			return;
 		case =>
 			assert(pid == *proc: rt::pid_t);
 		};
 	};
 	rusage(&st, &ru);
 	return st;
 };
 
 // Checks if any child process has completed, returning its process info and
 // status if so.
 export fn peekany() ((process, status) | void | error) = {
 	let ru: rt::rusage = rt::rusage { ... };
 	let st: status = status { ... };
 	match (rt::wait4(-1, &st.status, rt::WNOHANG, &ru)) {
 	case let err: rt::errno =>
 		return errors::errno(err);
 	case let pid: rt::pid_t =>
 		switch (pid) {
 		case 0 =>
 			return;
 		case =>
 			return (pid, st);
 		};
 	};
 };
 
 // The exit status code of a process.
 export type exited = int;
 
 // The signal number which caused a process to terminate.
 export type signaled = signal::sig;
 
 // The exit status of a process.
 export type exit_status = (exited | signaled);
 
 // Returns a human friendly string describing the exit status. The string is
 // statically allocated; use [[strings::dup]] to extend its lifetime.
 export fn exitstr(status: exit_status) const str = {
 	static let buf: [1024]u8 = [0...];
 	match (status) {
 	case let i: exited =>
 		switch (i) {
 		case 0 =>
 			return "exited normally";
 		case =>
 			return fmt::bsprintf(buf, "exited with status {}",
 				i: int);
 		};
 	case let s: signaled =>
 		return fmt::bsprintf(buf, "exited with signal {}",
 			signal::signame(s));
 	};
 };
 
 // Returns the exit status of a completed process.
 export fn exit(stat: *status) exit_status = {
 	if (rt::wifexited(stat.status)) {
 		return rt::wexitstatus(stat.status): exited;
 	};
 	if (rt::wifsignaled(stat.status)) {
 		return rt::wtermsig(stat.status): signaled;
 	};
 	abort("Unexpected exit status");
 };
 
 // Checks the exit status of a completed process, returning void if successful,
 // or its status code as an error type if not.
 export fn check(stat: *status) (void | !exit_status) = {
 	if (rt::wifexited(stat.status)) {
 		switch (rt::wexitstatus(stat.status)) {
 		case 0 =>
 			return void;
 		case =>
 			return exit(stat);
 		};
 	};
 	return exit(stat);
 };
 
 // Terminates a process. On Linux, this sends [[unix::signal::sig::TERM]] to the
 // process.
 export fn kill(proc: process) (void | errors::error) = {
 	return sig(proc, signal::sig::TERM);
 };
 
 // Sends a signal to a child process. This function is only supported on
 // Unix-like systems.
 export fn sig(proc: process, sig: signal::sig) (void | errors::error) = {
 	match (rt::kill(proc, sig)) {
 	case let errno: rt::errno =>
 		return errors::errno(errno);
 	case void =>
 		return;
 	};
 };