/*
 * Written by Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include "internal.h"
#include "thread.h"
#include "mutex.h"
#include "cond.h"
#include "clock.h"
#include <trace/events/cobalt-posix.h>

static inline int
pthread_cond_init(struct cobalt_cond_shadow *cnd, const struct cobalt_condattr *attr)
{
	int synch_flags = XNSYNCH_PRIO, ret;
	struct cobalt_cond *cond, *old_cond;
	struct cobalt_cond_state *state;
	struct cobalt_ppd *sys_ppd;
	struct list_head *condq;
	spl_t s;

	cond = xnmalloc(sizeof(*cond));
	if (cond == NULL)
		return -ENOMEM;

	sys_ppd = cobalt_ppd_get(attr->pshared);
	state = cobalt_umm_alloc(&sys_ppd->umm, sizeof(*state));
	if (state == NULL) {
		ret = -EAGAIN;
		goto fail_umm;
	}
	cond->state = state;
	state->pending_signals = 0;
	state->mutex_state_offset = ~0U;

	xnlock_get_irqsave(&nklock, s);

	condq = &cobalt_current_resources(attr->pshared)->condq;
	if (cnd->magic == COBALT_COND_MAGIC && !list_empty(condq)) {
		old_cond = xnregistry_lookup(cnd->handle, NULL);
		if (cobalt_obj_active(old_cond, COBALT_COND_MAGIC,
				      typeof(*old_cond))) {
			ret = -EBUSY;
			goto fail_register;
		}
	}

	ret = xnregistry_enter_anon(cond, &cond->resnode.handle);
	if (ret < 0)
		goto fail_register;
	if (attr->pshared)
		cond->resnode.handle |= XNSYNCH_PSHARED;
	cond->magic = COBALT_COND_MAGIC;
	xnsynch_init(&cond->synchbase, synch_flags, NULL);
	cond->attr = *attr;
	cond->mutex = NULL;
	cobalt_add_resource(&cond->resnode, cond, attr->pshared);

	cnd->handle = cond->resnode.handle;
	cnd->state_offset = cobalt_umm_offset(&sys_ppd->umm, state);
	cnd->magic = COBALT_COND_MAGIC;

	xnlock_put_irqrestore(&nklock, s);

	return 0;
fail_register:
	xnlock_put_irqrestore(&nklock, s);
	cobalt_umm_free(&sys_ppd->umm, state);
fail_umm:
	xnfree(cond);

	return ret;
}

static inline int pthread_cond_destroy(struct cobalt_cond_shadow *cnd)
{
	struct cobalt_cond *cond;
	spl_t s;

	xnlock_get_irqsave(&nklock, s);
	cond = xnregistry_lookup(cnd->handle, NULL);
	if (cond == NULL) {
		xnlock_put_irqrestore(&nklock, s);
		return -EINVAL;
	}

	if (!cobalt_obj_active(cnd, COBALT_COND_MAGIC, struct cobalt_cond_shadow)
	    || !cobalt_obj_active(cond, COBALT_COND_MAGIC, struct cobalt_cond)) {
		xnlock_put_irqrestore(&nklock, s);
		return -EINVAL;
	}

	if (cond->resnode.scope !=
	    cobalt_current_resources(cond->attr.pshared)) {
		xnlock_put_irqrestore(&nklock, s);
		return -EPERM;
	}

	if (xnsynch_pended_p(&cond->synchbase) || cond->mutex) {
		xnlock_put_irqrestore(&nklock, s);
		return -EBUSY;
	}

	cobalt_cond_reclaim(&cond->resnode, s); /* drops lock */

	cobalt_mark_deleted(cnd);

	return 0;
}

