21 #define TRACE_SYSTEM cobalt_posix
23 #if !defined(_TRACE_COBALT_POSIX_H) || defined(TRACE_HEADER_MULTI_READ)
24 #define _TRACE_COBALT_POSIX_H
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>
32 #define __timespec_fields(__name) \
33 __field(__kernel_time_t, tv_sec_##__name) \
34 __field(long, tv_nsec_##__name)
36 #define __assign_timespec(__to, __from) \
38 __entry->tv_sec_##__to = (__from)->tv_sec; \
39 __entry->tv_nsec_##__to = (__from)->tv_nsec; \
42 #define __timespec_args(__name) \
43 __entry->tv_sec_##__name, __entry->tv_nsec_##__name
46 #define __sc_x32(__name) , { sc_cobalt_##__name + __COBALT_X32_BASE, "x32-" #__name }
48 #define __sc_x32(__name)
51 #ifdef CONFIG_IA32_EMULATION
52 #define __sc_compat(__name) , { sc_cobalt_##__name + __COBALT_IA32_BASE, "compat-" #__name }
54 #define __sc_compat(__name)
57 #define __cobalt_symbolic_syscall(__name) \
58 { sc_cobalt_##__name, #__name } \
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))
166 DECLARE_EVENT_CLASS(syscall_entry,
167 TP_PROTO(
unsigned int nr),
171 __field(
unsigned int, nr)
178 TP_printk(
"syscall=%s", __cobalt_syscall_name(__entry->nr))
181 DECLARE_EVENT_CLASS(syscall_exit,
182 TP_PROTO(
long result),
186 __field(
long, result)
190 __entry->result = result;
193 TP_printk(
"result=%ld", __entry->result)
196 #define cobalt_print_sched_policy(__policy) \
197 __print_symbolic(__policy, \
198 {SCHED_NORMAL, "normal"}, \
199 {SCHED_FIFO, "fifo"}, \
202 {SCHED_QUOTA, "quota"}, \
203 {SCHED_SPORADIC, "sporadic"}, \
204 {SCHED_COBALT, "cobalt"}, \
205 {SCHED_WEAK, "weak"})
207 const char *cobalt_trace_parse_sched_params(
struct trace_seq *,
int,
208 struct sched_param_ex *);
210 #define __parse_sched_params(policy, params) \
211 cobalt_trace_parse_sched_params(p, policy, \
212 (struct sched_param_ex *)(params))
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),
220 __field(
unsigned long, pth)
222 __dynamic_array(
char, param_ex,
sizeof(
struct sched_param_ex))
227 __entry->policy = policy;
228 memcpy(__get_dynamic_array(param_ex), param_ex,
sizeof(*param_ex));
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))
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),
247 __dynamic_array(
char, param_ex,
sizeof(
struct sched_param_ex))
252 __entry->policy = policy;
253 memcpy(__get_dynamic_array(param_ex), param_ex,
sizeof(*param_ex));
256 TP_printk(
"pid=%d policy=%s param={ %s }",
258 cobalt_print_sched_policy(__entry->policy),
259 __parse_sched_params(__entry->policy,
260 __get_dynamic_array(param_ex))
264 DECLARE_EVENT_CLASS(cobalt_void,
276 DEFINE_EVENT(syscall_entry, cobalt_head_sysentry,
277 TP_PROTO(
unsigned int nr),
281 DEFINE_EVENT(syscall_exit, cobalt_head_sysexit,
282 TP_PROTO(
long result),
286 DEFINE_EVENT(syscall_entry, cobalt_root_sysentry,
287 TP_PROTO(
unsigned int nr),
291 DEFINE_EVENT(syscall_exit, cobalt_root_sysexit,
292 TP_PROTO(
long result),
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)
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)
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)
314 TRACE_EVENT(cobalt_pthread_setschedprio,
315 TP_PROTO(
unsigned long pth,
int prio),
318 __field(
unsigned long, pth)
323 __entry->prio = prio;
325 TP_printk(
"pth=%p prio=%d", (
void *)__entry->pth, __entry->prio)
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"})
334 TRACE_EVENT(cobalt_pthread_setmode,
335 TP_PROTO(
int clrmask,
int setmask),
336 TP_ARGS(clrmask, setmask),
338 __field(
int, clrmask)
339 __field(
int, setmask)
342 __entry->clrmask = clrmask;
343 __entry->setmask = setmask;
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))
350 TRACE_EVENT(cobalt_pthread_setname,
351 TP_PROTO(
unsigned long pth,
const char *name),
354 __field(
unsigned long, pth)
359 __assign_str(name, name);
361 TP_printk(
"pth=%p name=%s", (
void *)__entry->pth, __get_str(name))
364 DECLARE_EVENT_CLASS(cobalt_posix_pid,
373 TP_printk(
"pid=%d", __entry->pid)
376 DEFINE_EVENT(cobalt_posix_pid, cobalt_pthread_stat,
381 TRACE_EVENT(cobalt_pthread_kill,
382 TP_PROTO(
unsigned long pth,
int sig),
385 __field(
unsigned long, pth)
392 TP_printk(
"pth=%p sig=%d", (
void *)__entry->pth, __entry->sig)
395 TRACE_EVENT(cobalt_pthread_join,
396 TP_PROTO(
unsigned long pth),
399 __field(
unsigned long, pth)
404 TP_printk(
"pth=%p", (
void *)__entry->pth)
407 TRACE_EVENT(cobalt_pthread_pid,
408 TP_PROTO(
unsigned long pth),
411 __field(
unsigned long, pth)
416 TP_printk(
"pth=%p", (
void *)__entry->pth)
419 TRACE_EVENT(cobalt_pthread_extend,
420 TP_PROTO(
unsigned long pth,
const char *name),
423 __field(
unsigned long, pth)
428 __assign_str(name, name);
430 TP_printk(
"pth=%p +personality=%s", (
void *)__entry->pth, __get_str(name))
433 TRACE_EVENT(cobalt_pthread_restrict,
434 TP_PROTO(
unsigned long pth,
const char *name),
437 __field(
unsigned long, pth)
442 __assign_str(name, name);
444 TP_printk(
"pth=%p -personality=%s", (
void *)__entry->pth, __get_str(name))
447 DEFINE_EVENT(cobalt_void, cobalt_pthread_yield,
452 TRACE_EVENT(cobalt_sched_setconfig,
453 TP_PROTO(
int cpu,
int policy,
size_t len),
454 TP_ARGS(cpu, policy, len),
462 __entry->policy = policy;
465 TP_printk(
"cpu=%d policy=%d(%s) len=%zu",
466 __entry->cpu, __entry->policy,
467 cobalt_print_sched_policy(__entry->policy),
471 TRACE_EVENT(cobalt_sched_get_config,
472 TP_PROTO(
int cpu,
int policy,
size_t rlen),
473 TP_ARGS(cpu, policy, rlen),
477 __field(ssize_t, rlen)
481 __entry->policy = policy;
482 __entry->rlen = rlen;
484 TP_printk(
"cpu=%d policy=%d(%s) rlen=%Zd",
485 __entry->cpu, __entry->policy,
486 cobalt_print_sched_policy(__entry->policy),
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)
496 DEFINE_EVENT(cobalt_posix_pid, cobalt_sched_getscheduler,
501 DECLARE_EVENT_CLASS(cobalt_posix_prio_bound,
502 TP_PROTO(
int policy,
int prio),
503 TP_ARGS(policy, prio),
509 __entry->policy = policy;
510 __entry->prio = prio;
512 TP_printk(
"policy=%d(%s) prio=%d",
514 cobalt_print_sched_policy(__entry->policy),
518 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_min_prio,
519 TP_PROTO(
int policy,
int prio),
520 TP_ARGS(policy, prio)
523 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_max_prio,
524 TP_PROTO(
int policy,
int prio),
525 TP_ARGS(policy, prio)
528 DECLARE_EVENT_CLASS(cobalt_posix_sem,
529 TP_PROTO(xnhandle_t handle),
532 __field(xnhandle_t, handle)
535 __entry->handle = handle;
537 TP_printk(
"sem=%#x", __entry->handle)
540 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_wait,
541 TP_PROTO(xnhandle_t handle),
545 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_trywait,
546 TP_PROTO(xnhandle_t handle),
550 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_timedwait,
551 TP_PROTO(xnhandle_t handle),
555 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_post,
556 TP_PROTO(xnhandle_t handle),
560 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_destroy,
561 TP_PROTO(xnhandle_t handle),
565 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_broadcast,
566 TP_PROTO(xnhandle_t handle),
570 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_inquire,
571 TP_PROTO(xnhandle_t handle),
575 TRACE_EVENT(cobalt_psem_getvalue,
576 TP_PROTO(xnhandle_t handle,
int value),
577 TP_ARGS(handle, value),
579 __field(xnhandle_t, handle)
583 __entry->handle = handle;
584 __entry->value = value;
586 TP_printk(
"sem=%#x value=%d", __entry->handle, __entry->value)
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"})
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),
605 __field(xnhandle_t, handle)
607 __field(
unsigned int, value)
610 __assign_str(name, name);
611 __entry->handle = handle;
612 __entry->flags = flags;
613 __entry->value = value;
615 TP_printk(
"sem=%#x(%s) flags=%#x(%s) value=%u",
619 cobalt_print_sem_flags(__entry->flags),
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),
629 __field(
unsigned int, value)
633 __assign_str(name, name);
634 __entry->flags = flags;
635 __entry->value = value;
636 __entry->status = status;
638 TP_printk(
"name=%s flags=%#x(%s) value=%u error=%d",
641 cobalt_print_sem_flags(__entry->flags),
642 __entry->value, __entry->status)
645 #define cobalt_print_oflags(__flags) \
646 __print_flags(__flags, "|", \
647 {O_RDONLY, "rdonly"}, \
648 {O_WRONLY, "wronly"}, \
650 {O_CREAT, "creat"}, \
652 {O_DIRECT, "direct"}, \
653 {O_NONBLOCK, "nonblock"}, \
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),
662 __field(xnhandle_t, handle)
664 __field(mode_t, mode)
665 __field(
unsigned int, value)
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;
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)
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),
692 __field(mode_t, mode)
693 __field(
unsigned int, value)
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;
708 TP_printk(
"named_sem=%s oflags=%#x(%s) mode=%o value=%u error=%d",
710 __entry->oflags, cobalt_print_oflags(__entry->oflags),
711 __entry->mode, __entry->value, __entry->status)
714 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_close,
715 TP_PROTO(xnhandle_t handle),
719 TRACE_EVENT(cobalt_psem_unlink,
720 TP_PROTO(
const char *name),
726 __assign_str(name, name);
728 TP_printk(
"name=%s", __get_str(name))
731 DECLARE_EVENT_CLASS(cobalt_clock_timespec,
732 TP_PROTO(clockid_t clk_id,
const struct timespec *val),
733 TP_ARGS(clk_id, val),
736 __field(clockid_t, clk_id)
737 __timespec_fields(val)
741 __entry->clk_id = clk_id;
742 __assign_timespec(val, val);
745 TP_printk(
"clock_id=%d timeval=(%ld.%09ld)",
751 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_getres,
752 TP_PROTO(clockid_t clk_id,
const struct timespec *res),
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)
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)
766 TRACE_EVENT(cobalt_clock_adjtime,
767 TP_PROTO(clockid_t clk_id,
struct timex *tx),
771 __field(clockid_t, clk_id)
772 __field(
struct timex *, tx)
776 __entry->clk_id = clk_id;
780 TP_printk(
"clock_id=%d timex=%p",
786 #define cobalt_print_timer_flags(__flags) \
787 __print_flags(__flags, "|", \
788 {TIMER_ABSTIME, "TIMER_ABSTIME"})
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),
795 __field(clockid_t, clk_id)
797 __timespec_fields(time)
801 __entry->clk_id = clk_id;
802 __entry->flags = flags;
803 __assign_timespec(time, time);
806 TP_printk(
"clock_id=%d flags=%#x(%s) rqt=(%ld.%09ld)",
808 __entry->flags, cobalt_print_timer_flags(__entry->flags),
809 __timespec_args(time)
813 DECLARE_EVENT_CLASS(cobalt_clock_ident,
814 TP_PROTO(
const char *name, clockid_t clk_id),
815 TP_ARGS(name, clk_id),
818 __field(clockid_t, clk_id)
821 __assign_str(name, name);
822 __entry->clk_id = clk_id;
824 TP_printk(
"name=%s, id=%#x", __get_str(name), __entry->clk_id)
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)
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)
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"})
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),
848 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
849 __field(clockid_t, clk_id)
850 __field(
int, pshared)
853 __entry->u_cnd = u_cnd;
854 __entry->clk_id = attr->clock;
855 __entry->pshared = attr->pshared;
857 TP_printk(
"cond=%p attr={ .clock=%s, .pshared=%d }",
859 cobalt_print_clock(__entry->clk_id),
863 TRACE_EVENT(cobalt_cond_destroy,
864 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd),
867 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
870 __entry->u_cnd = u_cnd;
872 TP_printk(
"cond=%p", __entry->u_cnd)
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),
881 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
882 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
883 __timespec_fields(timeout)
886 __entry->u_cnd = u_cnd;
887 __entry->u_mx = u_mx;
888 __assign_timespec(timeout, timeout);
890 TP_printk(
"cond=%p, mutex=%p, timeout=(%ld.%09ld)",
891 __entry->u_cnd, __entry->u_mx, __timespec_args(timeout))
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),
899 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
900 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
903 __entry->u_cnd = u_cnd;
904 __entry->u_mx = u_mx;
906 TP_printk(
"cond=%p, mutex=%p",
907 __entry->u_cnd, __entry->u_mx)
910 TRACE_EVENT(cobalt_mq_open,
911 TP_PROTO(
const char *name,
int oflags, mode_t mode),
912 TP_ARGS(name, oflags, mode),
917 __field(mode_t, mode)
921 __assign_str(name, name);
922 __entry->oflags = oflags;
923 __entry->mode = (oflags & O_CREAT) ? mode : 0;
926 TP_printk(
"name=%s oflags=%#x(%s) mode=%o",
928 __entry->oflags, cobalt_print_oflags(__entry->oflags),
932 TRACE_EVENT(cobalt_mq_notify,
933 TP_PROTO(mqd_t mqd,
const struct sigevent *sev),
943 __entry->signo = sev && sev->sigev_notify != SIGEV_NONE ?
944 sev->sigev_signo : 0;
947 TP_printk(
"mqd=%d signo=%d",
948 __entry->mqd, __entry->signo)
951 TRACE_EVENT(cobalt_mq_close,
963 TP_printk(
"mqd=%d", __entry->mqd)
966 TRACE_EVENT(cobalt_mq_unlink,
967 TP_PROTO(
const char *name),
975 __assign_str(name, name);
978 TP_printk(
"name=%s", __get_str(name))
981 TRACE_EVENT(cobalt_mq_send,
982 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
984 TP_ARGS(mqd, u_buf, len, prio),
987 __field(
const void __user *, u_buf)
989 __field(
unsigned int, prio)
993 __entry->u_buf = u_buf;
995 __entry->prio = prio;
997 TP_printk(
"mqd=%d buf=%p len=%zu prio=%u",
998 __entry->mqd, __entry->u_buf, __entry->len,
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),
1008 __field(
const void __user *, u_buf)
1009 __field(
size_t, len)
1010 __timespec_fields(timeout)
1014 __entry->u_buf = u_buf;
1016 __assign_timespec(timeout, timeout);
1018 TP_printk(
"mqd=%d buf=%p len=%zu timeout=(%ld.%09ld)",
1019 __entry->mqd, __entry->u_buf, __entry->len,
1020 __timespec_args(timeout))
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),
1028 __field(
const void __user *, u_buf)
1029 __field(
size_t, len)
1033 __entry->u_buf = u_buf;
1036 TP_printk(
"mqd=%d buf=%p len=%zu",
1037 __entry->mqd, __entry->u_buf, __entry->len)
1040 DECLARE_EVENT_CLASS(cobalt_posix_mqattr,
1041 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
1045 __field(
long, flags)
1046 __field(
long, curmsgs)
1047 __field(
long, msgsize)
1048 __field(
long, maxmsg)
1052 __entry->flags = attr->mq_flags;
1053 __entry->curmsgs = attr->mq_curmsgs;
1054 __entry->msgsize = attr->mq_msgsize;
1055 __entry->maxmsg = attr->mq_maxmsg;
1057 TP_printk(
"mqd=%d flags=%#lx(%s) curmsgs=%ld msgsize=%ld maxmsg=%ld",
1059 __entry->flags, cobalt_print_oflags(__entry->flags),
1066 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_getattr,
1067 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
1071 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_setattr,
1072 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
1076 #define cobalt_print_evflags(__flags) \
1077 __print_flags(__flags, "|", \
1078 {COBALT_EVENT_SHARED, "shared"}, \
1079 {COBALT_EVENT_PRIO, "prio"})
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),
1086 __field(
const struct cobalt_event_shadow __user *, u_event)
1087 __field(
unsigned long, value)
1091 __entry->u_event = u_event;
1092 __entry->value = value;
1093 __entry->flags = flags;
1095 TP_printk(
"event=%p value=%lu flags=%#x(%s)",
1096 __entry->u_event, __entry->value,
1097 __entry->flags, cobalt_print_evflags(__entry->flags))
1100 #define cobalt_print_evmode(__mode) \
1101 __print_symbolic(__mode, \
1102 {COBALT_EVENT_ANY, "any"}, \
1103 {COBALT_EVENT_ALL, "all"})
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),
1111 __field(
const struct cobalt_event_shadow __user *, u_event)
1112 __field(
unsigned long, bits)
1114 __timespec_fields(timeout)
1117 __entry->u_event = u_event;
1118 __entry->bits = bits;
1119 __entry->mode = mode;
1120 __assign_timespec(timeout, timeout);
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))
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),
1133 __field(
const struct cobalt_event_shadow __user *, u_event)
1134 __field(
unsigned long, bits)
1138 __entry->u_event = u_event;
1139 __entry->bits = bits;
1140 __entry->mode = mode;
1142 TP_printk(
"event=%p bits=%#lx mode=%#x(%s)",
1143 __entry->u_event, __entry->bits, __entry->mode,
1144 cobalt_print_evmode(__entry->mode))
1147 DECLARE_EVENT_CLASS(cobalt_event_ident,
1148 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1151 __field(
const struct cobalt_event_shadow __user *, u_event)
1154 __entry->u_event = u_event;
1156 TP_printk(
"event=%p", __entry->u_event)
1159 DEFINE_EVENT(cobalt_event_ident, cobalt_event_destroy,
1160 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1164 DEFINE_EVENT(cobalt_event_ident, cobalt_event_sync,
1165 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1169 DEFINE_EVENT(cobalt_event_ident, cobalt_event_inquire,
1170 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1177 #undef TRACE_INCLUDE_PATH
1178 #undef TRACE_INCLUDE_FILE
1179 #define TRACE_INCLUDE_FILE cobalt-posix
1180 #include <trace/define_trace.h>