2 #define TRACE_SYSTEM cobalt-posix
4 #if !defined(_TRACE_COBALT_POSIX_H) || defined(TRACE_HEADER_MULTI_READ)
5 #define _TRACE_COBALT_POSIX_H
7 #include <linux/tracepoint.h>
8 #include <xenomai/posix/cond.h>
9 #include <xenomai/posix/mqueue.h>
10 #include <xenomai/posix/event.h>
12 #define __timespec_fields(__name) \
13 __field(__kernel_time_t, tv_sec_##__name) \
14 __field(long, tv_nsec_##__name)
16 #define __assign_timespec(__to, __from) \
18 __entry->tv_sec_##__to = (__from)->tv_sec; \
19 __entry->tv_nsec_##__to = (__from)->tv_nsec; \
22 #define __timespec_args(__name) \
23 __entry->tv_sec_##__name, __entry->tv_nsec_##__name
25 DECLARE_EVENT_CLASS(syscall_entry,
26 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
30 __field(
struct xnthread *, thread)
31 __string(name, thread ? thread->name :
"(anon)")
32 __field(
unsigned int, nr)
36 __entry->thread = thread;
37 __assign_str(name, thread ? thread->name :
"(anon)");
41 TP_printk(
"thread=%p(%s) syscall=%u",
42 __entry->thread, __get_str(name), __entry->nr)
45 DECLARE_EVENT_CLASS(syscall_exit,
46 TP_PROTO(
struct xnthread *thread,
long result),
47 TP_ARGS(thread, result),
50 __field(
struct xnthread *, thread)
55 __entry->thread = thread;
56 __entry->result = result;
59 TP_printk(
"thread=%p result=%ld",
60 __entry->thread, __entry->result)
63 #define cobalt_print_sched_policy(__policy) \
64 __print_symbolic(__policy, \
65 {SCHED_NORMAL, "normal"}, \
66 {SCHED_FIFO, "fifo"}, \
69 {SCHED_QUOTA, "quota"}, \
70 {SCHED_SPORADIC, "sporadic"}, \
71 {SCHED_COBALT, "cobalt"}, \
74 #define cobalt_print_sched_params(__policy, __p_ex) \
76 const char *__ret = p->buffer + p->len; \
79 trace_seq_printf(p, "priority=%d, group=%d", \
80 (__p_ex)->sched_priority, \
81 (__p_ex)->sched_quota_group); \
84 trace_seq_printf(p, "priority=%d, partition=%d", \
85 (__p_ex)->sched_priority, \
86 (__p_ex)->sched_tp_partition); \
90 case SCHED_SPORADIC: \
91 trace_seq_printf(p, "priority=%d, low_priority=%d, " \
92 "budget=(%ld.%09ld), period=(%ld.%09ld), "\
94 (__p_ex)->sched_priority, \
95 (__p_ex)->sched_ss_low_priority, \
96 (__p_ex)->sched_ss_init_budget.tv_sec, \
97 (__p_ex)->sched_ss_init_budget.tv_nsec, \
98 (__p_ex)->sched_ss_repl_period.tv_sec, \
99 (__p_ex)->sched_ss_repl_period.tv_nsec, \
100 (__p_ex)->sched_ss_max_repl); \
107 trace_seq_printf(p, "priority=%d", \
108 (__p_ex)->sched_priority); \
114 DECLARE_EVENT_CLASS(cobalt_posix_schedparam,
115 TP_PROTO(
unsigned long pth,
int policy,
116 const struct sched_param_ex *param_ex),
117 TP_ARGS(pth, policy, param_ex),
120 __field(
unsigned long, pth)
122 __dynamic_array(
char, param_ex,
sizeof(
struct sched_param_ex))
127 __entry->policy = policy;
128 memcpy(__get_dynamic_array(param_ex), param_ex,
sizeof(*param_ex));
131 TP_printk(
"pth=%p policy=%d(%s) param={ %s }",
132 (
void *)__entry->pth, __entry->policy,
133 cobalt_print_sched_policy(__entry->policy),
134 cobalt_print_sched_params(__entry->policy,
135 (
struct sched_param_ex *)
136 __get_dynamic_array(param_ex))
140 DECLARE_EVENT_CLASS(cobalt_void,
144 __array(
char, dummy, 0)
152 DEFINE_EVENT(syscall_entry, cobalt_head_sysentry,
153 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
157 DEFINE_EVENT(syscall_exit, cobalt_head_sysexit,
158 TP_PROTO(
struct xnthread *thread,
long result),
159 TP_ARGS(thread, result)
162 DEFINE_EVENT(syscall_entry, cobalt_root_sysentry,
163 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
167 DEFINE_EVENT(syscall_exit, cobalt_root_sysexit,
168 TP_PROTO(
struct xnthread *thread,
long result),
169 TP_ARGS(thread, result)
172 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_create,
173 TP_PROTO(
unsigned long pth,
int policy,
174 const struct sched_param_ex *param_ex),
175 TP_ARGS(pth, policy, param_ex)
178 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_setschedparam,
179 TP_PROTO(
unsigned long pth,
int policy,
180 const struct sched_param_ex *param_ex),
181 TP_ARGS(pth, policy, param_ex)
184 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_getschedparam,
185 TP_PROTO(
unsigned long pth,
int policy,
186 const struct sched_param_ex *param_ex),
187 TP_ARGS(pth, policy, param_ex)
190 #define cobalt_print_thread_mode(__mode) \
191 __print_flags(__mode, "|", \
192 {PTHREAD_WARNSW, "warnsw"}, \
193 {PTHREAD_LOCK_SCHED, "lock"}, \
194 {PTHREAD_DISABLE_LOCKBREAK, "nolockbreak"})
196 TRACE_EVENT(cobalt_pthread_setmode,
197 TP_PROTO(
int clrmask,
int setmask),
198 TP_ARGS(clrmask, setmask),
200 __field(
int, clrmask)
201 __field(
int, setmask)
204 __entry->clrmask = clrmask;
205 __entry->setmask = setmask;
207 TP_printk(
"clrmask=%#x(%s) setmask=%#x(%s)",
208 __entry->clrmask, cobalt_print_thread_mode(__entry->clrmask),
209 __entry->setmask, cobalt_print_thread_mode(__entry->setmask))
212 TRACE_EVENT(cobalt_pthread_setname,
213 TP_PROTO(
unsigned long pth,
const char *name),
216 __field(
unsigned long, pth)
221 __assign_str(name, name);
223 TP_printk(
"pth=%p name=%s", (
void *)__entry->pth, __get_str(name))
226 DECLARE_EVENT_CLASS(cobalt_posix_pid,
235 TP_printk(
"pid=%d", __entry->pid)
238 DEFINE_EVENT(cobalt_posix_pid, cobalt_pthread_stat,
243 TRACE_EVENT(cobalt_pthread_kill,
244 TP_PROTO(
unsigned long pth,
int sig),
247 __field(
unsigned long, pth)
254 TP_printk(
"pth=%p sig=%d", (
void *)__entry->pth, __entry->sig)
257 TRACE_EVENT(cobalt_pthread_join,
258 TP_PROTO(
unsigned long pth),
261 __field(
unsigned long, pth)
266 TP_printk(
"pth=%p", (
void *)__entry->pth)
269 TRACE_EVENT(cobalt_pthread_pid,
270 TP_PROTO(
unsigned long pth),
273 __field(
unsigned long, pth)
278 TP_printk(
"pth=%p", (
void *)__entry->pth)
281 TRACE_EVENT(cobalt_pthread_extend,
282 TP_PROTO(
unsigned long pth,
const char *name),
285 __field(
unsigned long, pth)
290 __assign_str(name, name);
292 TP_printk(
"pth=%p +personality=%s", (
void *)__entry->pth, __get_str(name))
295 TRACE_EVENT(cobalt_pthread_restrict,
296 TP_PROTO(
unsigned long pth,
const char *name),
299 __field(
unsigned long, pth)
304 __assign_str(name, name);
306 TP_printk(
"pth=%p -personality=%s", (
void *)__entry->pth, __get_str(name))
309 DEFINE_EVENT(cobalt_void, cobalt_pthread_yield,
314 TRACE_EVENT(cobalt_sched_setconfig,
315 TP_PROTO(
int cpu,
int policy,
size_t len),
316 TP_ARGS(cpu, policy, len),
324 __entry->policy = policy;
327 TP_printk(
"cpu=%d policy=%d(%s) len=%Zu",
328 __entry->cpu, __entry->policy,
329 cobalt_print_sched_policy(__entry->policy),
333 TRACE_EVENT(cobalt_sched_get_config,
334 TP_PROTO(
int cpu,
int policy,
size_t rlen),
335 TP_ARGS(cpu, policy, rlen),
339 __field(ssize_t, rlen)
343 __entry->policy = policy;
344 __entry->rlen = rlen;
346 TP_printk(
"cpu=%d policy=%d(%s) rlen=%Zd",
347 __entry->cpu, __entry->policy,
348 cobalt_print_sched_policy(__entry->policy),
352 DECLARE_EVENT_CLASS(cobalt_posix_prio_bound,
353 TP_PROTO(
int policy,
int prio),
354 TP_ARGS(policy, prio),
360 __entry->policy = policy;
361 __entry->prio = prio;
363 TP_printk(
"policy=%d(%s) prio=%d",
365 cobalt_print_sched_policy(__entry->policy),
369 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_min_prio,
370 TP_PROTO(
int policy,
int prio),
371 TP_ARGS(policy, prio)
374 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_max_prio,
375 TP_PROTO(
int policy,
int prio),
376 TP_ARGS(policy, prio)
379 DECLARE_EVENT_CLASS(cobalt_posix_sem,
380 TP_PROTO(xnhandle_t handle),
383 __field(xnhandle_t, handle)
386 __entry->handle = handle;
388 TP_printk(
"sem=%#x", __entry->handle)
391 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_wait,
392 TP_PROTO(xnhandle_t handle),
396 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_trywait,
397 TP_PROTO(xnhandle_t handle),
401 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_timedwait,
402 TP_PROTO(xnhandle_t handle),
406 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_post,
407 TP_PROTO(xnhandle_t handle),
411 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_destroy,
412 TP_PROTO(xnhandle_t handle),
416 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_broadcast,
417 TP_PROTO(xnhandle_t handle),
421 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_inquire,
422 TP_PROTO(xnhandle_t handle),
426 TRACE_EVENT(cobalt_psem_getvalue,
427 TP_PROTO(xnhandle_t handle,
int value),
428 TP_ARGS(handle, value),
430 __field(xnhandle_t, handle)
434 __entry->handle = handle;
435 __entry->value = value;
437 TP_printk(
"sem=%#x value=%d", __entry->handle, __entry->value)
440 #define cobalt_print_sem_flags(__flags) \
441 __print_flags(__flags, "|", \
442 {SEM_FIFO, "fifo"}, \
443 {SEM_PULSE, "pulse"}, \
444 {SEM_PSHARED, "pshared"}, \
445 {SEM_REPORT, "report"}, \
446 {SEM_WARNDEL, "warndel"}, \
447 {SEM_RAWCLOCK, "rawclock"}, \
448 {SEM_NOBUSYDEL, "nobusydel"})
450 TRACE_EVENT(cobalt_psem_init,
451 TP_PROTO(
const char *name, xnhandle_t handle,
452 int flags,
unsigned int value),
453 TP_ARGS(name, handle, flags, value),
456 __field(xnhandle_t, handle)
458 __field(
unsigned int, value)
461 __assign_str(name, name);
462 __entry->handle = handle;
463 __entry->flags = flags;
464 __entry->value = value;
466 TP_printk(
"sem=%#x(%s) flags=%#x(%s) value=%u",
470 cobalt_print_sem_flags(__entry->flags),
474 TRACE_EVENT(cobalt_psem_init_failed,
475 TP_PROTO(
const char *name,
int flags,
unsigned int value,
int status),
476 TP_ARGS(name, flags, value, status),
480 __field(
unsigned int, value)
484 __assign_str(name, name);
485 __entry->flags = flags;
486 __entry->value = value;
487 __entry->status = status;
489 TP_printk(
"name=%s flags=%#x(%s) value=%u error=%d",
492 cobalt_print_sem_flags(__entry->flags),
493 __entry->value, __entry->status)
496 #define cobalt_print_oflags(__flags) \
497 __print_flags(__flags, "|", \
498 {O_RDONLY, "rdonly"}, \
499 {O_WRONLY, "wronly"}, \
501 {O_CREAT, "creat"}, \
503 {O_DIRECT, "direct"}, \
504 {O_NONBLOCK, "nonblock"}, \
507 TRACE_EVENT(cobalt_psem_open,
508 TP_PROTO(
const char *name, xnhandle_t handle,
509 int oflags, mode_t mode,
unsigned int value),
510 TP_ARGS(name, handle, oflags, mode, value),
513 __field(xnhandle_t, handle)
515 __field(mode_t, mode)
516 __field(
unsigned int, value)
519 __assign_str(name, name);
520 __entry->handle = handle;
521 __entry->oflags = oflags;
522 if (oflags & O_CREAT) {
523 __entry->mode = mode;
524 __entry->value = value;
530 TP_printk(
"named_sem=%#x=(%s) oflags=%#x(%s) mode=%o value=%u",
531 __entry->handle, __get_str(name),
532 __entry->oflags, cobalt_print_oflags(__entry->oflags),
533 __entry->mode, __entry->value)
536 TRACE_EVENT(cobalt_psem_open_failed,
537 TP_PROTO(
const char *name,
int oflags, mode_t mode,
538 unsigned int value,
int status),
539 TP_ARGS(name, oflags, mode, value, status),
543 __field(mode_t, mode)
544 __field(
unsigned int, value)
548 __assign_str(name, name);
549 __entry->oflags = oflags;
550 __entry->status = status;
551 if (oflags & O_CREAT) {
552 __entry->mode = mode;
553 __entry->value = value;
559 TP_printk(
"named_sem=%s oflags=%#x(%s) mode=%o value=%u error=%d",
561 __entry->oflags, cobalt_print_oflags(__entry->oflags),
562 __entry->mode, __entry->value, __entry->status)
565 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_close,
566 TP_PROTO(xnhandle_t handle),
570 TRACE_EVENT(cobalt_psem_unlink,
571 TP_PROTO(
const char *name),
577 __assign_str(name, name);
579 TP_printk(
"name=%s", __get_str(name))
582 DECLARE_EVENT_CLASS(cobalt_clock_timespec,
583 TP_PROTO(clockid_t clk_id,
const struct timespec *val),
584 TP_ARGS(clk_id, val),
587 __field(clockid_t, clk_id)
588 __timespec_fields(val)
592 __entry->clk_id = clk_id;
593 __assign_timespec(val, val);
596 TP_printk(
"clock_id=%d timeval=(%ld.%09ld)",
602 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_getres,
603 TP_PROTO(clockid_t clk_id,
const struct timespec *res),
607 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_gettime,
608 TP_PROTO(clockid_t clk_id,
const struct timespec *time),
609 TP_ARGS(clk_id, time)
612 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_settime,
613 TP_PROTO(clockid_t clk_id,
const struct timespec *time),
614 TP_ARGS(clk_id, time)
617 #define cobalt_print_timer_flags(__flags) \
618 __print_flags(__flags, "|", \
619 {TIMER_ABSTIME, "TIMER_ABSTIME"})
621 TRACE_EVENT(cobalt_clock_nanosleep,
622 TP_PROTO(clockid_t clk_id,
int flags,
const struct timespec *time),
623 TP_ARGS(clk_id, flags, time),
626 __field(clockid_t, clk_id)
628 __timespec_fields(time)
632 __entry->clk_id = clk_id;
633 __entry->flags = flags;
634 __assign_timespec(time, time);
637 TP_printk(
"clock_id=%d flags=%#x(%s) rqt=(%ld.%09ld)",
639 __entry->flags, cobalt_print_timer_flags(__entry->flags),
640 __timespec_args(time)
644 DECLARE_EVENT_CLASS(cobalt_clock_ident,
645 TP_PROTO(
const char *name, clockid_t clk_id),
646 TP_ARGS(name, clk_id),
649 __field(clockid_t, clk_id)
652 __assign_str(name, name);
653 __entry->clk_id = clk_id;
655 TP_printk(
"name=%s, id=%#x", __get_str(name), __entry->clk_id)
658 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_register,
659 TP_PROTO(
const char *name, clockid_t clk_id),
660 TP_ARGS(name, clk_id)
663 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_deregister,
664 TP_PROTO(
const char *name, clockid_t clk_id),
665 TP_ARGS(name, clk_id)
668 #define cobalt_print_clock(__clk_id) \
669 __print_symbolic(__clk_id, \
670 {CLOCK_MONOTONIC, "CLOCK_MONOTONIC"}, \
671 {CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW"}, \
672 {CLOCK_REALTIME, "CLOCK_REALTIME"})
674 TRACE_EVENT(cobalt_cond_init,
675 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
676 const struct cobalt_condattr *attr),
677 TP_ARGS(u_cnd, attr),
679 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
680 __field(clockid_t, clk_id)
681 __field(
int, pshared)
684 __entry->u_cnd = u_cnd;
685 __entry->clk_id = attr->clock;
686 __entry->pshared = attr->pshared;
688 TP_printk(
"cond=%p attr={ .clock=%s, .pshared=%d }",
690 cobalt_print_clock(__entry->clk_id),
694 TRACE_EVENT(cobalt_cond_destroy,
695 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd),
698 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
701 __entry->u_cnd = u_cnd;
703 TP_printk(
"cond=%p", __entry->u_cnd)
706 TRACE_EVENT(cobalt_cond_timedwait,
707 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
708 const struct cobalt_mutex_shadow __user *u_mx,
709 const struct timespec *timeout),
710 TP_ARGS(u_cnd, u_mx, timeout),
712 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
713 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
714 __timespec_fields(timeout)
717 __entry->u_cnd = u_cnd;
718 __entry->u_mx = u_mx;
719 __assign_timespec(timeout, timeout);
721 TP_printk(
"cond=%p, mutex=%p, timeout=(%ld.%09ld)",
722 __entry->u_cnd, __entry->u_mx, __timespec_args(timeout))
725 TRACE_EVENT(cobalt_cond_wait,
726 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
727 const struct cobalt_mutex_shadow __user *u_mx),
728 TP_ARGS(u_cnd, u_mx),
730 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
731 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
734 __entry->u_cnd = u_cnd;
735 __entry->u_mx = u_mx;
737 TP_printk(
"cond=%p, mutex=%p",
738 __entry->u_cnd, __entry->u_mx)
741 TRACE_EVENT(cobalt_mq_open,
742 TP_PROTO(
const char *name,
int oflags, mode_t mode),
743 TP_ARGS(name, oflags, mode),
748 __field(mode_t, mode)
752 __assign_str(name, name);
753 __entry->oflags = oflags;
754 __entry->mode = (oflags & O_CREAT) ? mode : 0;
757 TP_printk(
"name=%s oflags=%#x(%s) mode=%o",
759 __entry->oflags, cobalt_print_oflags(__entry->oflags),
763 TRACE_EVENT(cobalt_mq_notify,
764 TP_PROTO(mqd_t mqd,
const struct sigevent *sev),
774 __entry->signo = sev && sev->sigev_notify != SIGEV_NONE ?
775 sev->sigev_signo : 0;
778 TP_printk(
"mqd=%d signo=%d",
779 __entry->mqd, __entry->signo)
782 TRACE_EVENT(cobalt_mq_close,
794 TP_printk(
"mqd=%d", __entry->mqd)
797 TRACE_EVENT(cobalt_mq_unlink,
798 TP_PROTO(
const char *name),
806 __assign_str(name, name);
809 TP_printk(
"name=%s", __get_str(name))
812 TRACE_EVENT(cobalt_mq_send,
813 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
815 TP_ARGS(mqd, u_buf, len, prio),
818 __field(
const void __user *, u_buf)
820 __field(
unsigned int, prio)
824 __entry->u_buf = u_buf;
826 __entry->prio = prio;
828 TP_printk(
"mqd=%d buf=%p len=%Zu prio=%u",
829 __entry->mqd, __entry->u_buf, __entry->len,
833 TRACE_EVENT(cobalt_mq_timedreceive,
834 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
835 const struct timespec *timeout),
836 TP_ARGS(mqd, u_buf, len, timeout),
839 __field(
const void __user *, u_buf)
841 __timespec_fields(timeout)
845 __entry->u_buf = u_buf;
847 __assign_timespec(timeout, timeout);
849 TP_printk(
"mqd=%d buf=%p len=%Zu timeout=(%ld.%09ld)",
850 __entry->mqd, __entry->u_buf, __entry->len,
851 __timespec_args(timeout))
854 TRACE_EVENT(cobalt_mq_receive,
855 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len),
856 TP_ARGS(mqd, u_buf, len),
859 __field(
const void __user *, u_buf)
864 __entry->u_buf = u_buf;
867 TP_printk(
"mqd=%d buf=%p len=%Zu",
868 __entry->mqd, __entry->u_buf, __entry->len)
871 DECLARE_EVENT_CLASS(cobalt_posix_mqattr,
872 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
877 __field(
long, curmsgs)
878 __field(
long, msgsize)
879 __field(
long, maxmsg)
883 __entry->flags = attr->mq_flags;
884 __entry->curmsgs = attr->mq_curmsgs;
885 __entry->msgsize = attr->mq_msgsize;
886 __entry->maxmsg = attr->mq_maxmsg;
888 TP_printk(
"mqd=%d flags=%#lx(%s) curmsgs=%ld msgsize=%ld maxmsg=%ld",
890 __entry->flags, cobalt_print_oflags(__entry->flags),
897 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_getattr,
898 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
902 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_setattr,
903 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
907 #define cobalt_print_evflags(__flags) \
908 __print_flags(__flags, "|", \
909 {COBALT_EVENT_SHARED, "shared"}, \
910 {COBALT_EVENT_PRIO, "prio"})
912 TRACE_EVENT(cobalt_event_init,
913 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
914 unsigned long value,
int flags),
915 TP_ARGS(u_event, value, flags),
917 __field(
const struct cobalt_event_shadow __user *, u_event)
918 __field(
unsigned long, value)
922 __entry->u_event = u_event;
923 __entry->value = value;
924 __entry->flags = flags;
926 TP_printk(
"event=%p value=%lu flags=%#x(%s)",
927 __entry->u_event, __entry->value,
928 __entry->flags, cobalt_print_evflags(__entry->flags))
931 #define cobalt_print_evmode(__mode) \
932 __print_symbolic(__mode, \
933 {COBALT_EVENT_ANY, "any"}, \
934 {COBALT_EVENT_ALL, "all"})
936 TRACE_EVENT(cobalt_event_timedwait,
937 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
938 unsigned long bits,
int mode,
939 const struct timespec *timeout),
940 TP_ARGS(u_event, bits, mode, timeout),
942 __field(
const struct cobalt_event_shadow __user *, u_event)
943 __field(
unsigned long, bits)
945 __timespec_fields(timeout)
948 __entry->u_event = u_event;
949 __entry->bits = bits;
950 __entry->mode = mode;
951 __assign_timespec(timeout, timeout);
953 TP_printk(
"event=%p bits=%#lx mode=%#x(%s) timeout=(%ld.%09ld)",
954 __entry->u_event, __entry->bits, __entry->mode,
955 cobalt_print_evmode(__entry->mode),
956 __timespec_args(timeout))
959 TRACE_EVENT(cobalt_event_wait,
960 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
961 unsigned long bits,
int mode),
962 TP_ARGS(u_event, bits, mode),
964 __field(
const struct cobalt_event_shadow __user *, u_event)
965 __field(
unsigned long, bits)
969 __entry->u_event = u_event;
970 __entry->bits = bits;
971 __entry->mode = mode;
973 TP_printk(
"event=%p bits=%#lx mode=%#x(%s)",
974 __entry->u_event, __entry->bits, __entry->mode,
975 cobalt_print_evmode(__entry->mode))
978 DECLARE_EVENT_CLASS(cobalt_event_ident,
979 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
982 __field(
const struct cobalt_event_shadow __user *, u_event)
985 __entry->u_event = u_event;
987 TP_printk(
"event=%p", __entry->u_event)
990 DEFINE_EVENT(cobalt_event_ident, cobalt_event_destroy,
991 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
995 DEFINE_EVENT(cobalt_event_ident, cobalt_event_sync,
996 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1000 DEFINE_EVENT(cobalt_event_ident, cobalt_event_inquire,
1001 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1008 #include <trace/define_trace.h>