/*
 * Copyright (C) 2001,2002,2003 Philippe Gerum <rpm@xenomai.org>.
 *
 * Xenomai 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.
 *
 * Xenomai 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 Xenomai; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */
#ifndef _COBALT_KERNEL_THREAD_H
#define _COBALT_KERNEL_THREAD_H

#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/sched/rt.h>
#include <pipeline/thread.h>
#include <pipeline/inband_work.h>
#include <cobalt/kernel/list.h>
#include <cobalt/kernel/stat.h>
#include <cobalt/kernel/timer.h>
#include <cobalt/kernel/registry.h>
#include <cobalt/kernel/schedparam.h>
#include <cobalt/kernel/trace.h>
#include <cobalt/kernel/synch.h>
#include <cobalt/uapi/kernel/thread.h>
#include <cobalt/uapi/signal.h>
#include <asm/xenomai/machine.h>
#include <asm/xenomai/thread.h>

/**
 * @addtogroup cobalt_core_thread
 * @{
 */
#define XNTHREAD_BLOCK_BITS   (XNSUSP|XNPEND|XNDELAY|XNDORMANT|XNRELAX|XNHELD|XNDBGSTOP)
#define XNTHREAD_MODE_BITS    (XNRRB|XNWARN|XNTRAPLB)

#define XNTHREAD_SIGDEBUG		0
#define XNTHREAD_SIGSHADOW_HARDEN	1
#define XNTHREAD_SIGSHADOW_BACKTRACE	2
#define XNTHREAD_SIGSHADOW_HOME		3
#define XNTHREAD_SIGTERM		4
#define XNTHREAD_MAX_SIGNALS		5

struct xnthread;
struct xnsched;
struct xnselector;
struct xnsched_class;
struct xnsched_tpslot;
struct xnthread_personality;
struct completion;

struct lostage_signal {
	struct pipeline_inband_work inband_work; /* Must be first. */
	struct task_struct *task;
	int signo, sigval;
	struct lostage_signal *self; /* Revisit: I-pipe requirement */
};

struct xnthread_init_attr {
	struct xnthread_personality *personality;
	cpumask_t affinity;
	int flags;
	const char *name;
};

struct xnthread_start_attr {
	int mode;
	void (*entry)(void *cookie);
	void *cookie;
};

struct xnthread_wait_context {
	int posted;
};

struct xnthread_personality {
	const char *name;
	unsigned int magic;
	int xid;
	atomic_t refcnt;
	struct {
		void *(*attach_process)(void);
		void (*detach_process)(void *arg);
		void (*map_thread)(struct xnthread *thread);
		struct xnthread_personality *(*relax_thread)(struct xnthread *thread);
		struct xnthread_personality *(*harden_thread)(struct xnthread *thread);
		struct xnthread_personality *(*move_thread)(struct xnthread *thread,
							    int dest_cpu);
		struct xnthread_personality *(*exit_thread)(struct xnthread *thread);
		struct xnthread_personality *(*finalize_thread)(struct xnthread *thread);
	} ops;
	struct module *module;
};

struct xnthread {
	struct xnarchtcb tcb;	/* Architecture-dependent block */

	__u32 state;		/* Thread state flags */
	__u32 info;		/* Thread information flags */
	__u32 local_info;	/* Local thread information flags */

	struct xnsched *sched;		/* Thread scheduler */
	struct xnsched_class *sched_class; /* Current scheduling class */
	struct xnsched_class *base_class; /* Base scheduling class */

#ifdef CONFIG_XENO_OPT_SCHED_TP
	struct xnsched_tpslot *tps;	/* Current partition slot for TP scheduling */
	struct list_head tp_link;	/* Link in per-sched TP thread queue */
#endif
#ifdef CONFIG_XENO_OPT_SCHED_SPORADIC
	struct xnsched_sporadic_data *pss; /* Sporadic scheduling data. */
#endif
#ifdef CONFIG_XENO_OPT_SCHED_QUOTA
	struct xnsched_quota_group *quota; /* Quota scheduling group. */
	struct list_head quota_expired;
	struct list_head quota_next;
#endif
	cpumask_t affinity;	/* Processor affinity. */

	/** Base priority (before PI/PP boost) */
	int bprio;

	/** Current (effective) priority */
	int cprio;

	/**
	 * Weighted priority (cprio + scheduling class weight).
	 */
	int wprio;

