2 #define TRACE_SYSTEM cobalt-rtdm
4 #if !defined(_TRACE_COBALT_RTDM_H) || defined(TRACE_HEADER_MULTI_READ)
5 #define _TRACE_COBALT_RTDM_H
7 #include <linux/tracepoint.h>
8 #include <linux/mman.h>
17 struct _rtdm_mmap_request;
19 DECLARE_EVENT_CLASS(fd_event,
20 TP_PROTO(
struct rtdm_fd *fd,
int ufd),
29 __entry->dev = rtdm_fd_to_context(fd)->device;
33 TP_printk(
"device=%p fd=%d",
34 __entry->dev, __entry->ufd)
37 DECLARE_EVENT_CLASS(fd_request,
38 TP_PROTO(
struct task_struct *task,
39 struct rtdm_fd *fd,
int ufd,
unsigned long arg),
40 TP_ARGS(task, fd, ufd, arg),
43 __array(
char, comm, TASK_COMM_LEN)
47 __field(
unsigned long, arg)
51 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
52 __entry->pid = task->pid;
53 __entry->dev = rtdm_fd_to_context(fd)->device;
58 TP_printk(
"device=%p fd=%d arg=%#lx pid=%d comm=%s",
59 __entry->dev, __entry->ufd, __entry->arg,
60 __entry->pid, __entry->comm)
63 DECLARE_EVENT_CLASS(fd_request_status,
64 TP_PROTO(
struct task_struct *task,
65 struct rtdm_fd *fd,
int ufd,
int status),
66 TP_ARGS(task, fd, ufd, status),
69 __array(
char, comm, TASK_COMM_LEN)
76 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
77 __entry->pid = task->pid;
79 !IS_ERR(fd) ? rtdm_fd_to_context(fd)->device : NULL;
83 TP_printk(
"device=%p fd=%d pid=%d comm=%s",
84 __entry->dev, __entry->ufd, __entry->pid, __entry->comm)
87 DECLARE_EVENT_CLASS(task_op,
88 TP_PROTO(
struct xnthread *task),
92 __field(
struct xnthread *, task)
93 __string(task_name, task->name)
98 __assign_str(task_name, task->name);
101 TP_printk(
"task %p(%s)", __entry->task, __get_str(task_name))
104 DECLARE_EVENT_CLASS(event_op,
105 TP_PROTO(
struct rtdm_event *ev),
109 __field(
struct rtdm_event *, ev)
116 TP_printk(
"event=%p", __entry->ev)
119 DECLARE_EVENT_CLASS(sem_op,
120 TP_PROTO(
struct rtdm_sem *sem),
124 __field(
struct rtdm_sem *, sem)
131 TP_printk(
"sem=%p", __entry->sem)
134 DECLARE_EVENT_CLASS(mutex_op,
135 TP_PROTO(
struct rtdm_mutex *mutex),
139 __field(
struct rtdm_mutex *, mutex)
143 __entry->mutex = mutex;
146 TP_printk(
"mutex=%p", __entry->mutex)
149 TRACE_EVENT(cobalt_device_register,
155 __string(device_name, dev->name)
157 __field(
int, class_id)
158 __field(
int, subclass_id)
159 __field(
int, profile_version)
164 __assign_str(device_name, dev->name);
171 TP_printk(
"%s device %s=%p flags=0x%x, class=%d.%d profile=%d",
174 __get_str(device_name), __entry->dev,
175 __entry->flags, __entry->class_id, __entry->subclass_id,
176 __entry->profile_version)
179 TRACE_EVENT(cobalt_device_unregister,
185 __string(device_name, dev->name)
190 __assign_str(device_name, dev->name);
193 TP_printk(
"device %s=%p",
194 __get_str(device_name), __entry->dev)
197 DEFINE_EVENT(fd_event, cobalt_fd_created,
198 TP_PROTO(
struct rtdm_fd *fd,
int ufd),
202 DEFINE_EVENT(fd_request, cobalt_fd_open,
203 TP_PROTO(
struct task_struct *task,
204 struct rtdm_fd *fd,
int ufd,
205 unsigned long oflags),
206 TP_ARGS(task, fd, ufd, oflags)
209 DEFINE_EVENT(fd_request, cobalt_fd_close,
210 TP_PROTO(
struct task_struct *task,
211 struct rtdm_fd *fd,
int ufd,
212 unsigned long lock_count),
213 TP_ARGS(task, fd, ufd, lock_count)
216 DEFINE_EVENT(fd_request, cobalt_fd_socket,
217 TP_PROTO(
struct task_struct *task,
218 struct rtdm_fd *fd,
int ufd,
219 unsigned long protocol_family),
220 TP_ARGS(task, fd, ufd, protocol_family)
223 DEFINE_EVENT(fd_request, cobalt_fd_read,
224 TP_PROTO(
struct task_struct *task,
225 struct rtdm_fd *fd,
int ufd,
227 TP_ARGS(task, fd, ufd, len)
230 DEFINE_EVENT(fd_request, cobalt_fd_write,
231 TP_PROTO(
struct task_struct *task,
232 struct rtdm_fd *fd,
int ufd,
234 TP_ARGS(task, fd, ufd, len)
237 DEFINE_EVENT(fd_request, cobalt_fd_ioctl,
238 TP_PROTO(
struct task_struct *task,
239 struct rtdm_fd *fd,
int ufd,
240 unsigned long request),
241 TP_ARGS(task, fd, ufd, request)
244 DEFINE_EVENT(fd_request, cobalt_fd_sendmsg,
245 TP_PROTO(
struct task_struct *task,
246 struct rtdm_fd *fd,
int ufd,
247 unsigned long flags),
248 TP_ARGS(task, fd, ufd, flags)
251 DEFINE_EVENT(fd_request, cobalt_fd_recvmsg,
252 TP_PROTO(
struct task_struct *task,
253 struct rtdm_fd *fd,
int ufd,
254 unsigned long flags),
255 TP_ARGS(task, fd, ufd, flags)
258 #define cobalt_print_protbits(__prot) \
259 __print_flags(__prot, "|", \
260 {PROT_EXEC, "exec"}, \
261 {PROT_READ, "read"}, \
262 {PROT_WRITE, "write"})
264 #define cobalt_print_mapbits(__flags) \
265 __print_flags(__flags, "|", \
266 {MAP_SHARED, "shared"}, \
267 {MAP_PRIVATE, "private"}, \
268 {MAP_ANONYMOUS, "anon"}, \
269 {MAP_FIXED, "fixed"}, \
270 {MAP_HUGETLB, "huge"}, \
271 {MAP_NONBLOCK, "nonblock"}, \
272 {MAP_NORESERVE, "noreserve"}, \
273 {MAP_POPULATE, "populate"}, \
274 {MAP_UNINITIALIZED, "uninit"})
276 TRACE_EVENT(cobalt_fd_mmap,
277 TP_PROTO(
struct task_struct *task,
278 struct rtdm_fd *fd,
int ufd,
struct _rtdm_mmap_request *rma),
279 TP_ARGS(task, fd, ufd, rma),
282 __array(
char, comm, TASK_COMM_LEN)
286 __field(
size_t, length)
287 __field(off_t, offset)
293 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
294 __entry->pid = task->pid;
295 __entry->dev = rtdm_fd_to_context(fd)->device;
297 __entry->length = rma->length;
298 __entry->offset = rma->offset;
299 __entry->prot = rma->prot;
300 __entry->flags = rma->flags;
303 TP_printk(
"device=%p fd=%d area={ len:%Zu, off:%Lu }"
304 " prot=%#x(%s) flags=%#x(%s) pid=%d comm=%s",
305 __entry->dev, __entry->ufd, __entry->length,
306 (
unsigned long long)__entry->offset,
307 __entry->prot, cobalt_print_protbits(__entry->prot),
308 __entry->flags, cobalt_print_mapbits(__entry->flags),
309 __entry->pid, __entry->comm)
312 DEFINE_EVENT(fd_request_status, cobalt_fd_ioctl_status,
313 TP_PROTO(
struct task_struct *task,
314 struct rtdm_fd *fd,
int ufd,
316 TP_ARGS(task, fd, ufd, status)
319 DEFINE_EVENT(fd_request_status, cobalt_fd_read_status,
320 TP_PROTO(
struct task_struct *task,
321 struct rtdm_fd *fd,
int ufd,
323 TP_ARGS(task, fd, ufd, status)
326 DEFINE_EVENT(fd_request_status, cobalt_fd_write_status,
327 TP_PROTO(
struct task_struct *task,
328 struct rtdm_fd *fd,
int ufd,
330 TP_ARGS(task, fd, ufd, status)
333 DEFINE_EVENT(fd_request_status, cobalt_fd_recvmsg_status,
334 TP_PROTO(
struct task_struct *task,
335 struct rtdm_fd *fd,
int ufd,
337 TP_ARGS(task, fd, ufd, status)
340 DEFINE_EVENT(fd_request_status, cobalt_fd_sendmsg_status,
341 TP_PROTO(
struct task_struct *task,
342 struct rtdm_fd *fd,
int ufd,
344 TP_ARGS(task, fd, ufd, status)
347 DEFINE_EVENT(fd_request_status, cobalt_fd_mmap_status,
348 TP_PROTO(
struct task_struct *task,
349 struct rtdm_fd *fd,
int ufd,
351 TP_ARGS(task, fd, ufd, status)
354 DEFINE_EVENT(task_op, cobalt_driver_task_join,
355 TP_PROTO(
struct xnthread *task),
359 TRACE_EVENT(cobalt_driver_event_init,
360 TP_PROTO(
struct rtdm_event *ev,
unsigned long pending),
361 TP_ARGS(ev, pending),
364 __field(
struct rtdm_event *, ev)
365 __field(
unsigned long, pending)
370 __entry->pending = pending;
373 TP_printk(
"event=%p pending=%#lx",
374 __entry->ev, __entry->pending)
377 TRACE_EVENT(cobalt_driver_event_wait,
378 TP_PROTO(
struct rtdm_event *ev,
struct xnthread *task),
382 __field(
struct xnthread *, task)
383 __string(task_name, task->name)
384 __field(
struct rtdm_event *, ev)
388 __entry->task = task;
389 __assign_str(task_name, task->name);
393 TP_printk(
"event=%p task=%p(%s)",
394 __entry->ev, __entry->task, __get_str(task_name))
397 DEFINE_EVENT(event_op, cobalt_driver_event_signal,
398 TP_PROTO(
struct rtdm_event *ev),
402 DEFINE_EVENT(event_op, cobalt_driver_event_clear,
403 TP_PROTO(
struct rtdm_event *ev),
407 DEFINE_EVENT(event_op, cobalt_driver_event_pulse,
408 TP_PROTO(
struct rtdm_event *ev),
412 DEFINE_EVENT(event_op, cobalt_driver_event_destroy,
413 TP_PROTO(
struct rtdm_event *ev),
417 TRACE_EVENT(cobalt_driver_sem_init,
418 TP_PROTO(
struct rtdm_sem *sem,
unsigned long value),
422 __field(
struct rtdm_sem *, sem)
423 __field(
unsigned long, value)
428 __entry->value = value;
431 TP_printk(
"sem=%p value=%lu",
432 __entry->sem, __entry->value)
435 TRACE_EVENT(cobalt_driver_sem_wait,
436 TP_PROTO(
struct rtdm_sem *sem,
struct xnthread *task),
440 __field(
struct xnthread *, task)
441 __string(task_name, task->name)
442 __field(
struct rtdm_sem *, sem)
446 __entry->task = task;
447 __assign_str(task_name, task->name);
451 TP_printk(
"sem=%p task=%p(%s)",
452 __entry->sem, __entry->task, __get_str(task_name))
455 DEFINE_EVENT(sem_op, cobalt_driver_sem_up,
456 TP_PROTO(
struct rtdm_sem *sem),
460 DEFINE_EVENT(sem_op, cobalt_driver_sem_destroy,
461 TP_PROTO(
struct rtdm_sem *sem),
465 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_init,
466 TP_PROTO(
struct rtdm_mutex *mutex),
470 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_release,
471 TP_PROTO(
struct rtdm_mutex *mutex),
475 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_destroy,
476 TP_PROTO(
struct rtdm_mutex *mutex),
480 TRACE_EVENT(cobalt_driver_mutex_wait,
481 TP_PROTO(
struct rtdm_mutex *mutex,
struct xnthread *task),
482 TP_ARGS(mutex, task),
485 __field(
struct xnthread *, task)
486 __string(task_name, task->name)
487 __field(
struct rtdm_mutex *, mutex)
491 __entry->task = task;
492 __assign_str(task_name, task->name);
493 __entry->mutex = mutex;
496 TP_printk(
"mutex=%p task=%p(%s)",
497 __entry->mutex, __entry->task, __get_str(task_name))
503 #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