Xenomai  3.0.3
cobalt-posix.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_posix
22 #undef TRACE_INCLUDE_FILE
23 #define TRACE_INCLUDE_FILE cobalt-posix
24 
25 #if !defined(_TRACE_COBALT_POSIX_H) || defined(TRACE_HEADER_MULTI_READ)
26 #define _TRACE_COBALT_POSIX_H
27 
28 #include <linux/tracepoint.h>
29 #include <xenomai/posix/cond.h>
30 #include <xenomai/posix/mqueue.h>
31 #include <xenomai/posix/event.h>
32 
33 #define __timespec_fields(__name) \
34  __field(__kernel_time_t, tv_sec_##__name) \
35  __field(long, tv_nsec_##__name)
36 
37 #define __assign_timespec(__to, __from) \
38  do { \
39  __entry->tv_sec_##__to = (__from)->tv_sec; \
40  __entry->tv_nsec_##__to = (__from)->tv_nsec; \
41  } while (0)
42 
43 #define __timespec_args(__name) \
44  __entry->tv_sec_##__name, __entry->tv_nsec_##__name
45 
46 DECLARE_EVENT_CLASS(syscall_entry,
47  TP_PROTO(struct xnthread *thread, unsigned int nr),
48  TP_ARGS(thread, nr),
49 
50  TP_STRUCT__entry(
51  __field(struct xnthread *, thread)
52  __string(name, thread ? thread->name : "(anon)")
53  __field(unsigned int, nr)
54  ),
55 
56  TP_fast_assign(
57  __entry->thread = thread;
58  __assign_str(name, thread ? thread->name : "(anon)");
59  __entry->nr = nr;
60  ),
61 
62  TP_printk("thread=%p(%s) syscall=%u",
63  __entry->thread, __get_str(name), __entry->nr)
64 );
65 
66 DECLARE_EVENT_CLASS(syscall_exit,
67  TP_PROTO(struct xnthread *thread, long result),
68  TP_ARGS(thread, result),
69 
70  TP_STRUCT__entry(
71  __field(struct xnthread *, thread)
72  __field(long, result)
73  ),
74 
75  TP_fast_assign(
76  __entry->thread = thread;
77  __entry->result = result;
78  ),
79 
80  TP_printk("thread=%p result=%ld",
81  __entry->thread, __entry->result)
82 );
83 
84 #define cobalt_print_sched_policy(__policy) \
85  __print_symbolic(__policy, \
86  {SCHED_NORMAL, "normal"}, \
87  {SCHED_FIFO, "fifo"}, \
88  {SCHED_RR, "rr"}, \
89  {SCHED_TP, "tp"}, \
90  {SCHED_QUOTA, "quota"}, \
91  {SCHED_SPORADIC, "sporadic"}, \
92  {SCHED_COBALT, "cobalt"}, \
93  {SCHED_WEAK, "weak"})
94 
95 #define cobalt_print_sched_params(__policy, __p_ex) \
96 ({ \
97  const unsigned char *__ret = trace_seq_buffer_ptr(p); \
98  switch (__policy) { \
99  case SCHED_QUOTA: \
100  trace_seq_printf(p, "priority=%d, group=%d", \
101  (__p_ex)->sched_priority, \
102  (__p_ex)->sched_quota_group); \
103  break; \
104  case SCHED_TP: \
105  trace_seq_printf(p, "priority=%d, partition=%d", \
106  (__p_ex)->sched_priority, \
107  (__p_ex)->sched_tp_partition); \
108  break; \
109  case SCHED_NORMAL: \
110  break; \
111  case SCHED_SPORADIC: \
112  trace_seq_printf(p, "priority=%d, low_priority=%d, " \
113  "budget=(%ld.%09ld), period=(%ld.%09ld), "\
114  "maxrepl=%d", \
115  (__p_ex)->sched_priority, \
116  (__p_ex)->sched_ss_low_priority, \
117  (__p_ex)->sched_ss_init_budget.tv_sec, \
118  (__p_ex)->sched_ss_init_budget.tv_nsec, \
119  (__p_ex)->sched_ss_repl_period.tv_sec, \
120  (__p_ex)->sched_ss_repl_period.tv_nsec, \
121  (__p_ex)->sched_ss_max_repl); \
122  break; \
123  case SCHED_RR: \
124  case SCHED_FIFO: \
125  case SCHED_COBALT: \
126  case SCHED_WEAK: \
127  default: \
128  trace_seq_printf(p, "priority=%d", \
129  (__p_ex)->sched_priority); \
130  break; \
131  } \
132  trace_seq_putc(p, '\0'); \
133  __ret; \
134 })
135 
136 DECLARE_EVENT_CLASS(cobalt_posix_schedparam,
137  TP_PROTO(unsigned long pth, int policy,
138  const struct sched_param_ex *param_ex),
139  TP_ARGS(pth, policy, param_ex),
140 
141  TP_STRUCT__entry(
142  __field(unsigned long, pth)
143  __field(int, policy)
144  __dynamic_array(char, param_ex, sizeof(struct sched_param_ex))
145  ),
146 
147  TP_fast_assign(
148  __entry->pth = pth;
149  __entry->policy = policy;
150  memcpy(__get_dynamic_array(param_ex), param_ex, sizeof(*param_ex));
151  ),
152 
153  TP_printk("pth=%p policy=%d(%s) param={ %s }",
154  (void *)__entry->pth, __entry->policy,
155  cobalt_print_sched_policy(__entry->policy),
156  cobalt_print_sched_params(__entry->policy,
157  (struct sched_param_ex *)
158  __get_dynamic_array(param_ex))
159  )
160 );
161 
162 DECLARE_EVENT_CLASS(cobalt_posix_scheduler,
163  TP_PROTO(pid_t pid, int policy,
164  const struct sched_param_ex *param_ex),
165  TP_ARGS(pid, policy, param_ex),
166 
167  TP_STRUCT__entry(
168  __field(pid_t, pid)
169  __field(int, policy)
170  __dynamic_array(char, param_ex, sizeof(struct sched_param_ex))
171  ),
172 
173  TP_fast_assign(
174  __entry->pid = pid;
175  __entry->policy = policy;
176  memcpy(__get_dynamic_array(param_ex), param_ex, sizeof(*param_ex));
177  ),
178 
179  TP_printk("pid=%d policy=%d(%s) param={ %s }",
180  __entry->pid, __entry->policy,
181  cobalt_print_sched_policy(__entry->policy),
182  cobalt_print_sched_params(__entry->policy,
183  (struct sched_param_ex *)
184  __get_dynamic_array(param_ex))
185  )
186 );
187 
188 DECLARE_EVENT_CLASS(cobalt_void,
189  TP_PROTO(int dummy),
190  TP_ARGS(dummy),
191  TP_STRUCT__entry(
192  __array(char, dummy, 0)
193  ),
194  TP_fast_assign(
195  (void)dummy;
196  ),
197  TP_printk("%s", "")
198 );
199 
200 DEFINE_EVENT(syscall_entry, cobalt_head_sysentry,
201  TP_PROTO(struct xnthread *thread, unsigned int nr),
202  TP_ARGS(thread, nr)
203 );
204 
205 DEFINE_EVENT(syscall_exit, cobalt_head_sysexit,
206  TP_PROTO(struct xnthread *thread, long result),
207  TP_ARGS(thread, result)
208 );
209 
210 DEFINE_EVENT(syscall_entry, cobalt_root_sysentry,
211  TP_PROTO(struct xnthread *thread, unsigned int nr),
212  TP_ARGS(thread, nr)
213 );
214 
215 DEFINE_EVENT(syscall_exit, cobalt_root_sysexit,
216  TP_PROTO(struct xnthread *thread, long result),
217  TP_ARGS(thread, result)
218 );
219 
220 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_create,
221  TP_PROTO(unsigned long pth, int policy,
222  const struct sched_param_ex *param_ex),
223  TP_ARGS(pth, policy, param_ex)
224 );
225 
226 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_setschedparam,
227  TP_PROTO(unsigned long pth, int policy,
228  const struct sched_param_ex *param_ex),
229  TP_ARGS(pth, policy, param_ex)
230 );
231 
232 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_getschedparam,
233  TP_PROTO(unsigned long pth, int policy,
234  const struct sched_param_ex *param_ex),
235  TP_ARGS(pth, policy, param_ex)
236 );
237 
238 #define cobalt_print_thread_mode(__mode) \
239  __print_flags(__mode, "|", \
240  {PTHREAD_WARNSW, "warnsw"}, \
241  {PTHREAD_LOCK_SCHED, "lock"}, \
242  {PTHREAD_DISABLE_LOCKBREAK, "nolockbreak"})
243 
244 TRACE_EVENT(cobalt_pthread_setmode,
245  TP_PROTO(int clrmask, int setmask),
246  TP_ARGS(clrmask, setmask),
247  TP_STRUCT__entry(
248  __field(int, clrmask)
249  __field(int, setmask)
250  ),
251  TP_fast_assign(
252  __entry->clrmask = clrmask;
253  __entry->setmask = setmask;
254  ),
255  TP_printk("clrmask=%#x(%s) setmask=%#x(%s)",
256  __entry->clrmask, cobalt_print_thread_mode(__entry->clrmask),
257  __entry->setmask, cobalt_print_thread_mode(__entry->setmask))
258 );
259 
260 TRACE_EVENT(cobalt_pthread_setname,
261  TP_PROTO(unsigned long pth, const char *name),
262  TP_ARGS(pth, name),
263  TP_STRUCT__entry(
264  __field(unsigned long, pth)
265  __string(name, name)
266  ),
267  TP_fast_assign(
268  __entry->pth = pth;
269  __assign_str(name, name);
270  ),
271  TP_printk("pth=%p name=%s", (void *)__entry->pth, __get_str(name))
272 );
273 
274 DECLARE_EVENT_CLASS(cobalt_posix_pid,
275  TP_PROTO(pid_t pid),
276  TP_ARGS(pid),
277  TP_STRUCT__entry(
278  __field(pid_t, pid)
279  ),
280  TP_fast_assign(
281  __entry->pid = pid;
282  ),
283  TP_printk("pid=%d", __entry->pid)
284 );
285 
286 DEFINE_EVENT(cobalt_posix_pid, cobalt_pthread_stat,
287  TP_PROTO(pid_t pid),
288  TP_ARGS(pid)
289 );
290 
291 TRACE_EVENT(cobalt_pthread_kill,
292  TP_PROTO(unsigned long pth, int sig),
293  TP_ARGS(pth, sig),
294  TP_STRUCT__entry(
295  __field(unsigned long, pth)
296  __field(int, sig)
297  ),
298  TP_fast_assign(
299  __entry->pth = pth;
300  __entry->sig = sig;
301  ),
302  TP_printk("pth=%p sig=%d", (void *)__entry->pth, __entry->sig)
303 );
304 
305 TRACE_EVENT(cobalt_pthread_join,
306  TP_PROTO(unsigned long pth),
307  TP_ARGS(pth),
308  TP_STRUCT__entry(
309  __field(unsigned long, pth)
310  ),
311  TP_fast_assign(
312  __entry->pth = pth;
313  ),
314  TP_printk("pth=%p", (void *)__entry->pth)
315 );
316 
317 TRACE_EVENT(cobalt_pthread_pid,
318  TP_PROTO(unsigned long pth),
319  TP_ARGS(pth),
320  TP_STRUCT__entry(
321  __field(unsigned long, pth)
322  ),
323  TP_fast_assign(
324  __entry->pth = pth;
325  ),
326  TP_printk("pth=%p", (void *)__entry->pth)
327 );
328 
329 TRACE_EVENT(cobalt_pthread_extend,
330  TP_PROTO(unsigned long pth, const char *name),
331  TP_ARGS(pth, name),
332  TP_STRUCT__entry(
333  __field(unsigned long, pth)
334  __string(name, name)
335  ),
336  TP_fast_assign(
337  __entry->pth = pth;
338  __assign_str(name, name);
339  ),
340  TP_printk("pth=%p +personality=%s", (void *)__entry->pth, __get_str(name))
341 );
342 
343 TRACE_EVENT(cobalt_pthread_restrict,
344  TP_PROTO(unsigned long pth, const char *name),
345  TP_ARGS(pth, name),
346  TP_STRUCT__entry(
347  __field(unsigned long, pth)
348  __string(name, name)
349  ),
350  TP_fast_assign(
351  __entry->pth = pth;
352  __assign_str(name, name);
353  ),
354  TP_printk("pth=%p -personality=%s", (void *)__entry->pth, __get_str(name))
355 );
356 
357 DEFINE_EVENT(cobalt_void, cobalt_pthread_yield,
358  TP_PROTO(int dummy),
359  TP_ARGS(dummy)
360 );
361 
362 TRACE_EVENT(cobalt_sched_setconfig,
363  TP_PROTO(int cpu, int policy, size_t len),
364  TP_ARGS(cpu, policy, len),
365  TP_STRUCT__entry(
366  __field(int, cpu)
367  __field(int, policy)
368  __field(size_t, len)
369  ),
370  TP_fast_assign(
371  __entry->cpu = cpu;
372  __entry->policy = policy;
373  __entry->len = len;
374  ),
375  TP_printk("cpu=%d policy=%d(%s) len=%Zu",
376  __entry->cpu, __entry->policy,
377  cobalt_print_sched_policy(__entry->policy),
378  __entry->len)
379 );
380 
381 TRACE_EVENT(cobalt_sched_get_config,
382  TP_PROTO(int cpu, int policy, size_t rlen),
383  TP_ARGS(cpu, policy, rlen),
384  TP_STRUCT__entry(
385  __field(int, cpu)
386  __field(int, policy)
387  __field(ssize_t, rlen)
388  ),
389  TP_fast_assign(
390  __entry->cpu = cpu;
391  __entry->policy = policy;
392  __entry->rlen = rlen;
393  ),
394  TP_printk("cpu=%d policy=%d(%s) rlen=%Zd",
395  __entry->cpu, __entry->policy,
396  cobalt_print_sched_policy(__entry->policy),
397  __entry->rlen)
398 );
399 
400 DEFINE_EVENT(cobalt_posix_scheduler, cobalt_sched_setscheduler,
401  TP_PROTO(pid_t pid, int policy,
402  const struct sched_param_ex *param_ex),
403  TP_ARGS(pid, policy, param_ex)
404 );
405 
406 DEFINE_EVENT(cobalt_posix_pid, cobalt_sched_getscheduler,
407  TP_PROTO(pid_t pid),
408  TP_ARGS(pid)
409 );
410 
411 DECLARE_EVENT_CLASS(cobalt_posix_prio_bound,
412  TP_PROTO(int policy, int prio),
413  TP_ARGS(policy, prio),
414  TP_STRUCT__entry(
415  __field(int, policy)
416  __field(int, prio)
417  ),
418  TP_fast_assign(
419  __entry->policy = policy;
420  __entry->prio = prio;
421  ),
422  TP_printk("policy=%d(%s) prio=%d",
423  __entry->policy,
424  cobalt_print_sched_policy(__entry->policy),
425  __entry->prio)
426 );
427 
428 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_min_prio,
429  TP_PROTO(int policy, int prio),
430  TP_ARGS(policy, prio)
431 );
432 
433 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_max_prio,
434  TP_PROTO(int policy, int prio),
435  TP_ARGS(policy, prio)
436 );
437 
438 DECLARE_EVENT_CLASS(cobalt_posix_sem,
439  TP_PROTO(xnhandle_t handle),
440  TP_ARGS(handle),
441  TP_STRUCT__entry(
442  __field(xnhandle_t, handle)
443  ),
444  TP_fast_assign(
445  __entry->handle = handle;
446  ),
447  TP_printk("sem=%#x", __entry->handle)
448 );
449 
450 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_wait,
451  TP_PROTO(xnhandle_t handle),
452  TP_ARGS(handle)
453 );
454 
455 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_trywait,
456  TP_PROTO(xnhandle_t handle),
457  TP_ARGS(handle)
458 );
459 
460 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_timedwait,
461  TP_PROTO(xnhandle_t handle),
462  TP_ARGS(handle)
463 );
464 
465 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_post,
466  TP_PROTO(xnhandle_t handle),
467  TP_ARGS(handle)
468 );
469 
470 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_destroy,
471  TP_PROTO(xnhandle_t handle),
472  TP_ARGS(handle)
473 );
474 
475 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_broadcast,
476  TP_PROTO(xnhandle_t handle),
477  TP_ARGS(handle)
478 );
479 
480 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_inquire,
481  TP_PROTO(xnhandle_t handle),
482  TP_ARGS(handle)
483 );
484 
485 TRACE_EVENT(cobalt_psem_getvalue,
486  TP_PROTO(xnhandle_t handle, int value),
487  TP_ARGS(handle, value),
488  TP_STRUCT__entry(
489  __field(xnhandle_t, handle)
490  __field(int, value)
491  ),
492  TP_fast_assign(
493  __entry->handle = handle;
494  __entry->value = value;
495  ),
496  TP_printk("sem=%#x value=%d", __entry->handle, __entry->value)
497 );
498 
499 #define cobalt_print_sem_flags(__flags) \
500  __print_flags(__flags, "|", \
501  {SEM_FIFO, "fifo"}, \
502  {SEM_PULSE, "pulse"}, \
503  {SEM_PSHARED, "pshared"}, \
504  {SEM_REPORT, "report"}, \
505  {SEM_WARNDEL, "warndel"}, \
506  {SEM_RAWCLOCK, "rawclock"}, \
507  {SEM_NOBUSYDEL, "nobusydel"})
508 
509 TRACE_EVENT(cobalt_psem_init,
510  TP_PROTO(const char *name, xnhandle_t handle,
511  int flags, unsigned int value),
512  TP_ARGS(name, handle, flags, value),
513  TP_STRUCT__entry(
514  __string(name, name)
515  __field(xnhandle_t, handle)
516  __field(int, flags)
517  __field(unsigned int, value)
518  ),
519  TP_fast_assign(
520  __assign_str(name, name);
521  __entry->handle = handle;
522  __entry->flags = flags;
523  __entry->value = value;
524  ),
525  TP_printk("sem=%#x(%s) flags=%#x(%s) value=%u",
526  __entry->handle,
527  __get_str(name),
528  __entry->flags,
529  cobalt_print_sem_flags(__entry->flags),
530  __entry->value)
531 );
532 
533 TRACE_EVENT(cobalt_psem_init_failed,
534  TP_PROTO(const char *name, int flags, unsigned int value, int status),
535  TP_ARGS(name, flags, value, status),
536  TP_STRUCT__entry(
537  __string(name, name)
538  __field(int, flags)
539  __field(unsigned int, value)
540  __field(int, status)
541  ),
542  TP_fast_assign(
543  __assign_str(name, name);
544  __entry->flags = flags;
545  __entry->value = value;
546  __entry->status = status;
547  ),
548  TP_printk("name=%s flags=%#x(%s) value=%u error=%d",
549  __get_str(name),
550  __entry->flags,
551  cobalt_print_sem_flags(__entry->flags),
552  __entry->value, __entry->status)
553 );
554 
555 #define cobalt_print_oflags(__flags) \
556  __print_flags(__flags, "|", \
557  {O_RDONLY, "rdonly"}, \
558  {O_WRONLY, "wronly"}, \
559  {O_RDWR, "rdwr"}, \
560  {O_CREAT, "creat"}, \
561  {O_EXCL, "excl"}, \
562  {O_DIRECT, "direct"}, \
563  {O_NONBLOCK, "nonblock"}, \
564  {O_TRUNC, "trunc"})
565 
566 TRACE_EVENT(cobalt_psem_open,
567  TP_PROTO(const char *name, xnhandle_t handle,
568  int oflags, mode_t mode, unsigned int value),
569  TP_ARGS(name, handle, oflags, mode, value),
570  TP_STRUCT__entry(
571  __string(name, name)
572  __field(xnhandle_t, handle)
573  __field(int, oflags)
574  __field(mode_t, mode)
575  __field(unsigned int, value)
576  ),
577  TP_fast_assign(
578  __assign_str(name, name);
579  __entry->handle = handle;
580  __entry->oflags = oflags;
581  if (oflags & O_CREAT) {
582  __entry->mode = mode;
583  __entry->value = value;
584  } else {
585  __entry->mode = 0;
586  __entry->value = 0;
587  }
588  ),
589  TP_printk("named_sem=%#x=(%s) oflags=%#x(%s) mode=%o value=%u",
590  __entry->handle, __get_str(name),
591  __entry->oflags, cobalt_print_oflags(__entry->oflags),
592  __entry->mode, __entry->value)
593 );
594 
595 TRACE_EVENT(cobalt_psem_open_failed,
596  TP_PROTO(const char *name, int oflags, mode_t mode,
597  unsigned int value, int status),
598  TP_ARGS(name, oflags, mode, value, status),
599  TP_STRUCT__entry(
600  __string(name, name)
601  __field(int, oflags)
602  __field(mode_t, mode)
603  __field(unsigned int, value)
604  __field(int, status)
605  ),
606  TP_fast_assign(
607  __assign_str(name, name);
608  __entry->oflags = oflags;
609  __entry->status = status;
610  if (oflags & O_CREAT) {
611  __entry->mode = mode;
612  __entry->value = value;
613  } else {
614  __entry->mode = 0;
615  __entry->value = 0;
616  }
617  ),
618  TP_printk("named_sem=%s oflags=%#x(%s) mode=%o value=%u error=%d",
619  __get_str(name),
620  __entry->oflags, cobalt_print_oflags(__entry->oflags),
621  __entry->mode, __entry->value, __entry->status)
622 );
623 
624 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_close,
625  TP_PROTO(xnhandle_t handle),
626  TP_ARGS(handle)
627 );
628 
629 TRACE_EVENT(cobalt_psem_unlink,
630  TP_PROTO(const char *name),
631  TP_ARGS(name),
632  TP_STRUCT__entry(
633  __string(name, name)
634  ),
635  TP_fast_assign(
636  __assign_str(name, name);
637  ),
638  TP_printk("name=%s", __get_str(name))
639 );
640 
641 DECLARE_EVENT_CLASS(cobalt_clock_timespec,
642  TP_PROTO(clockid_t clk_id, const struct timespec *val),
643  TP_ARGS(clk_id, val),
644 
645  TP_STRUCT__entry(
646  __field(clockid_t, clk_id)
647  __timespec_fields(val)
648  ),
649 
650  TP_fast_assign(
651  __entry->clk_id = clk_id;
652  __assign_timespec(val, val);
653  ),
654 
655  TP_printk("clock_id=%d timeval=(%ld.%09ld)",
656  __entry->clk_id,
657  __timespec_args(val)
658  )
659 );
660 
661 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_getres,
662  TP_PROTO(clockid_t clk_id, const struct timespec *res),
663  TP_ARGS(clk_id, res)
664 );
665 
666 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_gettime,
667  TP_PROTO(clockid_t clk_id, const struct timespec *time),
668  TP_ARGS(clk_id, time)
669 );
670 
671 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_settime,
672  TP_PROTO(clockid_t clk_id, const struct timespec *time),
673  TP_ARGS(clk_id, time)
674 );
675 
676 #define cobalt_print_timer_flags(__flags) \
677  __print_flags(__flags, "|", \
678  {TIMER_ABSTIME, "TIMER_ABSTIME"})
679 
680 TRACE_EVENT(cobalt_clock_nanosleep,
681  TP_PROTO(clockid_t clk_id, int flags, const struct timespec *time),
682  TP_ARGS(clk_id, flags, time),
683 
684  TP_STRUCT__entry(
685  __field(clockid_t, clk_id)
686  __field(int, flags)
687  __timespec_fields(time)
688  ),
689 
690  TP_fast_assign(
691  __entry->clk_id = clk_id;
692  __entry->flags = flags;
693  __assign_timespec(time, time);
694  ),
695 
696  TP_printk("clock_id=%d flags=%#x(%s) rqt=(%ld.%09ld)",
697  __entry->clk_id,
698  __entry->flags, cobalt_print_timer_flags(__entry->flags),
699  __timespec_args(time)
700  )
701 );
702 
703 DECLARE_EVENT_CLASS(cobalt_clock_ident,
704  TP_PROTO(const char *name, clockid_t clk_id),
705  TP_ARGS(name, clk_id),
706  TP_STRUCT__entry(
707  __string(name, name)
708  __field(clockid_t, clk_id)
709  ),
710  TP_fast_assign(
711  __assign_str(name, name);
712  __entry->clk_id = clk_id;
713  ),
714  TP_printk("name=%s, id=%#x", __get_str(name), __entry->clk_id)
715 );
716 
717 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_register,
718  TP_PROTO(const char *name, clockid_t clk_id),
719  TP_ARGS(name, clk_id)
720 );
721 
722 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_deregister,
723  TP_PROTO(const char *name, clockid_t clk_id),
724  TP_ARGS(name, clk_id)
725 );
726 
727 #define cobalt_print_clock(__clk_id) \
728  __print_symbolic(__clk_id, \
729  {CLOCK_MONOTONIC, "CLOCK_MONOTONIC"}, \
730  {CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW"}, \
731  {CLOCK_REALTIME, "CLOCK_REALTIME"})
732 
733 TRACE_EVENT(cobalt_cond_init,
734  TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
735  const struct cobalt_condattr *attr),
736  TP_ARGS(u_cnd, attr),
737  TP_STRUCT__entry(
738  __field(const struct cobalt_cond_shadow __user *, u_cnd)
739  __field(clockid_t, clk_id)
740  __field(int, pshared)
741  ),
742  TP_fast_assign(
743  __entry->u_cnd = u_cnd;
744  __entry->clk_id = attr->clock;
745  __entry->pshared = attr->pshared;
746  ),
747  TP_printk("cond=%p attr={ .clock=%s, .pshared=%d }",
748  __entry->u_cnd,
749  cobalt_print_clock(__entry->clk_id),
750  __entry->pshared)
751 );
752 
753 TRACE_EVENT(cobalt_cond_destroy,
754  TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd),
755  TP_ARGS(u_cnd),
756  TP_STRUCT__entry(
757  __field(const struct cobalt_cond_shadow __user *, u_cnd)
758  ),
759  TP_fast_assign(
760  __entry->u_cnd = u_cnd;
761  ),
762  TP_printk("cond=%p", __entry->u_cnd)
763 );
764 
765 TRACE_EVENT(cobalt_cond_timedwait,
766  TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
767  const struct cobalt_mutex_shadow __user *u_mx,
768  const struct timespec *timeout),
769  TP_ARGS(u_cnd, u_mx, timeout),
770  TP_STRUCT__entry(
771  __field(const struct cobalt_cond_shadow __user *, u_cnd)
772  __field(const struct cobalt_mutex_shadow __user *, u_mx)
773  __timespec_fields(timeout)
774  ),
775  TP_fast_assign(
776  __entry->u_cnd = u_cnd;
777  __entry->u_mx = u_mx;
778  __assign_timespec(timeout, timeout);
779  ),
780  TP_printk("cond=%p, mutex=%p, timeout=(%ld.%09ld)",
781  __entry->u_cnd, __entry->u_mx, __timespec_args(timeout))
782 );
783 
784 TRACE_EVENT(cobalt_cond_wait,
785  TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
786  const struct cobalt_mutex_shadow __user *u_mx),
787  TP_ARGS(u_cnd, u_mx),
788  TP_STRUCT__entry(
789  __field(const struct cobalt_cond_shadow __user *, u_cnd)
790  __field(const struct cobalt_mutex_shadow __user *, u_mx)
791  ),
792  TP_fast_assign(
793  __entry->u_cnd = u_cnd;
794  __entry->u_mx = u_mx;
795  ),
796  TP_printk("cond=%p, mutex=%p",
797  __entry->u_cnd, __entry->u_mx)
798 );
799 
800 TRACE_EVENT(cobalt_mq_open,
801  TP_PROTO(const char *name, int oflags, mode_t mode),
802  TP_ARGS(name, oflags, mode),
803 
804  TP_STRUCT__entry(
805  __string(name, name)
806  __field(int, oflags)
807  __field(mode_t, mode)
808  ),
809 
810  TP_fast_assign(
811  __assign_str(name, name);
812  __entry->oflags = oflags;
813  __entry->mode = (oflags & O_CREAT) ? mode : 0;
814  ),
815 
816  TP_printk("name=%s oflags=%#x(%s) mode=%o",
817  __get_str(name),
818  __entry->oflags, cobalt_print_oflags(__entry->oflags),
819  __entry->mode)
820 );
821 
822 TRACE_EVENT(cobalt_mq_notify,
823  TP_PROTO(mqd_t mqd, const struct sigevent *sev),
824  TP_ARGS(mqd, sev),
825 
826  TP_STRUCT__entry(
827  __field(mqd_t, mqd)
828  __field(int, signo)
829  ),
830 
831  TP_fast_assign(
832  __entry->mqd = mqd;
833  __entry->signo = sev && sev->sigev_notify != SIGEV_NONE ?
834  sev->sigev_signo : 0;
835  ),
836 
837  TP_printk("mqd=%d signo=%d",
838  __entry->mqd, __entry->signo)
839 );
840 
841 TRACE_EVENT(cobalt_mq_close,
842  TP_PROTO(mqd_t mqd),
843  TP_ARGS(mqd),
844 
845  TP_STRUCT__entry(
846  __field(mqd_t, mqd)
847  ),
848 
849  TP_fast_assign(
850  __entry->mqd = mqd;
851  ),
852 
853  TP_printk("mqd=%d", __entry->mqd)
854 );
855 
856 TRACE_EVENT(cobalt_mq_unlink,
857  TP_PROTO(const char *name),
858  TP_ARGS(name),
859 
860  TP_STRUCT__entry(
861  __string(name, name)
862  ),
863 
864  TP_fast_assign(
865  __assign_str(name, name);
866  ),
867 
868  TP_printk("name=%s", __get_str(name))
869 );
870 
871 TRACE_EVENT(cobalt_mq_send,
872  TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len,
873  unsigned int prio),
874  TP_ARGS(mqd, u_buf, len, prio),
875  TP_STRUCT__entry(
876  __field(mqd_t, mqd)
877  __field(const void __user *, u_buf)
878  __field(size_t, len)
879  __field(unsigned int, prio)
880  ),
881  TP_fast_assign(
882  __entry->mqd = mqd;
883  __entry->u_buf = u_buf;
884  __entry->len = len;
885  __entry->prio = prio;
886  ),
887  TP_printk("mqd=%d buf=%p len=%Zu prio=%u",
888  __entry->mqd, __entry->u_buf, __entry->len,
889  __entry->prio)
890 );
891 
892 TRACE_EVENT(cobalt_mq_timedreceive,
893  TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len,
894  const struct timespec *timeout),
895  TP_ARGS(mqd, u_buf, len, timeout),
896  TP_STRUCT__entry(
897  __field(mqd_t, mqd)
898  __field(const void __user *, u_buf)
899  __field(size_t, len)
900  __timespec_fields(timeout)
901  ),
902  TP_fast_assign(
903  __entry->mqd = mqd;
904  __entry->u_buf = u_buf;
905  __entry->len = len;
906  __assign_timespec(timeout, timeout);
907  ),
908  TP_printk("mqd=%d buf=%p len=%Zu timeout=(%ld.%09ld)",
909  __entry->mqd, __entry->u_buf, __entry->len,
910  __timespec_args(timeout))
911 );
912 
913 TRACE_EVENT(cobalt_mq_receive,
914  TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len),
915  TP_ARGS(mqd, u_buf, len),
916  TP_STRUCT__entry(
917  __field(mqd_t, mqd)
918  __field(const void __user *, u_buf)
919  __field(size_t, len)
920  ),
921  TP_fast_assign(
922  __entry->mqd = mqd;
923  __entry->u_buf = u_buf;
924  __entry->len = len;
925  ),
926  TP_printk("mqd=%d buf=%p len=%Zu",
927  __entry->mqd, __entry->u_buf, __entry->len)
928 );
929 
930 DECLARE_EVENT_CLASS(cobalt_posix_mqattr,
931  TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
932  TP_ARGS(mqd, attr),
933  TP_STRUCT__entry(
934  __field(mqd_t, mqd)
935  __field(long, flags)
936  __field(long, curmsgs)
937  __field(long, msgsize)
938  __field(long, maxmsg)
939  ),
940  TP_fast_assign(
941  __entry->mqd = mqd;
942  __entry->flags = attr->mq_flags;
943  __entry->curmsgs = attr->mq_curmsgs;
944  __entry->msgsize = attr->mq_msgsize;
945  __entry->maxmsg = attr->mq_maxmsg;
946  ),
947  TP_printk("mqd=%d flags=%#lx(%s) curmsgs=%ld msgsize=%ld maxmsg=%ld",
948  __entry->mqd,
949  __entry->flags, cobalt_print_oflags(__entry->flags),
950  __entry->curmsgs,
951  __entry->msgsize,
952  __entry->maxmsg
953  )
954 );
955 
956 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_getattr,
957  TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
958  TP_ARGS(mqd, attr)
959 );
960 
961 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_setattr,
962  TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
963  TP_ARGS(mqd, attr)
964 );
965 
966 #define cobalt_print_evflags(__flags) \
967  __print_flags(__flags, "|", \
968  {COBALT_EVENT_SHARED, "shared"}, \
969  {COBALT_EVENT_PRIO, "prio"})
970 
971 TRACE_EVENT(cobalt_event_init,
972  TP_PROTO(const struct cobalt_event_shadow __user *u_event,
973  unsigned long value, int flags),
974  TP_ARGS(u_event, value, flags),
975  TP_STRUCT__entry(
976  __field(const struct cobalt_event_shadow __user *, u_event)
977  __field(unsigned long, value)
978  __field(int, flags)
979  ),
980  TP_fast_assign(
981  __entry->u_event = u_event;
982  __entry->value = value;
983  __entry->flags = flags;
984  ),
985  TP_printk("event=%p value=%lu flags=%#x(%s)",
986  __entry->u_event, __entry->value,
987  __entry->flags, cobalt_print_evflags(__entry->flags))
988 );
989 
990 #define cobalt_print_evmode(__mode) \
991  __print_symbolic(__mode, \
992  {COBALT_EVENT_ANY, "any"}, \
993  {COBALT_EVENT_ALL, "all"})
994 
995 TRACE_EVENT(cobalt_event_timedwait,
996  TP_PROTO(const struct cobalt_event_shadow __user *u_event,
997  unsigned long bits, int mode,
998  const struct timespec *timeout),
999  TP_ARGS(u_event, bits, mode, timeout),
1000  TP_STRUCT__entry(
1001  __field(const struct cobalt_event_shadow __user *, u_event)
1002  __field(unsigned long, bits)
1003  __field(int, mode)
1004  __timespec_fields(timeout)
1005  ),
1006  TP_fast_assign(
1007  __entry->u_event = u_event;
1008  __entry->bits = bits;
1009  __entry->mode = mode;
1010  __assign_timespec(timeout, timeout);
1011  ),
1012  TP_printk("event=%p bits=%#lx mode=%#x(%s) timeout=(%ld.%09ld)",
1013  __entry->u_event, __entry->bits, __entry->mode,
1014  cobalt_print_evmode(__entry->mode),
1015  __timespec_args(timeout))
1016 );
1017 
1018 TRACE_EVENT(cobalt_event_wait,
1019  TP_PROTO(const struct cobalt_event_shadow __user *u_event,
1020  unsigned long bits, int mode),
1021  TP_ARGS(u_event, bits, mode),
1022  TP_STRUCT__entry(
1023  __field(const struct cobalt_event_shadow __user *, u_event)
1024  __field(unsigned long, bits)
1025  __field(int, mode)
1026  ),
1027  TP_fast_assign(
1028  __entry->u_event = u_event;
1029  __entry->bits = bits;
1030  __entry->mode = mode;
1031  ),
1032  TP_printk("event=%p bits=%#lx mode=%#x(%s)",
1033  __entry->u_event, __entry->bits, __entry->mode,
1034  cobalt_print_evmode(__entry->mode))
1035 );
1036 
1037 DECLARE_EVENT_CLASS(cobalt_event_ident,
1038  TP_PROTO(const struct cobalt_event_shadow __user *u_event),
1039  TP_ARGS(u_event),
1040  TP_STRUCT__entry(
1041  __field(const struct cobalt_event_shadow __user *, u_event)
1042  ),
1043  TP_fast_assign(
1044  __entry->u_event = u_event;
1045  ),
1046  TP_printk("event=%p", __entry->u_event)
1047 );
1048 
1049 DEFINE_EVENT(cobalt_event_ident, cobalt_event_destroy,
1050  TP_PROTO(const struct cobalt_event_shadow __user *u_event),
1051  TP_ARGS(u_event)
1052 );
1053 
1054 DEFINE_EVENT(cobalt_event_ident, cobalt_event_sync,
1055  TP_PROTO(const struct cobalt_event_shadow __user *u_event),
1056  TP_ARGS(u_event)
1057 );
1058 
1059 DEFINE_EVENT(cobalt_event_ident, cobalt_event_inquire,
1060  TP_PROTO(const struct cobalt_event_shadow __user *u_event),
1061  TP_ARGS(u_event)
1062 );
1063 
1064 #endif /* _TRACE_COBALT_POSIX_H */
1065 
1066 /* This part must be outside protection */
1067 #include <trace/define_trace.h>