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