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 <xenomai/posix/cond.h>
28 #include <xenomai/posix/mqueue.h>
29 #include <xenomai/posix/event.h>
31 #define __timespec_fields(__name) \
32 __field(__kernel_time_t, tv_sec_##__name) \
33 __field(long, tv_nsec_##__name)
35 #define __assign_timespec(__to, __from) \
37 __entry->tv_sec_##__to = (__from)->tv_sec; \
38 __entry->tv_nsec_##__to = (__from)->tv_nsec; \
41 #define __timespec_args(__name) \
42 __entry->tv_sec_##__name, __entry->tv_nsec_##__name
44 DECLARE_EVENT_CLASS(syscall_entry,
45 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
49 __field(
struct xnthread *, thread)
50 __string(name, thread ? thread->name :
"(anon)")
51 __field(
unsigned int, nr)
55 __entry->thread = thread;
56 __assign_str(name, thread ? thread->name :
"(anon)");
60 TP_printk(
"thread=%p(%s) syscall=%u",
61 __entry->thread, __get_str(name), __entry->nr)
64 DECLARE_EVENT_CLASS(syscall_exit,
65 TP_PROTO(
struct xnthread *thread,
long result),
66 TP_ARGS(thread, result),
69 __field(
struct xnthread *, thread)
74 __entry->thread = thread;
75 __entry->result = result;
78 TP_printk(
"thread=%p result=%ld",
79 __entry->thread, __entry->result)
82 #define cobalt_print_sched_policy(__policy) \
83 __print_symbolic(__policy, \
84 {SCHED_NORMAL, "normal"}, \
85 {SCHED_FIFO, "fifo"}, \
88 {SCHED_QUOTA, "quota"}, \
89 {SCHED_SPORADIC, "sporadic"}, \
90 {SCHED_COBALT, "cobalt"}, \
93 #define cobalt_print_sched_params(__policy, __p_ex) \
95 const char *__ret = p->buffer + p->len; \
98 trace_seq_printf(p, "priority=%d, group=%d", \
99 (__p_ex)->sched_priority, \
100 (__p_ex)->sched_quota_group); \
103 trace_seq_printf(p, "priority=%d, partition=%d", \
104 (__p_ex)->sched_priority, \
105 (__p_ex)->sched_tp_partition); \
109 case SCHED_SPORADIC: \
110 trace_seq_printf(p, "priority=%d, low_priority=%d, " \
111 "budget=(%ld.%09ld), period=(%ld.%09ld), "\
113 (__p_ex)->sched_priority, \
114 (__p_ex)->sched_ss_low_priority, \
115 (__p_ex)->sched_ss_init_budget.tv_sec, \
116 (__p_ex)->sched_ss_init_budget.tv_nsec, \
117 (__p_ex)->sched_ss_repl_period.tv_sec, \
118 (__p_ex)->sched_ss_repl_period.tv_nsec, \
119 (__p_ex)->sched_ss_max_repl); \
126 trace_seq_printf(p, "priority=%d", \
127 (__p_ex)->sched_priority); \
133 DECLARE_EVENT_CLASS(cobalt_posix_schedparam,
134 TP_PROTO(
unsigned long pth,
int policy,
135 const struct sched_param_ex *param_ex),
136 TP_ARGS(pth, policy, param_ex),
139 __field(
unsigned long, pth)
141 __dynamic_array(
char, param_ex,
sizeof(
struct sched_param_ex))
146 __entry->policy = policy;
147 memcpy(__get_dynamic_array(param_ex), param_ex,
sizeof(*param_ex));
150 TP_printk(
"pth=%p policy=%d(%s) param={ %s }",
151 (
void *)__entry->pth, __entry->policy,
152 cobalt_print_sched_policy(__entry->policy),
153 cobalt_print_sched_params(__entry->policy,
154 (
struct sched_param_ex *)
155 __get_dynamic_array(param_ex))
159 DECLARE_EVENT_CLASS(cobalt_void,
163 __array(
char, dummy, 0)
171 DEFINE_EVENT(syscall_entry, cobalt_head_sysentry,
172 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
176 DEFINE_EVENT(syscall_exit, cobalt_head_sysexit,
177 TP_PROTO(
struct xnthread *thread,
long result),
178 TP_ARGS(thread, result)
181 DEFINE_EVENT(syscall_entry, cobalt_root_sysentry,
182 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
186 DEFINE_EVENT(syscall_exit, cobalt_root_sysexit,
187 TP_PROTO(
struct xnthread *thread,
long result),
188 TP_ARGS(thread, result)
191 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_create,
192 TP_PROTO(
unsigned long pth,
int policy,
193 const struct sched_param_ex *param_ex),
194 TP_ARGS(pth, policy, param_ex)
197 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_setschedparam,
198 TP_PROTO(
unsigned long pth,
int policy,
199 const struct sched_param_ex *param_ex),
200 TP_ARGS(pth, policy, param_ex)
203 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_getschedparam,
204 TP_PROTO(
unsigned long pth,
int policy,
205 const struct sched_param_ex *param_ex),
206 TP_ARGS(pth, policy, param_ex)
209 #define cobalt_print_thread_mode(__mode) \
210 __print_flags(__mode, "|", \
211 {PTHREAD_WARNSW, "warnsw"}, \
212 {PTHREAD_LOCK_SCHED, "lock"}, \
213 {PTHREAD_DISABLE_LOCKBREAK, "nolockbreak"})
215 TRACE_EVENT(cobalt_pthread_setmode,
216 TP_PROTO(
int clrmask,
int setmask),
217 TP_ARGS(clrmask, setmask),
219 __field(
int, clrmask)
220 __field(
int, setmask)
223 __entry->clrmask = clrmask;
224 __entry->setmask = setmask;
226 TP_printk(
"clrmask=%#x(%s) setmask=%#x(%s)",
227 __entry->clrmask, cobalt_print_thread_mode(__entry->clrmask),
228 __entry->setmask, cobalt_print_thread_mode(__entry->setmask))
231 TRACE_EVENT(cobalt_pthread_setname,
232 TP_PROTO(
unsigned long pth,
const char *name),
235 __field(
unsigned long, pth)
240 __assign_str(name, name);
242 TP_printk(
"pth=%p name=%s", (
void *)__entry->pth, __get_str(name))
245 DECLARE_EVENT_CLASS(cobalt_posix_pid,
254 TP_printk(
"pid=%d", __entry->pid)
257 DEFINE_EVENT(cobalt_posix_pid, cobalt_pthread_stat,
262 TRACE_EVENT(cobalt_pthread_kill,
263 TP_PROTO(
unsigned long pth,
int sig),
266 __field(
unsigned long, pth)
273 TP_printk(
"pth=%p sig=%d", (
void *)__entry->pth, __entry->sig)
276 TRACE_EVENT(cobalt_pthread_join,
277 TP_PROTO(
unsigned long pth),
280 __field(
unsigned long, pth)
285 TP_printk(
"pth=%p", (
void *)__entry->pth)
288 TRACE_EVENT(cobalt_pthread_pid,
289 TP_PROTO(
unsigned long pth),
292 __field(
unsigned long, pth)
297 TP_printk(
"pth=%p", (
void *)__entry->pth)
300 TRACE_EVENT(cobalt_pthread_extend,
301 TP_PROTO(
unsigned long pth,
const char *name),
304 __field(
unsigned long, pth)
309 __assign_str(name, name);
311 TP_printk(
"pth=%p +personality=%s", (
void *)__entry->pth, __get_str(name))
314 TRACE_EVENT(cobalt_pthread_restrict,
315 TP_PROTO(
unsigned long pth,
const char *name),
318 __field(
unsigned long, pth)
323 __assign_str(name, name);
325 TP_printk(
"pth=%p -personality=%s", (
void *)__entry->pth, __get_str(name))
328 DEFINE_EVENT(cobalt_void, cobalt_pthread_yield,
333 TRACE_EVENT(cobalt_sched_setconfig,
334 TP_PROTO(
int cpu,
int policy,
size_t len),
335 TP_ARGS(cpu, policy, len),
343 __entry->policy = policy;
346 TP_printk(
"cpu=%d policy=%d(%s) len=%Zu",
347 __entry->cpu, __entry->policy,
348 cobalt_print_sched_policy(__entry->policy),
352 TRACE_EVENT(cobalt_sched_get_config,
353 TP_PROTO(
int cpu,
int policy,
size_t rlen),
354 TP_ARGS(cpu, policy, rlen),
358 __field(ssize_t, rlen)
362 __entry->policy = policy;
363 __entry->rlen = rlen;
365 TP_printk(
"cpu=%d policy=%d(%s) rlen=%Zd",
366 __entry->cpu, __entry->policy,
367 cobalt_print_sched_policy(__entry->policy),
371 DECLARE_EVENT_CLASS(cobalt_posix_prio_bound,
372 TP_PROTO(
int policy,
int prio),
373 TP_ARGS(policy, prio),
379 __entry->policy = policy;
380 __entry->prio = prio;
382 TP_printk(
"policy=%d(%s) prio=%d",
384 cobalt_print_sched_policy(__entry->policy),
388 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_min_prio,
389 TP_PROTO(
int policy,
int prio),
390 TP_ARGS(policy, prio)
393 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_max_prio,
394 TP_PROTO(
int policy,
int prio),
395 TP_ARGS(policy, prio)
398 DECLARE_EVENT_CLASS(cobalt_posix_sem,
399 TP_PROTO(xnhandle_t handle),
402 __field(xnhandle_t, handle)
405 __entry->handle = handle;
407 TP_printk(
"sem=%#x", __entry->handle)
410 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_wait,
411 TP_PROTO(xnhandle_t handle),
415 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_trywait,
416 TP_PROTO(xnhandle_t handle),
420 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_timedwait,
421 TP_PROTO(xnhandle_t handle),
425 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_post,
426 TP_PROTO(xnhandle_t handle),
430 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_destroy,
431 TP_PROTO(xnhandle_t handle),
435 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_broadcast,
436 TP_PROTO(xnhandle_t handle),
440 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_inquire,
441 TP_PROTO(xnhandle_t handle),
445 TRACE_EVENT(cobalt_psem_getvalue,
446 TP_PROTO(xnhandle_t handle,
int value),
447 TP_ARGS(handle, value),
449 __field(xnhandle_t, handle)
453 __entry->handle = handle;
454 __entry->value = value;
456 TP_printk(
"sem=%#x value=%d", __entry->handle, __entry->value)
459 #define cobalt_print_sem_flags(__flags) \
460 __print_flags(__flags, "|", \
461 {SEM_FIFO, "fifo"}, \
462 {SEM_PULSE, "pulse"}, \
463 {SEM_PSHARED, "pshared"}, \
464 {SEM_REPORT, "report"}, \
465 {SEM_WARNDEL, "warndel"}, \
466 {SEM_RAWCLOCK, "rawclock"}, \
467 {SEM_NOBUSYDEL, "nobusydel"})
469 TRACE_EVENT(cobalt_psem_init,
470 TP_PROTO(
const char *name, xnhandle_t handle,
471 int flags,
unsigned int value),
472 TP_ARGS(name, handle, flags, value),
475 __field(xnhandle_t, handle)
477 __field(
unsigned int, value)
480 __assign_str(name, name);
481 __entry->handle = handle;
482 __entry->flags = flags;
483 __entry->value = value;
485 TP_printk(
"sem=%#x(%s) flags=%#x(%s) value=%u",
489 cobalt_print_sem_flags(__entry->flags),
493 TRACE_EVENT(cobalt_psem_init_failed,
494 TP_PROTO(
const char *name,
int flags,
unsigned int value,
int status),
495 TP_ARGS(name, flags, value, status),
499 __field(
unsigned int, value)
503 __assign_str(name, name);
504 __entry->flags = flags;
505 __entry->value = value;
506 __entry->status = status;
508 TP_printk(
"name=%s flags=%#x(%s) value=%u error=%d",
511 cobalt_print_sem_flags(__entry->flags),
512 __entry->value, __entry->status)
515 #define cobalt_print_oflags(__flags) \
516 __print_flags(__flags, "|", \
517 {O_RDONLY, "rdonly"}, \
518 {O_WRONLY, "wronly"}, \
520 {O_CREAT, "creat"}, \
522 {O_DIRECT, "direct"}, \
523 {O_NONBLOCK, "nonblock"}, \
526 TRACE_EVENT(cobalt_psem_open,
527 TP_PROTO(
const char *name, xnhandle_t handle,
528 int oflags, mode_t mode,
unsigned int value),
529 TP_ARGS(name, handle, oflags, mode, value),
532 __field(xnhandle_t, handle)
534 __field(mode_t, mode)
535 __field(
unsigned int, value)
538 __assign_str(name, name);
539 __entry->handle = handle;
540 __entry->oflags = oflags;
541 if (oflags & O_CREAT) {
542 __entry->mode = mode;
543 __entry->value = value;
549 TP_printk(
"named_sem=%#x=(%s) oflags=%#x(%s) mode=%o value=%u",
550 __entry->handle, __get_str(name),
551 __entry->oflags, cobalt_print_oflags(__entry->oflags),
552 __entry->mode, __entry->value)
555 TRACE_EVENT(cobalt_psem_open_failed,
556 TP_PROTO(
const char *name,
int oflags, mode_t mode,
557 unsigned int value,
int status),
558 TP_ARGS(name, oflags, mode, value, status),
562 __field(mode_t, mode)
563 __field(
unsigned int, value)
567 __assign_str(name, name);
568 __entry->oflags = oflags;
569 __entry->status = status;
570 if (oflags & O_CREAT) {
571 __entry->mode = mode;
572 __entry->value = value;
578 TP_printk(
"named_sem=%s oflags=%#x(%s) mode=%o value=%u error=%d",
580 __entry->oflags, cobalt_print_oflags(__entry->oflags),
581 __entry->mode, __entry->value, __entry->status)
584 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_close,
585 TP_PROTO(xnhandle_t handle),
589 TRACE_EVENT(cobalt_psem_unlink,
590 TP_PROTO(
const char *name),
596 __assign_str(name, name);
598 TP_printk(
"name=%s", __get_str(name))
601 DECLARE_EVENT_CLASS(cobalt_clock_timespec,
602 TP_PROTO(clockid_t clk_id,
const struct timespec *val),
603 TP_ARGS(clk_id, val),
606 __field(clockid_t, clk_id)
607 __timespec_fields(val)
611 __entry->clk_id = clk_id;
612 __assign_timespec(val, val);
615 TP_printk(
"clock_id=%d timeval=(%ld.%09ld)",
621 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_getres,
622 TP_PROTO(clockid_t clk_id,
const struct timespec *res),
626 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_gettime,
627 TP_PROTO(clockid_t clk_id,
const struct timespec *time),
628 TP_ARGS(clk_id, time)
631 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_settime,
632 TP_PROTO(clockid_t clk_id,
const struct timespec *time),
633 TP_ARGS(clk_id, time)
636 #define cobalt_print_timer_flags(__flags) \
637 __print_flags(__flags, "|", \
638 {TIMER_ABSTIME, "TIMER_ABSTIME"})
640 TRACE_EVENT(cobalt_clock_nanosleep,
641 TP_PROTO(clockid_t clk_id,
int flags,
const struct timespec *time),
642 TP_ARGS(clk_id, flags, time),
645 __field(clockid_t, clk_id)
647 __timespec_fields(time)
651 __entry->clk_id = clk_id;
652 __entry->flags = flags;
653 __assign_timespec(time, time);
656 TP_printk(
"clock_id=%d flags=%#x(%s) rqt=(%ld.%09ld)",
658 __entry->flags, cobalt_print_timer_flags(__entry->flags),
659 __timespec_args(time)
663 DECLARE_EVENT_CLASS(cobalt_clock_ident,
664 TP_PROTO(
const char *name, clockid_t clk_id),
665 TP_ARGS(name, clk_id),
668 __field(clockid_t, clk_id)
671 __assign_str(name, name);
672 __entry->clk_id = clk_id;
674 TP_printk(
"name=%s, id=%#x", __get_str(name), __entry->clk_id)
677 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_register,
678 TP_PROTO(
const char *name, clockid_t clk_id),
679 TP_ARGS(name, clk_id)
682 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_deregister,
683 TP_PROTO(
const char *name, clockid_t clk_id),
684 TP_ARGS(name, clk_id)
687 #define cobalt_print_clock(__clk_id) \
688 __print_symbolic(__clk_id, \
689 {CLOCK_MONOTONIC, "CLOCK_MONOTONIC"}, \
690 {CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW"}, \
691 {CLOCK_REALTIME, "CLOCK_REALTIME"})
693 TRACE_EVENT(cobalt_cond_init,
694 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
695 const struct cobalt_condattr *attr),
696 TP_ARGS(u_cnd, attr),
698 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
699 __field(clockid_t, clk_id)
700 __field(
int, pshared)
703 __entry->u_cnd = u_cnd;
704 __entry->clk_id = attr->clock;
705 __entry->pshared = attr->pshared;
707 TP_printk(
"cond=%p attr={ .clock=%s, .pshared=%d }",
709 cobalt_print_clock(__entry->clk_id),
713 TRACE_EVENT(cobalt_cond_destroy,
714 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd),
717 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
720 __entry->u_cnd = u_cnd;
722 TP_printk(
"cond=%p", __entry->u_cnd)
725 TRACE_EVENT(cobalt_cond_timedwait,
726 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
727 const struct cobalt_mutex_shadow __user *u_mx,
728 const struct timespec *timeout),
729 TP_ARGS(u_cnd, u_mx, timeout),
731 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
732 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
733 __timespec_fields(timeout)
736 __entry->u_cnd = u_cnd;
737 __entry->u_mx = u_mx;
738 __assign_timespec(timeout, timeout);
740 TP_printk(
"cond=%p, mutex=%p, timeout=(%ld.%09ld)",
741 __entry->u_cnd, __entry->u_mx, __timespec_args(timeout))
744 TRACE_EVENT(cobalt_cond_wait,
745 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
746 const struct cobalt_mutex_shadow __user *u_mx),
747 TP_ARGS(u_cnd, u_mx),
749 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
750 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
753 __entry->u_cnd = u_cnd;
754 __entry->u_mx = u_mx;
756 TP_printk(
"cond=%p, mutex=%p",
757 __entry->u_cnd, __entry->u_mx)
760 TRACE_EVENT(cobalt_mq_open,
761 TP_PROTO(
const char *name,
int oflags, mode_t mode),
762 TP_ARGS(name, oflags, mode),
767 __field(mode_t, mode)
771 __assign_str(name, name);
772 __entry->oflags = oflags;
773 __entry->mode = (oflags & O_CREAT) ? mode : 0;
776 TP_printk(
"name=%s oflags=%#x(%s) mode=%o",
778 __entry->oflags, cobalt_print_oflags(__entry->oflags),
782 TRACE_EVENT(cobalt_mq_notify,
783 TP_PROTO(mqd_t mqd,
const struct sigevent *sev),
793 __entry->signo = sev && sev->sigev_notify != SIGEV_NONE ?
794 sev->sigev_signo : 0;
797 TP_printk(
"mqd=%d signo=%d",
798 __entry->mqd, __entry->signo)
801 TRACE_EVENT(cobalt_mq_close,
813 TP_printk(
"mqd=%d", __entry->mqd)
816 TRACE_EVENT(cobalt_mq_unlink,
817 TP_PROTO(
const char *name),
825 __assign_str(name, name);
828 TP_printk(
"name=%s", __get_str(name))
831 TRACE_EVENT(cobalt_mq_send,
832 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
834 TP_ARGS(mqd, u_buf, len, prio),
837 __field(
const void __user *, u_buf)
839 __field(
unsigned int, prio)
843 __entry->u_buf = u_buf;
845 __entry->prio = prio;
847 TP_printk(
"mqd=%d buf=%p len=%Zu prio=%u",
848 __entry->mqd, __entry->u_buf, __entry->len,
852 TRACE_EVENT(cobalt_mq_timedreceive,
853 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
854 const struct timespec *timeout),
855 TP_ARGS(mqd, u_buf, len, timeout),
858 __field(
const void __user *, u_buf)
860 __timespec_fields(timeout)
864 __entry->u_buf = u_buf;
866 __assign_timespec(timeout, timeout);
868 TP_printk(
"mqd=%d buf=%p len=%Zu timeout=(%ld.%09ld)",
869 __entry->mqd, __entry->u_buf, __entry->len,
870 __timespec_args(timeout))
873 TRACE_EVENT(cobalt_mq_receive,
874 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len),
875 TP_ARGS(mqd, u_buf, len),
878 __field(
const void __user *, u_buf)
883 __entry->u_buf = u_buf;
886 TP_printk(
"mqd=%d buf=%p len=%Zu",
887 __entry->mqd, __entry->u_buf, __entry->len)
890 DECLARE_EVENT_CLASS(cobalt_posix_mqattr,
891 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
896 __field(
long, curmsgs)
897 __field(
long, msgsize)
898 __field(
long, maxmsg)
902 __entry->flags = attr->mq_flags;
903 __entry->curmsgs = attr->mq_curmsgs;
904 __entry->msgsize = attr->mq_msgsize;
905 __entry->maxmsg = attr->mq_maxmsg;
907 TP_printk(
"mqd=%d flags=%#lx(%s) curmsgs=%ld msgsize=%ld maxmsg=%ld",
909 __entry->flags, cobalt_print_oflags(__entry->flags),
916 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_getattr,
917 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
921 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_setattr,
922 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
926 #define cobalt_print_evflags(__flags) \
927 __print_flags(__flags, "|", \
928 {COBALT_EVENT_SHARED, "shared"}, \
929 {COBALT_EVENT_PRIO, "prio"})
931 TRACE_EVENT(cobalt_event_init,
932 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
933 unsigned long value,
int flags),
934 TP_ARGS(u_event, value, flags),
936 __field(
const struct cobalt_event_shadow __user *, u_event)
937 __field(
unsigned long, value)
941 __entry->u_event = u_event;
942 __entry->value = value;
943 __entry->flags = flags;
945 TP_printk(
"event=%p value=%lu flags=%#x(%s)",
946 __entry->u_event, __entry->value,
947 __entry->flags, cobalt_print_evflags(__entry->flags))
950 #define cobalt_print_evmode(__mode) \
951 __print_symbolic(__mode, \
952 {COBALT_EVENT_ANY, "any"}, \
953 {COBALT_EVENT_ALL, "all"})
955 TRACE_EVENT(cobalt_event_timedwait,
956 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
957 unsigned long bits,
int mode,
958 const struct timespec *timeout),
959 TP_ARGS(u_event, bits, mode, timeout),
961 __field(
const struct cobalt_event_shadow __user *, u_event)
962 __field(
unsigned long, bits)
964 __timespec_fields(timeout)
967 __entry->u_event = u_event;
968 __entry->bits = bits;
969 __entry->mode = mode;
970 __assign_timespec(timeout, timeout);
972 TP_printk(
"event=%p bits=%#lx mode=%#x(%s) timeout=(%ld.%09ld)",
973 __entry->u_event, __entry->bits, __entry->mode,
974 cobalt_print_evmode(__entry->mode),
975 __timespec_args(timeout))
978 TRACE_EVENT(cobalt_event_wait,
979 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
980 unsigned long bits,
int mode),
981 TP_ARGS(u_event, bits, mode),
983 __field(
const struct cobalt_event_shadow __user *, u_event)
984 __field(
unsigned long, bits)
988 __entry->u_event = u_event;
989 __entry->bits = bits;
990 __entry->mode = mode;
992 TP_printk(
"event=%p bits=%#lx mode=%#x(%s)",
993 __entry->u_event, __entry->bits, __entry->mode,
994 cobalt_print_evmode(__entry->mode))
997 DECLARE_EVENT_CLASS(cobalt_event_ident,
998 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1001 __field(
const struct cobalt_event_shadow __user *, u_event)
1004 __entry->u_event = u_event;
1006 TP_printk(
"event=%p", __entry->u_event)
1009 DEFINE_EVENT(cobalt_event_ident, cobalt_event_destroy,
1010 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1014 DEFINE_EVENT(cobalt_event_ident, cobalt_event_sync,
1015 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1019 DEFINE_EVENT(cobalt_event_ident, cobalt_event_inquire,
1020 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1027 #include <trace/define_trace.h>