Xenomai  3.0-rc7
cobalt-rtdm.h
1 /*
2  * Copyright (C) 2014 Jan Kiszka <jan.kiszka@siemens.com>.
3  * Copyright (C) 2014 Philippe Gerum <rpm@xenomai.org>.
4  *
5  * Xenomai is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published
7  * by the Free Software Foundation; either version 2 of the License,
8  * or (at your option) any later version.
9  *
10  * Xenomai is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with Xenomai; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
18  * 02111-1307, USA.
19  */
20 #undef TRACE_SYSTEM
21 #define TRACE_SYSTEM cobalt-rtdm
22 
23 #if !defined(_TRACE_COBALT_RTDM_H) || defined(TRACE_HEADER_MULTI_READ)
24 #define _TRACE_COBALT_RTDM_H
25 
26 #include <linux/tracepoint.h>
27 #include <linux/mman.h>
28 
29 struct rtdm_fd;
30 struct rtdm_event;
31 struct rtdm_sem;
32 struct rtdm_mutex;
33 struct xnthread;
34 struct rtdm_device;
35 struct rtdm_dev_context;
36 struct _rtdm_mmap_request;
37 
38 DECLARE_EVENT_CLASS(fd_event,
39  TP_PROTO(struct rtdm_fd *fd, int ufd),
40  TP_ARGS(fd, ufd),
41 
42  TP_STRUCT__entry(
43  __field(struct rtdm_device *, dev)
44  __field(int, ufd)
45  ),
46 
47  TP_fast_assign(
48  __entry->dev = rtdm_fd_to_context(fd)->device;
49  __entry->ufd = ufd;
50  ),
51 
52  TP_printk("device=%p fd=%d",
53  __entry->dev, __entry->ufd)
54 );
55 
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),
60 
61  TP_STRUCT__entry(
62  __array(char, comm, TASK_COMM_LEN)
63  __field(pid_t, pid)
64  __field(struct rtdm_device *, dev)
65  __field(int, ufd)
66  __field(unsigned long, arg)
67  ),
68 
69  TP_fast_assign(
70  memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
71  __entry->pid = task->pid;
72  __entry->dev = rtdm_fd_to_context(fd)->device;
73  __entry->ufd = ufd;
74  __entry->arg = arg;
75  ),
76 
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)
80 );
81 
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),
86 
87  TP_STRUCT__entry(
88  __array(char, comm, TASK_COMM_LEN)
89  __field(pid_t, pid)
90  __field(struct rtdm_device *, dev)
91  __field(int, ufd)
92  ),
93 
94  TP_fast_assign(
95  memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
96  __entry->pid = task->pid;
97  __entry->dev =
98  !IS_ERR(fd) ? rtdm_fd_to_context(fd)->device : NULL;
99  __entry->ufd = ufd;
100  ),
101 
102  TP_printk("device=%p fd=%d pid=%d comm=%s",
103  __entry->dev, __entry->ufd, __entry->pid, __entry->comm)
104 );
105 
106 DECLARE_EVENT_CLASS(task_op,
107  TP_PROTO(struct xnthread *task),
108  TP_ARGS(task),
109 
110  TP_STRUCT__entry(
111  __field(struct xnthread *, task)
112  __string(task_name, task->name)
113  ),
114 
115  TP_fast_assign(
116  __entry->task = task;
117  __assign_str(task_name, task->name);
118  ),
119 
120  TP_printk("task %p(%s)", __entry->task, __get_str(task_name))
121 );
122 
123 DECLARE_EVENT_CLASS(event_op,
124  TP_PROTO(struct rtdm_event *ev),
125  TP_ARGS(ev),
126 
127  TP_STRUCT__entry(
128  __field(struct rtdm_event *, ev)
129  ),
130 
131  TP_fast_assign(
132  __entry->ev = ev;
133  ),
134 
135  TP_printk("event=%p", __entry->ev)
136 );
137 
138 DECLARE_EVENT_CLASS(sem_op,
139  TP_PROTO(struct rtdm_sem *sem),
140  TP_ARGS(sem),
141 
142  TP_STRUCT__entry(
143  __field(struct rtdm_sem *, sem)
144  ),
145 
146  TP_fast_assign(
147  __entry->sem = sem;
148  ),
149 
150  TP_printk("sem=%p", __entry->sem)
151 );
152 
153 DECLARE_EVENT_CLASS(mutex_op,
154  TP_PROTO(struct rtdm_mutex *mutex),
155  TP_ARGS(mutex),
156 
157  TP_STRUCT__entry(
158  __field(struct rtdm_mutex *, mutex)
159  ),
160 
161  TP_fast_assign(
162  __entry->mutex = mutex;
163  ),
164 
165  TP_printk("mutex=%p", __entry->mutex)
166 );
167 
168 TRACE_EVENT(cobalt_device_register,
169  TP_PROTO(struct rtdm_device *dev),
170  TP_ARGS(dev),
171 
172  TP_STRUCT__entry(
173  __field(struct rtdm_device *, dev)
174  __string(device_name, dev->name)
175  __field(int, flags)
176  __field(int, class_id)
177  __field(int, subclass_id)
178  __field(int, profile_version)
179  ),
180 
181  TP_fast_assign(
182  __entry->dev = dev;
183  __assign_str(device_name, dev->name);
184  __entry->flags = dev->driver->device_flags;
185  __entry->class_id = dev->driver->profile_info.class_id;
186  __entry->subclass_id = dev->driver->profile_info.subclass_id;
187  __entry->profile_version = dev->driver->profile_info.version;
188  ),
189 
190  TP_printk("%s device %s=%p flags=0x%x, class=%d.%d profile=%d",
191  (__entry->flags & RTDM_DEVICE_TYPE_MASK)
192  == RTDM_NAMED_DEVICE ? "named" : "protocol",
193  __get_str(device_name), __entry->dev,
194  __entry->flags, __entry->class_id, __entry->subclass_id,
195  __entry->profile_version)
196 );
197 
198 TRACE_EVENT(cobalt_device_unregister,
199  TP_PROTO(struct rtdm_device *dev),
200  TP_ARGS(dev),
201 
202  TP_STRUCT__entry(
203  __field(struct rtdm_device *, dev)
204  __string(device_name, dev->name)
205  ),
206 
207  TP_fast_assign(
208  __entry->dev = dev;
209  __assign_str(device_name, dev->name);
210  ),
211 
212  TP_printk("device %s=%p",
213  __get_str(device_name), __entry->dev)
214 );
215 
216 DEFINE_EVENT(fd_event, cobalt_fd_created,
217  TP_PROTO(struct rtdm_fd *fd, int ufd),
218  TP_ARGS(fd, ufd)
219 );
220 
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)
226 );
227 
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)
233 );
234 
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)
240 );
241 
242 DEFINE_EVENT(fd_request, cobalt_fd_read,
243  TP_PROTO(struct task_struct *task,
244  struct rtdm_fd *fd, int ufd,
245  unsigned long len),
246  TP_ARGS(task, fd, ufd, len)
247 );
248 
249 DEFINE_EVENT(fd_request, cobalt_fd_write,
250  TP_PROTO(struct task_struct *task,
251  struct rtdm_fd *fd, int ufd,
252  unsigned long len),
253  TP_ARGS(task, fd, ufd, len)
254 );
255 
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)
261 );
262 
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)
268 );
269 
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)
275 );
276 
277 #define cobalt_print_protbits(__prot) \
278  __print_flags(__prot, "|", \
279  {PROT_EXEC, "exec"}, \
280  {PROT_READ, "read"}, \
281  {PROT_WRITE, "write"})
282 
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"})
294 
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),
299 
300  TP_STRUCT__entry(
301  __array(char, comm, TASK_COMM_LEN)
302  __field(pid_t, pid)
303  __field(struct rtdm_device *, dev)
304  __field(int, ufd)
305  __field(size_t, length)
306  __field(off_t, offset)
307  __field(int, prot)
308  __field(int, flags)
309  ),
310 
311  TP_fast_assign(
312  memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
313  __entry->pid = task->pid;
314  __entry->dev = rtdm_fd_to_context(fd)->device;
315  __entry->ufd = ufd;
316  __entry->length = rma->length;
317  __entry->offset = rma->offset;
318  __entry->prot = rma->prot;
319  __entry->flags = rma->flags;
320  ),
321 
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)
329 );
330 
331 DEFINE_EVENT(fd_request_status, cobalt_fd_ioctl_status,
332  TP_PROTO(struct task_struct *task,
333  struct rtdm_fd *fd, int ufd,
334  int status),
335  TP_ARGS(task, fd, ufd, status)
336 );
337 
338 DEFINE_EVENT(fd_request_status, cobalt_fd_read_status,
339  TP_PROTO(struct task_struct *task,
340  struct rtdm_fd *fd, int ufd,
341  int status),
342  TP_ARGS(task, fd, ufd, status)
343 );
344 
345 DEFINE_EVENT(fd_request_status, cobalt_fd_write_status,
346  TP_PROTO(struct task_struct *task,
347  struct rtdm_fd *fd, int ufd,
348  int status),
349  TP_ARGS(task, fd, ufd, status)
350 );
351 
352 DEFINE_EVENT(fd_request_status, cobalt_fd_recvmsg_status,
353  TP_PROTO(struct task_struct *task,
354  struct rtdm_fd *fd, int ufd,
355  int status),
356  TP_ARGS(task, fd, ufd, status)
357 );
358 
359 DEFINE_EVENT(fd_request_status, cobalt_fd_sendmsg_status,
360  TP_PROTO(struct task_struct *task,
361  struct rtdm_fd *fd, int ufd,
362  int status),
363  TP_ARGS(task, fd, ufd, status)
364 );
365 
366 DEFINE_EVENT(fd_request_status, cobalt_fd_mmap_status,
367  TP_PROTO(struct task_struct *task,
368  struct rtdm_fd *fd, int ufd,
369  int status),
370  TP_ARGS(task, fd, ufd, status)
371 );
372 
373 DEFINE_EVENT(task_op, cobalt_driver_task_join,
374  TP_PROTO(struct xnthread *task),
375  TP_ARGS(task)
376 );
377 
378 TRACE_EVENT(cobalt_driver_event_init,
379  TP_PROTO(struct rtdm_event *ev, unsigned long pending),
380  TP_ARGS(ev, pending),
381 
382  TP_STRUCT__entry(
383  __field(struct rtdm_event *, ev)
384  __field(unsigned long, pending)
385  ),
386 
387  TP_fast_assign(
388  __entry->ev = ev;
389  __entry->pending = pending;
390  ),
391 
392  TP_printk("event=%p pending=%#lx",
393  __entry->ev, __entry->pending)
394 );
395 
396 TRACE_EVENT(cobalt_driver_event_wait,
397  TP_PROTO(struct rtdm_event *ev, struct xnthread *task),
398  TP_ARGS(ev, task),
399 
400  TP_STRUCT__entry(
401  __field(struct xnthread *, task)
402  __string(task_name, task->name)
403  __field(struct rtdm_event *, ev)
404  ),
405 
406  TP_fast_assign(
407  __entry->task = task;
408  __assign_str(task_name, task->name);
409  __entry->ev = ev;
410  ),
411 
412  TP_printk("event=%p task=%p(%s)",
413  __entry->ev, __entry->task, __get_str(task_name))
414 );
415 
416 DEFINE_EVENT(event_op, cobalt_driver_event_signal,
417  TP_PROTO(struct rtdm_event *ev),
418  TP_ARGS(ev)
419 );
420 
421 DEFINE_EVENT(event_op, cobalt_driver_event_clear,
422  TP_PROTO(struct rtdm_event *ev),
423  TP_ARGS(ev)
424 );
425 
426 DEFINE_EVENT(event_op, cobalt_driver_event_pulse,
427  TP_PROTO(struct rtdm_event *ev),
428  TP_ARGS(ev)
429 );
430 
431 DEFINE_EVENT(event_op, cobalt_driver_event_destroy,
432  TP_PROTO(struct rtdm_event *ev),
433  TP_ARGS(ev)
434 );
435 
436 TRACE_EVENT(cobalt_driver_sem_init,
437  TP_PROTO(struct rtdm_sem *sem, unsigned long value),
438  TP_ARGS(sem, value),
439 
440  TP_STRUCT__entry(
441  __field(struct rtdm_sem *, sem)
442  __field(unsigned long, value)
443  ),
444 
445  TP_fast_assign(
446  __entry->sem = sem;
447  __entry->value = value;
448  ),
449 
450  TP_printk("sem=%p value=%lu",
451  __entry->sem, __entry->value)
452 );
453 
454 TRACE_EVENT(cobalt_driver_sem_wait,
455  TP_PROTO(struct rtdm_sem *sem, struct xnthread *task),
456  TP_ARGS(sem, task),
457 
458  TP_STRUCT__entry(
459  __field(struct xnthread *, task)
460  __string(task_name, task->name)
461  __field(struct rtdm_sem *, sem)
462  ),
463 
464  TP_fast_assign(
465  __entry->task = task;
466  __assign_str(task_name, task->name);
467  __entry->sem = sem;
468  ),
469 
470  TP_printk("sem=%p task=%p(%s)",
471  __entry->sem, __entry->task, __get_str(task_name))
472 );
473 
474 DEFINE_EVENT(sem_op, cobalt_driver_sem_up,
475  TP_PROTO(struct rtdm_sem *sem),
476  TP_ARGS(sem)
477 );
478 
479 DEFINE_EVENT(sem_op, cobalt_driver_sem_destroy,
480  TP_PROTO(struct rtdm_sem *sem),
481  TP_ARGS(sem)
482 );
483 
484 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_init,
485  TP_PROTO(struct rtdm_mutex *mutex),
486  TP_ARGS(mutex)
487 );
488 
489 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_release,
490  TP_PROTO(struct rtdm_mutex *mutex),
491  TP_ARGS(mutex)
492 );
493 
494 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_destroy,
495  TP_PROTO(struct rtdm_mutex *mutex),
496  TP_ARGS(mutex)
497 );
498 
499 TRACE_EVENT(cobalt_driver_mutex_wait,
500  TP_PROTO(struct rtdm_mutex *mutex, struct xnthread *task),
501  TP_ARGS(mutex, task),
502 
503  TP_STRUCT__entry(
504  __field(struct xnthread *, task)
505  __string(task_name, task->name)
506  __field(struct rtdm_mutex *, mutex)
507  ),
508 
509  TP_fast_assign(
510  __entry->task = task;
511  __assign_str(task_name, task->name);
512  __entry->mutex = mutex;
513  ),
514 
515  TP_printk("mutex=%p task=%p(%s)",
516  __entry->mutex, __entry->task, __get_str(task_name))
517 );
518 
519 #endif /* _TRACE_COBALT_RTDM_H */
520 
521 /* This part must be outside protection */
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