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