Index: kernel/generic/include/proc/thread.h
===================================================================
--- kernel/generic/include/proc/thread.h	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/include/proc/thread.h	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -237,7 +237,5 @@
 extern void thread_usleep(uint32_t);
 
-#define thread_join(t) \
-	thread_join_timeout((t), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
-
+extern errno_t thread_join(thread_t *);
 extern errno_t thread_join_timeout(thread_t *, uint32_t, unsigned int);
 extern void thread_detach(thread_t *);
Index: kernel/generic/include/synch/condvar.h
===================================================================
--- kernel/generic/include/synch/condvar.h	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/include/synch/condvar.h	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -46,9 +46,4 @@
 } condvar_t;
 
-#define condvar_wait(cv, mtx) \
-	_condvar_wait_timeout((cv), (mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
-#define condvar_wait_timeout(cv, mtx, usec) \
-	_condvar_wait_timeout((cv), (mtx), (usec), SYNCH_FLAGS_NONE)
-
 #ifdef CONFIG_SMP
 #define _condvar_wait_timeout_spinlock(cv, lock, usec, flags) \
@@ -62,6 +57,8 @@
 extern void condvar_signal(condvar_t *cv);
 extern void condvar_broadcast(condvar_t *cv);
-extern errno_t _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec,
-    int flags);
+
+extern errno_t condvar_wait(condvar_t *cv, mutex_t *mtx);
+extern errno_t condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec);
+
 extern errno_t _condvar_wait_timeout_spinlock_impl(condvar_t *cv, spinlock_t *lock,
     uint32_t usec, int flags);
Index: kernel/generic/include/synch/mutex.h
===================================================================
--- kernel/generic/include/synch/mutex.h	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/include/synch/mutex.h	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -56,16 +56,9 @@
 } mutex_t;
 
-#define mutex_lock(mtx) \
-	_mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
-
-#define mutex_trylock(mtx) \
-	_mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING)
-
-#define mutex_lock_timeout(mtx, usec) \
-	_mutex_lock_timeout((mtx), (usec), SYNCH_FLAGS_NON_BLOCKING)
-
 extern void mutex_initialize(mutex_t *, mutex_type_t);
 extern bool mutex_locked(mutex_t *);
-extern errno_t _mutex_lock_timeout(mutex_t *, uint32_t, unsigned int);
+extern errno_t mutex_trylock(mutex_t *);
+extern errno_t mutex_lock(mutex_t *);
+extern errno_t mutex_lock_timeout(mutex_t *, uint32_t);
 extern void mutex_unlock(mutex_t *);
 
Index: kernel/generic/include/synch/semaphore.h
===================================================================
--- kernel/generic/include/synch/semaphore.h	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/include/synch/semaphore.h	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -45,19 +45,9 @@
 } semaphore_t;
 
-#define semaphore_down(s) \
-	_semaphore_down_timeout((s), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
-
-#define semaphore_trydown(s) \
-	_semaphore_down_timeout((s), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING)
-
-#define semaphore_down_timeout(s, usec) \
-	_semaphore_down_timeout((s), (usec), SYNCH_FLAGS_NONE)
-
-#define semaphore_down_interruptable(s) \
-	(_semaphore_down_timeout((s), SYNCH_NO_TIMEOUT, \
-		SYNCH_FLAGS_INTERRUPTIBLE) != EINTR)
-
 extern void semaphore_initialize(semaphore_t *, int);
-extern errno_t _semaphore_down_timeout(semaphore_t *, uint32_t, unsigned int);
+extern errno_t _semaphore_down_timeout(semaphore_t *, uint32_t, unsigned);
+extern errno_t semaphore_down_timeout(semaphore_t *, uint32_t);
+extern errno_t semaphore_trydown(semaphore_t *);
+extern void semaphore_down(semaphore_t *);
 extern void semaphore_up(semaphore_t *);
 extern int semaphore_count_get(semaphore_t *);
Index: kernel/generic/include/synch/waitq.h
===================================================================
--- kernel/generic/include/synch/waitq.h	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/include/synch/waitq.h	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -69,12 +69,11 @@
 } waitq_t;
 
-#define waitq_sleep(wq) \
-	waitq_sleep_timeout((wq), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE, NULL)
-
 struct thread;
 
 extern void waitq_initialize(waitq_t *);
+extern errno_t waitq_sleep(waitq_t *);
 extern errno_t waitq_sleep_timeout(waitq_t *, uint32_t, unsigned int, bool *);
 extern ipl_t waitq_sleep_prepare(waitq_t *);
+extern errno_t waitq_sleep_unsafe(waitq_t *, bool *);
 extern errno_t waitq_sleep_timeout_unsafe(waitq_t *, uint32_t, unsigned int, bool *);
 extern void waitq_sleep_finish(waitq_t *, bool, ipl_t);
Index: kernel/generic/src/proc/thread.c
===================================================================
--- kernel/generic/src/proc/thread.c	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/src/proc/thread.c	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -629,4 +629,9 @@
 }
 
