21 #define TRACE_SYSTEM cobalt_rtdm
22 #undef TRACE_INCLUDE_FILE
23 #define TRACE_INCLUDE_FILE cobalt-rtdm
25 #if !defined(_TRACE_COBALT_RTDM_H) || defined(TRACE_HEADER_MULTI_READ)
26 #define _TRACE_COBALT_RTDM_H
28 #include <linux/tracepoint.h>
29 #include <linux/mman.h>
30 #include <linux/sched.h>
39 struct _rtdm_mmap_request;
41 DECLARE_EVENT_CLASS(fd_event,
42 TP_PROTO(
struct rtdm_fd *fd,
int ufd),
51 __entry->dev = rtdm_fd_to_context(fd)->device;
55 TP_printk(
"device=%p fd=%d",
56 __entry->dev, __entry->ufd)
59 DECLARE_EVENT_CLASS(fd_request,
60 TP_PROTO(
struct task_struct *task,
61 struct rtdm_fd *fd,
int ufd,
unsigned long arg),
62 TP_ARGS(task, fd, ufd, arg),
65 __array(
char, comm, TASK_COMM_LEN)
69 __field(
unsigned long, arg)
73 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
74 __entry->pid = task_pid_nr(task);
75 __entry->dev = rtdm_fd_to_context(fd)->device;
80 TP_printk(
"device=%p fd=%d arg=%#lx pid=%d comm=%s",
81 __entry->dev, __entry->ufd, __entry->arg,
82 __entry->pid, __entry->comm)
85 DECLARE_EVENT_CLASS(fd_request_status,
86 TP_PROTO(
struct task_struct *task,
87 struct rtdm_fd *fd,
int ufd,
int status),
88 TP_ARGS(task, fd, ufd, status),
91 __array(
char, comm, TASK_COMM_LEN)
98 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
99 __entry->pid = task_pid_nr(task);
101 !IS_ERR(fd) ? rtdm_fd_to_context(fd)->device : NULL;
105 TP_printk(
"device=%p fd=%d pid=%d comm=%s",
106 __entry->dev, __entry->ufd, __entry->pid, __entry->comm)
109 DECLARE_EVENT_CLASS(task_op,
110 TP_PROTO(
struct xnthread *task),
114 __field(
struct xnthread *, task)
115 __string(task_name, task->name)
119 __entry->task = task;
120 __assign_str(task_name, task->name);
123 TP_printk(
"task %p(%s)", __entry->task, __get_str(task_name))
126 DECLARE_EVENT_CLASS(event_op,
127 TP_PROTO(
struct rtdm_event *ev),
131 __field(
struct rtdm_event *, ev)
138 TP_printk(
"event=%p", __entry->ev)
141 DECLARE_EVENT_CLASS(sem_op,
142 TP_PROTO(
struct rtdm_sem *sem),
146 __field(
struct rtdm_sem *, sem)
153 TP_printk(
"sem=%p", __entry->sem)
156 DECLARE_EVENT_CLASS(mutex_op,
157 TP_PROTO(
struct rtdm_mutex *mutex),
161 __field(
struct rtdm_mutex *, mutex)
165 __entry->mutex = mutex;
168 TP_printk(
"mutex=%p", __entry->mutex)
171 TRACE_EVENT(cobalt_device_register,
177 __string(device_name, dev->name)
179 __field(
int, class_id)
180 __field(
int, subclass_id)
181 __field(
int, profile_version)
186 __assign_str(device_name, dev->name);
193 TP_printk(
"%s device %s=%p flags=0x%x, class=%d.%d profile=%d",
196 __get_str(device_name), __entry->dev,
197 __entry->flags, __entry->class_id, __entry->subclass_id,
198 __entry->profile_version)
201 TRACE_EVENT(cobalt_device_unregister,
207 __string(device_name, dev->name)
212 __assign_str(device_name, dev->name);
215 TP_printk(
"device %s=%p",
216 __get_str(device_name), __entry->dev)
219 DEFINE_EVENT(fd_event, cobalt_fd_created,
220 TP_PROTO(
struct rtdm_fd *fd,
int ufd),
224 DEFINE_EVENT(fd_request, cobalt_fd_open,
225 TP_PROTO(
struct task_struct *task,
226 struct rtdm_fd *fd,
int ufd,
227 unsigned long oflags),
228 TP_ARGS(task, fd, ufd, oflags)
231 DEFINE_EVENT(fd_request, cobalt_fd_close,
232 TP_PROTO(
struct task_struct *task,
233 struct rtdm_fd *fd,
int ufd,
234 unsigned long lock_count),
235 TP_ARGS(task, fd, ufd, lock_count)
238 DEFINE_EVENT(fd_request, cobalt_fd_socket,
239 TP_PROTO(
struct task_struct *task,
240 struct rtdm_fd *fd,
int ufd,
241 unsigned long protocol_family),
242 TP_ARGS(task, fd, ufd, protocol_family)
245 DEFINE_EVENT(fd_request, cobalt_fd_read,
246 TP_PROTO(
struct task_struct *task,
247 struct rtdm_fd *fd,
int ufd,
249 TP_ARGS(task, fd, ufd, len)
252 DEFINE_EVENT(fd_request, cobalt_fd_write,
253 TP_PROTO(
struct task_struct *task,
254 struct rtdm_fd *fd,
int ufd,
256 TP_ARGS(task, fd, ufd, len)
259 DEFINE_EVENT(fd_request, cobalt_fd_ioctl,
260 TP_PROTO(
struct task_struct *task,
261 struct rtdm_fd *fd,
int ufd,
262 unsigned long request),
263 TP_ARGS(task, fd, ufd, request)
266 DEFINE_EVENT(fd_request, cobalt_fd_sendmsg,
267 TP_PROTO(
struct task_struct *task,
268 struct rtdm_fd *fd,
int ufd,
269 unsigned long flags),
270 TP_ARGS(task, fd, ufd, flags)
273 DEFINE_EVENT(fd_request, cobalt_fd_recvmsg,
274 TP_PROTO(
struct task_struct *task,
275 struct rtdm_fd *fd,
int ufd,
276 unsigned long flags),
277 TP_ARGS(task, fd, ufd, flags)
280 #define cobalt_print_protbits(__prot) \
281 __print_flags(__prot, "|", \
282 {PROT_EXEC, "exec"}, \
283 {PROT_READ, "read"}, \
284 {PROT_WRITE, "write"})
286 #define cobalt_print_mapbits(__flags) \
287 __print_flags(__flags, "|", \
288 {MAP_SHARED, "shared"}, \
289 {MAP_PRIVATE, "private"}, \
290 {MAP_ANONYMOUS, "anon"}, \
291 {MAP_FIXED, "fixed"}, \
292 {MAP_HUGETLB, "huge"}, \
293 {MAP_NONBLOCK, "nonblock"}, \
294 {MAP_NORESERVE, "noreserve"}, \
295 {MAP_POPULATE, "populate"}, \
296 {MAP_UNINITIALIZED, "uninit"})
298 TRACE_EVENT(cobalt_fd_mmap,
299 TP_PROTO(
struct task_struct *task,
300 struct rtdm_fd *fd,
int ufd,
struct _rtdm_mmap_request *rma),
301 TP_ARGS(task, fd, ufd, rma),
304 __array(
char, comm, TASK_COMM_LEN)
308 __field(
size_t, length)
309 __field(off_t, offset)
315 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
316 __entry->pid = task_pid_nr(task);
317 __entry->dev = rtdm_fd_to_context(fd)->device;
319 __entry->length = rma->length;
320 __entry->offset = rma->offset;
321 __entry->prot = rma->prot;
322 __entry->flags = rma->flags;
325 TP_printk(
"device=%p fd=%d area={ len:%Zu, off:%Lu }"
326 " prot=%#x(%s) flags=%#x(%s) pid=%d comm=%s",
327 __entry->dev, __entry->ufd, __entry->length,
328 (
unsigned long long)__entry->offset,
329 __entry->prot, cobalt_print_protbits(__entry->prot),
330 __entry->flags, cobalt_print_mapbits(__entry->flags),
331 __entry->pid, __entry->comm)
334 DEFINE_EVENT(fd_request_status, cobalt_fd_ioctl_status,
335 TP_PROTO(
struct task_struct *task,
336 struct rtdm_fd *fd,
int ufd,
338 TP_ARGS(task, fd, ufd, status)
341 DEFINE_EVENT(fd_request_status, cobalt_fd_read_status,
342 TP_PROTO(
struct task_struct *task,
343 struct rtdm_fd *fd,
int ufd,
345 TP_ARGS(task, fd, ufd, status)
348 DEFINE_EVENT(fd_request_status, cobalt_fd_write_status,
349 TP_PROTO(
struct task_struct *task,
350 struct rtdm_fd *fd,
int ufd,
352 TP_ARGS(task, fd, ufd, status)
355 DEFINE_EVENT(fd_request_status, cobalt_fd_recvmsg_status,
356 TP_PROTO(
struct task_struct *task,
357 struct rtdm_fd *fd,
int ufd,
359 TP_ARGS(task, fd, ufd, status)
362 DEFINE_EVENT(fd_request_status, cobalt_fd_sendmsg_status,
363 TP_PROTO(
struct task_struct *task,
364 struct rtdm_fd *fd,
int ufd,
366 TP_ARGS(task, fd, ufd, status)
369 DEFINE_EVENT(fd_request_status, cobalt_fd_mmap_status,
370 TP_PROTO(
struct task_struct *task,
371 struct rtdm_fd *fd,
int ufd,
373 TP_ARGS(task, fd, ufd, status)
376 DEFINE_EVENT(task_op, cobalt_driver_task_join,
377 TP_PROTO(
struct xnthread *task),
381 TRACE_EVENT(cobalt_driver_event_init,
382 TP_PROTO(
struct rtdm_event *ev,
unsigned long pending),
383 TP_ARGS(ev, pending),
386 __field(
struct rtdm_event *, ev)
387 __field(
unsigned long, pending)
392 __entry->pending = pending;
395 TP_printk(
"event=%p pending=%#lx",
396 __entry->ev, __entry->pending)
399 TRACE_EVENT(cobalt_driver_event_wait,
400 TP_PROTO(
struct rtdm_event *ev,
struct xnthread *task),
404 __field(
struct xnthread *, task)
405 __string(task_name, task->name)
406 __field(
struct rtdm_event *, ev)
410 __entry->task = task;
411 __assign_str(task_name, task->name);
415 TP_printk(
"event=%p task=%p(%s)",
416 __entry->ev, __entry->task, __get_str(task_name))
419 DEFINE_EVENT(event_op, cobalt_driver_event_signal,
420 TP_PROTO(
struct rtdm_event *ev),
424 DEFINE_EVENT(event_op, cobalt_driver_event_clear,
425 TP_PROTO(
struct rtdm_event *ev),
429 DEFINE_EVENT(event_op, cobalt_driver_event_pulse,
430 TP_PROTO(
struct rtdm_event *ev),
434 DEFINE_EVENT(event_op, cobalt_driver_event_destroy,
435 TP_PROTO(
struct rtdm_event *ev),
439 TRACE_EVENT(cobalt_driver_sem_init,
440 TP_PROTO(
struct rtdm_sem *sem,
unsigned long value),
444 __field(
struct rtdm_sem *, sem)
445 __field(
unsigned long, value)
450 __entry->value = value;
453 TP_printk(
"sem=%p value=%lu",
454 __entry->sem, __entry->value)
457 TRACE_EVENT(cobalt_driver_sem_wait,
458 TP_PROTO(
struct rtdm_sem *sem,
struct xnthread *task),
462 __field(
struct xnthread *, task)
463 __string(task_name, task->name)
464 __field(
struct rtdm_sem *, sem)
468 __entry->task = task;
469 __assign_str(task_name, task->name);
473 TP_printk(
"sem=%p task=%p(%s)",
474 __entry->sem, __entry->task, __get_str(task_name))
477 DEFINE_EVENT(sem_op, cobalt_driver_sem_up,
478 TP_PROTO(
struct rtdm_sem *sem),
482 DEFINE_EVENT(sem_op, cobalt_driver_sem_destroy,
483 TP_PROTO(
struct rtdm_sem *sem),
487 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_init,
488 TP_PROTO(
struct rtdm_mutex *mutex),
492 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_release,
493 TP_PROTO(
struct rtdm_mutex *mutex),
497 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_destroy,
498 TP_PROTO(
struct rtdm_mutex *mutex),
502 TRACE_EVENT(cobalt_driver_mutex_wait,
503 TP_PROTO(
struct rtdm_mutex *mutex,
struct xnthread *task),
504 TP_ARGS(mutex, task),
507 __field(
struct xnthread *, task)
508 __string(task_name, task->name)
509 __field(
struct rtdm_mutex *, mutex)
513 __entry->task = task;
514 __assign_str(task_name, task->name);
515 __entry->mutex = mutex;
518 TP_printk(
"mutex=%p task=%p(%s)",
519 __entry->mutex, __entry->task, __get_str(task_name))
525 #include <trace/define_trace.h>
struct rtdm_profile_info profile_info
Class profile information.
Definition: driver.h:254
int device_flags
Device flags, see Device Flags for details.
Definition: driver.h:259
struct rtdm_driver * driver
Device driver.
Definition: driver.h:327
#define RTDM_NAMED_DEVICE
If set, the device is addressed via a clear-text name.
Definition: driver.h:83
Device context.
Definition: driver.h:136
RTDM device.
Definition: driver.h:325
#define RTDM_DEVICE_TYPE_MASK
Mask selecting the device type.
Definition: driver.h:90