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