Put back kal_process_wait, which a bulk edit had swallowed

⚠️⚠️ A REGEX SUBSTITUTION ACROSS A WHOLE FILE DELETED A FUNCTION I NEVER MEANT TO
TOUCH, and nothing local noticed: this file still compiled, because a definition
that is absent is not a compile error --- it is a link error, and only in a
program that calls it.

⭐ What found it was the cross-link job in openkal-musl, three repositories away:

    ld64.lld: error: undefined symbol: _kal_process_wait

⇒ Restored from the branch point rather than retyped. The test file is updated
for the 0.11 spawn record at the same time.

The lesson is recorded rather than resolved: a multi-line pattern applied to a
whole file can remove more than it matches, and the only thing that reports it is
something that LINKS. This repository builds a library and does not link a
program, so its own build could never have caught this.

Author: Sunrisepeak

src/process.cpp

@@ -229,6 +229,30 @@ void kal_process_channel_close(kal_stream s) {
 // Starting a program that receives exactly the directories named.
 
 // One program, whatever unit it is in --- the unit has its own operation below,
+int kal_process_wait(kal_process h, int* status, int* terminated_by_environment) {
+    if (h.h == 0) return kal_err_invalid;
+    int st = 0;
+    for (;;) {
+        const okm_long r = okm::sys(okm::nr_wait4, static_cast<okm_long>(h.h),
+                                    reinterpret_cast<okm_long>(&st), 0, 0);
+        if (okm::interrupted(r)) continue;
+        if (okm::failed(r)) return okm::translate(r);
+        break;
+    }
+    // The encoding is the kernel's: the low seven bits name the signal that
+    // ended the program and are zero when it ended by returning, in which case
+    // the next eight bits are what it returned.
+    const int signalled = st & 0x7f;
+    if (signalled == 0) {
+        if (status) *status = (st >> 8) & 0xff;
+        if (terminated_by_environment) *terminated_by_environment = 0;
+    } else {
+        if (status) *status = signalled;
+        if (terminated_by_environment) *terminated_by_environment = 1;
+    }
+    return kal_ok;
+}
+
 // so this one's meaning never turns on how the program was started.
 int kal_process_terminate(kal_process h) {
     if (h.h == 0) return kal_err_invalid;

tests/conformance_process_task.cpp

@@ -63,6 +63,11 @@ int main() {
     check(have_root, "a directory covering the file system is supplied");
 
     if (have_root) {
+        // How every start below is described. `work' is the same directory as
+        // `base' --- a caller that does not care passes it, openkal having no
+        // ambient working directory for a default to mean.
+        const kal_spawn how{ slash, slash, nullptr, nullptr, 0, 0 };
+
         // The program that succeeds and the program that fails are at
         // different places on different systems. The test locates them rather
         // than assuming, because assuming would make it a test of one system.
@@ -104,7 +109,7 @@ int main() {
         const kal_uintptr lens[] = { 7 };
         int rc = kal_err_invalid;
         if (t >= 0)
-            rc = kal_process_spawn(slash, true_paths[t], true_lens[t], argv, lens, 1,
+            rc = kal_process_spawn(&how, true_paths[t], true_lens[t], argv, lens, 1,
                                    nullptr, nullptr, 0, nullptr, &p);
         check(rc == kal_ok, "a program is started");
         if (rc == kal_ok) {
@@ -128,7 +133,7 @@ int main() {
         const char* qargv[] = { "openkal" };
         int qrc = kal_err_invalid;
         if (fpath >= 0)
-            qrc = kal_process_spawn(slash, false_paths[fpath], false_lens[fpath], qargv, lens, 1,
+            qrc = kal_process_spawn(&how, false_paths[fpath], false_lens[fpath], qargv, lens, 1,
                                     nullptr, nullptr, 0, nullptr, &q);
         check(qrc == kal_ok, "the program that fails is started");
         if (qrc == kal_ok) {
@@ -171,7 +176,7 @@ int main() {
         const kal_uintptr rlens[] = { 22, 2, script_len };
         int rrc = kal_err_invalid;
         if (sh >= 0)
-            rrc = kal_process_spawn(slash, sh_paths[sh], sh_lens[sh], rargv, rlens, 3,
+            rrc = kal_process_spawn(&how, sh_paths[sh], sh_lens[sh], rargv, rlens, 3,
                                     nullptr, nullptr, 0, nullptr, &r);
         check(rrc == kal_ok, "a shell is started");
         if (rrc == kal_ok) {
@@ -185,7 +190,9 @@ int main() {
 
     // A name that ascends is refused here as it is in the file system.
     kal_process bad{};
-    check(kal_process_spawn(kal::fs::working(), "../bin/true", 11,
+    const kal_spawn escape{ kal::fs::working(), kal::fs::working(),
+                            nullptr, nullptr, 0, 0 };
+    check(kal_process_spawn(&escape, "../bin/true", 11,
                             nullptr, nullptr, 0, nullptr, nullptr, 0, nullptr, &bad)
           != kal_ok, "an ascending program name is refused");