21 #define TRACE_SYSTEM cobalt-rtdm
23 #if !defined(_TRACE_COBALT_RTDM_H) || defined(TRACE_HEADER_MULTI_READ)
24 #define _TRACE_COBALT_RTDM_H
26 #include <linux/tracepoint.h>
27 #include <linux/mman.h>
36 struct _rtdm_mmap_request;
38 DECLARE_EVENT_CLASS(fd_event,
39 TP_PROTO(
struct rtdm_fd *fd,
int ufd),
48 __entry->dev = rtdm_fd_to_context(fd)->device;
52 TP_printk(
"device=%p fd=%d",
53 __entry->dev, __entry->ufd)
56 DECLARE_EVENT_CLASS(fd_request,
57 TP_PROTO(
struct task_struct *task,
58 struct rtdm_fd *fd,
int ufd,
unsigned long arg),
59 TP_ARGS(task, fd, ufd, arg),
62 __array(
char, comm, TASK_COMM_LEN)
66 __field(
unsigned long, arg)
70 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
71 __entry->pid = task->pid;
72 __entry->dev = rtdm_fd_to_context(fd)->device;
77 TP_printk(
"device=%p fd=%d arg=%#lx pid=%d comm=%s",
78 __entry->dev, __entry->ufd, __entry->arg,
79 __entry->pid, __entry->comm)
82 DECLARE_EVENT_CLASS(fd_request_status,
83 TP_PROTO(
struct task_struct *task,
84 struct rtdm_fd *fd,
int ufd,
int status),
85 TP_ARGS(task, fd, ufd, status),
88 __array(
char, comm, TASK_COMM_LEN)
95 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
96 __entry->pid = task->pid;
98 !IS_ERR(fd) ? rtdm_fd_to_context(fd)->device : NULL;
102 TP_printk(
"device=%p fd=%d pid=%d comm=%s",
103 __entry->dev, __entry->ufd, __entry->pid, __entry->comm)
106 DECLARE_EVENT_CLASS(task_op,
107 TP_PROTO(
struct xnthread *task),
111 __field(
struct xnthread *, task)
112 __string(task_name, task->name)
116 __entry->task = task;
117 __assign_str(task_name, task->name);
120 TP_printk(
"task %p(%s)", __entry->task, __get_str(task_name))
123 DECLARE_EVENT_CLASS(event_op,
124 TP_PROTO(
struct rtdm_event *ev),
128 __field(
struct rtdm_event *, ev)
135 TP_printk(
"event=%p", __entry->ev)
138 DECLARE_EVENT_CLASS(sem_op,
139 TP_PROTO(
struct rtdm_sem *sem),
143 __field(
struct rtdm_sem *, sem)
150 TP_printk(
"sem=%p", __entry->sem)
153 DECLARE_EVENT_CLASS(mutex_op,
154 TP_PROTO(
struct rtdm_mutex *mutex),
158 __field(
struct rtdm_mutex *, mutex)
162 __entry->mutex = mutex;
165 TP_printk(
"mutex=%p", __entry->mutex)
168 TRACE_EVENT(cobalt_device_register,
174 __string(device_name, dev->name)
176 __field(
int, class_id)
177 __field(
int, subclass_id)
178 __field(
int, profile_version)
183 __assign_str(device_name, dev->name);
190 TP_printk(
"%s device %s=%p flags=0x%x, class=%d.%d profile=%d",
193 __get_str(device_name), __entry->dev,
194 __entry->flags, __entry->class_id, __entry->subclass_id,
195 __entry->profile_version)
198 TRACE_EVENT(cobalt_device_unregister,
204 __string(device_name, dev->name)
209 __assign_str(device_name, dev->name);
212 TP_printk(
"device %s=%p",
213 __get_str(device_name), __entry->dev)
216 DEFINE_EVENT(fd_event, cobalt_fd_created,
217 TP_PROTO(
struct rtdm_fd *fd,
int ufd),
221 DEFINE_EVENT(fd_request, cobalt_fd_open,
222 TP_PROTO(
struct task_struct *task,
223 struct rtdm_fd *fd,
int ufd,
224 unsigned long oflags),
225 TP_ARGS(task, fd, ufd, oflags)
228 DEFINE_EVENT(fd_request, cobalt_fd_close,
229 TP_PROTO(
struct task_struct *task,
230 struct rtdm_fd *fd,
int ufd,
231 unsigned long lock_count),
232 TP_ARGS(task, fd, ufd, lock_count)
235 DEFINE_EVENT(fd_request, cobalt_fd_socket,
236 TP_PROTO(
struct task_struct *task,
237 struct rtdm_fd *fd,
int ufd,
238 unsigned long protocol_family),
239 TP_ARGS(task, fd, ufd, protocol_family)
242 DEFINE_EVENT(fd_request, cobalt_fd_read,
243 TP_PROTO(
struct task_struct *task,
244 struct rtdm_fd *fd,
int ufd,
246 TP_ARGS(task, fd, ufd, len)
249 DEFINE_EVENT(fd_request, cobalt_fd_write,
250 TP_PROTO(
struct task_struct *task,
251 struct rtdm_fd *fd,
int ufd,
253 TP_ARGS(task, fd, ufd, len)
256 DEFINE_EVENT(fd_request, cobalt_fd_ioctl,
257 TP_PROTO(
struct task_struct *task,
258 struct rtdm_fd *fd,
int ufd,
259 unsigned long request),
260 TP_ARGS(task, fd, ufd, request)
263 DEFINE_EVENT(fd_request, cobalt_fd_sendmsg,
264 TP_PROTO(
struct task_struct *task,
265 struct rtdm_fd *fd,
int ufd,
266 unsigned long flags),
267 TP_ARGS(task, fd, ufd, flags)
270 DEFINE_EVENT(fd_request, cobalt_fd_recvmsg,
271 TP_PROTO(
struct task_struct *task,
272 struct rtdm_fd *fd,
int ufd,
273 unsigned long flags),
274 TP_ARGS(task, fd, ufd, flags)
277 #define cobalt_print_protbits(__prot) \
278 __print_flags(__prot, "|", \
279 {PROT_EXEC, "exec"}, \
280 {PROT_READ, "read"}, \
281 {PROT_WRITE, "write"})
283 #define cobalt_print_mapbits(__flags) \
284 __print_flags(__flags, "|", \
285 {MAP_SHARED, "shared"}, \
286 {MAP_PRIVATE, "private"}, \
287 {MAP_ANONYMOUS, "anon"}, \
288 {MAP_FIXED, "fixed"}, \
289 {MAP_HUGETLB, "huge"}, \
290 {MAP_NONBLOCK, "nonblock"}, \
291 {MAP_NORESERVE, "noreserve"}, \
292 {MAP_POPULATE, "populate"}, \
293 {MAP_UNINITIALIZED, "uninit"})
295 TRACE_EVENT(cobalt_fd_mmap,
296 TP_PROTO(
struct task_struct *task,
297 struct rtdm_fd *fd,
int ufd,
struct _rtdm_mmap_request *rma),
298 TP_ARGS(task, fd, ufd, rma),
301 __array(
char, comm, TASK_COMM_LEN)
305 __field(
size_t, length)
306 __field(off_t, offset)
312 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
313 __entry->pid = task->pid;
314 __entry->dev = rtdm_fd_to_context(fd)->device;
316 __entry->length = rma->length;
317 __entry->offset = rma->offset;
318 __entry->prot = rma->prot;
319 __entry->flags = rma->flags;
322 TP_printk(
"device=%p fd=%d area={ len:%Zu, off:%Lu }"
323 " prot=%#x(%s) flags=%#x(%s) pid=%d comm=%s",
324 __entry->dev, __entry->ufd, __entry->length,
325 (
unsigned long long)__entry->offset,
326 __entry->prot, cobalt_print_protbits(__entry->prot),
327 __entry->flags, cobalt_print_mapbits(__entry->flags),
328 __entry->pid, __entry->comm)
331 DEFINE_EVENT(fd_request_status, cobalt_fd_ioctl_status,
332 TP_PROTO(
struct task_struct *task,
333 struct rtdm_fd *fd,
int ufd,
335 TP_ARGS(task, fd, ufd, status)
338 DEFINE_EVENT(fd_request_status, cobalt_fd_read_status,
339 TP_PROTO(
struct task_struct *task,
340 struct rtdm_fd *fd,
int ufd,
342 TP_ARGS(task, fd, ufd, status)
345 DEFINE_EVENT(fd_request_status, cobalt_fd_write_status,
346 TP_PROTO(
struct task_struct *task,
347 struct rtdm_fd *fd,
int ufd,
349 TP_ARGS(task, fd, ufd, status)
352 DEFINE_EVENT(fd_request_status, cobalt_fd_recvmsg_status,
353 TP_PROTO(
struct task_struct *task,
354 struct rtdm_fd *fd,
int ufd,
356 TP_ARGS(task, fd, ufd, status)
359 DEFINE_EVENT(fd_request_status, cobalt_fd_sendmsg_status,
360 TP_PROTO(
struct task_struct *task,
361 struct rtdm_fd *fd,
int ufd,
363 TP_ARGS(task, fd, ufd, status)
366 DEFINE_EVENT(fd_request_status, cobalt_fd_mmap_status,
367 TP_PROTO(
struct task_struct *task,
368 struct rtdm_fd *fd,
int ufd,
370 TP_ARGS(task, fd, ufd, status)
373 DEFINE_EVENT(task_op, cobalt_driver_task_join,
374 TP_PROTO(
struct xnthread *task),
378 TRACE_EVENT(cobalt_driver_event_init,
379 TP_PROTO(
struct rtdm_event *ev,
unsigned long pending),
380 TP_ARGS(ev, pending),
383 __field(
struct rtdm_event *, ev)
384 __field(
unsigned long, pending)
389 __entry->pending = pending;
392 TP_printk(
"event=%p pending=%#lx",
393 __entry->ev, __entry->pending)
396 TRACE_EVENT(cobalt_driver_event_wait,
397 TP_PROTO(
struct rtdm_event *ev,
struct xnthread *task),
401 __field(
struct xnthread *, task)
402 __string(task_name, task->name)
403 __field(
struct rtdm_event *, ev)
407 __entry->task = task;
408 __assign_str(task_name, task->name);
412 TP_printk(
"event=%p task=%p(%s)",
413 __entry->ev, __entry->task, __get_str(task_name))
416 DEFINE_EVENT(event_op, cobalt_driver_event_signal,
417 TP_PROTO(
struct rtdm_event *ev),
421 DEFINE_EVENT(event_op, cobalt_driver_event_clear,
422 TP_PROTO(
struct rtdm_event *ev),
426 DEFINE_EVENT(event_op, cobalt_driver_event_pulse,
427 TP_PROTO(
struct rtdm_event *ev),
431 DEFINE_EVENT(event_op, cobalt_driver_event_destroy,
432 TP_PROTO(
struct rtdm_event *ev),
436 TRACE_EVENT(cobalt_driver_sem_init,
437 TP_PROTO(
struct rtdm_sem *sem,
unsigned long value),
441 __field(
struct rtdm_sem *, sem)
442 __field(
unsigned long, value)
447 __entry->value = value;
450 TP_printk(
"sem=%p value=%lu",
451 __entry->sem, __entry->value)
454 TRACE_EVENT(cobalt_driver_sem_wait,
455 TP_PROTO(
struct rtdm_sem *sem,
struct xnthread *task),
459 __field(
struct xnthread *, task)
460 __string(task_name, task->name)
461 __field(
struct rtdm_sem *, sem)
465 __entry->task = task;
466 __assign_str(task_name, task->name);
470 TP_printk(
"sem=%p task=%p(%s)",
471 __entry->sem, __entry->task, __get_str(task_name))
474 DEFINE_EVENT(sem_op, cobalt_driver_sem_up,
475 TP_PROTO(
struct rtdm_sem *sem),
479 DEFINE_EVENT(sem_op, cobalt_driver_sem_destroy,
480 TP_PROTO(
struct rtdm_sem *sem),
484 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_init,
485 TP_PROTO(
struct rtdm_mutex *mutex),
489 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_release,
490 TP_PROTO(
struct rtdm_mutex *mutex),
494 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_destroy,
495 TP_PROTO(
struct rtdm_mutex *mutex),
499 TRACE_EVENT(cobalt_driver_mutex_wait,
500 TP_PROTO(
struct rtdm_mutex *mutex,
struct xnthread *task),
501 TP_ARGS(mutex, task),
504 __field(
struct xnthread *, task)
505 __string(task_name, task->name)
506 __field(
struct rtdm_mutex *, mutex)
510 __entry->task = task;
511 __assign_str(task_name, task->name);
512 __entry->mutex = mutex;
515 TP_printk(
"mutex=%p task=%p(%s)",
516 __entry->mutex, __entry->task, __get_str(task_name))
522 #include <trace/define_trace.h>
struct rtdm_profile_info profile_info
Class profile information.
Definition: driver.h:251
int device_flags
Device flags, see Device Flags for details.
Definition: driver.h:256
struct rtdm_driver * driver
Device driver.
Definition: driver.h:323
#define RTDM_NAMED_DEVICE
If set, the device is addressed via a clear-text name.
Definition: driver.h:83
Device context.
Definition: driver.h:133
RTDM device.
Definition: driver.h:321
#define RTDM_DEVICE_TYPE_MASK
Mask selecting the device type.
Definition: driver.h:90