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