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); \
135 DECLARE_EVENT_CLASS(cobalt_posix_schedparam,
136 TP_PROTO(
unsigned long pth,
int policy,
137 const struct sched_param_ex *param_ex),
138 TP_ARGS(pth, policy, param_ex),
141 __field(
unsigned long, pth)
143 __dynamic_array(
char, param_ex,
sizeof(
struct sched_param_ex))
148 __entry->policy = policy;
149 memcpy(__get_dynamic_array(param_ex), param_ex,
sizeof(*param_ex));
152 TP_printk(
"pth=%p policy=%d(%s) param={ %s }",
153 (
void *)__entry->pth, __entry->policy,
154 cobalt_print_sched_policy(__entry->policy),
155 cobalt_print_sched_params(__entry->policy,
156 (
struct sched_param_ex *)
157 __get_dynamic_array(param_ex))
161 DECLARE_EVENT_CLASS(cobalt_posix_scheduler,
162 TP_PROTO(pid_t pid,
int policy,
163 const struct sched_param_ex *param_ex),
164 TP_ARGS(pid, policy, param_ex),
169 __dynamic_array(
char, param_ex,
sizeof(
struct sched_param_ex))
174 __entry->policy = policy;
175 memcpy(__get_dynamic_array(param_ex), param_ex,
sizeof(*param_ex));
178 TP_printk(
"pid=%d policy=%d(%s) param={ %s }",
179 __entry->pid, __entry->policy,
180 cobalt_print_sched_policy(__entry->policy),
181 cobalt_print_sched_params(__entry->policy,
182 (
struct sched_param_ex *)
183 __get_dynamic_array(param_ex))
187 DECLARE_EVENT_CLASS(cobalt_void,
191 __array(
char, dummy, 0)
199 DEFINE_EVENT(syscall_entry, cobalt_head_sysentry,
200 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
204 DEFINE_EVENT(syscall_exit, cobalt_head_sysexit,
205 TP_PROTO(
struct xnthread *thread,
long result),
206 TP_ARGS(thread, result)
209 DEFINE_EVENT(syscall_entry, cobalt_root_sysentry,
210 TP_PROTO(
struct xnthread *thread,
unsigned int nr),
214 DEFINE_EVENT(syscall_exit, cobalt_root_sysexit,
215 TP_PROTO(
struct xnthread *thread,
long result),
216 TP_ARGS(thread, result)
219 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_create,
220 TP_PROTO(
unsigned long pth,
int policy,
221 const struct sched_param_ex *param_ex),
222 TP_ARGS(pth, policy, param_ex)
225 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_setschedparam,
226 TP_PROTO(
unsigned long pth,
int policy,
227 const struct sched_param_ex *param_ex),
228 TP_ARGS(pth, policy, param_ex)
231 DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_getschedparam,
232 TP_PROTO(
unsigned long pth,
int policy,
233 const struct sched_param_ex *param_ex),
234 TP_ARGS(pth, policy, param_ex)
237 #define cobalt_print_thread_mode(__mode) \
238 __print_flags(__mode, "|", \
239 {PTHREAD_WARNSW, "warnsw"}, \
240 {PTHREAD_LOCK_SCHED, "lock"}, \
241 {PTHREAD_DISABLE_LOCKBREAK, "nolockbreak"})
243 TRACE_EVENT(cobalt_pthread_setmode,
244 TP_PROTO(
int clrmask,
int setmask),
245 TP_ARGS(clrmask, setmask),
247 __field(
int, clrmask)
248 __field(
int, setmask)
251 __entry->clrmask = clrmask;
252 __entry->setmask = setmask;
254 TP_printk(
"clrmask=%#x(%s) setmask=%#x(%s)",
255 __entry->clrmask, cobalt_print_thread_mode(__entry->clrmask),
256 __entry->setmask, cobalt_print_thread_mode(__entry->setmask))
259 TRACE_EVENT(cobalt_pthread_setname,
260 TP_PROTO(
unsigned long pth,
const char *name),
263 __field(
unsigned long, pth)
268 __assign_str(name, name);
270 TP_printk(
"pth=%p name=%s", (
void *)__entry->pth, __get_str(name))
273 DECLARE_EVENT_CLASS(cobalt_posix_pid,
282 TP_printk(
"pid=%d", __entry->pid)
285 DEFINE_EVENT(cobalt_posix_pid, cobalt_pthread_stat,
290 TRACE_EVENT(cobalt_pthread_kill,
291 TP_PROTO(
unsigned long pth,
int sig),
294 __field(
unsigned long, pth)
301 TP_printk(
"pth=%p sig=%d", (
void *)__entry->pth, __entry->sig)
304 TRACE_EVENT(cobalt_pthread_join,
305 TP_PROTO(
unsigned long pth),
308 __field(
unsigned long, pth)
313 TP_printk(
"pth=%p", (
void *)__entry->pth)
316 TRACE_EVENT(cobalt_pthread_pid,
317 TP_PROTO(
unsigned long pth),
320 __field(
unsigned long, pth)
325 TP_printk(
"pth=%p", (
void *)__entry->pth)
328 TRACE_EVENT(cobalt_pthread_extend,
329 TP_PROTO(
unsigned long pth,
const char *name),
332 __field(
unsigned long, pth)
337 __assign_str(name, name);
339 TP_printk(
"pth=%p +personality=%s", (
void *)__entry->pth, __get_str(name))
342 TRACE_EVENT(cobalt_pthread_restrict,
343 TP_PROTO(
unsigned long pth,
const char *name),
346 __field(
unsigned long, pth)
351 __assign_str(name, name);
353 TP_printk(
"pth=%p -personality=%s", (
void *)__entry->pth, __get_str(name))
356 DEFINE_EVENT(cobalt_void, cobalt_pthread_yield,
361 TRACE_EVENT(cobalt_sched_setconfig,
362 TP_PROTO(
int cpu,
int policy,
size_t len),
363 TP_ARGS(cpu, policy, len),
371 __entry->policy = policy;
374 TP_printk(
"cpu=%d policy=%d(%s) len=%Zu",
375 __entry->cpu, __entry->policy,
376 cobalt_print_sched_policy(__entry->policy),
380 TRACE_EVENT(cobalt_sched_get_config,
381 TP_PROTO(
int cpu,
int policy,
size_t rlen),
382 TP_ARGS(cpu, policy, rlen),
386 __field(ssize_t, rlen)
390 __entry->policy = policy;
391 __entry->rlen = rlen;
393 TP_printk(
"cpu=%d policy=%d(%s) rlen=%Zd",
394 __entry->cpu, __entry->policy,
395 cobalt_print_sched_policy(__entry->policy),
399 DEFINE_EVENT(cobalt_posix_scheduler, cobalt_sched_setscheduler,
400 TP_PROTO(pid_t pid,
int policy,
401 const struct sched_param_ex *param_ex),
402 TP_ARGS(pid, policy, param_ex)
405 DEFINE_EVENT(cobalt_posix_pid, cobalt_sched_getscheduler,
410 DECLARE_EVENT_CLASS(cobalt_posix_prio_bound,
411 TP_PROTO(
int policy,
int prio),
412 TP_ARGS(policy, prio),
418 __entry->policy = policy;
419 __entry->prio = prio;
421 TP_printk(
"policy=%d(%s) prio=%d",
423 cobalt_print_sched_policy(__entry->policy),
427 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_min_prio,
428 TP_PROTO(
int policy,
int prio),
429 TP_ARGS(policy, prio)
432 DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_max_prio,
433 TP_PROTO(
int policy,
int prio),
434 TP_ARGS(policy, prio)
437 DECLARE_EVENT_CLASS(cobalt_posix_sem,
438 TP_PROTO(xnhandle_t handle),
441 __field(xnhandle_t, handle)
444 __entry->handle = handle;
446 TP_printk(
"sem=%#x", __entry->handle)
449 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_wait,
450 TP_PROTO(xnhandle_t handle),
454 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_trywait,
455 TP_PROTO(xnhandle_t handle),
459 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_timedwait,
460 TP_PROTO(xnhandle_t handle),
464 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_post,
465 TP_PROTO(xnhandle_t handle),
469 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_destroy,
470 TP_PROTO(xnhandle_t handle),
474 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_broadcast,
475 TP_PROTO(xnhandle_t handle),
479 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_inquire,
480 TP_PROTO(xnhandle_t handle),
484 TRACE_EVENT(cobalt_psem_getvalue,
485 TP_PROTO(xnhandle_t handle,
int value),
486 TP_ARGS(handle, value),
488 __field(xnhandle_t, handle)
492 __entry->handle = handle;
493 __entry->value = value;
495 TP_printk(
"sem=%#x value=%d", __entry->handle, __entry->value)
498 #define cobalt_print_sem_flags(__flags) \
499 __print_flags(__flags, "|", \
500 {SEM_FIFO, "fifo"}, \
501 {SEM_PULSE, "pulse"}, \
502 {SEM_PSHARED, "pshared"}, \
503 {SEM_REPORT, "report"}, \
504 {SEM_WARNDEL, "warndel"}, \
505 {SEM_RAWCLOCK, "rawclock"}, \
506 {SEM_NOBUSYDEL, "nobusydel"})
508 TRACE_EVENT(cobalt_psem_init,
509 TP_PROTO(
const char *name, xnhandle_t handle,
510 int flags,
unsigned int value),
511 TP_ARGS(name, handle, flags, value),
514 __field(xnhandle_t, handle)
516 __field(
unsigned int, value)
519 __assign_str(name, name);
520 __entry->handle = handle;
521 __entry->flags = flags;
522 __entry->value = value;
524 TP_printk(
"sem=%#x(%s) flags=%#x(%s) value=%u",
528 cobalt_print_sem_flags(__entry->flags),
532 TRACE_EVENT(cobalt_psem_init_failed,
533 TP_PROTO(
const char *name,
int flags,
unsigned int value,
int status),
534 TP_ARGS(name, flags, value, status),
538 __field(
unsigned int, value)
542 __assign_str(name, name);
543 __entry->flags = flags;
544 __entry->value = value;
545 __entry->status = status;
547 TP_printk(
"name=%s flags=%#x(%s) value=%u error=%d",
550 cobalt_print_sem_flags(__entry->flags),
551 __entry->value, __entry->status)
554 #define cobalt_print_oflags(__flags) \
555 __print_flags(__flags, "|", \
556 {O_RDONLY, "rdonly"}, \
557 {O_WRONLY, "wronly"}, \
559 {O_CREAT, "creat"}, \
561 {O_DIRECT, "direct"}, \
562 {O_NONBLOCK, "nonblock"}, \
565 TRACE_EVENT(cobalt_psem_open,
566 TP_PROTO(
const char *name, xnhandle_t handle,
567 int oflags, mode_t mode,
unsigned int value),
568 TP_ARGS(name, handle, oflags, mode, value),
571 __field(xnhandle_t, handle)
573 __field(mode_t, mode)
574 __field(
unsigned int, value)
577 __assign_str(name, name);
578 __entry->handle = handle;
579 __entry->oflags = oflags;
580 if (oflags & O_CREAT) {
581 __entry->mode = mode;
582 __entry->value = value;
588 TP_printk(
"named_sem=%#x=(%s) oflags=%#x(%s) mode=%o value=%u",
589 __entry->handle, __get_str(name),
590 __entry->oflags, cobalt_print_oflags(__entry->oflags),
591 __entry->mode, __entry->value)
594 TRACE_EVENT(cobalt_psem_open_failed,
595 TP_PROTO(
const char *name,
int oflags, mode_t mode,
596 unsigned int value,
int status),
597 TP_ARGS(name, oflags, mode, value, status),
601 __field(mode_t, mode)
602 __field(
unsigned int, value)
606 __assign_str(name, name);
607 __entry->oflags = oflags;
608 __entry->status = status;
609 if (oflags & O_CREAT) {
610 __entry->mode = mode;
611 __entry->value = value;
617 TP_printk(
"named_sem=%s oflags=%#x(%s) mode=%o value=%u error=%d",
619 __entry->oflags, cobalt_print_oflags(__entry->oflags),
620 __entry->mode, __entry->value, __entry->status)
623 DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_close,
624 TP_PROTO(xnhandle_t handle),
628 TRACE_EVENT(cobalt_psem_unlink,
629 TP_PROTO(
const char *name),
635 __assign_str(name, name);
637 TP_printk(
"name=%s", __get_str(name))
640 DECLARE_EVENT_CLASS(cobalt_clock_timespec,
641 TP_PROTO(clockid_t clk_id,
const struct timespec *val),
642 TP_ARGS(clk_id, val),
645 __field(clockid_t, clk_id)
646 __timespec_fields(val)
650 __entry->clk_id = clk_id;
651 __assign_timespec(val, val);
654 TP_printk(
"clock_id=%d timeval=(%ld.%09ld)",
660 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_getres,
661 TP_PROTO(clockid_t clk_id,
const struct timespec *res),
665 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_gettime,
666 TP_PROTO(clockid_t clk_id,
const struct timespec *time),
667 TP_ARGS(clk_id, time)
670 DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_settime,
671 TP_PROTO(clockid_t clk_id,
const struct timespec *time),
672 TP_ARGS(clk_id, time)
675 #define cobalt_print_timer_flags(__flags) \
676 __print_flags(__flags, "|", \
677 {TIMER_ABSTIME, "TIMER_ABSTIME"})
679 TRACE_EVENT(cobalt_clock_nanosleep,
680 TP_PROTO(clockid_t clk_id,
int flags,
const struct timespec *time),
681 TP_ARGS(clk_id, flags, time),
684 __field(clockid_t, clk_id)
686 __timespec_fields(time)
690 __entry->clk_id = clk_id;
691 __entry->flags = flags;
692 __assign_timespec(time, time);
695 TP_printk(
"clock_id=%d flags=%#x(%s) rqt=(%ld.%09ld)",
697 __entry->flags, cobalt_print_timer_flags(__entry->flags),
698 __timespec_args(time)
702 DECLARE_EVENT_CLASS(cobalt_clock_ident,
703 TP_PROTO(
const char *name, clockid_t clk_id),
704 TP_ARGS(name, clk_id),
707 __field(clockid_t, clk_id)
710 __assign_str(name, name);
711 __entry->clk_id = clk_id;
713 TP_printk(
"name=%s, id=%#x", __get_str(name), __entry->clk_id)
716 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_register,
717 TP_PROTO(
const char *name, clockid_t clk_id),
718 TP_ARGS(name, clk_id)
721 DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_deregister,
722 TP_PROTO(
const char *name, clockid_t clk_id),
723 TP_ARGS(name, clk_id)
726 #define cobalt_print_clock(__clk_id) \
727 __print_symbolic(__clk_id, \
728 {CLOCK_MONOTONIC, "CLOCK_MONOTONIC"}, \
729 {CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW"}, \
730 {CLOCK_REALTIME, "CLOCK_REALTIME"})
732 TRACE_EVENT(cobalt_cond_init,
733 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
734 const struct cobalt_condattr *attr),
735 TP_ARGS(u_cnd, attr),
737 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
738 __field(clockid_t, clk_id)
739 __field(
int, pshared)
742 __entry->u_cnd = u_cnd;
743 __entry->clk_id = attr->clock;
744 __entry->pshared = attr->pshared;
746 TP_printk(
"cond=%p attr={ .clock=%s, .pshared=%d }",
748 cobalt_print_clock(__entry->clk_id),
752 TRACE_EVENT(cobalt_cond_destroy,
753 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd),
756 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
759 __entry->u_cnd = u_cnd;
761 TP_printk(
"cond=%p", __entry->u_cnd)
764 TRACE_EVENT(cobalt_cond_timedwait,
765 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
766 const struct cobalt_mutex_shadow __user *u_mx,
767 const struct timespec *timeout),
768 TP_ARGS(u_cnd, u_mx, timeout),
770 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
771 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
772 __timespec_fields(timeout)
775 __entry->u_cnd = u_cnd;
776 __entry->u_mx = u_mx;
777 __assign_timespec(timeout, timeout);
779 TP_printk(
"cond=%p, mutex=%p, timeout=(%ld.%09ld)",
780 __entry->u_cnd, __entry->u_mx, __timespec_args(timeout))
783 TRACE_EVENT(cobalt_cond_wait,
784 TP_PROTO(
const struct cobalt_cond_shadow __user *u_cnd,
785 const struct cobalt_mutex_shadow __user *u_mx),
786 TP_ARGS(u_cnd, u_mx),
788 __field(
const struct cobalt_cond_shadow __user *, u_cnd)
789 __field(
const struct cobalt_mutex_shadow __user *, u_mx)
792 __entry->u_cnd = u_cnd;
793 __entry->u_mx = u_mx;
795 TP_printk(
"cond=%p, mutex=%p",
796 __entry->u_cnd, __entry->u_mx)
799 TRACE_EVENT(cobalt_mq_open,
800 TP_PROTO(
const char *name,
int oflags, mode_t mode),
801 TP_ARGS(name, oflags, mode),
806 __field(mode_t, mode)
810 __assign_str(name, name);
811 __entry->oflags = oflags;
812 __entry->mode = (oflags & O_CREAT) ? mode : 0;
815 TP_printk(
"name=%s oflags=%#x(%s) mode=%o",
817 __entry->oflags, cobalt_print_oflags(__entry->oflags),
821 TRACE_EVENT(cobalt_mq_notify,
822 TP_PROTO(mqd_t mqd,
const struct sigevent *sev),
832 __entry->signo = sev && sev->sigev_notify != SIGEV_NONE ?
833 sev->sigev_signo : 0;
836 TP_printk(
"mqd=%d signo=%d",
837 __entry->mqd, __entry->signo)
840 TRACE_EVENT(cobalt_mq_close,
852 TP_printk(
"mqd=%d", __entry->mqd)
855 TRACE_EVENT(cobalt_mq_unlink,
856 TP_PROTO(
const char *name),
864 __assign_str(name, name);
867 TP_printk(
"name=%s", __get_str(name))
870 TRACE_EVENT(cobalt_mq_send,
871 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
873 TP_ARGS(mqd, u_buf, len, prio),
876 __field(
const void __user *, u_buf)
878 __field(
unsigned int, prio)
882 __entry->u_buf = u_buf;
884 __entry->prio = prio;
886 TP_printk(
"mqd=%d buf=%p len=%Zu prio=%u",
887 __entry->mqd, __entry->u_buf, __entry->len,
891 TRACE_EVENT(cobalt_mq_timedreceive,
892 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len,
893 const struct timespec *timeout),
894 TP_ARGS(mqd, u_buf, len, timeout),
897 __field(
const void __user *, u_buf)
899 __timespec_fields(timeout)
903 __entry->u_buf = u_buf;
905 __assign_timespec(timeout, timeout);
907 TP_printk(
"mqd=%d buf=%p len=%Zu timeout=(%ld.%09ld)",
908 __entry->mqd, __entry->u_buf, __entry->len,
909 __timespec_args(timeout))
912 TRACE_EVENT(cobalt_mq_receive,
913 TP_PROTO(mqd_t mqd,
const void __user *u_buf,
size_t len),
914 TP_ARGS(mqd, u_buf, len),
917 __field(
const void __user *, u_buf)
922 __entry->u_buf = u_buf;
925 TP_printk(
"mqd=%d buf=%p len=%Zu",
926 __entry->mqd, __entry->u_buf, __entry->len)
929 DECLARE_EVENT_CLASS(cobalt_posix_mqattr,
930 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
935 __field(
long, curmsgs)
936 __field(
long, msgsize)
937 __field(
long, maxmsg)
941 __entry->flags = attr->mq_flags;
942 __entry->curmsgs = attr->mq_curmsgs;
943 __entry->msgsize = attr->mq_msgsize;
944 __entry->maxmsg = attr->mq_maxmsg;
946 TP_printk(
"mqd=%d flags=%#lx(%s) curmsgs=%ld msgsize=%ld maxmsg=%ld",
948 __entry->flags, cobalt_print_oflags(__entry->flags),
955 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_getattr,
956 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
960 DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_setattr,
961 TP_PROTO(mqd_t mqd,
const struct mq_attr *attr),
965 #define cobalt_print_evflags(__flags) \
966 __print_flags(__flags, "|", \
967 {COBALT_EVENT_SHARED, "shared"}, \
968 {COBALT_EVENT_PRIO, "prio"})
970 TRACE_EVENT(cobalt_event_init,
971 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
972 unsigned long value,
int flags),
973 TP_ARGS(u_event, value, flags),
975 __field(
const struct cobalt_event_shadow __user *, u_event)
976 __field(
unsigned long, value)
980 __entry->u_event = u_event;
981 __entry->value = value;
982 __entry->flags = flags;
984 TP_printk(
"event=%p value=%lu flags=%#x(%s)",
985 __entry->u_event, __entry->value,
986 __entry->flags, cobalt_print_evflags(__entry->flags))
989 #define cobalt_print_evmode(__mode) \
990 __print_symbolic(__mode, \
991 {COBALT_EVENT_ANY, "any"}, \
992 {COBALT_EVENT_ALL, "all"})
994 TRACE_EVENT(cobalt_event_timedwait,
995 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
996 unsigned long bits,
int mode,
997 const struct timespec *timeout),
998 TP_ARGS(u_event, bits, mode, timeout),
1000 __field(
const struct cobalt_event_shadow __user *, u_event)
1001 __field(
unsigned long, bits)
1003 __timespec_fields(timeout)
1006 __entry->u_event = u_event;
1007 __entry->bits = bits;
1008 __entry->mode = mode;
1009 __assign_timespec(timeout, timeout);
1011 TP_printk(
"event=%p bits=%#lx mode=%#x(%s) timeout=(%ld.%09ld)",
1012 __entry->u_event, __entry->bits, __entry->mode,
1013 cobalt_print_evmode(__entry->mode),
1014 __timespec_args(timeout))
1017 TRACE_EVENT(cobalt_event_wait,
1018 TP_PROTO(
const struct cobalt_event_shadow __user *u_event,
1019 unsigned long bits,
int mode),
1020 TP_ARGS(u_event, bits, mode),
1022 __field(
const struct cobalt_event_shadow __user *, u_event)
1023 __field(
unsigned long, bits)
1027 __entry->u_event = u_event;
1028 __entry->bits = bits;
1029 __entry->mode = mode;
1031 TP_printk(
"event=%p bits=%#lx mode=%#x(%s)",
1032 __entry->u_event, __entry->bits, __entry->mode,
1033 cobalt_print_evmode(__entry->mode))
1036 DECLARE_EVENT_CLASS(cobalt_event_ident,
1037 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1040 __field(
const struct cobalt_event_shadow __user *, u_event)
1043 __entry->u_event = u_event;
1045 TP_printk(
"event=%p", __entry->u_event)
1048 DEFINE_EVENT(cobalt_event_ident, cobalt_event_destroy,
1049 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1053 DEFINE_EVENT(cobalt_event_ident, cobalt_event_sync,
1054 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1058 DEFINE_EVENT(cobalt_event_ident, cobalt_event_inquire,
1059 TP_PROTO(
const struct cobalt_event_shadow __user *u_event),
1066 #include <trace/define_trace.h>