+errno_t thread_join(thread_t *thread)
+{
+	return thread_join_timeout(thread, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+}
+
 /** Wait for another thread to exit.
  *
Index: kernel/generic/src/synch/condvar.c
===================================================================
--- kernel/generic/src/synch/condvar.c	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/src/synch/condvar.c	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -76,14 +76,8 @@
  * @param mtx		Mutex.
  * @param usec		Timeout value in microseconds.
- * @param flags		Select mode of operation.
- *
- * For exact description of meaning of possible combinations of usec and flags,
- * see comment for waitq_sleep_timeout().  Note that when
- * SYNCH_FLAGS_NON_BLOCKING is specified here, EAGAIN is always
- * returned.
  *
  * @return		See comment for waitq_sleep_timeout().
  */
-errno_t _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec, int flags)
+errno_t condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec)
 {
 	errno_t rc;
@@ -96,5 +90,26 @@
 
 	cv->wq.missed_wakeups = 0;	/* Enforce blocking. */
-	rc = waitq_sleep_timeout_unsafe(&cv->wq, usec, flags, &blocked);
+	rc = waitq_sleep_timeout_unsafe(&cv->wq, usec, SYNCH_FLAGS_NON_BLOCKING, &blocked);
+	assert(blocked || rc != EOK);
+
+	waitq_sleep_finish(&cv->wq, blocked, ipl);
+	/* Lock only after releasing the waitq to avoid a possible deadlock. */
+	mutex_lock(mtx);
+
+	return rc;
+}
+
+errno_t condvar_wait(condvar_t *cv, mutex_t *mtx)
+{
+	errno_t rc;
+	ipl_t ipl;
+	bool blocked;
+
+	ipl = waitq_sleep_prepare(&cv->wq);
+	/* Unlock only after the waitq is locked so we don't miss a wakeup. */
+	mutex_unlock(mtx);
+
+	cv->wq.missed_wakeups = 0;	/* Enforce blocking. */
+	rc = waitq_sleep_unsafe(&cv->wq, &blocked);
 	assert(blocked || rc != EOK);
 
Index: kernel/generic/src/synch/mutex.c
===================================================================
--- kernel/generic/src/synch/mutex.c	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/src/synch/mutex.c	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -85,5 +85,5 @@
  *
  */
-errno_t _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, unsigned int flags)
+static errno_t _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, unsigned int flags)
 {
 	errno_t rc;
@@ -128,4 +128,19 @@
 }
 
+errno_t mutex_trylock(mutex_t *mtx)
+{
+	return _mutex_lock_timeout(mtx, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
+}
+
+errno_t mutex_lock(mutex_t *mtx)
+{
+	return _mutex_lock_timeout(mtx, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+}
+
+errno_t mutex_lock_timeout(mutex_t *mtx, uint32_t usec)
+{
+	return _mutex_lock_timeout(mtx, usec, SYNCH_FLAGS_NON_BLOCKING);
+}
+
 /** Release mutex.
  *
Index: kernel/generic/src/synch/semaphore.c
===================================================================
--- kernel/generic/src/synch/semaphore.c	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/src/synch/semaphore.c	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -53,25 +53,37 @@
 {
 	waitq_initialize(&sem->wq);
-	waitq_count_set(&sem->wq, val);
+	if (val != 0)
+		waitq_count_set(&sem->wq, val);
 }
 
-/** Semaphore down
- *
- * Semaphore down.
- * Conditional mode and mode with timeout can be requested.
+errno_t _semaphore_down_timeout(semaphore_t *sem, uint32_t usec, unsigned flags)
+{
+	errno_t rc = waitq_sleep_timeout(&sem->wq, usec, flags, NULL);
+	assert(rc == EOK || rc == ETIMEOUT || rc == EAGAIN);
+	return rc;
+}
+
+errno_t semaphore_trydown(semaphore_t *sem)
+{
+	return _semaphore_down_timeout(sem, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
+}
+
+/** Semaphore down with timeout
  *
  * @param sem   Semaphore.
  * @param usec  Timeout in microseconds.
- * @param flags Select mode of operation.
- *
- * For exact description of possible combinations of
- * usec and flags, see comment for waitq_sleep_timeout().
  *
  * @return See comment for waitq_sleep_timeout().
  *
  */
-errno_t _semaphore_down_timeout(semaphore_t *sem, uint32_t usec, unsigned int flags)
+errno_t semaphore_down_timeout(semaphore_t *sem, uint32_t usec)
 {
-	return waitq_sleep_timeout(&sem->wq, usec, flags, NULL);
+	return _semaphore_down_timeout(sem, usec, SYNCH_FLAGS_NON_BLOCKING);
+}
+
+void semaphore_down(semaphore_t *sem)
+{
+	errno_t rc = waitq_sleep(&sem->wq);
+	assert(rc == EOK);
 }
 
Index: kernel/generic/src/synch/waitq.c
===================================================================
--- kernel/generic/src/synch/waitq.c	(revision 8a5534603d4acb29a283b131f0fae041dc2ed0b2)
+++ kernel/generic/src/synch/waitq.c	(revision 5110d0a1ed08ccaa0107b3c666b72c97dacb98d1)
@@ -194,4 +194,9 @@
 #define PARAM_NON_BLOCKING(flags, usec) \
 	(((flags) & SYNCH_FLAGS_NON_BLOCKING) && ((usec) == 0))
+
+errno_t waitq_sleep(waitq_t *wq)
+{
+	return waitq_sleep_timeout(wq, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE, NULL);
+}
 
 /** Sleep until either wakeup, timeout or interruption occurs
@@ -326,4 +331,9 @@
 
 	interrupts_restore(ipl);
+}
+
+errno_t waitq_sleep_unsafe(waitq_t *wq, bool *blocked)
+{
+	return waitq_sleep_timeout_unsafe(wq, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE, blocked);
 }