pthread: cancel remaining live threads at process exit

__pthread_exit_func() joins every non-idle joinable thread and
spin-waits for detached ones.  If the program exits while a
daemon-style thread is parked forever in pthread_cond_wait / sem_wait,
that loop never completes and the process becomes unkillable -- the
exit handshake hangs in pthread_join.

On POSIX systems exit() terminates all remaining threads.  Approximate
those semantics: request cancellation of every live thread before the
join/wait loop.  Parked threads wake (see previous commit), run their
cancellation cleanup handlers, and exit through the normal pthread
path, so dos.library''s parent/child process accounting stays intact;
the existing join loop then completes as before.  Threads that exit
promptly on their own are unaffected: cancellation is deferred and
only acts at cancellation points.

Found porting OpenJDK 17 to AmigaOS 4: java prints its output, then
the process hung forever in __pthread_exit_func joining the parked JVM
daemon threads.  With this change the JVM exits cleanly.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: derfsss

library/pthread/pthread.c

@@ -488,6 +488,20 @@ void __pthread_exit_func(void) {
     struct DOSIFace *IDOS = _IDOS;
     SHOWMSG("[__pthread_exit_func :] Pthread __pthread_exit_func called.\n");
 
+    /* A thread that never exits by itself (a daemon-style worker parked
+     * in pthread_cond_wait / sem_wait) would wedge the join/wait loop
+     * below forever, making the process unkillable.  On POSIX systems
+     * exit() simply terminates the remaining threads.  Approximate that:
+     * request cancellation of every live thread first, so parked threads
+     * wake, run their cancellation cleanup handlers and leave through
+     * the normal pthread exit path -- which keeps dos.library's
+     * parent/child process accounting intact (no force-removal). */
+    for (i = PTHREAD_FIRST_THREAD_ID; i < PTHREAD_THREADS_MAX; i++) {
+        inf = &threads[i];
+        if (inf->status != THREAD_STATE_IDLE && inf->task != NULL)
+            pthread_cancel(i);
+    }
+
     // if we don't do this we can easily end up with unloaded code being executed
     for (i = PTHREAD_FIRST_THREAD_ID; i < PTHREAD_THREADS_MAX; i++) {
         inf = &threads[i];