/*
 * Semaphore implementation Copyright (c) 2001 Matthew Wilcox, Hewlett-Packard
 */

#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/errno.h>
#include <linux/init.h>

/*
 * Semaphores are complex as we wish to avoid using two variables.
 * `count' has multiple roles, depending on its value.  If it is positive
 * or zero, there are no waiters.  The functions here will never be
 * called; see <asm/semaphore.h>
 *
 * When count is -1 it indicates there is at least one task waiting
 * for the semaphore.
 *
 * When count is less than that, there are '- count - 1' wakeups
 * pending.  ie if it has value -3, there are 2 wakeups pending.
 *
 * Note that these functions are only called when there is contention
 * on the lock, and as such all this is the "non-critical" part of the
 * whole semaphore business. The critical part is the inline stuff in
 * <asm/semaphore.h> where we want to avoid any extra jumps and calls.
 */
void __up(struct semaphore *sem)
{
	sem->count--;
	wake_up(&sem->wait);
}

#define wakers(count) (-1 - count)

#define DOWN_HEAD							\
	int ret = 0;							\
	DECLARE_WAITQUEUE(wait, current);				\
									\
	/* Note that someone is waiting */				\
	if (sem->count == 0)						\
		sem->count = -1;					\
									\
	/* protected by the sentry still -- use unlocked version */	\
	wait.flags = WQ_FLAG_EXCLUSIVE;					\
	__add_wait_queue_tail(&sem->wait, &wait);			\
 lost_race:								\
	spin_unlock_irq(&sem->sentry);					\

#define DOWN_TAIL							\
	spin_lock_irq(&sem->sentry);					\
	if (wakers(sem->count) == 0 && ret == 0)			\
		goto lost_race;	/* Someone stole our wakeup */		\
	__remove_wait_queue(&sem->wait, &wait);				\
	current->state = TASK_RUNNING;					\
	if (!waitqueue_active(&sem->wait) && (sem->count < 0))		\
		sem->count = wakers(sem->count);

#define UPDATE_COUNT							\
	sem->count += (sem->count < 0) ? 1 : - 1;
	

void __sched __down(struct semaphore * sem)
{
	DOWN_HEAD

	for(;;) {
		set_task_state(current, TASK_UNINTERRUPTIBLE);
		/* we can _read_ this without the sentry */
		if (sem->count != -1)
			break;
 		schedule();
 	}

	DOWN_TAIL
	UPDATE_COUNT
}

int __sched __down_interruptible(struct semaphore * sem)
{
	DOWN_HEAD

	for(;;) {
		set_task_state(current, TASK_INTERRUPTIBLE);
		/* we can _read_ this without the sentry */
		if (sem->count != -1)
			break;

		if (signal_pending(current)) {
			ret = -EINTR;
			break;
		}
		schedule();
	}

	DOWN_TAIL

	if (!ret) {
		UPDATE_COUNT
	}

	return ret;
}