* 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

headers/private/kernel/thread.h

@@ -13,6 +13,11 @@
 #include <thread_types.h>
 #include <arch/thread.h>
 
+// For the thread blocking inline functions only.
+#include <kscheduler.h>
+#include <ksignal.h>
+
+
 struct kernel_args;
 struct select_info;
 
@@ -72,6 +77,12 @@ status_t deselect_thread(int32 object, struct select_info *info, bool kernel);
 
 #define syscall_64_bit_return_value() arch_syscall_64_bit_return_value()
 
+status_t thread_block();
+status_t thread_block_with_timeout(uint32 timeoutFlags, bigtime_t timeout);
+status_t thread_block_with_timeout_locked(uint32 timeoutFlags,
+			bigtime_t timeout);
+bool thread_unblock(status_t threadID, status_t status);
+
 // used in syscalls.c
 status_t _user_set_thread_priority(thread_id thread, int32 newPriority);
 status_t _user_rename_thread(thread_id thread, const char *name);
@@ -100,4 +111,87 @@ int _user_setrlimit(int resource, const struct rlimit * rlp);
 }
 #endif
 
+
+/*!
+	\a thread must be the current thread.
+	Thread lock can be, but doesn't need to be held.
+*/
+static inline bool
+thread_is_interrupted(struct thread* thread, uint32 flags)
+{
+	return ((flags & B_CAN_INTERRUPT)
+			&& (thread->sig_pending & ~thread->sig_block_mask) != 0)
+		|| ((flags & B_KILL_CAN_INTERRUPT)
+			&& (thread->sig_pending & KILL_SIGNALS));
+}
+
+
+static inline bool
+thread_is_blocked(struct thread* thread)
+{
+	return thread->wait.status == 1;
+}
+
+
+/*!
+	\a thread must be the current thread.
+	Thread lock can be, but doesn't need to be locked.
+*/
+static inline void
+thread_prepare_to_block(struct thread* thread, uint32 flags, uint32 type,
+	void* object)
+{
+	thread->wait.flags = flags;
+	thread->wait.type = type;
+	thread->wait.object = object;
+	atomic_set(&thread->wait.status, 1);
+		// Set status last to guarantee that the other fields are initialized
+		// when a thread is waiting.
+}
+
+
+static inline status_t
+thread_block_locked(struct thread* thread)
+{
+	if (thread->wait.status == 1) {
+		// check for signals, if interruptable
+		if (thread_is_interrupted(thread, thread->wait.flags)) {
+			thread->wait.status = B_INTERRUPTED;
+		} else {
+			thread->next_state = B_THREAD_WAITING;
+			scheduler_reschedule();
+		}
+	}
+
+	return thread->wait.status;
+}
+
+
+static inline bool
+thread_unblock_locked(struct thread* thread, status_t status)
+{
+	if (atomic_test_and_set(&thread->wait.status, status, 1) != 1)
+		return false;
+
+	// wake up the thread, if it is sleeping
+	if (thread->state == B_THREAD_WAITING)
+		scheduler_enqueue_in_run_queue(thread);
+
+	return true;
+}
+
+
+static inline status_t
+thread_interrupt(struct thread* thread, bool kill)
+{
+	if ((thread->wait.flags & B_CAN_INTERRUPT) != 0
+		|| (kill && (thread->wait.flags & B_KILL_CAN_INTERRUPT) != 0)) {
+		thread_unblock_locked(thread, B_INTERRUPTED);
+		return B_OK;
+	}
+
+	return B_NOT_ALLOWED;
+}
+
+
 #endif /* _THREAD_H */