21 #define TRACE_SYSTEM cobalt_posix
22 #undef TRACE_INCLUDE_FILE
23 #define TRACE_INCLUDE_FILE cobalt-posix
25 #if !defined(_TRACE_COBALT_POSIX_H) || defined(TRACE_HEADER_MULTI_READ)
26 #define _TRACE_COBALT_POSIX_H
28 #include <linux/tracepoint.h>
29 #include <xenomai/posix/cond.h>
30 #include <xenomai/posix/mqueue.h>
31 #include <xenomai/posix/event.h>
33 #define __timespec_fields(__name) \
34 __field(__kernel_time_t, tv_sec_##__name) \
35 __field(long, tv_nsec_##__name)
37 #define __assign_timespec(__to, __from) \
39 __entry->tv_sec_##__to = (__from)->tv_sec; \
40 __entry->tv_nsec_##__to = (__from)->tv_nsec; \
43 #define __timespec_args(__name) \
44 __entry->tv_sec_##__name, __entry->tv_nsec_##__name
46 DECLARE_EVENT_CLASS(syscall_entry,
47 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
51 __field(
struct xnthread *, thread)
52 __string(name, thread ? thread->name :
"(anon)")
53 __field(
unsigned int, nr)
57 __entry->thread = thread;
58 __assign_str(name, thread ? thread->name :
"(anon)");
62 TP_printk(
"thread=%p(%s) syscall=%u",
63 __entry->thread, __get_str(name), __entry->nr)
66 DECLARE_EVENT_CLASS(syscall_exit,
67 TP_PROTO(
struct xnthread *thread,
long result),
68 TP_ARGS(thread, result),
71 __field(
struct xnthread *, thread)
76 __entry->thread = thread;
77 __entry->result = result;
80 TP_printk(
"thread=%p result=%ld",
81 __entry->thread, __entry->result)
84 #define cobalt_print_sched_policy(__policy) \
85 __print_symbolic(__policy, \
86 {SCHED_NORMAL, "normal"}, \
87 {SCHED_FIFO, "fifo"}, \
90 {SCHED_QUOTA, "quota"}, \
91 {SCHED_SPORADIC, "sporadic"}, \
92 {SCHED_COBALT, "cobalt"}, \
95 #define cobalt_print_sched_params(__policy, __p_ex) \
97 const unsigned char *__ret = trace_seq_buffer_ptr(p); \
100 trace_seq_printf(p, "priority=%d, group=%d", \
101 (__p_ex)->sched_priority, \
102 (__p_ex)->sched_quota_group); \
105 trace_seq_printf(p, "priority=%d, partition=%d", \
106 (__p_ex)->sched_priority, \
107 (__p_ex)->sched_tp_partition); \
111 case SCHED_SPORADIC: \
112 trace_seq_printf(p, "priority=%d, low_priority=%d, " \
113 "budget=(%ld.%09ld), period=(%ld.%09ld), "\
115 (__p_ex)->sched_priority, \
116 (__p_ex)->sched_ss_low_priority, \
117 (__p_ex)->sched_ss_init_budget.tv_sec, \
118 (__p_ex)->sched_ss_init_budget.tv_nsec, \
119 (__p_ex)->sched_ss_repl_period.tv_sec, \
120 (__p_ex)->sched_ss_repl_period.tv_nsec, \
121 (__p_ex)->sched_ss_max_repl); \
128 trace_seq_printf(p, "priority=%d", \
129 (__p_ex)->sched_priority); \
132 trace_seq_putc(p, '\0'); \
136 DECLARE_EVENT_CLASS(cobalt_posix_schedparam,
137 TP_PROTO(
unsigned long pth,
int policy,
138 const struct sched_param_ex *param_ex),
139 TP_ARGS(pth, policy, param_ex),
142 __field(
unsigned long, pth)
144 __dynamic_array(
char, param_ex,
sizeof(
struct sched_param_ex))
149 __entry->policy = policy;
150 memcpy(__get_dynamic_array(param_ex), param_ex,
sizeof(*param_ex));
153 TP_printk(
"pth=%p policy=%d(%s) param={ %s }",
154 (
void *)__entry->pth, __entry->policy,
155 cobalt_print_sched_policy(__entry->policy),
156 cobalt_print_sched_params(__entry->policy,
157 (
struct sched_param_ex *)
158 __get_dynamic_array(param_ex))
162 DECLARE_EVENT_CLASS(cobalt_posix_scheduler,
163 TP_PROTO(pid_t pid,
int policy,
164 const struct sched_param_ex *param_ex),
165 TP_ARGS(pid, policy, param_ex),
170 __dynamic_array(
char, param_ex,
sizeof(
struct sched_param_ex))
175 __entry->policy = policy;
176 memcpy(__get_dynamic_array(param_ex), param_ex,
sizeof(*param_ex));
179 TP_printk(
"pid=%d policy=%d(%s) param={ %s }",
180 __entry->pid, __entry->policy,
181 cobalt_print_sched_policy(__entry->policy),
182 cobalt_print_sched_params(__entry->policy,
183 (
struct sched_param_ex *)
184 __get_dynamic_array(param_ex))
188 DECLARE_EVENT_CLASS(cobalt_void,
192 __array(
char, dummy, 0)
200 DEFINE_EVENT(syscall_entry, cobalt_head_sysentry,
201 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
205 DEFINE_EVENT(syscall_exit, cobalt_head_sysexit,
206 TP_PROTO(
struct xnthread *thread,
long result),
207 TP_ARGS(thread, result)
210 DEFINE_EVENT(syscall_entry, cobalt_root_sysentry,
211 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
215 DEFINE_EVENT(syscall_exit, cobalt_root_sysexit,
216 TP_PROTO(
struct xnthread *thread,
long result),
217 TP_ARGS(thread, result)
220 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_create,
221 TP_PROTO(
unsigned long pth,
int policy,
222 const struct sched_param_ex *param_ex),
223 TP_ARGS(pth, policy, param_ex)
226 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_setschedparam,
227 TP_PROTO(
unsigned long pth,
int policy,
228 const struct sched_param_ex *param_ex),
229 TP_ARGS(pth, policy, param_ex)
232 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_getschedparam,
233 TP_PROTO(
unsigned long pth,
int policy,
234 const struct sched_param_ex *param_ex),
235 TP_ARGS(pth, policy, param_ex)
238 #define cobalt_print_thread_mode(__mode) \
239 __print_flags(__mode, "|", \
240 {PTHREAD_WARNSW, "warnsw"}, \
241 {PTHREAD_LOCK_SCHED, "lock"}, \
242 {PTHREAD_DISABLE_LOCKBREAK, "nolockbreak"})
244 TRACE_EVENT(cobalt_pthread_setmode,
245 TP_PROTO(
int clrmask,
int setmask),
246 TP_ARGS(clrmask, setmask),
248 __field(
int, clrmask)
249 __field(
int, setmask)
252 __entry->clrmask = clrmask;
253 __entry->setmask = setmask;
255 TP_printk(
"clrmask=%#x(%s) setmask=%#x(%s)",
256 __entry->clrmask, cobalt_print_thread_mode(__entry->clrmask),
257 __entry->setmask, cobalt_print_thread_mode(__entry->setmask))
260 TRACE_EVENT(cobalt_pthread_setname,
261 TP_PROTO(
unsigned long pth,
const char *name),
264 __field(
unsigned long, pth)
269 __assign_str(name, name);
271 TP_printk(
"pth=%p name=%s", (
void *)__entry->pth, __get_str(name))
274 DECLARE_EVENT_CLASS(cobalt_posix_pid,
283 TP_printk(
"pid=%d", __entry->pid)
286 DEFINE_EVENT(cobalt_posix_pid, cobalt_pthread_stat,
291 TRACE_EVENT(cobalt_pthread_kill,
292 TP_PROTO(
unsigned long pth,
int sig),
295 __field(
unsigned long, pth)
302 TP_printk(
"pth=%p sig=%d", (
void *)__entry->pth, __entry->sig)
305 TRACE_EVENT(cobalt_pthread_join,
306 TP_PROTO(
unsigned long pth),
309 __field(
unsigned long, pth)
314 TP_printk(
"pth=%p", (
void *)__entry->pth)
317 TRACE_EVENT(cobalt_pthread_pid,
318 TP_PROTO(
unsigned long pth),
321 __field(
unsigned long, pth)
326 TP_printk(
"pth=%p", (
void *)__entry->pth)
329 TRACE_EVENT(cobalt_pthread_extend,
330 TP_PROTO(
unsigned long pth,
const char *name),
333 __field(
unsigned long, pth)
338 __assign_str(name, name);
340 TP_printk(
"pth=%p +personality=%s", (
void *)__entry->pth, __get_str(name))
343 TRACE_EVENT(cobalt_pthread_restrict,
344 TP_PROTO(
unsigned long pth,
const char *name),
347 __field(
unsigned long, pth)
352 __assign_str(name, name);
354 TP_printk(
"pth=%p -personality=%s", (
void *)__entry->pth, __get_str(name))
357 DEFINE_EVENT(cobalt_void, cobalt_pthread_yield,
362 TRACE_EVENT(cobalt_sched_setconfig,
363 TP_PROTO(
int cpu,
int policy,
size_t len),
364 TP_ARGS(cpu, policy, len),
372 __entry->policy = policy;
375 TP_printk(
"cpu=%d policy=%d(%s) len=%Zu",
376 __entry->cpu, __entry->policy,
377 cobalt_print_sched_policy(__entry->policy),
381 TRACE_EVENT(cobalt_sched_get_config,
382 TP_PROTO(
int cpu,
int policy,
size_t rlen),
383 TP_ARGS(cpu, policy, rlen),
387 __field(ssize_t, rlen)
391 __entry->policy = policy;
392 __entry->rlen = rlen;
394 TP_printk(
"cpu=%d policy=%d(%s) rlen=%Zd",
395 __entry->cpu, __entry->policy,
396 cobalt_print_sched_policy(__entry->policy),
400 DEFINE_EVENT(cobalt_posix_scheduler, cobalt_sched_setscheduler,
401 TP_PROTO(pid_t pid,
int policy,
402 const struct sched_param_ex *param_ex),
403 TP_ARGS(pid, policy, param_ex)
406 DEFINE_EVENT(cobalt_posix_pid, cobalt_sched_getscheduler,
411 DECLARE_EVENT_CLASS(cobalt_posix_prio_bound,
412 TP_PROTO(
int policy,
int prio),
413 TP_ARGS(policy, prio),
419 __entry->policy = policy;
420 __entry->prio = prio;
422 TP_printk(
"policy=%d(%s) prio=%d",
424 cobalt_print_sched_policy(__entry->policy),
428 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_min_prio,
429 TP_PROTO(
int policy,
int prio),
430 TP_ARGS(policy, prio)
433 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_max_prio,
434 TP_PROTO(
int policy,
int prio),
435 TP_ARGS(policy, prio)
438 DECLARE_EVENT_CLASS(cobalt_posix_sem,
439 TP_PROTO(xnhandle_t handle),
442 __field(xnhandle_t, handle)
445 __entry->handle = handle;
447 TP_printk(
"sem=%#x", __entry->handle)
450 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_wait,
451 TP_PROTO(xnhandle_t handle),
455 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_trywait,
456 TP_PROTO(xnhandle_t handle),
460 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_timedwait,
461 TP_PROTO(xnhandle_t handle),
465 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_post,
466 TP_PROTO(xnhandle_t handle),
470 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_destroy,
471 TP_PROTO(xnhandle_t handle),
475 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_broadcast,
476 TP_PROTO(xnhandle_t handle),
480 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_inquire,
481 TP_PROTO(xnhandle_t handle),
485 TRACE_EVENT(cobalt_psem_getvalue,
486 TP_PROTO(xnhandle_t handle,
int value),
487 TP_ARGS(handle, value),
489 __field(xnhandle_t, handle)
493 __entry->handle = handle;
494 __entry->value = value;
496 TP_printk(
"sem=%#x value=%d", __entry->handle, __entry->value)
499 #define cobalt_print_sem_flags(__flags) \
500 __print_flags(__flags, "|", \
501 {SEM_FIFO, "fifo"}, \
502 {SEM_PULSE, "pulse"}, \
503 {SEM_PSHARED, "pshared"}, \
504 {SEM_REPORT, "report"}, \
505 {SEM_WARNDEL, "warndel"}, \
506 {SEM_RAWCLOCK, "rawclock"}, \
507 {SEM_NOBUSYDEL, "nobusydel"})
509 TRACE_EVENT(cobalt_psem_init,
510 TP_PROTO(
const char *name, xnhandle_t handle,
511 int flags,
unsigned int value),
512 TP_ARGS(name, handle, flags, value),
515 __field(xnhandle_t, handle)
517 __field(
unsigned int, value)
520 __assign_str(name, name);
521 __entry->handle = handle;
522 __entry->flags = flags;
523 __entry->value = value;
525 TP_printk(
"sem=%#x(%s) flags=%#x(%s) value=%u",
529 cobalt_print_sem_flags(__entry->flags),
533 TRACE_EVENT(cobalt_psem_init_failed,
534 TP_PROTO(
const char *name,
int flags,
unsigned int value,
int status),
535 TP_ARGS(name, flags, value, status),
539 __field(
unsigned int, value)
543 __assign_str(name, name);
544 __entry->flags = flags;
545 __entry->value = value;
546 __entry->status = status;
548 TP_printk(
"name=%s flags=%#x(%s) value=%u error=%d",
551 cobalt_print_sem_flags(__entry->flags),
552 __entry->value, __entry->status)
555 #define cobalt_print_oflags(__flags) \
556 __print_flags(__flags, "|", \
557 {O_RDONLY, "rdonly"}, \
558 {O_WRONLY, "wronly"}, \
560 {O_CREAT, "creat"}, \
562 {O_DIRECT, "direct"}, \
563 {O_NONBLOCK, "nonblock"}, \
566 TRACE_EVENT(cobalt_psem_open,
567 TP_PROTO(
const char *name, xnhandle_t handle,
568 int oflags, mode_t mode,
unsigned int value),
569 TP_ARGS(name, handle, oflags, mode, value),
572 __field(xnhandle_t, handle)
574 __field(mode_t, mode)
575 __field(
unsigned int, value)
578 __assign_str(name, name);
579 __entry->handle = handle;
580 __entry->oflags = oflags;
581 if (oflags & O_CREAT) {
582 __entry->mode = mode;
583 __entry->value = value;
589 TP_printk(
"named_sem=%#x=(%s) oflags=%#x(%s) mode=%o value=%u",
590 __entry->handle, __get_str(name),
591 __entry->oflags, cobalt_print_oflags(__entry->oflags),
592 __entry->mode, __entry->value)
595 TRACE_EVENT(cobalt_psem_open_failed,
596 TP_PROTO(
const char *name,
int oflags, mode_t mode,
597 unsigned int value,
int status),
598 TP_ARGS(name, oflags, mode, value, status),
602 __field(mode_t, mode)
603 __field(
unsigned int, value)
607 __assign_str(name, name);
608 __entry->oflags = oflags;
609 __entry->status = status;
610 if (oflags & O_CREAT) {
611 __entry->mode = mode;
612 __entry->value = value;
618 TP_printk(
"named_sem=%s oflags=%#x(%s) mode=%o value=%u error=%d",
620 __entry->oflags, cobalt_print_oflags(__entry->oflags),
621 __entry->mode, __entry->value, __entry->status)
624 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_close,
625 TP_PROTO(xnhandle_t handle),
629 TRACE_EVENT(cobalt_psem_unlink,
630 TP_PROTO(
const char *name),
636 __assign_str(name, name);
638 TP_printk(
"name=%s", __get_str(name))
641 DECLARE_EVENT_CLASS(cobalt_clock_timespec,
642 TP_PROTO(clockid_t clk_id,
const struct timespec *val),
643 TP_ARGS(clk_id, val),
646 __field(clockid_t, clk_id)
647 __timespec_fields(val)
651 __entry->clk_id = clk_id;
652 __assign_timespec(val, val);
655 TP_printk(
"clock_id=%d timeval=(%ld.%09ld)",
661 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_getres,
662 TP_PROTO(clockid_t clk_id,
const struct timespec *res),
666 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_gettime,
667 TP_PROTO(clockid_t clk_id,
const struct timespec *time),
668 TP_ARGS(clk_id, time)
671 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_settime,
672 TP_PROTO(clockid_t clk_id,
const struct timespec *time),
673 TP_ARGS(clk_id, time)
676 #define cobalt_print_timer_flags(__flags) \
677 __print_flags(__flags, "|", \
678 {TIMER_ABSTIME, "TIMER_ABSTIME"})
680 TRACE_EVENT(cobalt_clock_nanosleep,
681 TP_PROTO(clockid_t clk_id,
int flags,
const struct timespec *time),
682 TP_ARGS(clk_id, flags, time),
685 __field(clockid_t, clk_id)
687 __timespec_fields(time)
691 __entry->clk_id = clk_id;
692 __entry->flags = flags;
693 __assign_timespec(time, time);
696 TP_printk(
"clock_id=%d flags=%#x(%s) rqt=(%ld.%09ld)",
698 __entry->flags, cobalt_print_timer_flags(__entry->flags),
699 __timespec_args(time)
703 DECLARE_EVENT_CLASS(cobalt_clock_ident,
704 TP_PROTO(
const char *name, clockid_t clk_id),
705 TP_ARGS(name, clk_id),
708 __field(clockid_t, clk_id)
711 __assign_str(name, name);
712 __entry->clk_id = clk_id;
714 TP_printk(
"name=%s, id=%#x", __get_str(name), __entry->clk_id)
717 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_register,
718 TP_PROTO(
const char *name, clockid_t clk_id),
719 TP_ARGS(name, clk_id)
722 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_deregister,
723 TP_PROTO(
const char *name, clockid_t clk_id),
724 TP_ARGS(name, clk_id)
727 #define cobalt_print_clock(__clk_id) \
728 __print_symbolic(__clk_id, \
729 {CLOCK_MONOTONIC, "CLOCK_MONOTONIC"}, \
730 {CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW"}, \
731 {CLOCK_REALTIME, "CLOCK_REALTIME"})
733 TRACE_EVENT(cobalt_cond_init,
734 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
735 const struct cobalt_condattr *attr),
736 TP_ARGS(u_cnd, attr),
738 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
739 __field(clockid_t, clk_id)
740 __field(
int, pshared)
743 __entry->u_cnd = u_cnd;
744 __entry->clk_id = attr->clock;
745 __entry->pshared = attr->pshared;
747 TP_printk(
"cond=%p attr={ .clock=%s, .pshared=%d }",
749 cobalt_print_clock(__entry->clk_id),
753 TRACE_EVENT(cobalt_cond_destroy,
754 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd),
757 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
760 __entry->u_cnd = u_cnd;
762 TP_printk(
"cond=%p", __entry->u_cnd)
765 TRACE_EVENT(cobalt_cond_timedwait,
766 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
767 const struct cobalt_mutex_shadow __user *u_mx,
768 const struct timespec *timeout),
769 TP_ARGS(u_cnd, u_mx, timeout),
771 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
772 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
773 __timespec_fields(timeout)
776 __entry->u_cnd = u_cnd;
777 __entry->u_mx = u_mx;
778 __assign_timespec(timeout, timeout);
780 TP_printk(
"cond=%p, mutex=%p, timeout=(%ld.%09ld)",
781 __entry->u_cnd, __entry->u_mx, __timespec_args(timeout))
784 TRACE_EVENT(cobalt_cond_wait,
785 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
786 const struct cobalt_mutex_shadow __user *u_mx),
787 TP_ARGS(u_cnd, u_mx),
789 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
790 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
793 __entry->u_cnd = u_cnd;
794 __entry->u_mx = u_mx;
796 TP_printk(
"cond=%p, mutex=%p",
797 __entry->u_cnd, __entry->u_mx)
800 TRACE_EVENT(cobalt_mq_open,
801 TP_PROTO(
const char *name,
int oflags, mode_t mode),
802 TP_ARGS(name, oflags, mode),
807 __field(mode_t, mode)
811 __assign_str(name, name);
812 __entry->oflags = oflags;
813 __entry->mode = (oflags & O_CREAT) ? mode : 0;
816 TP_printk(
"name=%s oflags=%#x(%s) mode=%o",
818 __entry->oflags, cobalt_print_oflags(__entry->oflags),
822 TRACE_EVENT(cobalt_mq_notify,
823 TP_PROTO(mqd_t mqd,
const struct sigevent *sev),
833 __entry->signo = sev && sev->sigev_notify != SIGEV_NONE ?
834 sev->sigev_signo : 0;
837 TP_printk(
"mqd=%d signo=%d",
838 __entry->mqd, __entry->signo)
841 TRACE_EVENT(cobalt_mq_close,
853 TP_printk(
"mqd=%d", __entry->mqd)
856 TRACE_EVENT(cobalt_mq_unlink,
857 TP_PROTO(
const char *name),
865 __assign_str(name, name);
868 TP_printk(
"name=%s", __get_str(name))
871 TRACE_EVENT(cobalt_mq_send,
872 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
874 TP_ARGS(mqd, u_buf, len, prio),
877 __field(
const void __user *, u_buf)
879 __field(
unsigned int, prio)
883 __entry->u_buf = u_buf;
885 __entry->prio = prio;
887 TP_printk(
"mqd=%d buf=%p len=%Zu prio=%u",
888 __entry->mqd, __entry->u_buf, __entry->len,
892 TRACE_EVENT(cobalt_mq_timedreceive,
893 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
894 const struct timespec *timeout),
895 TP_ARGS(mqd, u_buf, len, timeout),
898 __field(
const void __user *, u_buf)
900 __timespec_fields(timeout)
904 __entry->u_buf = u_buf;
906 __assign_timespec(timeout, timeout);
908 TP_printk(
"mqd=%d buf=%p len=%Zu timeout=(%ld.%09ld)",
909 __entry->mqd, __entry->u_buf, __entry->len,
910 __timespec_args(timeout))
913 TRACE_EVENT(cobalt_mq_receive,
914 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len),
915 TP_ARGS(mqd, u_buf, len),
918 __field(
const void __user *, u_buf)
923 __entry->u_buf = u_buf;
926 TP_printk(
"mqd=%d buf=%p len=%Zu",
927 __entry->mqd, __entry->u_buf, __entry->len)
930 DECLARE_EVENT_CLASS(cobalt_posix_mqattr,
931 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
936 __field(
long, curmsgs)
937 __field(
long, msgsize)
938 __field(
long, maxmsg)
942 __entry->flags = attr->mq_flags;
943 __entry->curmsgs = attr->mq_curmsgs;
944 __entry->msgsize = attr->mq_msgsize;
945 __entry->maxmsg = attr->mq_maxmsg;
947 TP_printk(
"mqd=%d flags=%#lx(%s) curmsgs=%ld msgsize=%ld maxmsg=%ld",
949 __entry->flags, cobalt_print_oflags(__entry->flags),
956 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_getattr,
957 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
961 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_setattr,
962 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
966 #define cobalt_print_evflags(__flags) \
967 __print_flags(__flags, "|", \
968 {COBALT_EVENT_SHARED, "shared"}, \
969 {COBALT_EVENT_PRIO, "prio"})
971 TRACE_EVENT(cobalt_event_init,
972 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
973 unsigned long value,
int flags),
974 TP_ARGS(u_event, value, flags),
976 __field(
const struct cobalt_event_shadow __user *, u_event)
977 __field(
unsigned long, value)
981 __entry->u_event = u_event;
982 __entry->value = value;
983 __entry->flags = flags;
985 TP_printk(
"event=%p value=%lu flags=%#x(%s)",
986 __entry->u_event, __entry->value,
987 __entry->flags, cobalt_print_evflags(__entry->flags))
990 #define cobalt_print_evmode(__mode) \
991 __print_symbolic(__mode, \
992 {COBALT_EVENT_ANY, "any"}, \
993 {COBALT_EVENT_ALL, "all"})
995 TRACE_EVENT(cobalt_event_timedwait,
996 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
997 unsigned long bits,
int mode,
998 const struct timespec *timeout),
999 TP_ARGS(u_event, bits, mode, timeout),
1001 __field(
const struct cobalt_event_shadow __user *, u_event)
1002 __field(
unsigned long, bits)
1004 __timespec_fields(timeout)
1007 __entry->u_event = u_event;
1008 __entry->bits = bits;
1009 __entry->mode = mode;
1010 __assign_timespec(timeout, timeout);
1012 TP_printk(
"event=%p bits=%#lx mode=%#x(%s) timeout=(%ld.%09ld)",
1013 __entry->u_event, __entry->bits, __entry->mode,
1014 cobalt_print_evmode(__entry->mode),
1015 __timespec_args(timeout))
1018 TRACE_EVENT(cobalt_event_wait,
1019 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
1020 unsigned long bits,
int mode),
1021 TP_ARGS(u_event, bits, mode),
1023 __field(
const struct cobalt_event_shadow __user *, u_event)
1024 __field(
unsigned long, bits)
1028 __entry->u_event = u_event;
1029 __entry->bits = bits;
1030 __entry->mode = mode;
1032 TP_printk(
"event=%p bits=%#lx mode=%#x(%s)",
1033 __entry->u_event, __entry->bits, __entry->mode,
1034 cobalt_print_evmode(__entry->mode))
1037 DECLARE_EVENT_CLASS(cobalt_event_ident,
1038 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1041 __field(
const struct cobalt_event_shadow __user *, u_event)
1044 __entry->u_event = u_event;
1046 TP_printk(
"event=%p", __entry->u_event)
1049 DEFINE_EVENT(cobalt_event_ident, cobalt_event_destroy,
1050 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1054 DEFINE_EVENT(cobalt_event_ident, cobalt_event_sync,
1055 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1059 DEFINE_EVENT(cobalt_event_ident, cobalt_event_inquire,
1060 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1067 #include <trace/define_trace.h>