* Introduced new job_control_entry structure which, among other things,

is used instead of death_entry for team::dead_children.
* Added team::{stopped,continued}_children, which, analoguously to
  dead_children, are used to track the state of stopped/continued
  children.
* A team does have a job_control_entry, which is allocated at team
  creation time. It will be inserted into the parent's
  {stopped,continued}_children lists as the team's main thread is
  stopped/continued and removed when waitpid() retrieves the child
  state. When the team dies the entry is detached from the team and goes
  into the parent's dead_children list.
* Removed the wait_for_any field from team_dead_children. It was solely
  used to avoid deletion of the contained entries in certain situations.
  wait_for_child() (the waitpid() backend) always deletes an entry now,
  regardless of whether other threads are waiting; that's in
  accordance with the waidpid() specification. wait_for_thread() removes
  the entry only, if the caller is the parent of the respective team.
* Introduced team_set_job_control_state() which performes the job
  control entry transitions between the respective lists and wakes up
  threads waiting in wait_for_child(). It is invoked on team death and
  when the team's main thread receives job control signals.
* Reorganized wait_for_child(). It handles WCONTINUED and WUNTRACED now,
  too. Removed a block that interpreted the supplied ID as thread ID.
* Added missing parts in waitpid().

Job control starts to work, though it seems to have some glitches.



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22088 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/system/kernel/signal.cpp

@@ -7,6 +7,9 @@
 
 /* POSIX signals handling routines */
 
+#include <stddef.h>
+#include <string.h>
+
 #include <OS.h>
 #include <KernelExport.h>
 
@@ -19,9 +22,8 @@
 #include <team.h>
 #include <thread.h>
 #include <user_debugger.h>
+#include <util/AutoLock.h>
 
-#include <stddef.h>
-#include <string.h>
 
 //#define TRACE_SIGNAL
 #ifdef TRACE_SIGNAL
@@ -133,13 +135,26 @@ handle_signals(struct thread *thread)
 			switch (signal) {
 				case SIGCHLD:
 				case SIGWINCH:
-				case SIGCONT:
 				case SIGURG:
 					// notify the debugger
 					if (debugSignal)
 						notify_debugger(thread, signal, handler, false);
 					continue;
 
+				case SIGCONT:
+					// notify the debugger
+					if (debugSignal
+						&& !notify_debugger(thread, signal, handler, false))
+						continue;
+
+					// notify threads waiting for team state changes
+					if (thread == thread->team->main_thread) {
+						InterruptsSpinLocker locker(team_spinlock);
+						team_set_job_control_state(thread->team,
+							JOB_CONTROL_STATE_CONTINUED, signal, false);
+					}
+					continue;
+
 				case SIGSTOP:
 				case SIGTSTP:
 				case SIGTTIN:
@@ -151,6 +166,13 @@ handle_signals(struct thread *thread)
 
 					thread->next_state = B_THREAD_SUSPENDED;
 					reschedule = true;
+
+					// notify threads waiting for team state changes
+					if (thread == thread->team->main_thread) {
+						InterruptsSpinLocker locker(team_spinlock);
+						team_set_job_control_state(thread->team,
+							JOB_CONTROL_STATE_STOPPED, signal, false);
+					}
 					continue;
 
 				case SIGQUIT: