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

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

#include <linux/tracepoint.h>
#include <linux/mman.h>
#include <linux/sched.h>

struct rtdm_fd;
struct rtdm_event;
struct rtdm_sem;
struct rtdm_mutex;
struct xnthread;
struct rtdm_device;
struct rtdm_dev_context;
struct _rtdm_mmap_request;

DECLARE_EVENT_CLASS(fd_event,
	TP_PROTO(struct rtdm_fd *fd, int ufd),
	TP_ARGS(fd, ufd),

	TP_STRUCT__entry(
		__field(struct rtdm_device *, dev)
		__field(int, ufd)
	),

	TP_fast_assign(
		__entry->dev = rtdm_fd_to_context(fd)->device;
		__entry->ufd = ufd;
	),

	TP_printk("device=%p fd=%d",
		  __entry->dev, __entry->ufd)
);

DECLARE_EVENT_CLASS(fd_request,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd, unsigned long arg),
	TP_ARGS(task, fd, ufd, arg),

	TP_STRUCT__entry(
		__array(char, comm, TASK_COMM_LEN)
		__field(pid_t, pid)
		__field(struct rtdm_device *, dev)
		__field(int, ufd)
		__field(unsigned long, arg)
	),

	TP_fast_assign(
		memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
		__entry->pid = task_pid_nr(task);
		__entry->dev = rtdm_fd_to_context(fd)->device;
		__entry->ufd = ufd;
		__entry->arg = arg;
	),

	TP_printk("device=%p fd=%d arg=%#lx pid=%d comm=%s",
		  __entry->dev, __entry->ufd, __entry->arg,
		  __entry->pid, __entry->comm)
);

DECLARE_EVENT_CLASS(fd_request_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd, int status),
	TP_ARGS(task, fd, ufd, status),

	TP_STRUCT__entry(
		__array(char, comm, TASK_COMM_LEN)
		__field(pid_t, pid)
		__field(struct rtdm_device *, dev)
		__field(int, ufd)
	),

	TP_fast_assign(
		memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
		__entry->pid = task_pid_nr(task);
		__entry->dev =
			!IS_ERR(fd) ? rtdm_fd_to_context(fd)->device : NULL;
		__entry->ufd = ufd;
	),

	TP_printk("device=%p fd=%d pid=%d comm=%s",
		  __entry->dev, __entry->ufd, __entry->pid, __entry->comm)
);

DECLARE_EVENT_CLASS(task_op,
	TP_PROTO(struct xnthread *task),
	TP_ARGS(task),

	TP_STRUCT__entry(
		__field(struct xnthread *, task)
		__string(task_name, task->name)
	),

	TP_fast_assign(
		__entry->task = task;
		__assign_str(task_name, task->name);
	),

	TP_printk("task %p(%s)", __entry->task, __get_str(task_name))
);

DECLARE_EVENT_CLASS(event_op,
	TP_PROTO(struct rtdm_event *ev),
	TP_ARGS(ev),

	TP_STRUCT__entry(
		__field(struct rtdm_event *, ev)
	),

	TP_fast_assign(
		__entry->ev = ev;
	),

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

DECLARE_EVENT_CLASS(sem_op,
	TP_PROTO(struct rtdm_sem *sem),
	TP_ARGS(sem),

	TP_STRUCT__entry(
		__field(struct rtdm_sem *, sem)
	),

	TP_fast_assign(
		__entry->sem = sem;
	),

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

DECLARE_EVENT_CLASS(mutex_op,
	TP_PROTO(struct rtdm_mutex *mutex),
	TP_ARGS(mutex),

	TP_STRUCT__entry(
		__field(struct rtdm_mutex *, mutex)
	),

	TP_fast_assign(
		__entry->mutex = mutex;
	),

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

TRACE_EVENT(cobalt_device_register,
	TP_PROTO(struct rtdm_device *dev),
	TP_ARGS(dev),

	TP_STRUCT__entry(
		__field(struct rtdm_device *, dev)
		__string(device_name, dev->name)
		__field(int, flags)
		__field(int, class_id)
		__field(int, subclass_id)
		__field(int, profile_version)
	),

	TP_fast_assign(
		__entry->dev	= dev;
		__assign_str(device_name, dev->name);
		__entry->flags = dev->driver->device_flags;
		__entry->class_id = dev->driver->profile_info.class_id;
		__entry->subclass_id = dev->driver->profile_info.subclass_id;
		__entry->profile_version = dev->driver->profile_info.version;
	),

	TP_printk("%s device %s=%p flags=0x%x, class=%d.%d profile=%d",
		  (__entry->flags & RTDM_DEVICE_TYPE_MASK)
		  == RTDM_NAMED_DEVICE ? "named" : "protocol",
		  __get_str(device_name), __entry->dev,
		  __entry->flags, __entry->class_id, __entry->subclass_id,
		  __entry->profile_version)
);

TRACE_EVENT(cobalt_device_unregister,
	TP_PROTO(struct rtdm_device *dev),
	TP_ARGS(dev),

	TP_STRUCT__entry(
		__field(struct rtdm_device *, dev)
		__string(device_name, dev->name)
	),

	TP_fast_assign(
		__entry->dev	= dev;
		__assign_str(device_name, dev->name);
	),

	TP_printk("device %s=%p",
		  __get_str(device_name), __entry->dev)
);

DEFINE_EVENT(fd_event, cobalt_fd_created,
	TP_PROTO(struct rtdm_fd *fd, int ufd),
	TP_ARGS(fd, ufd)
);

DEFINE_EVENT(fd_request, cobalt_fd_open,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long oflags),
	TP_ARGS(task, fd, ufd, oflags)
);

DEFINE_EVENT(fd_request, cobalt_fd_close,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long lock_count),
	TP_ARGS(task, fd, ufd, lock_count)
);

DEFINE_EVENT(fd_request, cobalt_fd_socket,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long protocol_family),
	TP_ARGS(task, fd, ufd, protocol_family)
);

DEFINE_EVENT(fd_request, cobalt_fd_read,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long len),
	TP_ARGS(task, fd, ufd, len)
);

DEFINE_EVENT(fd_request, cobalt_fd_write,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long len),
	TP_ARGS(task, fd, ufd, len)
);

DEFINE_EVENT(fd_request, cobalt_fd_ioctl,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long request),
	TP_ARGS(task, fd, ufd, request)
);

DEFINE_EVENT(fd_request, cobalt_fd_sendmsg,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long flags),
	TP_ARGS(task, fd, ufd, flags)
);

DEFINE_EVENT(fd_request, cobalt_fd_sendmmsg,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long flags),
	TP_ARGS(task, fd, ufd, flags)
);

DEFINE_EVENT(fd_request, cobalt_fd_recvmsg,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long flags),
	TP_ARGS(task, fd, ufd, flags)
);

DEFINE_EVENT(fd_request, cobalt_fd_recvmmsg,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 unsigned long flags),
	TP_ARGS(task, fd, ufd, flags)
);

#define cobalt_print_protbits(__prot)		\
	__print_flags(__prot,  "|", 		\
		      {PROT_EXEC, "exec"},	\
		      {PROT_READ, "read"},	\
		      {PROT_WRITE, "write"})

#define cobalt_print_mapbits(__flags)		\
	__print_flags(__flags,  "|", 		\
		      {MAP_SHARED, "shared"},	\
		      {MAP_PRIVATE, "private"},	\
		      {MAP_ANONYMOUS, "anon"},	\
		      {MAP_FIXED, "fixed"},	\
		      {MAP_HUGETLB, "huge"},	\
		      {MAP_NONBLOCK, "nonblock"},	\
		      {MAP_NORESERVE, "noreserve"},	\
		      {MAP_POPULATE, "populate"},	\
		      {MAP_UNINITIALIZED, "uninit"})

TRACE_EVENT(cobalt_fd_mmap,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd, struct _rtdm_mmap_request *rma),
        TP_ARGS(task, fd, ufd, rma),

	TP_STRUCT__entry(
		__array(char, comm, TASK_COMM_LEN)
		__field(pid_t, pid)
		__field(struct rtdm_device *, dev)
		__field(int, ufd)
		__field(size_t, length)
		__field(off_t, offset)
		__field(int, prot)
		__field(int, flags)
	),

	TP_fast_assign(
		memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
		__entry->pid = task_pid_nr(task);
		__entry->dev = rtdm_fd_to_context(fd)->device;
		__entry->ufd = ufd;
		__entry->length = rma->length;
		__entry->offset = rma->offset;
		__entry->prot = rma->prot;
		__entry->flags = rma->flags;
	),

	TP_printk("device=%p fd=%d area={ len:%zu, off:%Lu }"
		  " prot=%#x(%s) flags=%#x(%s) pid=%d comm=%s",
		  __entry->dev, __entry->ufd, __entry->length,
		  (unsigned long long)__entry->offset,
		  __entry->prot, cobalt_print_protbits(__entry->prot),
		  __entry->flags, cobalt_print_mapbits(__entry->flags),
		  __entry->pid, __entry->comm)
);

DEFINE_EVENT(fd_request_status, cobalt_fd_ioctl_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 int status),
	TP_ARGS(task, fd, ufd, status)
);

DEFINE_EVENT(fd_request_status, cobalt_fd_read_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 int status),
	TP_ARGS(task, fd, ufd, status)
);

DEFINE_EVENT(fd_request_status, cobalt_fd_write_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 int status),
	TP_ARGS(task, fd, ufd, status)
);

DEFINE_EVENT(fd_request_status, cobalt_fd_recvmsg_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 int status),
	TP_ARGS(task, fd, ufd, status)
);

DEFINE_EVENT(fd_request_status, cobalt_fd_recvmmsg_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 int status),
	TP_ARGS(task, fd, ufd, status)
);

DEFINE_EVENT(fd_request_status, cobalt_fd_sendmsg_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 int status),
	TP_ARGS(task, fd, ufd, status)
);

DEFINE_EVENT(fd_request_status, cobalt_fd_sendmmsg_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 int status),
	TP_ARGS(task, fd, ufd, status)
);

DEFINE_EVENT(fd_request_status, cobalt_fd_mmap_status,
	TP_PROTO(struct task_struct *task,
		 struct rtdm_fd *fd, int ufd,
		 int status),
	TP_ARGS(task, fd, ufd, status)
);

DEFINE_EVENT(task_op, cobalt_driver_task_join,
	TP_PROTO(struct xnthread *task),
	TP_ARGS(task)
);

TRACE_EVENT(cobalt_driver_event_init,
	TP_PROTO(struct rtdm_event *ev, unsigned long pending),
	TP_ARGS(ev, pending),

	TP_STRUCT__entry(
		__field(struct rtdm_event *, ev)
		__field(unsigned long,	pending)
	),

	TP_fast_assign(
		__entry->ev = ev;
		__entry->pending = pending;
	),

	TP_printk("event=%p pending=%#lx",
		  __entry->ev, __entry->pending)
);

TRACE_EVENT(cobalt_driver_event_wait,
	TP_PROTO(struct rtdm_event *ev, struct xnthread *task),
	TP_ARGS(ev, task),

	TP_STRUCT__entry(
		__field(struct xnthread *, task)
		__string(task_name, task->name)
		__field(struct rtdm_event *, ev)
	),

	TP_fast_assign(
		__entry->task = task;
		__assign_str(task_name, task->name);
		__entry->ev = ev;
	),

	TP_printk("event=%p task=%p(%s)",
		  __entry->ev, __entry->task, __get_str(task_name))
);

DEFINE_EVENT(event_op, cobalt_driver_event_signal,
	TP_PROTO(struct rtdm_event *ev),
	TP_ARGS(ev)
);

DEFINE_EVENT(event_op, cobalt_driver_event_clear,
	TP_PROTO(struct rtdm_event *ev),
	TP_ARGS(ev)
);

DEFINE_EVENT(event_op, cobalt_driver_event_pulse,
	TP_PROTO(struct rtdm_event *ev),
	TP_ARGS(ev)
);

DEFINE_EVENT(event_op, cobalt_driver_event_destroy,
	TP_PROTO(struct rtdm_event *ev),
	TP_ARGS(ev)
);

TRACE_EVENT(cobalt_driver_sem_init,
	TP_PROTO(struct rtdm_sem *sem, unsigned long value),
	TP_ARGS(sem, value),

	TP_STRUCT__entry(
		__field(struct rtdm_sem *, sem)
		__field(unsigned long, value)
	),

	TP_fast_assign(
		__entry->sem = sem;
		__entry->value = value;
	),

	TP_printk("sem=%p value=%lu",
		  __entry->sem, __entry->value)
);

TRACE_EVENT(cobalt_driver_sem_wait,
	TP_PROTO(struct rtdm_sem *sem, struct xnthread *task),
	TP_ARGS(sem, task),

	TP_STRUCT__entry(
		__field(struct xnthread *, task)
		__string(task_name, task->name)
		__field(struct rtdm_sem *, sem)
	),

	TP_fast_assign(
		__entry->task = task;
		__assign_str(task_name, task->name);
		__entry->sem = sem;
	),

	TP_printk("sem=%p task=%p(%s)",
		  __entry->sem, __entry->task, __get_str(task_name))
);

DEFINE_EVENT(sem_op, cobalt_driver_sem_up,
	TP_PROTO(struct rtdm_sem *sem),
	TP_ARGS(sem)
);

DEFINE_EVENT(sem_op, cobalt_driver_sem_destroy,
	TP_PROTO(struct rtdm_sem *sem),
	TP_ARGS(sem)
);

DEFINE_EVENT(mutex_op, cobalt_driver_mutex_init,
	TP_PROTO(struct rtdm_mutex *mutex),
	TP_ARGS(mutex)
);

DEFINE_EVENT(mutex_op, cobalt_driver_mutex_release,
	TP_PROTO(struct rtdm_mutex *mutex),
	TP_ARGS(mutex)
);

DEFINE_EVENT(mutex_op, cobalt_driver_mutex_destroy,
	TP_PROTO(struct rtdm_mutex *mutex),
	TP_ARGS(mutex)
);

TRACE_EVENT(cobalt_driver_mutex_wait,
	TP_PROTO(struct rtdm_mutex *mutex, struct xnthread *task),
	TP_ARGS(mutex, task),

	TP_STRUCT__entry(
		__field(struct xnthread *, task)
		__string(task_name, task->name)
		__field(struct rtdm_mutex *, mutex)
	),

	TP_fast_assign(
		__entry->task = task;
		__assign_str(task_name, task->name);
		__entry->mutex = mutex;
	),

	TP_printk("mutex=%p task=%p(%s)",
		  __entry->mutex, __entry->task, __get_str(task_name))
);

#endif /* _TRACE_COBALT_RTDM_H */

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