	int lock_count;	/** Scheduler lock count. */

	/**
	 * Thread holder in xnsched run queue. Ordered by
	 * thread->cprio.
	 */
	struct list_head rlink;

	/**
	 * Thread holder in xnsynch pendq. Prioritized by
	 * thread->cprio + scheduling class weight.
	 */
	struct list_head plink;

	/** Thread holder in global queue. */
	struct list_head glink;

	/**
	 * List of xnsynch owned by this thread which cause a priority
	 * boost due to one of the following reasons:
	 *
	 * - they are currently claimed by other thread(s) when
	 * enforcing the priority inheritance protocol (XNSYNCH_PI).
	 *
	 * - they require immediate priority ceiling (XNSYNCH_PP).
	 *
	 * This list is ordered by decreasing (weighted) thread
	 * priorities.
	 */
	struct list_head boosters;

	struct xnsynch *wchan;		/* Resource the thread pends on */

	struct xnsynch *wwake;		/* Wait channel the thread was resumed from */

	int res_count;			/* Held resources count */

	struct xntimer rtimer;		/* Resource timer */

	struct xntimer ptimer;		/* Periodic timer */

	xnticks_t rrperiod;		/* Allotted round-robin period (ns) */

  	struct xnthread_wait_context *wcontext;	/* Active wait context. */

	struct {
		xnstat_counter_t ssw;	/* Primary -> secondary mode switch count */
		xnstat_counter_t csw;	/* Context switches (includes secondary -> primary switches) */
		xnstat_counter_t xsc;	/* Xenomai syscalls */
		xnstat_counter_t pf;	/* Number of page faults */
		xnstat_exectime_t account; /* Execution time accounting entity */
		xnstat_exectime_t lastperiod; /* Interval marker for execution time reports */
	} stat;

	struct xnselector *selector;    /* For select. */

	xnhandle_t handle;	/* Handle in registry */

	char name[XNOBJECT_NAME_LEN]; /* Symbolic name of thread */

	void (*entry)(void *cookie); /* Thread entry routine */
	void *cookie;		/* Cookie to pass to the entry routine */

	/**
	 * Thread data visible from userland through a window on the
	 * global heap.
	 */
	struct xnthread_user_window *u_window;

	struct xnthread_personality *personality;

	struct completion exited;

#ifdef CONFIG_XENO_OPT_DEBUG
	const char *exe_path;	/* Executable path */
	u32 proghash;		/* Hash value for exe_path */
#endif
	struct lostage_signal sigarray[XNTHREAD_MAX_SIGNALS];
};

static inline int xnthread_get_state(const struct xnthread *thread)
{
	return thread->state;
}

static inline int xnthread_test_state(struct xnthread *thread, int bits)
{
	return thread->state & bits;
}

static inline void xnthread_set_state(struct xnthread *thread, int bits)
{
	thread->state |= bits;
}

static inline void xnthread_clear_state(struct xnthread *thread, int bits)
{
	thread->state &= ~bits;
}

static inline int xnthread_test_info(struct xnthread *thread, int bits)
{
	return thread->info & bits;
}

static inline void xnthread_set_info(struct xnthread *thread, int bits)
{
	thread->info |= bits;
}

static inline void xnthread_clear_info(struct xnthread *thread, int bits)
{
	thread->info &= ~bits;
}

static inline int xnthread_test_localinfo(struct xnthread *curr, int bits)
{
	return curr->local_info & bits;
}

static inline void xnthread_set_localinfo(struct xnthread *curr, int bits)
{
	curr->local_info |= bits;
}

static inline void xnthread_clear_localinfo(struct xnthread *curr, int bits)
{
	curr->local_info &= ~bits;
}

static inline struct xnarchtcb *xnthread_archtcb(struct xnthread *thread)
{
	return &thread->tcb;
}

static inline int xnthread_base_priority(const struct xnthread *thread)
{
	return thread->bprio;
}

static inline int xnthread_current_priority(const struct xnthread *thread)
{
	return thread->cprio;
}

static inline struct task_struct *xnthread_host_task(struct xnthread *thread)
{
	return xnarch_host_task(xnthread_archtcb(thread));
}

#define xnthread_for_each_booster(__pos, __thread)		\
	list_for_each_entry(__pos, &(__thread)->boosters, next)

