/*
 * Copyright (C) 2014 Jan Kiszka <jan.kiszka@siemens.com>.
 * Copyright (C) 2014 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.
 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM cobalt_posix

#if !defined(_TRACE_COBALT_POSIX_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_COBALT_POSIX_H

#include <linux/tracepoint.h>
#include <linux/trace_seq.h>
#include <xenomai/posix/cond.h>
#include <xenomai/posix/mqueue.h>
#include <xenomai/posix/event.h>

#define __timespec_fields(__name)				\
	__field(time64_t, tv_sec_##__name)			\
	__field(long, tv_nsec_##__name)

#define __assign_timespec(__to, __from)				\
	do {							\
		__entry->tv_sec_##__to = (__from)->tv_sec;	\
		__entry->tv_nsec_##__to = (__from)->tv_nsec;	\
	} while (0)

#define __timespec_args(__name)					\
	(long long)__entry->tv_sec_##__name, __entry->tv_nsec_##__name

#ifdef CONFIG_IA32_EMULATION
#define __sc_compat(__name)	, { sc_cobalt_##__name + __COBALT_IA32_BASE, "compat-" #__name }
#else
#define __sc_compat(__name)
#endif

#define __cobalt_symbolic_syscall(__name)				\
	{ sc_cobalt_##__name, #__name }					\
	__sc_compat(__name)						\

#define __cobalt_syscall_name(__nr)					\
	__print_symbolic((__nr),					\
		__cobalt_symbolic_syscall(bind),			\
		__cobalt_symbolic_syscall(thread_create),		\
		__cobalt_symbolic_syscall(thread_getpid),		\
		__cobalt_symbolic_syscall(thread_setmode),		\
		__cobalt_symbolic_syscall(thread_setname),		\
		__cobalt_symbolic_syscall(thread_join),			\
		__cobalt_symbolic_syscall(thread_kill),			\
		__cobalt_symbolic_syscall(thread_setschedparam_ex),	\
		__cobalt_symbolic_syscall(thread_getschedparam_ex),	\
		__cobalt_symbolic_syscall(thread_setschedprio),		\
		__cobalt_symbolic_syscall(thread_getstat),		\
		__cobalt_symbolic_syscall(sem_init),			\
		__cobalt_symbolic_syscall(sem_destroy),			\
		__cobalt_symbolic_syscall(sem_post),			\
		__cobalt_symbolic_syscall(sem_wait),			\
		__cobalt_symbolic_syscall(sem_trywait),			\
		__cobalt_symbolic_syscall(sem_getvalue),		\
		__cobalt_symbolic_syscall(sem_open),			\
		__cobalt_symbolic_syscall(sem_close),			\
		__cobalt_symbolic_syscall(sem_unlink),			\
		__cobalt_symbolic_syscall(sem_timedwait),		\
		__cobalt_symbolic_syscall(sem_inquire),			\
		__cobalt_symbolic_syscall(sem_broadcast_np),		\
		__cobalt_symbolic_syscall(clock_getres),		\
		__cobalt_symbolic_syscall(clock_gettime),		\
		__cobalt_symbolic_syscall(clock_settime),		\
		__cobalt_symbolic_syscall(clock_nanosleep),		\
		__cobalt_symbolic_syscall(mutex_init),			\
		__cobalt_symbolic_syscall(mutex_check_init),		\
		__cobalt_symbolic_syscall(mutex_destroy),		\
		__cobalt_symbolic_syscall(mutex_lock),			\
		__cobalt_symbolic_syscall(mutex_timedlock),		\
		__cobalt_symbolic_syscall(mutex_trylock),		\
		__cobalt_symbolic_syscall(mutex_unlock),		\
		__cobalt_symbolic_syscall(cond_init),			\
		__cobalt_symbolic_syscall(cond_destroy),		\
		__cobalt_symbolic_syscall(cond_wait_prologue),		\
		__cobalt_symbolic_syscall(cond_wait_epilogue),		\
		__cobalt_symbolic_syscall(mq_open),			\
		__cobalt_symbolic_syscall(mq_close),			\
		__cobalt_symbolic_syscall(mq_unlink),			\
		__cobalt_symbolic_syscall(mq_getattr),			\
		__cobalt_symbolic_syscall(mq_timedsend),		\
		__cobalt_symbolic_syscall(mq_timedreceive),		\
		__cobalt_symbolic_syscall(mq_notify),			\
		__cobalt_symbolic_syscall(sched_minprio),		\
		__cobalt_symbolic_syscall(sched_maxprio),		\
		__cobalt_symbolic_syscall(sched_weightprio),		\
		__cobalt_symbolic_syscall(sched_yield),			\
		__cobalt_symbolic_syscall(sched_setscheduler_ex),	\
		__cobalt_symbolic_syscall(sched_getscheduler_ex),	\
		__cobalt_symbolic_syscall(sched_setconfig_np),		\
		__cobalt_symbolic_syscall(sched_getconfig_np),		\
		__cobalt_symbolic_syscall(timer_create),		\
		__cobalt_symbolic_syscall(timer_delete),		\
		__cobalt_symbolic_syscall(timer_settime),		\
		__cobalt_symbolic_syscall(timer_gettime),		\
		__cobalt_symbolic_syscall(timer_getoverrun),		\
		__cobalt_symbolic_syscall(timerfd_create),		\
		__cobalt_symbolic_syscall(timerfd_settime),		\
		__cobalt_symbolic_syscall(timerfd_gettime),		\
		__cobalt_symbolic_syscall(sigwait),			\
		__cobalt_symbolic_syscall(sigwaitinfo),			\
		__cobalt_symbolic_syscall(sigtimedwait),		\
		__cobalt_symbolic_syscall(sigpending),			\
		__cobalt_symbolic_syscall(kill),			\
		__cobalt_symbolic_syscall(sigqueue),			\
		__cobalt_symbolic_syscall(monitor_init),		\
		__cobalt_symbolic_syscall(monitor_destroy),		\
		__cobalt_symbolic_syscall(monitor_enter),		\
		__cobalt_symbolic_syscall(monitor_wait),		\
		__cobalt_symbolic_syscall(monitor_sync),		\
		__cobalt_symbolic_syscall(monitor_exit),		\
		__cobalt_symbolic_syscall(event_init),			\
		__cobalt_symbolic_syscall(event_wait),			\
		__cobalt_symbolic_syscall(event_sync),			\
		__cobalt_symbolic_syscall(event_destroy),		\
		__cobalt_symbolic_syscall(event_inquire),		\
		__cobalt_symbolic_syscall(open),			\
		__cobalt_symbolic_syscall(socket),			\
		__cobalt_symbolic_syscall(close),			\
		__cobalt_symbolic_syscall(ioctl),			\
		__cobalt_symbolic_syscall(read),			\
		__cobalt_symbolic_syscall(write),			\
		__cobalt_symbolic_syscall(recvmsg),			\
		__cobalt_symbolic_syscall(sendmsg),			\
		__cobalt_symbolic_syscall(mmap),			\
		__cobalt_symbolic_syscall(select),			\
		__cobalt_symbolic_syscall(fcntl),			\
		__cobalt_symbolic_syscall(migrate),			\
		__cobalt_symbolic_syscall(archcall),			\
		__cobalt_symbolic_syscall(trace),			\
		__cobalt_symbolic_syscall(corectl),			\
		__cobalt_symbolic_syscall(get_current),			\
		__cobalt_symbolic_syscall(backtrace),			\
		__cobalt_symbolic_syscall(serialdbg),			\
		__cobalt_symbolic_syscall(extend),			\
		__cobalt_symbolic_syscall(ftrace_puts),			\
		__cobalt_symbolic_syscall(recvmmsg),			\
		__cobalt_symbolic_syscall(sendmmsg),			\
		__cobalt_symbolic_syscall(clock_adjtime),		\
		__cobalt_symbolic_syscall(sem_timedwait64),		\
		__cobalt_symbolic_syscall(clock_gettime64),		\
		__cobalt_symbolic_syscall(clock_settime64),		\
		__cobalt_symbolic_syscall(clock_nanosleep64),		\
		__cobalt_symbolic_syscall(clock_getres64),		\
		__cobalt_symbolic_syscall(clock_adjtime64),		\
		__cobalt_symbolic_syscall(mutex_timedlock64),		\
		__cobalt_symbolic_syscall(mq_timedsend64),  		\
		__cobalt_symbolic_syscall(mq_timedreceive64),		\
		__cobalt_symbolic_syscall(sigtimedwait64),		\
		__cobalt_symbolic_syscall(monitor_wait64),		\
		__cobalt_symbolic_syscall(event_wait64),		\
		__cobalt_symbolic_syscall(recvmmsg64))

DECLARE_EVENT_CLASS(cobalt_syscall_entry,
	TP_PROTO(unsigned int nr),
	TP_ARGS(nr),

	TP_STRUCT__entry(
		__field(unsigned int, nr)
	),

	TP_fast_assign(
		__entry->nr = nr;
	),

	TP_printk("syscall=%s", __cobalt_syscall_name(__entry->nr))
);

DECLARE_EVENT_CLASS(cobalt_syscall_exit,
	TP_PROTO(long result),
	TP_ARGS(result),

	TP_STRUCT__entry(
		__field(long, result)
	),

	TP_fast_assign(
		__entry->result = result;
	),

	TP_printk("result=%ld", __entry->result)
);

#define cobalt_print_sched_policy(__policy)			\
	__print_symbolic(__policy,				\
			 {SCHED_NORMAL, "normal"},		\
			 {SCHED_FIFO, "fifo"},			\
			 {SCHED_RR, "rr"},			\
			 {SCHED_TP, "tp"},			\
			 {SCHED_QUOTA, "quota"},		\
			 {SCHED_SPORADIC, "sporadic"},		\
			 {SCHED_COBALT, "cobalt"},		\
			 {SCHED_WEAK, "weak"})

const char *cobalt_trace_parse_sched_params(struct trace_seq *, int,
					    struct sched_param_ex *);

#define __parse_sched_params(policy, params)			\
	cobalt_trace_parse_sched_params(p, policy,		\
					(struct sched_param_ex *)(params))

DECLARE_EVENT_CLASS(cobalt_posix_schedparam,
	TP_PROTO(unsigned long pth, int policy,
		 const struct sched_param_ex *param_ex),
	TP_ARGS(pth, policy, param_ex),

	TP_STRUCT__entry(
		__field(unsigned long, pth)
		__field(int, policy)
		__dynamic_array(char, param_ex, sizeof(struct sched_param_ex))
	),

	TP_fast_assign(
		__entry->pth = pth;
		__entry->policy = policy;
		memcpy(__get_dynamic_array(param_ex), param_ex, sizeof(*param_ex));
	),

	TP_printk("pth=%p policy=%s param={ %s }",
		  (void *)__entry->pth,
		  cobalt_print_sched_policy(__entry->policy),
		  __parse_sched_params(__entry->policy,
				       __get_dynamic_array(param_ex))
	)
);

DECLARE_EVENT_CLASS(cobalt_posix_scheduler,
	TP_PROTO(pid_t pid, int policy,
		 const struct sched_param_ex *param_ex),
	TP_ARGS(pid, policy, param_ex),

	TP_STRUCT__entry(
		__field(pid_t, pid)
		__field(int, policy)
		__dynamic_array(char, param_ex, sizeof(struct sched_param_ex))
	),

	TP_fast_assign(
		__entry->pid = pid;
		__entry->policy = policy;
		memcpy(__get_dynamic_array(param_ex), param_ex, sizeof(*param_ex));
	),

	TP_printk("pid=%d policy=%s param={ %s }",
		  __entry->pid,
		  cobalt_print_sched_policy(__entry->policy),
		  __parse_sched_params(__entry->policy,
				       __get_dynamic_array(param_ex))
	)
);

DECLARE_EVENT_CLASS(cobalt_void,
	TP_PROTO(int dummy),
	TP_ARGS(dummy),
	TP_STRUCT__entry(
		__field(int, dummy)
	),
	TP_fast_assign(
		(void)dummy;
	),
	TP_printk("%s", "")
);

DEFINE_EVENT(cobalt_syscall_entry, cobalt_head_sysentry,
	TP_PROTO(unsigned int nr),
	TP_ARGS(nr)
);

DEFINE_EVENT(cobalt_syscall_exit, cobalt_head_sysexit,
	TP_PROTO(long result),
	TP_ARGS(result)
);

DEFINE_EVENT(cobalt_syscall_entry, cobalt_root_sysentry,
	TP_PROTO(unsigned int nr),
	TP_ARGS(nr)
);

DEFINE_EVENT(cobalt_syscall_exit, cobalt_root_sysexit,
	TP_PROTO(long result),
	TP_ARGS(result)
);

DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_create,
	TP_PROTO(unsigned long pth, int policy,
		 const struct sched_param_ex *param_ex),
	TP_ARGS(pth, policy, param_ex)
);

DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_setschedparam,
	TP_PROTO(unsigned long pth, int policy,
		 const struct sched_param_ex *param_ex),
	TP_ARGS(pth, policy, param_ex)
);

DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_getschedparam,
	TP_PROTO(unsigned long pth, int policy,
		 const struct sched_param_ex *param_ex),
	TP_ARGS(pth, policy, param_ex)
);

TRACE_EVENT(cobalt_pthread_setschedprio,
	TP_PROTO(unsigned long pth, int prio),
	TP_ARGS(pth, prio),
	TP_STRUCT__entry(
		__field(unsigned long, pth)
		__field(int, prio)
	),
	TP_fast_assign(
		__entry->pth = pth;
		__entry->prio = prio;
	),
	TP_printk("pth=%p prio=%d", (void *)__entry->pth, __entry->prio)
);

#define cobalt_print_thread_mode(__mode)			\
	__print_flags(__mode, "|",				\
		      {PTHREAD_WARNSW, "warnsw"},		\
		      {PTHREAD_LOCK_SCHED, "lock"},		\
		      {PTHREAD_DISABLE_LOCKBREAK, "nolockbreak"})

TRACE_EVENT(cobalt_pthread_setmode,
	TP_PROTO(int clrmask, int setmask),
	TP_ARGS(clrmask, setmask),
	TP_STRUCT__entry(
		__field(int, clrmask)
		__field(int, setmask)
	),
	TP_fast_assign(
		__entry->clrmask = clrmask;
		__entry->setmask = setmask;
	),
	TP_printk("clrmask=%#x(%s) setmask=%#x(%s)",
		  __entry->clrmask, cobalt_print_thread_mode(__entry->clrmask),
		  __entry->setmask, cobalt_print_thread_mode(__entry->setmask))
);

TRACE_EVENT(cobalt_pthread_setname,
	TP_PROTO(unsigned long pth, const char *name),
	TP_ARGS(pth, name),
	TP_STRUCT__entry(
		__field(unsigned long, pth)
		__string(name, name)
	),
	TP_fast_assign(
		__entry->pth = pth;
		__assign_str(name, name);
	),
	TP_printk("pth=%p name=%s", (void *)__entry->pth, __get_str(name))
);

DECLARE_EVENT_CLASS(cobalt_posix_pid,
	TP_PROTO(pid_t pid),
	TP_ARGS(pid),
	TP_STRUCT__entry(
		__field(pid_t, pid)
	),
	TP_fast_assign(
		__entry->pid = pid;
	),
	TP_printk("pid=%d", __entry->pid)
);

DEFINE_EVENT(cobalt_posix_pid, cobalt_pthread_stat,
	TP_PROTO(pid_t pid),
	TP_ARGS(pid)
);

TRACE_EVENT(cobalt_pthread_kill,
	TP_PROTO(unsigned long pth, int sig),
	TP_ARGS(pth, sig),
	TP_STRUCT__entry(
		__field(unsigned long, pth)
		__field(int, sig)
	),
	TP_fast_assign(
		__entry->pth = pth;
		__entry->sig = sig;
	),
	TP_printk("pth=%p sig=%d", (void *)__entry->pth, __entry->sig)
);

TRACE_EVENT(cobalt_pthread_join,
	TP_PROTO(unsigned long pth),
	TP_ARGS(pth),
	TP_STRUCT__entry(
		__field(unsigned long, pth)
	),
	TP_fast_assign(
		__entry->pth = pth;
	),
	TP_printk("pth=%p", (void *)__entry->pth)
);

TRACE_EVENT(cobalt_pthread_pid,
	TP_PROTO(unsigned long pth),
	TP_ARGS(pth),
	TP_STRUCT__entry(
		__field(unsigned long, pth)
	),
	TP_fast_assign(
		__entry->pth = pth;
	),
	TP_printk("pth=%p", (void *)__entry->pth)
);

TRACE_EVENT(cobalt_pthread_extend,
	TP_PROTO(unsigned long pth, const char *name),
	TP_ARGS(pth, name),
	TP_STRUCT__entry(
		__field(unsigned long, pth)
		__string(name, name)
	),
	TP_fast_assign(
		__entry->pth = pth;
		__assign_str(name, name);
	),
	TP_printk("pth=%p +personality=%s", (void *)__entry->pth, __get_str(name))
);

TRACE_EVENT(cobalt_pthread_restrict,
	TP_PROTO(unsigned long pth, const char *name),
	TP_ARGS(pth, name),
	TP_STRUCT__entry(
		__field(unsigned long, pth)
		__string(name, name)
	),
	TP_fast_assign(
		__entry->pth = pth;
		__assign_str(name, name);
	),
	TP_printk("pth=%p -personality=%s", (void *)__entry->pth, __get_str(name))
);

DEFINE_EVENT(cobalt_void, cobalt_pthread_yield,
	TP_PROTO(int dummy),
	TP_ARGS(dummy)
);

TRACE_EVENT(cobalt_sched_setconfig,
	TP_PROTO(int cpu, int policy, size_t len),
	TP_ARGS(cpu, policy, len),
	TP_STRUCT__entry(
		__field(int, cpu)
		__field(int, policy)
		__field(size_t, len)
	),
	TP_fast_assign(
		__entry->cpu = cpu;
		__entry->policy = policy;
		__entry->len = len;
	),
	TP_printk("cpu=%d policy=%d(%s) len=%zu",
		  __entry->cpu, __entry->policy,
		  cobalt_print_sched_policy(__entry->policy),
		  __entry->len)
);

TRACE_EVENT(cobalt_sched_get_config,
	TP_PROTO(int cpu, int policy, size_t rlen),
	TP_ARGS(cpu, policy, rlen),
	TP_STRUCT__entry(
		__field(int, cpu)
		__field(int, policy)
		__field(ssize_t, rlen)
	),
	TP_fast_assign(
		__entry->cpu = cpu;
		__entry->policy = policy;
		__entry->rlen = rlen;
	),
	TP_printk("cpu=%d policy=%d(%s) rlen=%Zd",
		  __entry->cpu, __entry->policy,
		  cobalt_print_sched_policy(__entry->policy),
		  __entry->rlen)
);

DEFINE_EVENT(cobalt_posix_scheduler, cobalt_sched_setscheduler,
	TP_PROTO(pid_t pid, int policy,
		 const struct sched_param_ex *param_ex),
	TP_ARGS(pid, policy, param_ex)
);

DEFINE_EVENT(cobalt_posix_pid, cobalt_sched_getscheduler,
	TP_PROTO(pid_t pid),
	TP_ARGS(pid)
);

DECLARE_EVENT_CLASS(cobalt_posix_prio_bound,
	TP_PROTO(int policy, int prio),
	TP_ARGS(policy, prio),
	TP_STRUCT__entry(
		__field(int, policy)
		__field(int, prio)
	),
	TP_fast_assign(
		__entry->policy = policy;
		__entry->prio = prio;
	),
	TP_printk("policy=%d(%s) prio=%d",
		  __entry->policy,
		  cobalt_print_sched_policy(__entry->policy),
		  __entry->prio)
);

DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_min_prio,
	TP_PROTO(int policy, int prio),
	TP_ARGS(policy, prio)
);

DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_max_prio,
	TP_PROTO(int policy, int prio),
	TP_ARGS(policy, prio)
);

DECLARE_EVENT_CLASS(cobalt_posix_sem,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle),
	TP_STRUCT__entry(
		__field(xnhandle_t, handle)
	),
	TP_fast_assign(
		__entry->handle = handle;
	),
	TP_printk("sem=%#x", __entry->handle)
);

DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_wait,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle)
);

DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_trywait,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle)
);

DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_timedwait,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle)
);

DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_post,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle)
);

DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_destroy,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle)
);

DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_broadcast,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle)
);

DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_inquire,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle)
);

TRACE_EVENT(cobalt_psem_getvalue,
	TP_PROTO(xnhandle_t handle, int value),
	TP_ARGS(handle, value),
	TP_STRUCT__entry(
		__field(xnhandle_t, handle)
		__field(int, value)
	),
	TP_fast_assign(
		__entry->handle = handle;
		__entry->value = value;
	),
	TP_printk("sem=%#x value=%d", __entry->handle, __entry->value)
);

#define cobalt_print_sem_flags(__flags)				\
  	__print_flags(__flags, "|",				\
			 {SEM_FIFO, "fifo"},			\
			 {SEM_PULSE, "pulse"},			\
			 {SEM_PSHARED, "pshared"},		\
			 {SEM_REPORT, "report"},		\
			 {SEM_WARNDEL, "warndel"},		\
			 {SEM_RAWCLOCK, "rawclock"},		\
			 {SEM_NOBUSYDEL, "nobusydel"})

TRACE_EVENT(cobalt_psem_init,
	TP_PROTO(const char *name, xnhandle_t handle,
		 int flags, unsigned int value),
	TP_ARGS(name, handle, flags, value),
	TP_STRUCT__entry(
		__string(name, name)
		__field(xnhandle_t, handle)
		__field(int, flags)
		__field(unsigned int, value)
	),
	TP_fast_assign(
		__assign_str(name, name);
		__entry->handle = handle;
		__entry->flags = flags;
		__entry->value = value;
	),
	TP_printk("sem=%#x(%s) flags=%#x(%s) value=%u",
		  __entry->handle,
		  __get_str(name),
		  __entry->flags,
		  cobalt_print_sem_flags(__entry->flags),
		  __entry->value)
);

TRACE_EVENT(cobalt_psem_init_failed,
	TP_PROTO(const char *name, int flags, unsigned int value, int status),
	TP_ARGS(name, flags, value, status),
	TP_STRUCT__entry(
		__string(name, name)
		__field(int, flags)
		__field(unsigned int, value)
		__field(int, status)
	),
	TP_fast_assign(
		__assign_str(name, name);
		__entry->flags = flags;
		__entry->value = value;
		__entry->status = status;
	),
	TP_printk("name=%s flags=%#x(%s) value=%u error=%d",
		  __get_str(name),
		  __entry->flags,
		  cobalt_print_sem_flags(__entry->flags),
		  __entry->value, __entry->status)
);

#define cobalt_print_oflags(__flags)		\
	__print_flags(__flags,  "|", 		\
		      {O_RDONLY, "rdonly"},	\
		      {O_WRONLY, "wronly"},	\
		      {O_RDWR, "rdwr"},		\
		      {O_CREAT, "creat"},	\
		      {O_EXCL, "excl"},		\
		      {O_DIRECT, "direct"},	\
		      {O_NONBLOCK, "nonblock"},	\
		      {O_TRUNC, "trunc"})

TRACE_EVENT(cobalt_psem_open,
	TP_PROTO(const char *name, xnhandle_t handle,
		 int oflags, mode_t mode, unsigned int value),
	TP_ARGS(name, handle, oflags, mode, value),
	TP_STRUCT__entry(
		__string(name, name)
		__field(xnhandle_t, handle)
		__field(int, oflags)
		__field(mode_t, mode)
		__field(unsigned int, value)
	),
	TP_fast_assign(
		__assign_str(name, name);
		__entry->handle = handle;
		__entry->oflags = oflags;
		if (oflags & O_CREAT) {
			__entry->mode = mode;
			__entry->value = value;
		} else {
			__entry->mode = 0;
			__entry->value = 0;
		}
	),
	TP_printk("named_sem=%#x=(%s) oflags=%#x(%s) mode=%o value=%u",
		  __entry->handle, __get_str(name),
		  __entry->oflags, cobalt_print_oflags(__entry->oflags),
		  __entry->mode, __entry->value)
);

TRACE_EVENT(cobalt_psem_open_failed,
	TP_PROTO(const char *name, int oflags, mode_t mode,
		 unsigned int value, int status),
	TP_ARGS(name, oflags, mode, value, status),
	TP_STRUCT__entry(
		__string(name, name)
		__field(int, oflags)
		__field(mode_t, mode)
		__field(unsigned int, value)
		__field(int, status)
	),
	TP_fast_assign(
		__assign_str(name, name);
		__entry->oflags = oflags;
		__entry->status = status;
		if (oflags & O_CREAT) {
			__entry->mode = mode;
			__entry->value = value;
		} else {
			__entry->mode = 0;
			__entry->value = 0;
		}
	),
	TP_printk("named_sem=%s oflags=%#x(%s) mode=%o value=%u error=%d",
		  __get_str(name),
		  __entry->oflags, cobalt_print_oflags(__entry->oflags),
		  __entry->mode, __entry->value, __entry->status)
);

DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_close,
	TP_PROTO(xnhandle_t handle),
	TP_ARGS(handle)
);

TRACE_EVENT(cobalt_psem_unlink,
	TP_PROTO(const char *name),
	TP_ARGS(name),
	TP_STRUCT__entry(
		__string(name, name)
	),
	TP_fast_assign(
		__assign_str(name, name);
	),
	TP_printk("name=%s", __get_str(name))
);

DECLARE_EVENT_CLASS(cobalt_clock_timespec,
	TP_PROTO(clockid_t clk_id, const struct timespec64 *val),
	TP_ARGS(clk_id, val),

	TP_STRUCT__entry(
		__field(clockid_t, clk_id)
		__timespec_fields(val)
	),

	TP_fast_assign(
		__entry->clk_id = clk_id;
		__assign_timespec(val, val);
	),

	TP_printk("clock_id=%d timeval=(%lld.%09ld)",
		  __entry->clk_id,
		  __timespec_args(val)
	)
);

DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_getres,
	TP_PROTO(clockid_t clk_id, const struct timespec64 *res),
	TP_ARGS(clk_id, res)
);

DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_gettime,
	TP_PROTO(clockid_t clk_id, const struct timespec64 *time),
	TP_ARGS(clk_id, time)
);

DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_settime,
	TP_PROTO(clockid_t clk_id, const struct timespec64 *time),
	TP_ARGS(clk_id, time)
);

TRACE_EVENT(cobalt_clock_adjtime,
	TP_PROTO(clockid_t clk_id, struct __kernel_timex *tx),
	TP_ARGS(clk_id, tx),

	TP_STRUCT__entry(
		__field(clockid_t, clk_id)
		__field(struct __kernel_timex *, tx)
	),

	TP_fast_assign(
		__entry->clk_id = clk_id;
		__entry->tx = tx;
	),

	TP_printk("clock_id=%d timex=%p",
		  __entry->clk_id,
		  __entry->tx
	)
);

#define cobalt_print_timer_flags(__flags)			\
	__print_flags(__flags, "|",				\
		      {TIMER_ABSTIME, "TIMER_ABSTIME"})

TRACE_EVENT(cobalt_clock_nanosleep,
	TP_PROTO(clockid_t clk_id, int flags, const struct timespec64 *time),
	TP_ARGS(clk_id, flags, time),

	TP_STRUCT__entry(
		__field(clockid_t, clk_id)
		__field(int, flags)
		__timespec_fields(time)
	),

	TP_fast_assign(
		__entry->clk_id = clk_id;
		__entry->flags = flags;
		__assign_timespec(time, time);
	),

	TP_printk("clock_id=%d flags=%#x(%s) rqt=(%lld.%09ld)",
		  __entry->clk_id,
		  __entry->flags, cobalt_print_timer_flags(__entry->flags),
		  __timespec_args(time)
	)
);

DECLARE_EVENT_CLASS(cobalt_clock_ident,
	TP_PROTO(const char *name, clockid_t clk_id),
	TP_ARGS(name, clk_id),
	TP_STRUCT__entry(
		__string(name, name)
		__field(clockid_t, clk_id)
	),
	TP_fast_assign(
		__assign_str(name, name);
		__entry->clk_id = clk_id;
	),
	TP_printk("name=%s, id=%#x", __get_str(name), __entry->clk_id)
);

DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_register,
	TP_PROTO(const char *name, clockid_t clk_id),
	TP_ARGS(name, clk_id)
);

DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_deregister,
	TP_PROTO(const char *name, clockid_t clk_id),
	TP_ARGS(name, clk_id)
);

#define cobalt_print_clock(__clk_id)					\
	__print_symbolic(__clk_id,					\
			 {CLOCK_MONOTONIC, "CLOCK_MONOTONIC"},		\
			 {CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW"},	\
			 {CLOCK_REALTIME, "CLOCK_REALTIME"})

TRACE_EVENT(cobalt_cond_init,
	TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
		 const struct cobalt_condattr *attr),
	TP_ARGS(u_cnd, attr),
	TP_STRUCT__entry(
		__field(const struct cobalt_cond_shadow __user *, u_cnd)
		__field(clockid_t, clk_id)
		__field(int, pshared)
	),
	TP_fast_assign(
		__entry->u_cnd = u_cnd;
		__entry->clk_id = attr->clock;
		__entry->pshared = attr->pshared;
	),
	TP_printk("cond=%p attr={ .clock=%s, .pshared=%d }",
		  __entry->u_cnd,
		  cobalt_print_clock(__entry->clk_id),
		  __entry->pshared)
);

TRACE_EVENT(cobalt_cond_destroy,
	TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd),
	TP_ARGS(u_cnd),
	TP_STRUCT__entry(
		__field(const struct cobalt_cond_shadow __user *, u_cnd)
	),
	TP_fast_assign(
		__entry->u_cnd = u_cnd;
	),
	TP_printk("cond=%p", __entry->u_cnd)
);

TRACE_EVENT(cobalt_cond_timedwait,
	TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
		 const struct cobalt_mutex_shadow __user *u_mx,
		 const struct timespec64 *timeout),
	TP_ARGS(u_cnd, u_mx, timeout),
	TP_STRUCT__entry(
		__field(const struct cobalt_cond_shadow __user *, u_cnd)
		__field(const struct cobalt_mutex_shadow __user *, u_mx)
		__timespec_fields(timeout)
	),
	TP_fast_assign(
		__entry->u_cnd = u_cnd;
		__entry->u_mx = u_mx;
		__assign_timespec(timeout, timeout);
	),
	TP_printk("cond=%p, mutex=%p, timeout=(%lld.%09ld)",
		  __entry->u_cnd, __entry->u_mx, __timespec_args(timeout))
);

TRACE_EVENT(cobalt_cond_wait,
	TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
		 const struct cobalt_mutex_shadow __user *u_mx),
	TP_ARGS(u_cnd, u_mx),
	TP_STRUCT__entry(
		__field(const struct cobalt_cond_shadow __user *, u_cnd)
		__field(const struct cobalt_mutex_shadow __user *, u_mx)
	),
	TP_fast_assign(
		__entry->u_cnd = u_cnd;
		__entry->u_mx = u_mx;
	),
	TP_printk("cond=%p, mutex=%p",
		  __entry->u_cnd, __entry->u_mx)
);

TRACE_EVENT(cobalt_mq_open,
	TP_PROTO(const char *name, int oflags, mode_t mode),
	TP_ARGS(name, oflags, mode),

	TP_STRUCT__entry(
		__string(name, name)
		__field(int, oflags)
		__field(mode_t, mode)
	),

	TP_fast_assign(
		__assign_str(name, name);
		__entry->oflags = oflags;
		__entry->mode = (oflags & O_CREAT) ? mode : 0;
	),

	TP_printk("name=%s oflags=%#x(%s) mode=%o",
		  __get_str(name),
		  __entry->oflags, cobalt_print_oflags(__entry->oflags),
		  __entry->mode)
);

TRACE_EVENT(cobalt_mq_notify,
	TP_PROTO(mqd_t mqd, const struct sigevent *sev),
	TP_ARGS(mqd, sev),

	TP_STRUCT__entry(
		__field(mqd_t, mqd)
		__field(int, signo)
	),

	TP_fast_assign(
		__entry->mqd = mqd;
		__entry->signo = sev && sev->sigev_notify != SIGEV_NONE ?
			sev->sigev_signo : 0;
	),

	TP_printk("mqd=%d signo=%d",
		  __entry->mqd, __entry->signo)
);

TRACE_EVENT(cobalt_mq_close,
	TP_PROTO(mqd_t mqd),
	TP_ARGS(mqd),

	TP_STRUCT__entry(
		__field(mqd_t, mqd)
	),

	TP_fast_assign(
		__entry->mqd = mqd;
	),

	TP_printk("mqd=%d", __entry->mqd)
);

TRACE_EVENT(cobalt_mq_unlink,
	TP_PROTO(const char *name),
	TP_ARGS(name),

	TP_STRUCT__entry(
		__string(name, name)
	),

	TP_fast_assign(
		__assign_str(name, name);
	),

	TP_printk("name=%s", __get_str(name))
);

TRACE_EVENT(cobalt_mq_send,
	TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len,
		 unsigned int prio),
	TP_ARGS(mqd, u_buf, len, prio),
	TP_STRUCT__entry(
		__field(mqd_t, mqd)
		__field(const void __user *, u_buf)
		__field(size_t, len)
		__field(unsigned int, prio)
	),
	TP_fast_assign(
		__entry->mqd = mqd;
		__entry->u_buf = u_buf;
		__entry->len = len;
		__entry->prio = prio;
	),
	TP_printk("mqd=%d buf=%p len=%zu prio=%u",
		  __entry->mqd, __entry->u_buf, __entry->len,
		  __entry->prio)
);

TRACE_EVENT(cobalt_mq_timedreceive,
	TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len,
		 const struct timespec64 *timeout),
	TP_ARGS(mqd, u_buf, len, timeout),
	TP_STRUCT__entry(
		__field(mqd_t, mqd)
		__field(const void __user *, u_buf)
		__field(size_t, len)
		__timespec_fields(timeout)
	),
	TP_fast_assign(
		__entry->mqd = mqd;
		__entry->u_buf = u_buf;
		__entry->len = len;
		__assign_timespec(timeout, timeout);
	),
	TP_printk("mqd=%d buf=%p len=%zu timeout=(%lld.%09ld)",
		  __entry->mqd, __entry->u_buf, __entry->len,
		  __timespec_args(timeout))
);

TRACE_EVENT(cobalt_mq_receive,
	TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len),
	TP_ARGS(mqd, u_buf, len),
	TP_STRUCT__entry(
		__field(mqd_t, mqd)
		__field(const void __user *, u_buf)
		__field(size_t, len)
	),
	TP_fast_assign(
		__entry->mqd = mqd;
		__entry->u_buf = u_buf;
		__entry->len = len;
	),
	TP_printk("mqd=%d buf=%p len=%zu",
		  __entry->mqd, __entry->u_buf, __entry->len)
);

DECLARE_EVENT_CLASS(cobalt_posix_mqattr,
	TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
	TP_ARGS(mqd, attr),
	TP_STRUCT__entry(
		__field(mqd_t, mqd)
		__field(long, flags)
		__field(long, curmsgs)
		__field(long, msgsize)
		__field(long, maxmsg)
	),
	TP_fast_assign(
		__entry->mqd = mqd;
		__entry->flags = attr->mq_flags;
		__entry->curmsgs = attr->mq_curmsgs;
		__entry->msgsize = attr->mq_msgsize;
		__entry->maxmsg = attr->mq_maxmsg;
	),
	TP_printk("mqd=%d flags=%#lx(%s) curmsgs=%ld msgsize=%ld maxmsg=%ld",
		  __entry->mqd,
		  __entry->flags, cobalt_print_oflags(__entry->flags),
		  __entry->curmsgs,
		  __entry->msgsize,
		  __entry->maxmsg
	)
);

DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_getattr,
	TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
	TP_ARGS(mqd, attr)
);

DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_setattr,
	TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
	TP_ARGS(mqd, attr)
);

#define cobalt_print_evflags(__flags)			\
	__print_flags(__flags,  "|",			\
		      {COBALT_EVENT_SHARED, "shared"},	\
		      {COBALT_EVENT_PRIO, "prio"})

TRACE_EVENT(cobalt_event_init,
	TP_PROTO(const struct cobalt_event_shadow __user *u_event,
		 unsigned long value, int flags),
	TP_ARGS(u_event, value, flags),
	TP_STRUCT__entry(
		__field(const struct cobalt_event_shadow __user *, u_event)
		__field(unsigned long, value)
		__field(int, flags)
	),
	TP_fast_assign(
		__entry->u_event = u_event;
		__entry->value = value;
		__entry->flags = flags;
	),
	TP_printk("event=%p value=%lu flags=%#x(%s)",
		  __entry->u_event, __entry->value,
		  __entry->flags, cobalt_print_evflags(__entry->flags))
);

#define cobalt_print_evmode(__mode)			\
	__print_symbolic(__mode,			\
			 {COBALT_EVENT_ANY, "any"},	\
			 {COBALT_EVENT_ALL, "all"})

TRACE_EVENT(cobalt_event_timedwait,
	TP_PROTO(const struct cobalt_event_shadow __user *u_event,
		 unsigned long bits, int mode,
		 const struct timespec64 *timeout),
	TP_ARGS(u_event, bits, mode, timeout),
	TP_STRUCT__entry(
		__field(const struct cobalt_event_shadow __user *, u_event)
		__field(unsigned long, bits)
		__field(int, mode)
		__timespec_fields(timeout)
	),
	TP_fast_assign(
		__entry->u_event = u_event;
		__entry->bits = bits;
		__entry->mode = mode;
		__assign_timespec(timeout, timeout);
	),
	TP_printk("event=%p bits=%#lx mode=%#x(%s) timeout=(%lld.%09ld)",
		  __entry->u_event, __entry->bits, __entry->mode,
		  cobalt_print_evmode(__entry->mode),
		  __timespec_args(timeout))
);

TRACE_EVENT(cobalt_event_wait,
	TP_PROTO(const struct cobalt_event_shadow __user *u_event,
		 unsigned long bits, int mode),
	TP_ARGS(u_event, bits, mode),
	TP_STRUCT__entry(
		__field(const struct cobalt_event_shadow __user *, u_event)
		__field(unsigned long, bits)
		__field(int, mode)
	),
	TP_fast_assign(
		__entry->u_event = u_event;
		__entry->bits = bits;
		__entry->mode = mode;
	),
	TP_printk("event=%p bits=%#lx mode=%#x(%s)",
		  __entry->u_event, __entry->bits, __entry->mode,
		  cobalt_print_evmode(__entry->mode))
);

DECLARE_EVENT_CLASS(cobalt_event_ident,
	TP_PROTO(const struct cobalt_event_shadow __user *u_event),
	TP_ARGS(u_event),
	TP_STRUCT__entry(
		__field(const struct cobalt_event_shadow __user *, u_event)
	),
	TP_fast_assign(
		__entry->u_event = u_event;
	),
	TP_printk("event=%p", __entry->u_event)
);

DEFINE_EVENT(cobalt_event_ident, cobalt_event_destroy,
	TP_PROTO(const struct cobalt_event_shadow __user *u_event),
	TP_ARGS(u_event)
);

DEFINE_EVENT(cobalt_event_ident, cobalt_event_sync,
	TP_PROTO(const struct cobalt_event_shadow __user *u_event),
	TP_ARGS(u_event)
);

DEFINE_EVENT(cobalt_event_ident, cobalt_event_inquire,
	TP_PROTO(const struct cobalt_event_shadow __user *u_event),
	TP_ARGS(u_event)
);

#endif /* _TRACE_COBALT_POSIX_H */

/* This part must be outside protection */
#undef TRACE_INCLUDE_PATH
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE cobalt-posix
#include <trace/define_trace.h>