/*
 * 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_core

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

#include <linux/tracepoint.h>
#include <linux/math64.h>
#include <cobalt/kernel/timer.h>
#include <cobalt/kernel/registry.h>
#include <cobalt/uapi/kernel/types.h>

struct xnsched;
struct xnthread;
struct xnsynch;
struct xnsched_class;
struct xnsched_quota_group;
struct xnthread_init_attr;

DECLARE_EVENT_CLASS(thread_event,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread),

	TP_STRUCT__entry(
		__field(pid_t, pid)
		__field(unsigned long, state)
		__field(unsigned long, info)
	),

	TP_fast_assign(
		__entry->state = thread->state;
		__entry->info = thread->info;
		__entry->pid = xnthread_host_pid(thread);
	),

	TP_printk("pid=%d state=0x%lx info=0x%lx",
		  __entry->pid, __entry->state, __entry->info)
);

DECLARE_EVENT_CLASS(curr_thread_event,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread),

	TP_STRUCT__entry(
		__field(struct xnthread *, thread)
		__field(unsigned long, state)
		__field(unsigned long, info)
	),

	TP_fast_assign(
		__entry->state = thread->state;
		__entry->info = thread->info;
	),

	TP_printk("state=0x%lx info=0x%lx",
		  __entry->state, __entry->info)
);

DECLARE_EVENT_CLASS(synch_wait_event,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch),

	TP_STRUCT__entry(
		__field(struct xnsynch *, synch)
	),

	TP_fast_assign(
		__entry->synch = synch;
	),

	TP_printk("synch=%p", __entry->synch)
);

DECLARE_EVENT_CLASS(synch_post_event,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch),

	TP_STRUCT__entry(
		__field(struct xnsynch *, synch)
	),

	TP_fast_assign(
		__entry->synch = synch;
	),

	TP_printk("synch=%p", __entry->synch)
);

DECLARE_EVENT_CLASS(irq_event,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq),

	TP_STRUCT__entry(
		__field(unsigned int, irq)
	),

	TP_fast_assign(
		__entry->irq = irq;
	),

	TP_printk("irq=%u", __entry->irq)
);

DECLARE_EVENT_CLASS(clock_event,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq),

	TP_STRUCT__entry(
		__field(unsigned int, irq)
	),

	TP_fast_assign(
		__entry->irq = irq;
	),

	TP_printk("clock_irq=%u", __entry->irq)
);

DECLARE_EVENT_CLASS(timer_event,
	TP_PROTO(struct xntimer *timer),
	TP_ARGS(timer),

	TP_STRUCT__entry(
		__field(struct xntimer *, timer)
	),

	TP_fast_assign(
		__entry->timer = timer;
	),

	TP_printk("timer=%p", __entry->timer)
);

DECLARE_EVENT_CLASS(registry_event,
	TP_PROTO(const char *key, void *addr),
	TP_ARGS(key, addr),

	TP_STRUCT__entry(
		__string(key, key ?: "(anon)")
		__field(void *, addr)
	),

	TP_fast_assign(
		__assign_str(key, key ?: "(anon)");
		__entry->addr = addr;
	),

	TP_printk("key=%s, addr=%p", __get_str(key), __entry->addr)
);

TRACE_EVENT(cobalt_schedule,
	TP_PROTO(struct xnsched *sched),
	TP_ARGS(sched),

	TP_STRUCT__entry(
		__field(unsigned long, status)
	),

	TP_fast_assign(
		__entry->status = sched->status;
	),

	TP_printk("status=0x%lx", __entry->status)
);

TRACE_EVENT(cobalt_schedule_remote,
	TP_PROTO(struct xnsched *sched),
	TP_ARGS(sched),

	TP_STRUCT__entry(
		__field(unsigned long, status)
	),

	TP_fast_assign(
		__entry->status = sched->status;
	),

	TP_printk("status=0x%lx", __entry->status)
);

TRACE_EVENT(cobalt_switch_context,
	TP_PROTO(struct xnthread *prev, struct xnthread *next),
	TP_ARGS(prev, next),

	TP_STRUCT__entry(
		__field(struct xnthread *, prev)
		__string(prev_name, prev->name)
		__field(pid_t, prev_pid)
		__field(int, prev_prio)
		__field(unsigned long, prev_state)
		__field(struct xnthread *, next)
		__string(next_name, next->name)
		__field(pid_t, next_pid)
		__field(int, next_prio)
	),

	TP_fast_assign(
		__entry->prev = prev;
		__assign_str(prev_name, prev->name);
		__entry->prev_pid = xnthread_host_pid(prev);
		__entry->prev_prio = xnthread_current_priority(prev);
		__entry->prev_state = prev->state;
		__entry->next = next;
		__assign_str(next_name, next->name);
		__entry->next_pid = xnthread_host_pid(next);
		__entry->next_prio = xnthread_current_priority(next);
	),

	TP_printk("prev_name=%s prev_pid=%d prev_prio=%d prev_state=0x%lx ==> next_name=%s next_pid=%d next_prio=%d",
		  __get_str(prev_name), __entry->prev_pid,
		  __entry->prev_prio, __entry->prev_state,
		  __get_str(next_name), __entry->next_pid, __entry->next_prio)
);

#ifdef CONFIG_XENO_OPT_SCHED_QUOTA

TRACE_EVENT(cobalt_schedquota_refill,
	TP_PROTO(int dummy),
	TP_ARGS(dummy),

	TP_STRUCT__entry(
		__field(int, dummy)
	),

	TP_fast_assign(
		(void)dummy;
	),

	TP_printk("%s", "")
);

DECLARE_EVENT_CLASS(schedquota_group_event,
	TP_PROTO(struct xnsched_quota_group *tg),
	TP_ARGS(tg),

	TP_STRUCT__entry(
		__field(int, tgid)
	),

	TP_fast_assign(
		__entry->tgid = tg->tgid;
	),

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

DEFINE_EVENT(schedquota_group_event, cobalt_schedquota_create_group,
	TP_PROTO(struct xnsched_quota_group *tg),
	TP_ARGS(tg)
);

DEFINE_EVENT(schedquota_group_event, cobalt_schedquota_destroy_group,
	TP_PROTO(struct xnsched_quota_group *tg),
	TP_ARGS(tg)
);

TRACE_EVENT(cobalt_schedquota_set_limit,
	TP_PROTO(struct xnsched_quota_group *tg,
		 int percent,
		 int peak_percent),
	TP_ARGS(tg, percent, peak_percent),

	TP_STRUCT__entry(
		__field(int, tgid)
		__field(int, percent)
		__field(int, peak_percent)
	),

	TP_fast_assign(
		__entry->tgid = tg->tgid;
		__entry->percent = percent;
		__entry->peak_percent = peak_percent;
	),

	TP_printk("tgid=%d percent=%d peak_percent=%d",
		  __entry->tgid, __entry->percent, __entry->peak_percent)
);

DECLARE_EVENT_CLASS(schedquota_thread_event,
	TP_PROTO(struct xnsched_quota_group *tg,
		 struct xnthread *thread),
	TP_ARGS(tg, thread),

	TP_STRUCT__entry(
		__field(int, tgid)
		__field(struct xnthread *, thread)
		__field(pid_t, pid)
	),

	TP_fast_assign(
		__entry->tgid = tg->tgid;
		__entry->thread = thread;
		__entry->pid = xnthread_host_pid(thread);
	),

	TP_printk("tgid=%d thread=%p pid=%d",
		  __entry->tgid, __entry->thread, __entry->pid)
);

DEFINE_EVENT(schedquota_thread_event, cobalt_schedquota_add_thread,
	TP_PROTO(struct xnsched_quota_group *tg,
		 struct xnthread *thread),
	TP_ARGS(tg, thread)
);

DEFINE_EVENT(schedquota_thread_event, cobalt_schedquota_remove_thread,
	TP_PROTO(struct xnsched_quota_group *tg,
		 struct xnthread *thread),
	TP_ARGS(tg, thread)
);

#endif /* CONFIG_XENO_OPT_SCHED_QUOTA */

TRACE_EVENT(cobalt_thread_init,
	TP_PROTO(struct xnthread *thread,
		 const struct xnthread_init_attr *attr,
		 struct xnsched_class *sched_class),
	TP_ARGS(thread, attr, sched_class),

	TP_STRUCT__entry(
		__field(struct xnthread *, thread)
		__string(thread_name, thread->name)
		__string(class_name, sched_class->name)
		__field(unsigned long, flags)
		__field(int, cprio)
	),

	TP_fast_assign(
		__entry->thread = thread;
		__assign_str(thread_name, thread->name);
		__entry->flags = attr->flags;
		__assign_str(class_name, sched_class->name);
		__entry->cprio = thread->cprio;
	),

	TP_printk("thread=%p name=%s flags=0x%lx class=%s prio=%d",
		   __entry->thread, __get_str(thread_name), __entry->flags,
		   __get_str(class_name), __entry->cprio)
);

TRACE_EVENT(cobalt_thread_suspend,
	TP_PROTO(struct xnthread *thread, unsigned long mask, xnticks_t timeout,
		 xntmode_t timeout_mode, struct xnsynch *wchan),
	TP_ARGS(thread, mask, timeout, timeout_mode, wchan),

	TP_STRUCT__entry(
		__field(pid_t, pid)
		__field(unsigned long, mask)
		__field(xnticks_t, timeout)
		__field(xntmode_t, timeout_mode)
		__field(struct xnsynch *, wchan)
	),

	TP_fast_assign(
		__entry->pid = xnthread_host_pid(thread);
		__entry->mask = mask;
		__entry->timeout = timeout;
		__entry->timeout_mode = timeout_mode;
		__entry->wchan = wchan;
	),

	TP_printk("pid=%d mask=0x%lx timeout=%Lu timeout_mode=%d wchan=%p",
		  __entry->pid, __entry->mask,
		  __entry->timeout, __entry->timeout_mode, __entry->wchan)
);

TRACE_EVENT(cobalt_thread_resume,
	TP_PROTO(struct xnthread *thread, unsigned long mask),
	TP_ARGS(thread, mask),

	TP_STRUCT__entry(
		__string(name, thread->name)
		__field(pid_t, pid)
		__field(unsigned long, mask)
	),

	TP_fast_assign(
		__assign_str(name, thread->name);
		__entry->pid = xnthread_host_pid(thread);
		__entry->mask = mask;
	),

	TP_printk("name=%s pid=%d mask=0x%lx",
		  __get_str(name), __entry->pid, __entry->mask)
);

TRACE_EVENT(cobalt_thread_fault,
	TP_PROTO(unsigned long ip, unsigned int type),
	TP_ARGS(ip, type),

	TP_STRUCT__entry(
		__field(unsigned long, ip)
		__field(unsigned int, type)
	),

	TP_fast_assign(
		__entry->ip = ip;
		__entry->type = type;
	),

	TP_printk("ip=%#lx type=%#x",
		  __entry->ip, __entry->type)
);

TRACE_EVENT(cobalt_thread_set_current_prio,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread),

	TP_STRUCT__entry(
		__field(struct xnthread *, thread)
		__field(pid_t, pid)
		__field(int, cprio)
	),

	TP_fast_assign(
		__entry->thread = thread;
		__entry->pid = xnthread_host_pid(thread);
		__entry->cprio = xnthread_current_priority(thread);
	),

	TP_printk("thread=%p pid=%d prio=%d",
		  __entry->thread, __entry->pid, __entry->cprio)
);

DEFINE_EVENT(thread_event, cobalt_thread_start,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(thread_event, cobalt_thread_cancel,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(thread_event, cobalt_thread_join,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(thread_event, cobalt_thread_unblock,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(curr_thread_event, cobalt_thread_wait_period,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(curr_thread_event, cobalt_thread_missed_period,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(curr_thread_event, cobalt_thread_set_mode,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

TRACE_EVENT(cobalt_thread_migrate,
	TP_PROTO(unsigned int cpu),
	TP_ARGS(cpu),

	TP_STRUCT__entry(
		__field(unsigned int, cpu)
	),

	TP_fast_assign(
		__entry->cpu = cpu;
	),

	TP_printk("cpu=%u", __entry->cpu)
);

TRACE_EVENT(cobalt_thread_migrate_passive,
	TP_PROTO(struct xnthread *thread, unsigned int cpu),
	TP_ARGS(thread, cpu),

	TP_STRUCT__entry(
		__field(struct xnthread *, thread)
		__field(pid_t, pid)
		__field(unsigned int, cpu)
	),

	TP_fast_assign(
		__entry->thread = thread;
		__entry->pid = xnthread_host_pid(thread);
		__entry->cpu = cpu;
	),

	TP_printk("thread=%p pid=%d cpu=%u",
		  __entry->thread, __entry->pid, __entry->cpu)
);

DEFINE_EVENT(curr_thread_event, cobalt_shadow_gohard,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(curr_thread_event, cobalt_watchdog_signal,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(curr_thread_event, cobalt_shadow_hardened,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

#define cobalt_print_relax_reason(reason)				\
	__print_symbolic(reason,					\
			 { SIGDEBUG_UNDEFINED,		"undefined" },	\
			 { SIGDEBUG_MIGRATE_SIGNAL,	"signal" },	\
			 { SIGDEBUG_MIGRATE_SYSCALL,	"syscall" },	\
			 { SIGDEBUG_MIGRATE_FAULT,	"fault" })

TRACE_EVENT(cobalt_shadow_gorelax,
	TP_PROTO(int reason),
	TP_ARGS(reason),

	TP_STRUCT__entry(
		__field(int, reason)
	),

	TP_fast_assign(
		__entry->reason = reason;
	),

	TP_printk("reason=%s", cobalt_print_relax_reason(__entry->reason))
);

DEFINE_EVENT(curr_thread_event, cobalt_shadow_relaxed,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

DEFINE_EVENT(curr_thread_event, cobalt_shadow_entry,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

TRACE_EVENT(cobalt_shadow_map,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread),

	TP_STRUCT__entry(
		__field(struct xnthread *, thread)
		__field(pid_t, pid)
		__field(int, prio)
	),

	TP_fast_assign(
		__entry->thread = thread;
		__entry->pid = xnthread_host_pid(thread);
		__entry->prio = xnthread_base_priority(thread);
	),

	TP_printk("thread=%p pid=%d prio=%d",
		  __entry->thread, __entry->pid, __entry->prio)
);

DEFINE_EVENT(curr_thread_event, cobalt_shadow_unmap,
	TP_PROTO(struct xnthread *thread),
	TP_ARGS(thread)
);

TRACE_EVENT(cobalt_lostage_request,
        TP_PROTO(const char *type, struct task_struct *task),
	TP_ARGS(type, task),

	TP_STRUCT__entry(
		__field(pid_t, pid)
		__array(char, comm, TASK_COMM_LEN)
		__field(const char *, type)
	),

	TP_fast_assign(
		__entry->type = type;
		__entry->pid = task_pid_nr(task);
		memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
	),

	TP_printk("request=%s pid=%d comm=%s",
		  __entry->type, __entry->pid, __entry->comm)
);

TRACE_EVENT(cobalt_lostage_wakeup,
	TP_PROTO(struct task_struct *task),
	TP_ARGS(task),

	TP_STRUCT__entry(
		__field(pid_t, pid)
		__array(char, comm, TASK_COMM_LEN)
	),

	TP_fast_assign(
		__entry->pid = task_pid_nr(task);
		memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
	),

	TP_printk("pid=%d comm=%s",
		  __entry->pid, __entry->comm)
);

TRACE_EVENT(cobalt_lostage_signal,
	TP_PROTO(struct task_struct *task, int sig),
	TP_ARGS(task, sig),

	TP_STRUCT__entry(
		__field(pid_t, pid)
		__array(char, comm, TASK_COMM_LEN)
		__field(int, sig)
	),

	TP_fast_assign(
		__entry->pid = task_pid_nr(task);
		__entry->sig = sig;
		memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
	),

	TP_printk("pid=%d comm=%s sig=%d",
		  __entry->pid, __entry->comm, __entry->sig)
);

DEFINE_EVENT(irq_event, cobalt_irq_entry,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq)
);

DEFINE_EVENT(irq_event, cobalt_irq_exit,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq)
);

DEFINE_EVENT(irq_event, cobalt_irq_attach,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq)
);

DEFINE_EVENT(irq_event, cobalt_irq_detach,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq)
);

DEFINE_EVENT(irq_event, cobalt_irq_enable,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq)
);

DEFINE_EVENT(irq_event, cobalt_irq_disable,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq)
);

DEFINE_EVENT(clock_event, cobalt_clock_entry,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq)
);

DEFINE_EVENT(clock_event, cobalt_clock_exit,
	TP_PROTO(unsigned int irq),
	TP_ARGS(irq)
);

DEFINE_EVENT(timer_event, cobalt_timer_stop,
	TP_PROTO(struct xntimer *timer),
	TP_ARGS(timer)
);

DEFINE_EVENT(timer_event, cobalt_timer_expire,
	TP_PROTO(struct xntimer *timer),
	TP_ARGS(timer)
);

#define cobalt_print_timer_mode(mode)			\
	__print_symbolic(mode,				\
			 { XN_RELATIVE, "rel" },	\
			 { XN_ABSOLUTE, "abs" },	\
			 { XN_REALTIME, "rt" })

TRACE_EVENT(cobalt_timer_start,
	TP_PROTO(struct xntimer *timer, xnticks_t value, xnticks_t interval,
		 xntmode_t mode),
	TP_ARGS(timer, value, interval, mode),

	TP_STRUCT__entry(
		__field(struct xntimer *, timer)
#ifdef CONFIG_XENO_OPT_STATS
		__string(name, timer->name)
#endif
		__field(xnticks_t, value)
		__field(xnticks_t, interval)
		__field(xntmode_t, mode)
	),

	TP_fast_assign(
		__entry->timer = timer;
#ifdef CONFIG_XENO_OPT_STATS
		__assign_str(name, timer->name);
#endif
		__entry->value = value;
		__entry->interval = interval;
		__entry->mode = mode;
	),

	TP_printk("timer=%p(%s) value=%Lu interval=%Lu mode=%s",
		  __entry->timer,
#ifdef CONFIG_XENO_OPT_STATS
		  __get_str(name),
#else
		  "(anon)",
#endif
		  __entry->value, __entry->interval,
		  cobalt_print_timer_mode(__entry->mode))
);

#ifdef CONFIG_SMP

TRACE_EVENT(cobalt_timer_migrate,
	TP_PROTO(struct xntimer *timer, unsigned int cpu),
	TP_ARGS(timer, cpu),

	TP_STRUCT__entry(
		__field(struct xntimer *, timer)
		__field(unsigned int, cpu)
	),

	TP_fast_assign(
		__entry->timer = timer;
		__entry->cpu = cpu;
	),

	TP_printk("timer=%p cpu=%u",
		  __entry->timer, __entry->cpu)
);

#endif /* CONFIG_SMP */

DEFINE_EVENT(synch_wait_event, cobalt_synch_sleepon,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch)
);

DEFINE_EVENT(synch_wait_event, cobalt_synch_try_acquire,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch)
);

DEFINE_EVENT(synch_wait_event, cobalt_synch_acquire,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch)
);

DEFINE_EVENT(synch_post_event, cobalt_synch_release,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch)
);

DEFINE_EVENT(synch_post_event, cobalt_synch_wakeup,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch)
);

DEFINE_EVENT(synch_post_event, cobalt_synch_wakeup_many,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch)
);

DEFINE_EVENT(synch_post_event, cobalt_synch_flush,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch)
);

DEFINE_EVENT(synch_post_event, cobalt_synch_forget,
	TP_PROTO(struct xnsynch *synch),
	TP_ARGS(synch)
);

DEFINE_EVENT(registry_event, cobalt_registry_enter,
	TP_PROTO(const char *key, void *addr),
	TP_ARGS(key, addr)
);

DEFINE_EVENT(registry_event, cobalt_registry_remove,
	TP_PROTO(const char *key, void *addr),
	TP_ARGS(key, addr)
);

DEFINE_EVENT(registry_event, cobalt_registry_unlink,
	TP_PROTO(const char *key, void *addr),
	TP_ARGS(key, addr)
);

TRACE_EVENT(cobalt_tick_shot,
	TP_PROTO(s64 delta),
	TP_ARGS(delta),

	TP_STRUCT__entry(
		__field(u64, secs)
		__field(u32, nsecs)
		__field(s64, delta)
	),

	TP_fast_assign(
		__entry->delta = delta;
		__entry->secs = div_u64_rem(trace_clock_local() + delta,
					    NSEC_PER_SEC, &__entry->nsecs);
	),

	TP_printk("next tick at %Lu.%06u (delay: %Ld us)",
		  (unsigned long long)__entry->secs,
		  __entry->nsecs / 1000, div_s64(__entry->delta, 1000))
);

TRACE_EVENT(cobalt_trace,
	TP_PROTO(const char *msg),
	TP_ARGS(msg),
	TP_STRUCT__entry(
		__string(msg, msg)
	),
	TP_fast_assign(
		__assign_str(msg, msg);
	),
	TP_printk("%s", __get_str(msg))
);

TRACE_EVENT(cobalt_trace_longval,
	TP_PROTO(int id, u64 val),
	TP_ARGS(id, val),
	TP_STRUCT__entry(
		__field(int, id)
		__field(u64, val)
	),
	TP_fast_assign(
		__entry->id = id;
		__entry->val = val;
	),
	TP_printk("id=%#x, v=%llu", __entry->id, __entry->val)
);

TRACE_EVENT(cobalt_trace_pid,
	TP_PROTO(pid_t pid, int prio),
	TP_ARGS(pid, prio),
	TP_STRUCT__entry(
		__field(pid_t, pid)
		__field(int, prio)
	),
	TP_fast_assign(
		__entry->pid = pid;
		__entry->prio = prio;
	),
	TP_printk("pid=%d, prio=%d", __entry->pid, __entry->prio)
);

TRACE_EVENT(cobalt_latpeak,
	TP_PROTO(int latmax_ns),
	TP_ARGS(latmax_ns),
	TP_STRUCT__entry(
		 __field(int, latmax_ns)
	),
	TP_fast_assign(
		__entry->latmax_ns = latmax_ns;
	),
	TP_printk("** latency peak: %d.%.3d us **",
		  __entry->latmax_ns / 1000,
		  __entry->latmax_ns % 1000)
);

/* Basically cobalt_trace() + trigger point */
TRACE_EVENT(cobalt_trigger,
	TP_PROTO(const char *issuer),
	TP_ARGS(issuer),
	TP_STRUCT__entry(
		__string(issuer, issuer)
	),
	TP_fast_assign(
		__assign_str(issuer, issuer);
	),
	TP_printk("%s", __get_str(issuer))
);

#endif /* _TRACE_COBALT_CORE_H */

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