static inline int cobalt_cond_timedwait_prologue(struct xnthread *cur,
						 struct cobalt_cond *cond,
						 struct cobalt_mutex *mutex,
						 xnticks_t abs_to)
{
	int err, ret;
	spl_t s;

	xnlock_get_irqsave(&nklock, s);

	/* If another thread waiting for cond does not use the same mutex */
	if (!cobalt_obj_active(cond, COBALT_COND_MAGIC, struct cobalt_cond)
	    || (cond->mutex && cond->mutex != mutex)) {
		err = -EINVAL;
		goto unlock_and_return;
	}

	if (cond->resnode.scope !=
	    cobalt_current_resources(cond->attr.pshared)) {
		err = -EPERM;
		goto unlock_and_return;
	}

	if (mutex->attr.pshared != cond->attr.pshared) {
		err = -EINVAL;
		goto unlock_and_return;
	}

	/* Unlock mutex. */
	err = cobalt_mutex_release(cur, mutex);
	if (err < 0)
		goto unlock_and_return;

	/* err == 1 means a reschedule is needed, but do not
	   reschedule here, releasing the mutex and suspension must be
	   done atomically in pthread_cond_*wait. */

	/* Bind mutex to cond. */
	if (cond->mutex == NULL) {
		cond->mutex = mutex;
		list_add_tail(&cond->mutex_link, &mutex->conds);
	}

	/* Wait for another thread to signal the condition. */
	if (abs_to != XN_INFINITE)
		ret = xnsynch_sleep_on(&cond->synchbase, abs_to,
				       clock_flag(TIMER_ABSTIME, cond->attr.clock));
	else
		ret = xnsynch_sleep_on(&cond->synchbase, XN_INFINITE, XN_RELATIVE);

	/* There are three possible wakeup conditions :
	   - cond_signal / cond_broadcast, no status bit is set, and the function
	     should return 0 ;
	   - timeout, the status XNTIMEO is set, and the function should return
	     ETIMEDOUT ;
	   - pthread_kill, the status bit XNBREAK is set, but ignored, the
	     function simply returns EINTR (used only by the user-space
	     interface, replaced by 0 anywhere else), causing a wakeup, spurious
	     or not whether pthread_cond_signal was called between pthread_kill
	     and the moment when xnsynch_sleep_on returned ;
	 */

	err = 0;

	if (ret & XNBREAK)
		err = -EINTR;
	else if (ret & XNTIMEO)
		err = -ETIMEDOUT;

unlock_and_return:
	xnlock_put_irqrestore(&nklock, s);

	return err;
}

static inline int cobalt_cond_timedwait_epilogue(struct xnthread *cur,
						 struct cobalt_cond *cond,
						 struct cobalt_mutex *mutex)
{
	int err;
	spl_t s;

	xnlock_get_irqsave(&nklock, s);

	err = __cobalt_mutex_acquire_unchecked(cur, mutex, NULL);
	if (err == -EINTR)
		goto unlock_and_return;

	/*
	 * Unbind mutex and cond, if no other thread is waiting, if
	 * the job was not already done.
	 */
	if (!xnsynch_pended_p(&cond->synchbase) && cond->mutex == mutex) {
		cond->mutex = NULL;
		list_del(&cond->mutex_link);
	}

unlock_and_return:
	xnlock_put_irqrestore(&nklock, s);

	return err;
}

COBALT_SYSCALL(cond_init, current,
	       (struct cobalt_cond_shadow __user *u_cnd,
		const struct cobalt_condattr __user *u_attr))
{
	struct cobalt_cond_shadow cnd;
	struct cobalt_condattr attr;
	int err;

	if (cobalt_copy_from_user(&cnd, u_cnd, sizeof(cnd)))
		return -EFAULT;

	if (cobalt_copy_from_user(&attr, u_attr, sizeof(attr)))
		return -EFAULT;

	trace_cobalt_cond_init(u_cnd, &attr);

	err = pthread_cond_init(&cnd, &attr);
	if (err < 0)
		return err;

	return cobalt_copy_to_user(u_cnd, &cnd, sizeof(*u_cnd));
}

COBALT_SYSCALL(cond_destroy, current,
	       (struct cobalt_cond_shadow __user *u_cnd))
{
	struct cobalt_cond_shadow cnd;
	int err;

	if (cobalt_copy_from_user(&cnd, u_cnd, sizeof(cnd)))
		return -EFAULT;

	trace_cobalt_cond_destroy(u_cnd);

	err = pthread_cond_destroy(&cnd);
	if (err < 0)
		return err;

	return cobalt_copy_to_user(u_cnd, &cnd, sizeof(*u_cnd));
}

struct us_cond_data {
	int err;
};

static inline int cond_fetch_timeout(struct timespec64 *ts,
				     const void __user *u_ts)
{
	return u_ts == NULL ? -EFAULT :	cobalt_get_u_timespec(ts, u_ts);
}

