Xenomai  3.0.2
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 #undef TRACE_INCLUDE_FILE
23 #define TRACE_INCLUDE_FILE cobalt-rtdm
24 
25 #if !defined(_TRACE_COBALT_RTDM_H) || defined(TRACE_HEADER_MULTI_READ)
26 #define _TRACE_COBALT_RTDM_H
27 
28 #include <linux/tracepoint.h>
29 #include <linux/mman.h>
30 #include <linux/sched.h>
31 
32 struct rtdm_fd;
33 struct rtdm_event;
34 struct rtdm_sem;
35 struct rtdm_mutex;
36 struct xnthread;
37 struct rtdm_device;
38 struct rtdm_dev_context;
39 struct _rtdm_mmap_request;
40 
41 DECLARE_EVENT_CLASS(fd_event,
42  TP_PROTO(struct rtdm_fd *fd, int ufd),
43  TP_ARGS(fd, ufd),
44 
45  TP_STRUCT__entry(
46  __field(struct rtdm_device *, dev)
47  __field(int, ufd)
48  ),
49 
50  TP_fast_assign(
51  __entry->dev = rtdm_fd_to_context(fd)->device;
52  __entry->ufd = ufd;
53  ),
54 
55  TP_printk("device=%p fd=%d",
56  __entry->dev, __entry->ufd)
57 );
58 
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),
63 
64  TP_STRUCT__entry(
65  __array(char, comm, TASK_COMM_LEN)
66  __field(pid_t, pid)
67  __field(struct rtdm_device *, dev)
68  __field(int, ufd)
69  __field(unsigned long, arg)
70  ),
71 
72  TP_fast_assign(
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;
76  __entry->ufd = ufd;
77  __entry->arg = arg;
78  ),
79 
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)
83 );
84 
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),
89 
90  TP_STRUCT__entry(
91  __array(char, comm, TASK_COMM_LEN)
92  __field(pid_t, pid)
93  __field(struct rtdm_device *, dev)
94  __field(int, ufd)
95  ),
96 
97  TP_fast_assign(
98  memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
99  __entry->pid = task_pid_nr(task);
100  __entry->dev =
101  !IS_ERR(fd) ? rtdm_fd_to_context(fd)->device : NULL;
102  __entry->ufd = ufd;
103  ),
104 
105  TP_printk("device=%p fd=%d pid=%d comm=%s",
106  __entry->dev, __entry->ufd, __entry->pid, __entry->comm)
107 );
108 
109 DECLARE_EVENT_CLASS(task_op,
110  TP_PROTO(struct xnthread *task),
111  TP_ARGS(task),
112 
113  TP_STRUCT__entry(
114  __field(struct xnthread *, task)
115  __string(task_name, task->name)
116  ),
117 
118  TP_fast_assign(
119  __entry->task = task;
120  __assign_str(task_name, task->name);
121  ),
122 
123  TP_printk("task %p(%s)", __entry->task, __get_str(task_name))
124 );
125 
126 DECLARE_EVENT_CLASS(event_op,
127  TP_PROTO(struct rtdm_event *ev),
128  TP_ARGS(ev),
129 
130  TP_STRUCT__entry(
131  __field(struct rtdm_event *, ev)
132  ),
133 
134  TP_fast_assign(
135  __entry->ev = ev;
136  ),
137 
138  TP_printk("event=%p", __entry->ev)
139 );
140 
141 DECLARE_EVENT_CLASS(sem_op,
142  TP_PROTO(struct rtdm_sem *sem),
143  TP_ARGS(sem),
144 
145  TP_STRUCT__entry(
146  __field(struct rtdm_sem *, sem)
147  ),
148 
149  TP_fast_assign(
150  __entry->sem = sem;
151  ),
152 
153  TP_printk("sem=%p", __entry->sem)
154 );
155 
156 DECLARE_EVENT_CLASS(mutex_op,
157  TP_PROTO(struct rtdm_mutex *mutex),
158  TP_ARGS(mutex),
159 
160  TP_STRUCT__entry(
161  __field(struct rtdm_mutex *, mutex)
162  ),
163 
164  TP_fast_assign(
165  __entry->mutex = mutex;
166  ),
167 
168  TP_printk("mutex=%p", __entry->mutex)
169 );
170 
171 TRACE_EVENT(cobalt_device_register,
172  TP_PROTO(struct rtdm_device *dev),
173  TP_ARGS(dev),
174 
175  TP_STRUCT__entry(
176  __field(struct rtdm_device *, dev)
177  __string(device_name, dev->name)
178  __field(int, flags)
179  __field(int, class_id)
180  __field(int, subclass_id)
181  __field(int, profile_version)
182  ),
183 
184  TP_fast_assign(
185  __entry->dev = dev;
186  __assign_str(device_name, dev->name);
187  __entry->flags = dev->driver->device_flags;
188  __entry->class_id = dev->driver->profile_info.class_id;
189  __entry->subclass_id = dev->driver->profile_info.subclass_id;
190  __entry->profile_version = dev->driver->profile_info.version;
191  ),
192 
193  TP_printk("%s device %s=%p flags=0x%x, class=%d.%d profile=%d",
194  (__entry->flags & RTDM_DEVICE_TYPE_MASK)
195  == RTDM_NAMED_DEVICE ? "named" : "protocol",
196  __get_str(device_name), __entry->dev,
197  __entry->flags, __entry->class_id, __entry->subclass_id,
198  __entry->profile_version)
199 );
200 
201 TRACE_EVENT(cobalt_device_unregister,
202  TP_PROTO(struct rtdm_device *dev),
203  TP_ARGS(dev),
204 
205  TP_STRUCT__entry(
206  __field(struct rtdm_device *, dev)
207  __string(device_name, dev->name)
208  ),
209 
210  TP_fast_assign(
211  __entry->dev = dev;
212  __assign_str(device_name, dev->name);
213  ),
214 
215  TP_printk("device %s=%p",
216  __get_str(device_name), __entry->dev)
217 );
218 
219 DEFINE_EVENT(fd_event, cobalt_fd_created,
220  TP_PROTO(struct rtdm_fd *fd, int ufd),
221  TP_ARGS(fd, ufd)
222 );
223 
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)
229 );
230 
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)
236 );
237 
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)
243 );
244 
245 DEFINE_EVENT(fd_request, cobalt_fd_read,
246  TP_PROTO(struct task_struct *task,
247  struct rtdm_fd *fd, int ufd,
248  unsigned long len),
249  TP_ARGS(task, fd, ufd, len)
250 );
251 
252 DEFINE_EVENT(fd_request, cobalt_fd_write,
253  TP_PROTO(struct task_struct *task,
254  struct rtdm_fd *fd, int ufd,
255  unsigned long len),
256  TP_ARGS(task, fd, ufd, len)
257 );
258 
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)
264 );
265 
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)
271 );
272 
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)
278 );
279 
280 #define cobalt_print_protbits(__prot) \
281  __print_flags(__prot, "|", \
282  {PROT_EXEC, "exec"}, \
283  {PROT_READ, "read"}, \
284  {PROT_WRITE, "write"})
285 
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"})
297 
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),
302 
303  TP_STRUCT__entry(
304  __array(char, comm, TASK_COMM_LEN)
305  __field(pid_t, pid)
306  __field(struct rtdm_device *, dev)
307  __field(int, ufd)
308  __field(size_t, length)
309  __field(off_t, offset)
310  __field(int, prot)
311  __field(int, flags)
312  ),
313 
314  TP_fast_assign(
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;
318  __entry->ufd = ufd;
319  __entry->length = rma->length;
320  __entry->offset = rma->offset;
321  __entry->prot = rma->prot;
322  __entry->flags = rma->flags;
323  ),
324 
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)
332 );
333 
334 DEFINE_EVENT(fd_request_status, cobalt_fd_ioctl_status,
335  TP_PROTO(struct task_struct *task,
336  struct rtdm_fd *fd, int ufd,
337  int status),
338  TP_ARGS(task, fd, ufd, status)
339 );
340 
341 DEFINE_EVENT(fd_request_status, cobalt_fd_read_status,
342  TP_PROTO(struct task_struct *task,
343  struct rtdm_fd *fd, int ufd,
344  int status),
345  TP_ARGS(task, fd, ufd, status)
346 );
347 
348 DEFINE_EVENT(fd_request_status, cobalt_fd_write_status,
349  TP_PROTO(struct task_struct *task,
350  struct rtdm_fd *fd, int ufd,
351  int status),
352  TP_ARGS(task, fd, ufd, status)
353 );
354 
355 DEFINE_EVENT(fd_request_status, cobalt_fd_recvmsg_status,
356  TP_PROTO(struct task_struct *task,
357  struct rtdm_fd *fd, int ufd,
358  int status),
359  TP_ARGS(task, fd, ufd, status)
360 );
361 
362 DEFINE_EVENT(fd_request_status, cobalt_fd_sendmsg_status,
363  TP_PROTO(struct task_struct *task,
364  struct rtdm_fd *fd, int ufd,
365  int status),
366  TP_ARGS(task, fd, ufd, status)
367 );
368 
369 DEFINE_EVENT(fd_request_status, cobalt_fd_mmap_status,
370  TP_PROTO(struct task_struct *task,
371  struct rtdm_fd *fd, int ufd,
372  int status),
373  TP_ARGS(task, fd, ufd, status)
374 );
375 
376 DEFINE_EVENT(task_op, cobalt_driver_task_join,
377  TP_PROTO(struct xnthread *task),
378  TP_ARGS(task)
379 );
380 
381 TRACE_EVENT(cobalt_driver_event_init,
382  TP_PROTO(struct rtdm_event *ev, unsigned long pending),
383  TP_ARGS(ev, pending),
384 
385  TP_STRUCT__entry(
386  __field(struct rtdm_event *, ev)
387  __field(unsigned long, pending)
388  ),
389 
390  TP_fast_assign(
391  __entry->ev = ev;
392  __entry->pending = pending;
393  ),
394 
395  TP_printk("event=%p pending=%#lx",
396  __entry->ev, __entry->pending)
397 );
398 
399 TRACE_EVENT(cobalt_driver_event_wait,
400  TP_PROTO(struct rtdm_event *ev, struct xnthread *task),
401  TP_ARGS(ev, task),
402 
403  TP_STRUCT__entry(
404  __field(struct xnthread *, task)
405  __string(task_name, task->name)
406  __field(struct rtdm_event *, ev)
407  ),
408 
409  TP_fast_assign(
410  __entry->task = task;
411  __assign_str(task_name, task->name);
412  __entry->ev = ev;
413  ),
414 
415  TP_printk("event=%p task=%p(%s)",
416  __entry->ev, __entry->task, __get_str(task_name))
417 );
418 
419 DEFINE_EVENT(event_op, cobalt_driver_event_signal,
420  TP_PROTO(struct rtdm_event *ev),
421  TP_ARGS(ev)
422 );
423 
424 DEFINE_EVENT(event_op, cobalt_driver_event_clear,
425  TP_PROTO(struct rtdm_event *ev),
426  TP_ARGS(ev)
427 );
428 
429 DEFINE_EVENT(event_op, cobalt_driver_event_pulse,
430  TP_PROTO(struct rtdm_event *ev),
431  TP_ARGS(ev)
432 );
433 
434 DEFINE_EVENT(event_op, cobalt_driver_event_destroy,
435  TP_PROTO(struct rtdm_event *ev),
436  TP_ARGS(ev)
437 );
438 
439 TRACE_EVENT(cobalt_driver_sem_init,
440  TP_PROTO(struct rtdm_sem *sem, unsigned long value),
441  TP_ARGS(sem, value),
442 
443  TP_STRUCT__entry(
444  __field(struct rtdm_sem *, sem)
445  __field(unsigned long, value)
446  ),
447 
448  TP_fast_assign(
449  __entry->sem = sem;
450  __entry->value = value;
451  ),
452 
453  TP_printk("sem=%p value=%lu",
454  __entry->sem, __entry->value)
455 );
456 
457 TRACE_EVENT(cobalt_driver_sem_wait,
458  TP_PROTO(struct rtdm_sem *sem, struct xnthread *task),
459  TP_ARGS(sem, task),
460 
461  TP_STRUCT__entry(
462  __field(struct xnthread *, task)
463  __string(task_name, task->name)
464  __field(struct rtdm_sem *, sem)
465  ),
466 
467  TP_fast_assign(
468  __entry->task = task;
469  __assign_str(task_name, task->name);
470  __entry->sem = sem;
471  ),
472 
473  TP_printk("sem=%p task=%p(%s)",
474  __entry->sem, __entry->task, __get_str(task_name))
475 );
476 
477 DEFINE_EVENT(sem_op, cobalt_driver_sem_up,
478  TP_PROTO(struct rtdm_sem *sem),
479  TP_ARGS(sem)
480 );
481 
482 DEFINE_EVENT(sem_op, cobalt_driver_sem_destroy,
483  TP_PROTO(struct rtdm_sem *sem),
484  TP_ARGS(sem)
485 );
486 
487 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_init,
488  TP_PROTO(struct rtdm_mutex *mutex),
489  TP_ARGS(mutex)
490 );
491 
492 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_release,
493  TP_PROTO(struct rtdm_mutex *mutex),
494  TP_ARGS(mutex)
495 );
496 
497 DEFINE_EVENT(mutex_op, cobalt_driver_mutex_destroy,
498  TP_PROTO(struct rtdm_mutex *mutex),
499  TP_ARGS(mutex)
500 );
501 
502 TRACE_EVENT(cobalt_driver_mutex_wait,
503  TP_PROTO(struct rtdm_mutex *mutex, struct xnthread *task),
504  TP_ARGS(mutex, task),
505 
506  TP_STRUCT__entry(
507  __field(struct xnthread *, task)
508  __string(task_name, task->name)
509  __field(struct rtdm_mutex *, mutex)
510  ),
511 
512  TP_fast_assign(
513  __entry->task = task;
514  __assign_str(task_name, task->name);
515  __entry->mutex = mutex;
516  ),
517 
518  TP_printk("mutex=%p task=%p(%s)",
519  __entry->mutex, __entry->task, __get_str(task_name))
520 );
521 
522 #endif /* _TRACE_COBALT_RTDM_H */
523 
524 /* This part must be outside protection */
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