#define xnthread_for_each_booster_safe(__pos, __tmp, __thread)	\
	list_for_each_entry_safe(__pos, __tmp, &(__thread)->boosters, next)

#define xnthread_run_handler(__t, __h, __a...)				\
	do {								\
		struct xnthread_personality *__p__ = (__t)->personality;	\
		if ((__p__)->ops.__h)					\
			(__p__)->ops.__h(__t, ##__a);			\
	} while (0)

#define xnthread_run_handler_stack(__t, __h, __a...)			\
	do {								\
		struct xnthread_personality *__p__ = (__t)->personality;	\
		do {							\
			if ((__p__)->ops.__h == NULL)			\
				break;					\
			__p__ = (__p__)->ops.__h(__t, ##__a);		\
		} while (__p__);					\
	} while (0)

static inline
struct xnthread_wait_context *xnthread_get_wait_context(struct xnthread *thread)
{
	return thread->wcontext;
}

static inline
int xnthread_register(struct xnthread *thread, const char *name)
{
	return xnregistry_enter(name, thread, &thread->handle, NULL);
}

static inline
struct xnthread *xnthread_lookup(xnhandle_t threadh)
{
	struct xnthread *thread = xnregistry_lookup(threadh, NULL);
	return thread && thread->handle == xnhandle_get_index(threadh) ? thread : NULL;
}

static inline void xnthread_sync_window(struct xnthread *thread)
{
	if (thread->u_window) {
		thread->u_window->state = thread->state;
		thread->u_window->info = thread->info;
	}
}

static inline
void xnthread_clear_sync_window(struct xnthread *thread, int state_bits)
{
	if (thread->u_window) {
		thread->u_window->state = thread->state & ~state_bits;
		thread->u_window->info = thread->info;
	}
}

static inline
void xnthread_set_sync_window(struct xnthread *thread, int state_bits)
{
	if (thread->u_window) {
		thread->u_window->state = thread->state | state_bits;
		thread->u_window->info = thread->info;
	}
}

static inline int normalize_priority(int prio)
{
	return prio < MAX_RT_PRIO ? prio : MAX_RT_PRIO - 1;
}

int __xnthread_init(struct xnthread *thread,
		    const struct xnthread_init_attr *attr,
		    struct xnsched *sched,
		    struct xnsched_class *sched_class,
		    const union xnsched_policy_param *sched_param);

void __xnthread_test_cancel(struct xnthread *curr);

void __xnthread_cleanup(struct xnthread *curr);

void __xnthread_discard(struct xnthread *thread);

/**
 * @fn struct xnthread *xnthread_current(void)
 * @brief Retrieve the current Cobalt core TCB.
 *
 * Returns the address of the current Cobalt core thread descriptor,
 * or NULL if running over a regular Linux task. This call is not
 * affected by the current runtime mode of the core thread.
 *
 * @note The returned value may differ from xnsched_current_thread()
 * called from the same context, since the latter returns the root
 * thread descriptor for the current CPU if the caller is running in
 * secondary mode.
 *
 * @coretags{unrestricted}
 */
static inline struct xnthread *xnthread_current(void)
{
	return pipeline_current()->thread;
}

/**
 * @fn struct xnthread *xnthread_from_task(struct task_struct *p)
 * @brief Retrieve the Cobalt core TCB attached to a Linux task.
 *
 * Returns the address of the Cobalt core thread descriptor attached
 * to the Linux task @a p, or NULL if @a p is a regular Linux
 * task. This call is not affected by the current runtime mode of the
 * core thread.
 *
 * @coretags{unrestricted}
 */
static inline struct xnthread *xnthread_from_task(struct task_struct *p)
{
	return pipeline_thread_from_task(p);
}

/**
 * @fn void xnthread_test_cancel(void)
 * @brief Introduce a thread cancellation point.
 *
 * Terminates the current thread if a cancellation request is pending
 * for it, i.e. if xnthread_cancel() was called.
 *
 * @coretags{mode-unrestricted}
 */
static inline void xnthread_test_cancel(void)
{
	struct xnthread *curr = xnthread_current();

	if (curr && xnthread_test_info(curr, XNCANCELD))
		__xnthread_test_cancel(curr);
}

static inline
void xnthread_complete_wait(struct xnthread_wait_context *wc)
{
	wc->posted = 1;
}

static inline
int xnthread_wait_complete_p(struct xnthread_wait_context *wc)
{
	return wc->posted;
}

#ifdef CONFIG_XENO_ARCH_FPU
void xnthread_switch_fpu(struct xnsched *sched);
#else
static inline void xnthread_switch_fpu(struct xnsched *sched) { }
#endif /* CONFIG_XENO_ARCH_FPU */

void xnthread_deregister(struct xnthread *thread);

char *xnthread_format_status(unsigned long status,
			     char *buf, int size);

pid_t xnthread_host_pid(struct xnthread *thread);

int xnthread_set_clock(struct xnthread *thread,
		       struct xnclock *newclock);

xnticks_t xnthread_get_timeout(struct xnthread *thread,
			       xnticks_t ns);

xnticks_t xnthread_get_period(struct xnthread *thread);

void xnthread_prepare_wait(struct xnthread_wait_context *wc);

int xnthread_init(struct xnthread *thread,
		  const struct xnthread_init_attr *attr,
		  struct xnsched_class *sched_class,
		  const union xnsched_policy_param *sched_param);

int xnthread_start(struct xnthread *thread,
		   const struct xnthread_start_attr *attr);

int xnthread_set_mode(int clrmask,
		      int setmask);

void xnthread_suspend(struct xnthread *thread,
		      int mask,
		      xnticks_t timeout,
		      xntmode_t timeout_mode,
		      struct xnsynch *wchan);

void xnthread_resume(struct xnthread *thread,
		     int mask);

int xnthread_unblock(struct xnthread *thread);

int xnthread_set_periodic(struct xnthread *thread,
			  xnticks_t idate,
			  xntmode_t timeout_mode,
			  xnticks_t period);

int xnthread_wait_period(unsigned long *overruns_r);

int xnthread_set_slice(struct xnthread *thread,
		       xnticks_t quantum);

void xnthread_cancel(struct xnthread *thread);

int xnthread_join(struct xnthread *thread, bool uninterruptible);

int xnthread_harden(void);

void xnthread_relax(int notify, int reason);

void __xnthread_kick(struct xnthread *thread);

void xnthread_kick(struct xnthread *thread);

void __xnthread_demote(struct xnthread *thread);

void xnthread_demote(struct xnthread *thread);

void __xnthread_signal(struct xnthread *thread, int sig, int arg);

void xnthread_signal(struct xnthread *thread, int sig, int arg);

void xnthread_pin_initial(struct xnthread *thread);

void xnthread_call_mayday(struct xnthread *thread, int reason);

static inline void xnthread_get_resource(struct xnthread *curr)
{
	if (xnthread_test_state(curr, XNWEAK|XNDEBUG))
		curr->res_count++;
}

static inline int xnthread_put_resource(struct xnthread *curr)
{
	if (xnthread_test_state(curr, XNWEAK) ||
	    IS_ENABLED(CONFIG_XENO_OPT_DEBUG_MUTEX_SLEEP)) {
		if (unlikely(curr->res_count == 0)) {
			if (xnthread_test_state(curr, XNWARN))
				xnthread_signal(curr, SIGDEBUG,
						SIGDEBUG_RESCNT_IMBALANCE);
			return -EPERM;
		}
		curr->res_count--;
	}

	return 0;
}

static inline void xnthread_commit_ceiling(struct xnthread *curr)
{
	if (curr->u_window->pp_pending)
		xnsynch_commit_ceiling(curr);
}

#ifdef CONFIG_SMP

void xnthread_migrate_passive(struct xnthread *thread,
			      struct xnsched *sched);
#else

static inline void xnthread_migrate_passive(struct xnthread *thread,
					    struct xnsched *sched)
{ }

#endif

int __xnthread_set_schedparam(struct xnthread *thread,
			      struct xnsched_class *sched_class,
			      const union xnsched_policy_param *sched_param);

int xnthread_set_schedparam(struct xnthread *thread,
			    struct xnsched_class *sched_class,
			    const union xnsched_policy_param *sched_param);

int xnthread_killall(int grace, int mask);

void __xnthread_propagate_schedparam(struct xnthread *curr);

static inline void xnthread_propagate_schedparam(struct xnthread *curr)
{
	if (xnthread_test_info(curr, XNSCHEDP))
		__xnthread_propagate_schedparam(curr);
}

extern struct xnthread_personality xenomai_personality;

/** @} */

#endif /* !_COBALT_KERNEL_THREAD_H */