cobalt-rtdm.h

/*
 * 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;
                __wrap_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;
                __wrap_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;
                __wrap_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;
                __wrap_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;
                __wrap_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;
                __wrap_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>