int __cobalt_cond_wait_prologue(struct cobalt_cond_shadow __user *u_cnd,
				struct cobalt_mutex_shadow __user *u_mx,
				int *u_err,
				void __user *u_ts,
				int (*fetch_timeout)(struct timespec64 *ts,
						     const void __user *u_ts))
{
	struct xnthread *cur = xnthread_current();
	struct cobalt_cond *cond;
	struct cobalt_mutex *mx;
	struct us_cond_data d;
	struct timespec64 ts;
	xnhandle_t handle;
	int err, perr = 0;
	__u32 offset;

	handle = cobalt_get_handle_from_user(&u_cnd->handle);
	cond = xnregistry_lookup(handle, NULL);

	handle = cobalt_get_handle_from_user(&u_mx->handle);
	mx = xnregistry_lookup(handle, NULL);

	if (cond->mutex == NULL) {
		__xn_get_user(offset, &u_mx->state_offset);
		cond->state->mutex_state_offset = offset;
	}

	if (fetch_timeout) {
		err = fetch_timeout(&ts, u_ts);
		if (err == 0) {
			trace_cobalt_cond_timedwait(u_cnd, u_mx, &ts);
			err = cobalt_cond_timedwait_prologue(cur, cond, mx,
							     ts2ns(&ts) + 1);
		}
	} else {
		trace_cobalt_cond_wait(u_cnd, u_mx);
		err = cobalt_cond_timedwait_prologue(cur, cond, mx, XN_INFINITE);
	}

	switch(err) {
	case 0:
	case -ETIMEDOUT:
		perr = d.err = err;
		err = cobalt_cond_timedwait_epilogue(cur, cond, mx);
		break;

	case -EINTR:
		perr = err;
		d.err = 0;	/* epilogue should return 0. */
		break;

	default:
		/* Please gcc and handle the case which will never
		   happen */
		d.err = EINVAL;
	}

	if (cond->mutex == NULL)
		cond->state->mutex_state_offset = ~0U;

	if (err == -EINTR)
		__xn_put_user(d.err, u_err);

	return err == 0 ? perr : err;
}

/* pthread_cond_wait_prologue(cond, mutex, count_ptr, timed, timeout) */
COBALT_SYSCALL(cond_wait_prologue, nonrestartable,
	       (struct cobalt_cond_shadow __user *u_cnd,
		struct cobalt_mutex_shadow __user *u_mx,
		int *u_err,
		unsigned int timed,
		struct __user_old_timespec __user *u_ts))
{
	return __cobalt_cond_wait_prologue(u_cnd, u_mx, u_err, u_ts,
					   timed ? cond_fetch_timeout : NULL);
}

COBALT_SYSCALL(cond_wait_epilogue, primary,
	       (struct cobalt_cond_shadow __user *u_cnd,
		struct cobalt_mutex_shadow __user *u_mx))
{
	struct xnthread *cur = xnthread_current();
	struct cobalt_cond *cond;
	struct cobalt_mutex *mx;
	xnhandle_t handle;
	int err;

	handle = cobalt_get_handle_from_user(&u_cnd->handle);
	cond = xnregistry_lookup(handle, NULL);

	handle = cobalt_get_handle_from_user(&u_mx->handle);
	mx = xnregistry_lookup(handle, NULL);
	err = cobalt_cond_timedwait_epilogue(cur, cond, mx);

	if (cond->mutex == NULL)
		cond->state->mutex_state_offset = ~0U;

	return err;
}

int cobalt_cond_deferred_signals(struct cobalt_cond *cond)
{
	struct cobalt_cond_state *state;
	__u32 pending_signals;
	int need_resched;

	state = cond->state;
	pending_signals = state->pending_signals;

	switch(pending_signals) {
	default:
		state->pending_signals = 0;
		need_resched = xnsynch_wakeup_many_sleepers(&cond->synchbase,
							    pending_signals);
		break;

	case ~0U:
		need_resched =
			xnsynch_flush(&cond->synchbase, 0) == XNSYNCH_RESCHED;
		state->pending_signals = 0;
		break;

	case 0:
		need_resched = 0;
		break;
	}

	return need_resched;
}

void cobalt_cond_reclaim(struct cobalt_resnode *node, spl_t s)
{
	struct cobalt_cond *cond;

	cond = container_of(node, struct cobalt_cond, resnode);
	xnregistry_remove(node->handle);
	cobalt_del_resource(node);
	xnsynch_destroy(&cond->synchbase);
	cobalt_mark_deleted(cond);
	xnlock_put_irqrestore(&nklock, s);

	cobalt_umm_free(&cobalt_ppd_get(cond->attr.pshared)->umm,
			cond->state);
	xnfree(cond);
}