Xenomai  3.0-rc3
cobalt-rtdm.h
1 #undef TRACE_SYSTEM
2 #define TRACE_SYSTEM cobalt-rtdm
3 
4 #if !defined(_TRACE_COBALT_RTDM_H) || defined(TRACE_HEADER_MULTI_READ)
5 #define _TRACE_COBALT_RTDM_H
6 
7 #include <linux/tracepoint.h>
8 #include <linux/mman.h>
9 
10 struct rtdm_fd;
11 struct rtdm_event;
12 struct rtdm_sem;
13 struct rtdm_mutex;
14 struct xnthread;
15 struct rtdm_device;
16 struct rtdm_dev_context;
17 struct _rtdm_mmap_request;
18 
19 DECLARE_EVENT_CLASS(fd_event,
20  TP_PROTO(struct rtdm_fd *fd, int ufd),
21  TP_ARGS(fd, ufd),
22 
23  TP_STRUCT__entry(
24  __field(struct rtdm_device *, dev)
25  __field(int, ufd)
26  ),
27 
28  TP_fast_assign(
29  __entry->dev = rtdm_fd_to_context(fd)->device;
30  __entry->ufd = ufd;
31  ),
32 
33  TP_printk("device=%p fd=%d",
34  __entry->dev, __entry->ufd)
35 );
36 
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),
41 
42  TP_STRUCT__entry(
43  __array(char, comm, TASK_COMM_LEN)
44  __field(pid_t, pid)
45  __field(struct rtdm_device *, dev)
46  __field(int, ufd)
47  __field(unsigned long, arg)
48  ),
49 
50  TP_fast_assign(
51  memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
52  __entry->pid = task->pid;
53  __entry->dev = rtdm_fd_to_context(fd)->device;
54  __entry->ufd = ufd;
55  __entry->arg = arg;
56  ),
57 
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)
61 );
62 
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),
67 
68  TP_STRUCT__entry(
69  __array(char, comm, TASK_COMM_LEN)
70  __field(pid_t, pid)
71  __field(struct rtdm_device *, dev)
72  __field(int, ufd)
73  ),
74 
75  TP_fast_assign(
76  memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
77  __entry->pid = task->pid;
78  __entry->dev =
79  !IS_ERR(fd) ? rtdm_fd_to_context(fd)->device : NULL;
80  __entry->ufd = ufd;
81  ),
82 
83  TP_printk("device=%p fd=%d pid=%d comm=%s",
84  __entry->dev, __entry->ufd, __entry->pid, __entry->comm)
85 );
86 
87 DECLARE_EVENT_CLASS(task_op,
88  TP_PROTO(struct xnthread *task),
89  TP_ARGS(task),
90 
91  TP_STRUCT__entry(
92  __field(struct xnthread *, task)
93  __string(task_name, task->name)
94  ),
95 
96  TP_fast_assign(
97  __entry->task = task;
98  __assign_str(task_name, task->name);
99  ),
100 
101  TP_printk("task %p(%s)", __entry->task, __get_str(task_name))
102 );
103 
104 DECLARE_EVENT_CLASS(event_op,
105  TP_PROTO(struct rtdm_event *ev),
106  TP_ARGS(ev),
107 
108  TP_STRUCT__entry(
109  __field(struct rtdm_event *, ev)
110  ),
111 
112  TP_fast_assign(
113  __entry->ev = ev;
114  ),
115 
116  TP_printk("event=%p", __entry->ev)
117 );
118 
119 DECLARE_EVENT_CLASS(sem_op,
120  TP_PROTO(struct rtdm_sem *sem),
121  TP_ARGS(sem),
122 
123  TP_STRUCT__entry(
124  __field(struct rtdm_sem *, sem)
125  ),
126 
127  TP_fast_assign(
128  __entry->sem = sem;
129  ),
130 
131  TP_printk("sem=%p", __entry->sem)
132 );
133 
134 DECLARE_EVENT_CLASS(mutex_op,
135  TP_PROTO(struct rtdm_mutex *mutex),
136  TP_ARGS(mutex),
137 
138  TP_STRUCT__entry(
139  __field(struct rtdm_mutex *, mutex)
140  ),
141 
142  TP_fast_assign(
143  __entry->mutex = mutex;
144  ),
145 
146  TP_printk("mutex=%p", __entry->mutex)
147 );
148 
149 TRACE_EVENT(cobalt_device_register,
150  TP_PROTO(struct rtdm_device *dev),
151  TP_ARGS(dev),
152 
153  TP_STRUCT__entry(
154  __field(struct rtdm_device *, dev)
155  __string(device_name, dev->name)
156  __field(int, flags)
157  __field(int, class_id)
158  __field(int, subclass_id)
159  __field(int, profile_version)
160  ),
161 
162  TP_fast_assign(
163  __entry->dev = dev;
164  __assign_str(device_name, dev->name);
165  __entry->flags = dev->driver->device_flags;
166  __entry->class_id = dev->driver->profile_info.class_id;
167  __entry->subclass_id = dev->driver->profile_info.subclass_id;
168  __entry->profile_version = dev->driver->profile_info.version;
169  ),
170 
171  TP_printk("%s device %s=%p flags=0x%x, class=%d.%d profile=%d",
172  (__entry->flags & RTDM_DEVICE_TYPE_MASK)
173  == RTDM_NAMED_DEVICE ? "named" : "protocol",
174  __get_str(device_name), __entry->dev,
175  __entry->flags, __entry->class_id, __entry->subclass_id,
176  __entry->profile_version)
177 );
178 
179 TRACE_EVENT(cobalt_device_unregister,
180  TP_PROTO(struct rtdm_device *dev),
181  TP_ARGS(dev),
182 
183  TP_STRUCT__entry(
184  __field(struct rtdm_device *, dev)
185  __string(device_name, dev->name)
186  ),
187 
188  TP_fast_assign(
189  __entry->dev = dev;
190  __assign_str(device_name, dev->name);
191  ),
192 
193  TP_printk("device %s=%p",
194  __get_str(device_name), __entry->dev)
195 );
196 
197 DEFINE_EVENT(fd_event, cobalt_fd_created,
198  TP_PROTO(struct rtdm_fd *fd, int ufd),
199  TP_ARGS(fd, ufd)
200 );
201 
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)
207 );
208 
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)
214 );
215 
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)
221 );
222 
223 DEFINE_EVENT(fd_request, cobalt_fd_read,
224  TP_PROTO(struct task_struct *task,
225  struct rtdm_fd *fd, int ufd,
226  unsigned long len),
227  TP_ARGS(task, fd, ufd, len)
228 );
229 
230 DEFINE_EVENT(fd_request, cobalt_fd_write,
231  TP_PROTO(struct task_struct *task,
232  struct rtdm_fd *fd, int ufd,
233  unsigned long len),
234  TP_ARGS(task, fd, ufd, len)
235 );
236 
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)
242 );
243 
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)
249 );
250 
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)
256 );
257 
258 #define cobalt_print_protbits(__prot) \
259  __print_flags(__prot, "|", \
260  {PROT_EXEC, "exec"}, \
261  {PROT_READ, "read"}, \
262  {PROT_WRITE, "write"})
263 
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"})
275 
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),
280 
281  TP_STRUCT__entry(
282  __array(char, comm, TASK_COMM_LEN)
283  __field(pid_t, pid)
284  __field(struct rtdm_device *, dev)
285  __field(int, ufd)
286  __field(size_t, length)
287  __field(off_t, offset)
288  __field(int, prot)
289  __field(int, flags)
290  ),
291 
292  TP_fast_assign(
293  memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
294  __entry->pid = task->pid;
295  __entry->dev = rtdm_fd_to_context(fd)->device;
296  __entry->ufd = ufd;
297  __entry->length = rma->length;
298  __entry->offset = rma->offset;
299  __entry->prot = rma->prot;
300  __entry->flags = rma->flags;
301  ),
302 
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)
310 );
311 
312 DEFINE_EVENT(fd_request_status, cobalt_fd_ioctl_status,
313  TP_PROTO(struct task_struct *task,
314  struct rtdm_fd *fd, int ufd,
315  int status),
316  TP_ARGS(task, fd, ufd, status)
317 );
318 
319 DEFINE_EVENT(fd_request_status, cobalt_fd_read_status,
320  TP_PROTO(struct task_struct *task,
321  struct rtdm_fd *fd, int ufd,
322  int status),
323  TP_ARGS(task, fd, ufd, status)
324 );
325 
326 DEFINE_EVENT(fd_request_status, cobalt_fd_write_status,
327  TP_PROTO(struct task_struct *task,
328  struct rtdm_fd *fd, int ufd,
329  int status),
330  TP_ARGS(task, fd, ufd, status)
331 );
332 
333 DEFINE_EVENT(fd_request_status, cobalt_fd_recvmsg_status,
334  TP_PROTO(struct task_struct *task,
335  struct rtdm_fd *fd, int ufd,
336  int status),
337  TP_ARGS(task, fd, ufd, status)
338 );
339 
340 DEFINE_EVENT(fd_request_status, cobalt_fd_sendmsg_status,
341  TP_PROTO(struct task_struct *task,
342  struct rtdm_fd *fd, int ufd,
343  int status),
344  TP_ARGS(task, fd, ufd, status)
345 );
346 
347 DEFINE_EVENT(fd_request_status, cobalt_fd_mmap_status,
348  TP_PROTO(struct task_struct *task,
349  struct rtdm_fd *fd, int ufd,
350  int status),
351  TP_ARGS(task, fd, ufd, status)
352 );
353 
354 DEFINE_EVENT(task_op, cobalt_driver_task_join,
355  TP_PROTO(struct xnthread *task),
356  TP_ARGS(task)
357 );
358 
359 TRACE_EVENT(cobalt_driver_event_init,
360  TP_PROTO(struct rtdm_event *ev, unsigned long pending),
361  TP_ARGS(ev, pending),
362 
363  TP_STRUCT__entry(
364  __field(struct rtdm_event *, ev)
365  __field(unsigned long, pending)
366  ),
367 
368  TP_fast_assign(
369  __entry->ev = ev;
370  __entry->pending = pending;
371  ),
372 
373  TP_printk("event=%p pending=%#lx",
374  __entry->ev, __entry->pending)
375 );
376 
377 TRACE_EVENT(cobalt_driver_event_wait,
378  TP_PROTO(struct rtdm_event *ev, struct xnthread *task),
379  TP_ARGS(ev, task),
380 
381  TP_STRUCT__entry(
382  __field(struct xnthread *, task)
383  __string(task_name, task->name)
384  __field(struct rtdm_event *, ev)
385  ),
386 
387  TP_fast_assign(
388  __entry->task = task;
389  __assign_str(task_name, task->name);
390  __entry->ev = ev;
391  ),
392 
393  TP_printk("event=%p task=%p(%s)",
394  __entry->ev, __entry->task, __get_str(task_name))
395 );
396 
397 DEFINE_EVENT(event_op, cobalt_driver_event_signal,
398  TP_PROTO(struct rtdm_event *ev),
399  TP_ARGS(ev)
400 );
401 
402 DEFINE_EVENT(event_op, cobalt_driver_event_clear,
403  TP_PROTO(struct rtdm_event *ev),
404  TP_ARGS(ev)
405 );
406 
407 DEFINE_EVENT(event_op, cobalt_driver_event_pulse,
408  TP_PROTO(struct rtdm_event *ev),
409  TP_ARGS(ev)
410 );
411 
412 DEFINE_EVENT(event_op, cobalt_driver_event_destroy,
413  TP_PROTO(struct rtdm_event *ev),
414  TP_ARGS(ev)
415 );
416 
417 TRACE_EVENT(cobalt_driver_sem_init,
418  TP_PROTO(struct rtdm_sem *sem, unsigned long value),
419  TP_ARGS(sem, value),
420 
421  TP_STRUCT__entry(
422  __field(struct rtdm_sem *, sem)
423  __field(unsigned long, value)
424  ),
425 
426  TP_fast_assign(
427  __entry->sem = sem;
428  __entry->value = value;
429  ),
430 
431  TP_printk("sem=%p value=%lu",
432  __entry->sem, __entry->value)
433 );
434 
435 TRACE_EVENT(cobalt_driver_sem_wait,
436  TP_PROTO(struct rtdm_sem *sem, struct xnthread *task),
437  TP_ARGS(sem, task),
438 
439  TP_STRUCT__entry(
440  __field(struct xnthread *, task)
441  __string(task_name, task->name)
442  __field(struct rtdm_sem *, sem)
443  ),
444 
445  TP_fast_assign(
446  __entry->task = task;
447  __assign_str(task_name, task->name);
448  __entry->sem = sem;
449  ),
450 
451  TP_printk("sem=%p task=%p(%s)",
452  __entry->sem, __entry->task, __get_str(task_name))
453 );
454 
455 DEFINE_EVENT(sem_op, cobalt_driver_sem_up,
456  TP_PROTO(struct rtdm_sem *sem),
457  TP_ARGS(sem)
458 );
459 
460 DEFINE_EVENT(sem_op, cobalt_driver_sem_destroy,
461  TP_PROTO(struct rtdm_sem *sem),
462  TP_ARGS(sem)
463 );
464 
465 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_init,
466  TP_PROTO(struct rtdm_mutex *mutex),
467  TP_ARGS(mutex)
468 );
469 
470 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_release,
471  TP_PROTO(struct rtdm_mutex *mutex),
472  TP_ARGS(mutex)
473 );
474 
475 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_destroy,
476  TP_PROTO(struct rtdm_mutex *mutex),
477  TP_ARGS(mutex)
478 );
479 
480 TRACE_EVENT(cobalt_driver_mutex_wait,
481  TP_PROTO(struct rtdm_mutex *mutex, struct xnthread *task),
482  TP_ARGS(mutex, task),
483 
484  TP_STRUCT__entry(
485  __field(struct xnthread *, task)
486  __string(task_name, task->name)
487  __field(struct rtdm_mutex *, mutex)
488  ),
489 
490  TP_fast_assign(
491  __entry->task = task;
492  __assign_str(task_name, task->name);
493  __entry->mutex = mutex;
494  ),
495 
496  TP_printk("mutex=%p task=%p(%s)",
497  __entry->mutex, __entry->task, __get_str(task_name))
498 );
499 
500 #endif /* _TRACE_COBALT_RTDM_H */
501 
502 /* This part must be outside protection */
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