Xenomai 3.3.2
Loading...
Searching...
No Matches
cobalt-posix.h
1/*
2 * Copyright (C) 2014 Jan Kiszka <jan.kiszka@siemens.com>.
3 * Copyright (C) 2014 Philippe Gerum <rpm@xenomai.org>.
4 *
5 * Xenomai is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published
7 * by the Free Software Foundation; either version 2 of the License,
8 * or (at your option) any later version.
9 *
10 * Xenomai is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with Xenomai; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
18 * 02111-1307, USA.
19 */
20#undef TRACE_SYSTEM
21#define TRACE_SYSTEM cobalt_posix
22
23#if !defined(_TRACE_COBALT_POSIX_H) || defined(TRACE_HEADER_MULTI_READ)
24#define _TRACE_COBALT_POSIX_H
25
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>
31
32#define __timespec_fields(__name) \
33 __field(time64_t, tv_sec_##__name) \
34 __field(long, tv_nsec_##__name)
35
36#define __assign_timespec(__to, __from) \
37 do { \
38 __entry->tv_sec_##__to = (__from)->tv_sec; \
39 __entry->tv_nsec_##__to = (__from)->tv_nsec; \
40 } while (0)
41
42#define __timespec_args(__name) \
43 (long long)__entry->tv_sec_##__name, __entry->tv_nsec_##__name
44
45#ifdef CONFIG_XENO_ARCH_SYS3264
46#define __sc_compat(__name) , { sc_cobalt_##__name + __COBALT_COMPAT32_BASE, "compat-" #__name }
47#else
48#define __sc_compat(__name)
49#endif
50
51#define __cobalt_symbolic_syscall(__name) \
52 { sc_cobalt_##__name, #__name } \
53 __sc_compat(__name) \
54
55#define __cobalt_syscall_name(__nr) \
56 __print_symbolic((__nr), \
57 __cobalt_symbolic_syscall(bind), \
58 __cobalt_symbolic_syscall(thread_create), \
59 __cobalt_symbolic_syscall(thread_getpid), \
60 __cobalt_symbolic_syscall(thread_setmode), \
61 __cobalt_symbolic_syscall(thread_setname), \
62 __cobalt_symbolic_syscall(thread_join), \
63 __cobalt_symbolic_syscall(thread_kill), \
64 __cobalt_symbolic_syscall(thread_setschedparam_ex), \
65 __cobalt_symbolic_syscall(thread_getschedparam_ex), \
66 __cobalt_symbolic_syscall(thread_setschedprio), \
67 __cobalt_symbolic_syscall(thread_getstat), \
68 __cobalt_symbolic_syscall(sem_init), \
69 __cobalt_symbolic_syscall(sem_destroy), \
70 __cobalt_symbolic_syscall(sem_post), \
71 __cobalt_symbolic_syscall(sem_wait), \
72 __cobalt_symbolic_syscall(sem_trywait), \
73 __cobalt_symbolic_syscall(sem_getvalue), \
74 __cobalt_symbolic_syscall(sem_open), \
75 __cobalt_symbolic_syscall(sem_close), \
76 __cobalt_symbolic_syscall(sem_unlink), \
77 __cobalt_symbolic_syscall(sem_timedwait), \
78 __cobalt_symbolic_syscall(sem_inquire), \
79 __cobalt_symbolic_syscall(sem_broadcast_np), \
80 __cobalt_symbolic_syscall(clock_getres), \
81 __cobalt_symbolic_syscall(clock_gettime), \
82 __cobalt_symbolic_syscall(clock_settime), \
83 __cobalt_symbolic_syscall(clock_nanosleep), \
84 __cobalt_symbolic_syscall(mutex_init), \
85 __cobalt_symbolic_syscall(mutex_check_init), \
86 __cobalt_symbolic_syscall(mutex_destroy), \
87 __cobalt_symbolic_syscall(mutex_lock), \
88 __cobalt_symbolic_syscall(mutex_timedlock), \
89 __cobalt_symbolic_syscall(mutex_trylock), \
90 __cobalt_symbolic_syscall(mutex_unlock), \
91 __cobalt_symbolic_syscall(cond_init), \
92 __cobalt_symbolic_syscall(cond_destroy), \
93 __cobalt_symbolic_syscall(cond_wait_prologue), \
94 __cobalt_symbolic_syscall(cond_wait_epilogue), \
95 __cobalt_symbolic_syscall(mq_open), \
96 __cobalt_symbolic_syscall(mq_close), \
97 __cobalt_symbolic_syscall(mq_unlink), \
98 __cobalt_symbolic_syscall(mq_getattr), \
99 __cobalt_symbolic_syscall(mq_timedsend), \
100 __cobalt_symbolic_syscall(mq_timedreceive), \
101 __cobalt_symbolic_syscall(mq_notify), \
102 __cobalt_symbolic_syscall(sched_minprio), \
103 __cobalt_symbolic_syscall(sched_maxprio), \
104 __cobalt_symbolic_syscall(sched_weightprio), \
105 __cobalt_symbolic_syscall(sched_yield), \
106 __cobalt_symbolic_syscall(sched_setscheduler_ex), \
107 __cobalt_symbolic_syscall(sched_getscheduler_ex), \
108 __cobalt_symbolic_syscall(sched_setconfig_np), \
109 __cobalt_symbolic_syscall(sched_getconfig_np), \
110 __cobalt_symbolic_syscall(timer_create), \
111 __cobalt_symbolic_syscall(timer_delete), \
112 __cobalt_symbolic_syscall(timer_settime), \
113 __cobalt_symbolic_syscall(timer_gettime), \
114 __cobalt_symbolic_syscall(timer_getoverrun), \
115 __cobalt_symbolic_syscall(timerfd_create), \
116 __cobalt_symbolic_syscall(timerfd_settime), \
117 __cobalt_symbolic_syscall(timerfd_gettime), \
118 __cobalt_symbolic_syscall(sigwait), \
119 __cobalt_symbolic_syscall(sigwaitinfo), \
120 __cobalt_symbolic_syscall(sigtimedwait), \
121 __cobalt_symbolic_syscall(sigpending), \
122 __cobalt_symbolic_syscall(kill), \
123 __cobalt_symbolic_syscall(sigqueue), \
124 __cobalt_symbolic_syscall(monitor_init), \
125 __cobalt_symbolic_syscall(monitor_destroy), \
126 __cobalt_symbolic_syscall(monitor_enter), \
127 __cobalt_symbolic_syscall(monitor_wait), \
128 __cobalt_symbolic_syscall(monitor_sync), \
129 __cobalt_symbolic_syscall(monitor_exit), \
130 __cobalt_symbolic_syscall(event_init), \
131 __cobalt_symbolic_syscall(event_wait), \
132 __cobalt_symbolic_syscall(event_sync), \
133 __cobalt_symbolic_syscall(event_destroy), \
134 __cobalt_symbolic_syscall(event_inquire), \
135 __cobalt_symbolic_syscall(open), \
136 __cobalt_symbolic_syscall(socket), \
137 __cobalt_symbolic_syscall(close), \
138 __cobalt_symbolic_syscall(ioctl), \
139 __cobalt_symbolic_syscall(read), \
140 __cobalt_symbolic_syscall(write), \
141 __cobalt_symbolic_syscall(recvmsg), \
142 __cobalt_symbolic_syscall(sendmsg), \
143 __cobalt_symbolic_syscall(mmap), \
144 __cobalt_symbolic_syscall(select), \
145 __cobalt_symbolic_syscall(fcntl), \
146 __cobalt_symbolic_syscall(migrate), \
147 __cobalt_symbolic_syscall(trace), \
148 __cobalt_symbolic_syscall(corectl), \
149 __cobalt_symbolic_syscall(get_current), \
150 __cobalt_symbolic_syscall(backtrace), \
151 __cobalt_symbolic_syscall(serialdbg), \
152 __cobalt_symbolic_syscall(extend), \
153 __cobalt_symbolic_syscall(ftrace_puts), \
154 __cobalt_symbolic_syscall(recvmmsg), \
155 __cobalt_symbolic_syscall(sendmmsg), \
156 __cobalt_symbolic_syscall(clock_adjtime), \
157 __cobalt_symbolic_syscall(sem_timedwait64), \
158 __cobalt_symbolic_syscall(clock_gettime64), \
159 __cobalt_symbolic_syscall(clock_settime64), \
160 __cobalt_symbolic_syscall(clock_nanosleep64), \
161 __cobalt_symbolic_syscall(clock_getres64), \
162 __cobalt_symbolic_syscall(clock_adjtime64), \
163 __cobalt_symbolic_syscall(mutex_timedlock64), \
164 __cobalt_symbolic_syscall(mq_timedsend64), \
165 __cobalt_symbolic_syscall(mq_timedreceive64), \
166 __cobalt_symbolic_syscall(sigtimedwait64), \
167 __cobalt_symbolic_syscall(monitor_wait64), \
168 __cobalt_symbolic_syscall(event_wait64), \
169 __cobalt_symbolic_syscall(recvmmsg64), \
170 __cobalt_symbolic_syscall(cond_wait_prologue64), \
171 __cobalt_symbolic_syscall(timer_settime64), \
172 __cobalt_symbolic_syscall(timer_gettime64), \
173 __cobalt_symbolic_syscall(timerfd_settime64), \
174 __cobalt_symbolic_syscall(timerfd_gettime64), \
175 __cobalt_symbolic_syscall(pselect64))
176
177DECLARE_EVENT_CLASS(cobalt_syscall_entry,
178 TP_PROTO(unsigned int nr),
179 TP_ARGS(nr),
180
181 TP_STRUCT__entry(
182 __field(unsigned int, nr)
183 ),
184
185 TP_fast_assign(
186 __entry->nr = nr;
187 ),
188
189 TP_printk("syscall=%s", __cobalt_syscall_name(__entry->nr))
190);
191
192DECLARE_EVENT_CLASS(cobalt_syscall_exit,
193 TP_PROTO(long result),
194 TP_ARGS(result),
195
196 TP_STRUCT__entry(
197 __field(long, result)
198 ),
199
200 TP_fast_assign(
201 __entry->result = result;
202 ),
203
204 TP_printk("result=%ld", __entry->result)
205);
206
207#define cobalt_print_sched_policy(__policy) \
208 __print_symbolic(__policy, \
209 {SCHED_NORMAL, "normal"}, \
210 {SCHED_FIFO, "fifo"}, \
211 {SCHED_RR, "rr"}, \
212 {SCHED_TP, "tp"}, \
213 {SCHED_QUOTA, "quota"}, \
214 {SCHED_SPORADIC, "sporadic"}, \
215 {SCHED_COBALT, "cobalt"}, \
216 {SCHED_WEAK, "weak"})
217
218const char *cobalt_trace_parse_sched_params(struct trace_seq *, int,
219 struct sched_param_ex *);
220
221#define __parse_sched_params(policy, params) \
222 cobalt_trace_parse_sched_params(p, policy, \
223 (struct sched_param_ex *)(params))
224
225DECLARE_EVENT_CLASS(cobalt_posix_schedparam,
226 TP_PROTO(unsigned long pth, int policy,
227 const struct sched_param_ex *param_ex),
228 TP_ARGS(pth, policy, param_ex),
229
230 TP_STRUCT__entry(
231 __field(unsigned long, pth)
232 __field(int, policy)
233 __dynamic_array(char, param_ex, sizeof(struct sched_param_ex))
234 ),
235
236 TP_fast_assign(
237 __entry->pth = pth;
238 __entry->policy = policy;
239 memcpy(__get_dynamic_array(param_ex), param_ex, sizeof(*param_ex));
240 ),
241
242 TP_printk("pth=%p policy=%s param={ %s }",
243 (void *)__entry->pth,
244 cobalt_print_sched_policy(__entry->policy),
245 __parse_sched_params(__entry->policy,
246 __get_dynamic_array(param_ex))
247 )
248);
249
250DECLARE_EVENT_CLASS(cobalt_posix_scheduler,
251 TP_PROTO(pid_t pid, int policy,
252 const struct sched_param_ex *param_ex),
253 TP_ARGS(pid, policy, param_ex),
254
255 TP_STRUCT__entry(
256 __field(pid_t, pid)
257 __field(int, policy)
258 __dynamic_array(char, param_ex, sizeof(struct sched_param_ex))
259 ),
260
261 TP_fast_assign(
262 __entry->pid = pid;
263 __entry->policy = policy;
264 memcpy(__get_dynamic_array(param_ex), param_ex, sizeof(*param_ex));
265 ),
266
267 TP_printk("pid=%d policy=%s param={ %s }",
268 __entry->pid,
269 cobalt_print_sched_policy(__entry->policy),
270 __parse_sched_params(__entry->policy,
271 __get_dynamic_array(param_ex))
272 )
273);
274
275DECLARE_EVENT_CLASS(cobalt_void,
276 TP_PROTO(int dummy),
277 TP_ARGS(dummy),
278 TP_STRUCT__entry(
279 __field(int, dummy)
280 ),
281 TP_fast_assign(
282 (void)dummy;
283 ),
284 TP_printk("%s", "")
285);
286
287DEFINE_EVENT(cobalt_syscall_entry, cobalt_head_sysentry,
288 TP_PROTO(unsigned int nr),
289 TP_ARGS(nr)
290);
291
292DEFINE_EVENT(cobalt_syscall_exit, cobalt_head_sysexit,
293 TP_PROTO(long result),
294 TP_ARGS(result)
295);
296
297DEFINE_EVENT(cobalt_syscall_entry, cobalt_root_sysentry,
298 TP_PROTO(unsigned int nr),
299 TP_ARGS(nr)
300);
301
302DEFINE_EVENT(cobalt_syscall_exit, cobalt_root_sysexit,
303 TP_PROTO(long result),
304 TP_ARGS(result)
305);
306
307DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_create,
308 TP_PROTO(unsigned long pth, int policy,
309 const struct sched_param_ex *param_ex),
310 TP_ARGS(pth, policy, param_ex)
311);
312
313DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_setschedparam,
314 TP_PROTO(unsigned long pth, int policy,
315 const struct sched_param_ex *param_ex),
316 TP_ARGS(pth, policy, param_ex)
317);
318
319DEFINE_EVENT(cobalt_posix_schedparam, cobalt_pthread_getschedparam,
320 TP_PROTO(unsigned long pth, int policy,
321 const struct sched_param_ex *param_ex),
322 TP_ARGS(pth, policy, param_ex)
323);
324
325TRACE_EVENT(cobalt_pthread_setschedprio,
326 TP_PROTO(unsigned long pth, int prio),
327 TP_ARGS(pth, prio),
328 TP_STRUCT__entry(
329 __field(unsigned long, pth)
330 __field(int, prio)
331 ),
332 TP_fast_assign(
333 __entry->pth = pth;
334 __entry->prio = prio;
335 ),
336 TP_printk("pth=%p prio=%d", (void *)__entry->pth, __entry->prio)
337);
338
339#define cobalt_print_thread_mode(__mode) \
340 __print_flags(__mode, "|", \
341 {PTHREAD_WARNSW, "warnsw"}, \
342 {PTHREAD_LOCK_SCHED, "lock"}, \
343 {PTHREAD_DISABLE_LOCKBREAK, "nolockbreak"})
344
345TRACE_EVENT(cobalt_pthread_setmode,
346 TP_PROTO(int clrmask, int setmask),
347 TP_ARGS(clrmask, setmask),
348 TP_STRUCT__entry(
349 __field(int, clrmask)
350 __field(int, setmask)
351 ),
352 TP_fast_assign(
353 __entry->clrmask = clrmask;
354 __entry->setmask = setmask;
355 ),
356 TP_printk("clrmask=%#x(%s) setmask=%#x(%s)",
357 __entry->clrmask, cobalt_print_thread_mode(__entry->clrmask),
358 __entry->setmask, cobalt_print_thread_mode(__entry->setmask))
359);
360
361TRACE_EVENT(cobalt_pthread_setname,
362 TP_PROTO(unsigned long pth, const char *name),
363 TP_ARGS(pth, name),
364 TP_STRUCT__entry(
365 __field(unsigned long, pth)
366 __string(name, name)
367 ),
368 TP_fast_assign(
369 __entry->pth = pth;
370 __wrap_assign_str(name, name);
371 ),
372 TP_printk("pth=%p name=%s", (void *)__entry->pth, __get_str(name))
373);
374
375DECLARE_EVENT_CLASS(cobalt_posix_pid,
376 TP_PROTO(pid_t pid),
377 TP_ARGS(pid),
378 TP_STRUCT__entry(
379 __field(pid_t, pid)
380 ),
381 TP_fast_assign(
382 __entry->pid = pid;
383 ),
384 TP_printk("pid=%d", __entry->pid)
385);
386
387DEFINE_EVENT(cobalt_posix_pid, cobalt_pthread_stat,
388 TP_PROTO(pid_t pid),
389 TP_ARGS(pid)
390);
391
392TRACE_EVENT(cobalt_pthread_kill,
393 TP_PROTO(unsigned long pth, int sig),
394 TP_ARGS(pth, sig),
395 TP_STRUCT__entry(
396 __field(unsigned long, pth)
397 __field(int, sig)
398 ),
399 TP_fast_assign(
400 __entry->pth = pth;
401 __entry->sig = sig;
402 ),
403 TP_printk("pth=%p sig=%d", (void *)__entry->pth, __entry->sig)
404);
405
406TRACE_EVENT(cobalt_pthread_join,
407 TP_PROTO(unsigned long pth),
408 TP_ARGS(pth),
409 TP_STRUCT__entry(
410 __field(unsigned long, pth)
411 ),
412 TP_fast_assign(
413 __entry->pth = pth;
414 ),
415 TP_printk("pth=%p", (void *)__entry->pth)
416);
417
418TRACE_EVENT(cobalt_pthread_pid,
419 TP_PROTO(unsigned long pth),
420 TP_ARGS(pth),
421 TP_STRUCT__entry(
422 __field(unsigned long, pth)
423 ),
424 TP_fast_assign(
425 __entry->pth = pth;
426 ),
427 TP_printk("pth=%p", (void *)__entry->pth)
428);
429
430TRACE_EVENT(cobalt_pthread_extend,
431 TP_PROTO(unsigned long pth, const char *name),
432 TP_ARGS(pth, name),
433 TP_STRUCT__entry(
434 __field(unsigned long, pth)
435 __string(name, name)
436 ),
437 TP_fast_assign(
438 __entry->pth = pth;
439 __wrap_assign_str(name, name);
440 ),
441 TP_printk("pth=%p +personality=%s", (void *)__entry->pth, __get_str(name))
442);
443
444TRACE_EVENT(cobalt_pthread_restrict,
445 TP_PROTO(unsigned long pth, const char *name),
446 TP_ARGS(pth, name),
447 TP_STRUCT__entry(
448 __field(unsigned long, pth)
449 __string(name, name)
450 ),
451 TP_fast_assign(
452 __entry->pth = pth;
453 __wrap_assign_str(name, name);
454 ),
455 TP_printk("pth=%p -personality=%s", (void *)__entry->pth, __get_str(name))
456);
457
458DEFINE_EVENT(cobalt_void, cobalt_pthread_yield,
459 TP_PROTO(int dummy),
460 TP_ARGS(dummy)
461);
462
463TRACE_EVENT(cobalt_sched_setconfig,
464 TP_PROTO(int cpu, int policy, size_t len),
465 TP_ARGS(cpu, policy, len),
466 TP_STRUCT__entry(
467 __field(int, cpu)
468 __field(int, policy)
469 __field(size_t, len)
470 ),
471 TP_fast_assign(
472 __entry->cpu = cpu;
473 __entry->policy = policy;
474 __entry->len = len;
475 ),
476 TP_printk("cpu=%d policy=%d(%s) len=%zu",
477 __entry->cpu, __entry->policy,
478 cobalt_print_sched_policy(__entry->policy),
479 __entry->len)
480);
481
482TRACE_EVENT(cobalt_sched_get_config,
483 TP_PROTO(int cpu, int policy, size_t rlen),
484 TP_ARGS(cpu, policy, rlen),
485 TP_STRUCT__entry(
486 __field(int, cpu)
487 __field(int, policy)
488 __field(ssize_t, rlen)
489 ),
490 TP_fast_assign(
491 __entry->cpu = cpu;
492 __entry->policy = policy;
493 __entry->rlen = rlen;
494 ),
495 TP_printk("cpu=%d policy=%d(%s) rlen=%Zd",
496 __entry->cpu, __entry->policy,
497 cobalt_print_sched_policy(__entry->policy),
498 __entry->rlen)
499);
500
501DEFINE_EVENT(cobalt_posix_scheduler, cobalt_sched_setscheduler,
502 TP_PROTO(pid_t pid, int policy,
503 const struct sched_param_ex *param_ex),
504 TP_ARGS(pid, policy, param_ex)
505);
506
507DEFINE_EVENT(cobalt_posix_pid, cobalt_sched_getscheduler,
508 TP_PROTO(pid_t pid),
509 TP_ARGS(pid)
510);
511
512DECLARE_EVENT_CLASS(cobalt_posix_prio_bound,
513 TP_PROTO(int policy, int prio),
514 TP_ARGS(policy, prio),
515 TP_STRUCT__entry(
516 __field(int, policy)
517 __field(int, prio)
518 ),
519 TP_fast_assign(
520 __entry->policy = policy;
521 __entry->prio = prio;
522 ),
523 TP_printk("policy=%d(%s) prio=%d",
524 __entry->policy,
525 cobalt_print_sched_policy(__entry->policy),
526 __entry->prio)
527);
528
529DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_min_prio,
530 TP_PROTO(int policy, int prio),
531 TP_ARGS(policy, prio)
532);
533
534DEFINE_EVENT(cobalt_posix_prio_bound, cobalt_sched_max_prio,
535 TP_PROTO(int policy, int prio),
536 TP_ARGS(policy, prio)
537);
538
539DECLARE_EVENT_CLASS(cobalt_posix_sem,
540 TP_PROTO(xnhandle_t handle),
541 TP_ARGS(handle),
542 TP_STRUCT__entry(
543 __field(xnhandle_t, handle)
544 ),
545 TP_fast_assign(
546 __entry->handle = handle;
547 ),
548 TP_printk("sem=%#x", __entry->handle)
549);
550
551DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_wait,
552 TP_PROTO(xnhandle_t handle),
553 TP_ARGS(handle)
554);
555
556DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_trywait,
557 TP_PROTO(xnhandle_t handle),
558 TP_ARGS(handle)
559);
560
561DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_timedwait,
562 TP_PROTO(xnhandle_t handle),
563 TP_ARGS(handle)
564);
565
566DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_post,
567 TP_PROTO(xnhandle_t handle),
568 TP_ARGS(handle)
569);
570
571DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_destroy,
572 TP_PROTO(xnhandle_t handle),
573 TP_ARGS(handle)
574);
575
576DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_broadcast,
577 TP_PROTO(xnhandle_t handle),
578 TP_ARGS(handle)
579);
580
581DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_inquire,
582 TP_PROTO(xnhandle_t handle),
583 TP_ARGS(handle)
584);
585
586TRACE_EVENT(cobalt_psem_getvalue,
587 TP_PROTO(xnhandle_t handle, int value),
588 TP_ARGS(handle, value),
589 TP_STRUCT__entry(
590 __field(xnhandle_t, handle)
591 __field(int, value)
592 ),
593 TP_fast_assign(
594 __entry->handle = handle;
595 __entry->value = value;
596 ),
597 TP_printk("sem=%#x value=%d", __entry->handle, __entry->value)
598);
599
600#define cobalt_print_sem_flags(__flags) \
601 __print_flags(__flags, "|", \
602 {SEM_FIFO, "fifo"}, \
603 {SEM_PULSE, "pulse"}, \
604 {SEM_PSHARED, "pshared"}, \
605 {SEM_REPORT, "report"}, \
606 {SEM_WARNDEL, "warndel"}, \
607 {SEM_RAWCLOCK, "rawclock"}, \
608 {SEM_NOBUSYDEL, "nobusydel"})
609
610TRACE_EVENT(cobalt_psem_init,
611 TP_PROTO(const char *name, xnhandle_t handle,
612 int flags, unsigned int value),
613 TP_ARGS(name, handle, flags, value),
614 TP_STRUCT__entry(
615 __string(name, name)
616 __field(xnhandle_t, handle)
617 __field(int, flags)
618 __field(unsigned int, value)
619 ),
620 TP_fast_assign(
621 __wrap_assign_str(name, name);
622 __entry->handle = handle;
623 __entry->flags = flags;
624 __entry->value = value;
625 ),
626 TP_printk("sem=%#x(%s) flags=%#x(%s) value=%u",
627 __entry->handle,
628 __get_str(name),
629 __entry->flags,
630 cobalt_print_sem_flags(__entry->flags),
631 __entry->value)
632);
633
634TRACE_EVENT(cobalt_psem_init_failed,
635 TP_PROTO(const char *name, int flags, unsigned int value, int status),
636 TP_ARGS(name, flags, value, status),
637 TP_STRUCT__entry(
638 __string(name, name)
639 __field(int, flags)
640 __field(unsigned int, value)
641 __field(int, status)
642 ),
643 TP_fast_assign(
644 __wrap_assign_str(name, name);
645 __entry->flags = flags;
646 __entry->value = value;
647 __entry->status = status;
648 ),
649 TP_printk("name=%s flags=%#x(%s) value=%u error=%d",
650 __get_str(name),
651 __entry->flags,
652 cobalt_print_sem_flags(__entry->flags),
653 __entry->value, __entry->status)
654);
655
656#define cobalt_print_oflags(__flags) \
657 __print_flags(__flags, "|", \
658 {O_RDONLY, "rdonly"}, \
659 {O_WRONLY, "wronly"}, \
660 {O_RDWR, "rdwr"}, \
661 {O_CREAT, "creat"}, \
662 {O_EXCL, "excl"}, \
663 {O_DIRECT, "direct"}, \
664 {O_NONBLOCK, "nonblock"}, \
665 {O_TRUNC, "trunc"})
666
667TRACE_EVENT(cobalt_psem_open,
668 TP_PROTO(const char *name, xnhandle_t handle,
669 int oflags, mode_t mode, unsigned int value),
670 TP_ARGS(name, handle, oflags, mode, value),
671 TP_STRUCT__entry(
672 __string(name, name)
673 __field(xnhandle_t, handle)
674 __field(int, oflags)
675 __field(mode_t, mode)
676 __field(unsigned int, value)
677 ),
678 TP_fast_assign(
679 __wrap_assign_str(name, name);
680 __entry->handle = handle;
681 __entry->oflags = oflags;
682 if (oflags & O_CREAT) {
683 __entry->mode = mode;
684 __entry->value = value;
685 } else {
686 __entry->mode = 0;
687 __entry->value = 0;
688 }
689 ),
690 TP_printk("named_sem=%#x=(%s) oflags=%#x(%s) mode=%o value=%u",
691 __entry->handle, __get_str(name),
692 __entry->oflags, cobalt_print_oflags(__entry->oflags),
693 __entry->mode, __entry->value)
694);
695
696TRACE_EVENT(cobalt_psem_open_failed,
697 TP_PROTO(const char *name, int oflags, mode_t mode,
698 unsigned int value, int status),
699 TP_ARGS(name, oflags, mode, value, status),
700 TP_STRUCT__entry(
701 __string(name, name)
702 __field(int, oflags)
703 __field(mode_t, mode)
704 __field(unsigned int, value)
705 __field(int, status)
706 ),
707 TP_fast_assign(
708 __wrap_assign_str(name, name);
709 __entry->oflags = oflags;
710 __entry->status = status;
711 if (oflags & O_CREAT) {
712 __entry->mode = mode;
713 __entry->value = value;
714 } else {
715 __entry->mode = 0;
716 __entry->value = 0;
717 }
718 ),
719 TP_printk("named_sem=%s oflags=%#x(%s) mode=%o value=%u error=%d",
720 __get_str(name),
721 __entry->oflags, cobalt_print_oflags(__entry->oflags),
722 __entry->mode, __entry->value, __entry->status)
723);
724
725DEFINE_EVENT(cobalt_posix_sem, cobalt_psem_close,
726 TP_PROTO(xnhandle_t handle),
727 TP_ARGS(handle)
728);
729
730TRACE_EVENT(cobalt_psem_unlink,
731 TP_PROTO(const char *name),
732 TP_ARGS(name),
733 TP_STRUCT__entry(
734 __string(name, name)
735 ),
736 TP_fast_assign(
737 __wrap_assign_str(name, name);
738 ),
739 TP_printk("name=%s", __get_str(name))
740);
741
742DECLARE_EVENT_CLASS(cobalt_clock_timespec,
743 TP_PROTO(clockid_t clk_id, const struct timespec64 *val),
744 TP_ARGS(clk_id, val),
745
746 TP_STRUCT__entry(
747 __field(clockid_t, clk_id)
748 __timespec_fields(val)
749 ),
750
751 TP_fast_assign(
752 __entry->clk_id = clk_id;
753 __assign_timespec(val, val);
754 ),
755
756 TP_printk("clock_id=%d timeval=(%lld.%09ld)",
757 __entry->clk_id,
758 __timespec_args(val)
759 )
760);
761
762DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_getres,
763 TP_PROTO(clockid_t clk_id, const struct timespec64 *res),
764 TP_ARGS(clk_id, res)
765);
766
767DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_gettime,
768 TP_PROTO(clockid_t clk_id, const struct timespec64 *time),
769 TP_ARGS(clk_id, time)
770);
771
772DEFINE_EVENT(cobalt_clock_timespec, cobalt_clock_settime,
773 TP_PROTO(clockid_t clk_id, const struct timespec64 *time),
774 TP_ARGS(clk_id, time)
775);
776
777TRACE_EVENT(cobalt_clock_adjtime,
778 TP_PROTO(clockid_t clk_id, struct __kernel_timex *tx),
779 TP_ARGS(clk_id, tx),
780
781 TP_STRUCT__entry(
782 __field(clockid_t, clk_id)
783 __field(struct __kernel_timex *, tx)
784 ),
785
786 TP_fast_assign(
787 __entry->clk_id = clk_id;
788 __entry->tx = tx;
789 ),
790
791 TP_printk("clock_id=%d timex=%p",
792 __entry->clk_id,
793 __entry->tx
794 )
795);
796
797#define cobalt_print_timer_flags(__flags) \
798 __print_flags(__flags, "|", \
799 {TIMER_ABSTIME, "TIMER_ABSTIME"})
800
801TRACE_EVENT(cobalt_clock_nanosleep,
802 TP_PROTO(clockid_t clk_id, int flags, const struct timespec64 *time),
803 TP_ARGS(clk_id, flags, time),
804
805 TP_STRUCT__entry(
806 __field(clockid_t, clk_id)
807 __field(int, flags)
808 __timespec_fields(time)
809 ),
810
811 TP_fast_assign(
812 __entry->clk_id = clk_id;
813 __entry->flags = flags;
814 __assign_timespec(time, time);
815 ),
816
817 TP_printk("clock_id=%d flags=%#x(%s) rqt=(%lld.%09ld)",
818 __entry->clk_id,
819 __entry->flags, cobalt_print_timer_flags(__entry->flags),
820 __timespec_args(time)
821 )
822);
823
824DECLARE_EVENT_CLASS(cobalt_clock_ident,
825 TP_PROTO(const char *name, clockid_t clk_id),
826 TP_ARGS(name, clk_id),
827 TP_STRUCT__entry(
828 __string(name, name)
829 __field(clockid_t, clk_id)
830 ),
831 TP_fast_assign(
832 __wrap_assign_str(name, name);
833 __entry->clk_id = clk_id;
834 ),
835 TP_printk("name=%s, id=%#x", __get_str(name), __entry->clk_id)
836);
837
838DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_register,
839 TP_PROTO(const char *name, clockid_t clk_id),
840 TP_ARGS(name, clk_id)
841);
842
843DEFINE_EVENT(cobalt_clock_ident, cobalt_clock_deregister,
844 TP_PROTO(const char *name, clockid_t clk_id),
845 TP_ARGS(name, clk_id)
846);
847
848#define cobalt_print_clock(__clk_id) \
849 __print_symbolic(__clk_id, \
850 {CLOCK_MONOTONIC, "CLOCK_MONOTONIC"}, \
851 {CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW"}, \
852 {CLOCK_REALTIME, "CLOCK_REALTIME"})
853
854TRACE_EVENT(cobalt_cond_init,
855 TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
856 const struct cobalt_condattr *attr),
857 TP_ARGS(u_cnd, attr),
858 TP_STRUCT__entry(
859 __field(const struct cobalt_cond_shadow __user *, u_cnd)
860 __field(clockid_t, clk_id)
861 __field(int, pshared)
862 ),
863 TP_fast_assign(
864 __entry->u_cnd = u_cnd;
865 __entry->clk_id = attr->clock;
866 __entry->pshared = attr->pshared;
867 ),
868 TP_printk("cond=%p attr={ .clock=%s, .pshared=%d }",
869 __entry->u_cnd,
870 cobalt_print_clock(__entry->clk_id),
871 __entry->pshared)
872);
873
874TRACE_EVENT(cobalt_cond_destroy,
875 TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd),
876 TP_ARGS(u_cnd),
877 TP_STRUCT__entry(
878 __field(const struct cobalt_cond_shadow __user *, u_cnd)
879 ),
880 TP_fast_assign(
881 __entry->u_cnd = u_cnd;
882 ),
883 TP_printk("cond=%p", __entry->u_cnd)
884);
885
886TRACE_EVENT(cobalt_cond_timedwait,
887 TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
888 const struct cobalt_mutex_shadow __user *u_mx,
889 const struct timespec64 *timeout),
890 TP_ARGS(u_cnd, u_mx, timeout),
891 TP_STRUCT__entry(
892 __field(const struct cobalt_cond_shadow __user *, u_cnd)
893 __field(const struct cobalt_mutex_shadow __user *, u_mx)
894 __timespec_fields(timeout)
895 ),
896 TP_fast_assign(
897 __entry->u_cnd = u_cnd;
898 __entry->u_mx = u_mx;
899 __assign_timespec(timeout, timeout);
900 ),
901 TP_printk("cond=%p, mutex=%p, timeout=(%lld.%09ld)",
902 __entry->u_cnd, __entry->u_mx, __timespec_args(timeout))
903);
904
905TRACE_EVENT(cobalt_cond_wait,
906 TP_PROTO(const struct cobalt_cond_shadow __user *u_cnd,
907 const struct cobalt_mutex_shadow __user *u_mx),
908 TP_ARGS(u_cnd, u_mx),
909 TP_STRUCT__entry(
910 __field(const struct cobalt_cond_shadow __user *, u_cnd)
911 __field(const struct cobalt_mutex_shadow __user *, u_mx)
912 ),
913 TP_fast_assign(
914 __entry->u_cnd = u_cnd;
915 __entry->u_mx = u_mx;
916 ),
917 TP_printk("cond=%p, mutex=%p",
918 __entry->u_cnd, __entry->u_mx)
919);
920
921TRACE_EVENT(cobalt_mq_open,
922 TP_PROTO(const char *name, int oflags, mode_t mode),
923 TP_ARGS(name, oflags, mode),
924
925 TP_STRUCT__entry(
926 __string(name, name)
927 __field(int, oflags)
928 __field(mode_t, mode)
929 ),
930
931 TP_fast_assign(
932 __wrap_assign_str(name, name);
933 __entry->oflags = oflags;
934 __entry->mode = (oflags & O_CREAT) ? mode : 0;
935 ),
936
937 TP_printk("name=%s oflags=%#x(%s) mode=%o",
938 __get_str(name),
939 __entry->oflags, cobalt_print_oflags(__entry->oflags),
940 __entry->mode)
941);
942
943TRACE_EVENT(cobalt_mq_notify,
944 TP_PROTO(mqd_t mqd, const struct sigevent *sev),
945 TP_ARGS(mqd, sev),
946
947 TP_STRUCT__entry(
948 __field(mqd_t, mqd)
949 __field(int, signo)
950 ),
951
952 TP_fast_assign(
953 __entry->mqd = mqd;
954 __entry->signo = sev && sev->sigev_notify != SIGEV_NONE ?
955 sev->sigev_signo : 0;
956 ),
957
958 TP_printk("mqd=%d signo=%d",
959 __entry->mqd, __entry->signo)
960);
961
962TRACE_EVENT(cobalt_mq_close,
963 TP_PROTO(mqd_t mqd),
964 TP_ARGS(mqd),
965
966 TP_STRUCT__entry(
967 __field(mqd_t, mqd)
968 ),
969
970 TP_fast_assign(
971 __entry->mqd = mqd;
972 ),
973
974 TP_printk("mqd=%d", __entry->mqd)
975);
976
977TRACE_EVENT(cobalt_mq_unlink,
978 TP_PROTO(const char *name),
979 TP_ARGS(name),
980
981 TP_STRUCT__entry(
982 __string(name, name)
983 ),
984
985 TP_fast_assign(
986 __wrap_assign_str(name, name);
987 ),
988
989 TP_printk("name=%s", __get_str(name))
990);
991
992TRACE_EVENT(cobalt_mq_send,
993 TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len,
994 unsigned int prio),
995 TP_ARGS(mqd, u_buf, len, prio),
996 TP_STRUCT__entry(
997 __field(mqd_t, mqd)
998 __field(const void __user *, u_buf)
999 __field(size_t, len)
1000 __field(unsigned int, prio)
1001 ),
1002 TP_fast_assign(
1003 __entry->mqd = mqd;
1004 __entry->u_buf = u_buf;
1005 __entry->len = len;
1006 __entry->prio = prio;
1007 ),
1008 TP_printk("mqd=%d buf=%p len=%zu prio=%u",
1009 __entry->mqd, __entry->u_buf, __entry->len,
1010 __entry->prio)
1011);
1012
1013TRACE_EVENT(cobalt_mq_timedreceive,
1014 TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len,
1015 const struct timespec64 *timeout),
1016 TP_ARGS(mqd, u_buf, len, timeout),
1017 TP_STRUCT__entry(
1018 __field(mqd_t, mqd)
1019 __field(const void __user *, u_buf)
1020 __field(size_t, len)
1021 __timespec_fields(timeout)
1022 ),
1023 TP_fast_assign(
1024 __entry->mqd = mqd;
1025 __entry->u_buf = u_buf;
1026 __entry->len = len;
1027 __assign_timespec(timeout, timeout);
1028 ),
1029 TP_printk("mqd=%d buf=%p len=%zu timeout=(%lld.%09ld)",
1030 __entry->mqd, __entry->u_buf, __entry->len,
1031 __timespec_args(timeout))
1032);
1033
1034TRACE_EVENT(cobalt_mq_receive,
1035 TP_PROTO(mqd_t mqd, const void __user *u_buf, size_t len),
1036 TP_ARGS(mqd, u_buf, len),
1037 TP_STRUCT__entry(
1038 __field(mqd_t, mqd)
1039 __field(const void __user *, u_buf)
1040 __field(size_t, len)
1041 ),
1042 TP_fast_assign(
1043 __entry->mqd = mqd;
1044 __entry->u_buf = u_buf;
1045 __entry->len = len;
1046 ),
1047 TP_printk("mqd=%d buf=%p len=%zu",
1048 __entry->mqd, __entry->u_buf, __entry->len)
1049);
1050
1051DECLARE_EVENT_CLASS(cobalt_posix_mqattr,
1052 TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
1053 TP_ARGS(mqd, attr),
1054 TP_STRUCT__entry(
1055 __field(mqd_t, mqd)
1056 __field(long, flags)
1057 __field(long, curmsgs)
1058 __field(long, msgsize)
1059 __field(long, maxmsg)
1060 ),
1061 TP_fast_assign(
1062 __entry->mqd = mqd;
1063 __entry->flags = attr->mq_flags;
1064 __entry->curmsgs = attr->mq_curmsgs;
1065 __entry->msgsize = attr->mq_msgsize;
1066 __entry->maxmsg = attr->mq_maxmsg;
1067 ),
1068 TP_printk("mqd=%d flags=%#lx(%s) curmsgs=%ld msgsize=%ld maxmsg=%ld",
1069 __entry->mqd,
1070 __entry->flags, cobalt_print_oflags(__entry->flags),
1071 __entry->curmsgs,
1072 __entry->msgsize,
1073 __entry->maxmsg
1074 )
1075);
1076
1077DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_getattr,
1078 TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
1079 TP_ARGS(mqd, attr)
1080);
1081
1082DEFINE_EVENT(cobalt_posix_mqattr, cobalt_mq_setattr,
1083 TP_PROTO(mqd_t mqd, const struct mq_attr *attr),
1084 TP_ARGS(mqd, attr)
1085);
1086
1087#define cobalt_print_evflags(__flags) \
1088 __print_flags(__flags, "|", \
1089 {COBALT_EVENT_SHARED, "shared"}, \
1090 {COBALT_EVENT_PRIO, "prio"})
1091
1092TRACE_EVENT(cobalt_event_init,
1093 TP_PROTO(const struct cobalt_event_shadow __user *u_event,
1094 unsigned long value, int flags),
1095 TP_ARGS(u_event, value, flags),
1096 TP_STRUCT__entry(
1097 __field(const struct cobalt_event_shadow __user *, u_event)
1098 __field(unsigned long, value)
1099 __field(int, flags)
1100 ),
1101 TP_fast_assign(
1102 __entry->u_event = u_event;
1103 __entry->value = value;
1104 __entry->flags = flags;
1105 ),
1106 TP_printk("event=%p value=%lu flags=%#x(%s)",
1107 __entry->u_event, __entry->value,
1108 __entry->flags, cobalt_print_evflags(__entry->flags))
1109);
1110
1111#define cobalt_print_evmode(__mode) \
1112 __print_symbolic(__mode, \
1113 {COBALT_EVENT_ANY, "any"}, \
1114 {COBALT_EVENT_ALL, "all"})
1115
1116TRACE_EVENT(cobalt_event_timedwait,
1117 TP_PROTO(const struct cobalt_event_shadow __user *u_event,
1118 unsigned long bits, int mode,
1119 const struct timespec64 *timeout),
1120 TP_ARGS(u_event, bits, mode, timeout),
1121 TP_STRUCT__entry(
1122 __field(const struct cobalt_event_shadow __user *, u_event)
1123 __field(unsigned long, bits)
1124 __field(int, mode)
1125 __timespec_fields(timeout)
1126 ),
1127 TP_fast_assign(
1128 __entry->u_event = u_event;
1129 __entry->bits = bits;
1130 __entry->mode = mode;
1131 __assign_timespec(timeout, timeout);
1132 ),
1133 TP_printk("event=%p bits=%#lx mode=%#x(%s) timeout=(%lld.%09ld)",
1134 __entry->u_event, __entry->bits, __entry->mode,
1135 cobalt_print_evmode(__entry->mode),
1136 __timespec_args(timeout))
1137);
1138
1139TRACE_EVENT(cobalt_event_wait,
1140 TP_PROTO(const struct cobalt_event_shadow __user *u_event,
1141 unsigned long bits, int mode),
1142 TP_ARGS(u_event, bits, mode),
1143 TP_STRUCT__entry(
1144 __field(const struct cobalt_event_shadow __user *, u_event)
1145 __field(unsigned long, bits)
1146 __field(int, mode)
1147 ),
1148 TP_fast_assign(
1149 __entry->u_event = u_event;
1150 __entry->bits = bits;
1151 __entry->mode = mode;
1152 ),
1153 TP_printk("event=%p bits=%#lx mode=%#x(%s)",
1154 __entry->u_event, __entry->bits, __entry->mode,
1155 cobalt_print_evmode(__entry->mode))
1156);
1157
1158DECLARE_EVENT_CLASS(cobalt_event_ident,
1159 TP_PROTO(const struct cobalt_event_shadow __user *u_event),
1160 TP_ARGS(u_event),
1161 TP_STRUCT__entry(
1162 __field(const struct cobalt_event_shadow __user *, u_event)
1163 ),
1164 TP_fast_assign(
1165 __entry->u_event = u_event;
1166 ),
1167 TP_printk("event=%p", __entry->u_event)
1168);
1169
1170DEFINE_EVENT(cobalt_event_ident, cobalt_event_destroy,
1171 TP_PROTO(const struct cobalt_event_shadow __user *u_event),
1172 TP_ARGS(u_event)
1173);
1174
1175DEFINE_EVENT(cobalt_event_ident, cobalt_event_sync,
1176 TP_PROTO(const struct cobalt_event_shadow __user *u_event),
1177 TP_ARGS(u_event)
1178);
1179
1180DEFINE_EVENT(cobalt_event_ident, cobalt_event_inquire,
1181 TP_PROTO(const struct cobalt_event_shadow __user *u_event),
1182 TP_ARGS(u_event)
1183);
1184
1185#endif /* _TRACE_COBALT_POSIX_H */
1186
1187/* This part must be outside protection */
1188#undef TRACE_INCLUDE_PATH
1189#undef TRACE_INCLUDE_FILE
1190#define TRACE_INCLUDE_FILE cobalt-posix
1191#include <trace/define_trace.h>