* Introduced a set of functions (thread_prepare_to_block(),

thread_block(), thread_unblock(),...) that allow a thread to wait for
  something without needing a semaphore or condition variable. It can
  simply block and another thread can unblock it. Supports timeouts and
  interrupting. Both semaphores and condition variables use this
  common mechanism, now.
* Semaphores:
  - Some simplifications due to the thread blocking mechanism.
  - Changed locking order to sem -> thread. It was the other way around
    before and when introducing the wait_for_objects() support I had
    also introduced a situation where the locking was reverse, which
    could potentially cause a dead lock on SMP systems.
  - Instead of queueing thread structures, a semaphore queues
    queued_thread entries now, which are created on the stack. The
    thread::sem structure could thus be removed.
  - Added sem_entry::net_count, which is sem_entry::count plus the
    acquisition count of all waiting threads. This number is needed in
    remove_thread_from_sem() and instead of computing it there we
    maintain it.
  - Fixed remove_thread_from_sem(). It would not unblock threads, if
    the sem count was <= 0.
  - Made sem::last_acquirer unconditional. It is actually needed for
    sem_info::latest_holder. Fixed fill_sem_info() accordingly.
  - Added some optional tracing output, though only via ktrace_printf().
* Condition variables:
  - Could be simplified significantly through the use of the thread
    blocking mechanism. Removed a good deal of unnecessary code.
  - Moved the ConditionVariableEntry "flags" parameter from Wait() to
    Add(), and adjusted all places where condition variables are used
    accordingly.
* snooze() uses thread_block_with_timeout() instead of a semaphore.
* Simplified thread interrupting in the signal and user debugger code.
  Instead of separate functions for threads waiting on a semaphore or
  condititon variable, we only have a single thread_interrupt(), now.



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

src/system/kernel/debug/user_debugger.cpp

@@ -2366,12 +2366,13 @@ _user_debug_thread(thread_id threadID)
 				scheduler_enqueue_in_run_queue(thread);
 				break;
 
-			case B_THREAD_WAITING:
-				// thread waiting: interrupt it
-				if (thread->sem.blocking >= 0)
-					sem_interrupt_thread(thread);
-				else if (thread->condition_variable_entry)
-					condition_variable_interrupt_thread(thread);
+			default:
+				// thread may be waiting: interrupt it
+				thread_interrupt(thread, false);
+					// TODO: If the thread is already in the kernel and e.g.
+					// about to acquire a semaphore (before
+					// thread_prepare_to_block()), we won't interrupt it.
+					// Maybe we should rather send a signal (SIGTRAP).
 				break;
 		}
 	}