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