?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Drop main() prototype. Syncs with NetBSD-8
[minix.git] / minix / usr.bin / trace / service / pm.c
blob1bbef8896f2512dc3675bf3e255a6b873a2e9a21
1
2 #include "inc.h"
3
4 #include <signal.h>
5 #include <sys/time.h>
6 #include <sys/wait.h>
7 #include <sys/resource.h>
8 #include <sys/utsname.h>
9 #include <sys/reboot.h>
10 #include <minix/profile.h>
11
12 static int
13 pm_exit_out(struct trace_proc * proc, const message * m_out)
14 {
15
16 put_value(proc, "status", "%d", m_out->m_lc_pm_exit.status);
17
18 return CT_NORETURN;
19 }
20
21 static const struct flags wait4_options[] = {
22 FLAG(WNOHANG),
23 FLAG(WUNTRACED),
24 FLAG(WALTSIG),
25 FLAG(WALLSIG),
26 FLAG(WNOWAIT),
27 FLAG(WNOZOMBIE),
28 FLAG(WOPTSCHECKED),
29 };
30
31 static void
32 put_wait4_status(struct trace_proc * proc, const char * name, int status)
33 {
34 const char *signame;
35 int sig;
36
37 /*
38 * There is no suitable set of macros to be used here, so we're going
39 * to invent our own: W_EXITED, W_SIGNALED, and W_STOPPED. Hopefully
40 * they are sufficiently clear even though they don't actually exist.
41 * The code below is downright messy, but it also ensures that no bits
42 * are set unexpectedly in the status.
43 */
44 if (!valuesonly && WIFEXITED(status) &&
45 status == W_EXITCODE(WEXITSTATUS(status), 0)) {
46 put_value(proc, name, "W_EXITED(%d)",
47 WEXITSTATUS(status));
48
49 return;
50 }
51
52 /* WCOREDUMP() actually returns WCOREFLAG or 0, but better safe.. */
53 if (!valuesonly && WIFSIGNALED(status) && status == (W_EXITCODE(0,
54 WTERMSIG(status)) | (WCOREDUMP(status) ? WCOREFLAG : 0))) {
55 sig = WTERMSIG(status);
56
57 if ((signame = get_signal_name(sig)) != NULL)
58 put_value(proc, name, "W_SIGNALED(%s)", signame);
59 else
60 put_value(proc, name, "W_SIGNALED(%u)", sig);
61
62 if (WCOREDUMP(status))
63 put_text(proc, "|WCOREDUMP");
64
65 return;
66 }
67
68 if (!valuesonly && WIFSTOPPED(status) &&
69 status == W_STOPCODE(WSTOPSIG(status))) {
70 sig = WSTOPSIG(status);
71
72 if ((signame = get_signal_name(sig)) != NULL)
73 put_value(proc, name, "W_STOPPED(%s)", signame);
74 else
75 put_value(proc, name, "W_STOPPED(%u)", sig);
76
77 return;
78 }
79
80 /*
81 * If we get here, either valuesonly is enabled or the resulting status
82 * is not one we recognize, for example because extra bits are set.
83 */
84 put_value(proc, name, "0x%04x", status);
85 }
86
87 static int
88 pm_wait4_out(struct trace_proc * proc, const message * m_out)
89 {
90
91 put_value(proc, "pid", "%d", m_out->m_lc_pm_wait4.pid);
92
93 return CT_NOTDONE;
94 }
95
96 static void
97 put_struct_rusage(struct trace_proc * proc, const char * name, int flags,
98 vir_bytes addr)
99 {
100 struct rusage ru;
101
102 if (!put_open_struct(proc, name, flags, addr, &ru, sizeof(ru)))
103 return;
104
105 put_struct_timeval(proc, "ru_utime", PF_LOCADDR,
106 (vir_bytes)&ru.ru_utime);
107 put_struct_timeval(proc, "ru_stime", PF_LOCADDR,
108 (vir_bytes)&ru.ru_stime);
109
110 if (verbose > 0) {
111 put_value(proc, "ru_maxrss", "%ld", ru.ru_maxrss);
112 put_value(proc, "ru_minflt", "%ld", ru.ru_minflt);
113 put_value(proc, "ru_majflt", "%ld", ru.ru_majflt);
114 }
115
116 put_close_struct(proc, verbose > 0);
117 }
118
119 static void
120 pm_wait4_in(struct trace_proc * proc, const message * m_out,
121 const message * m_in, int failed)
122 {
123
124 /*
125 * If the result is zero, there is no status to show. Also, since the
126 * status is returned in the result message, we cannot print the user-
127 * given pointer. Instead, upon failure we show "&.." to indicate an
128 * unknown pointer.
129 */
130 if (!failed && m_in->m_type > 0)
131 put_wait4_status(proc, "status", m_in->m_pm_lc_wait4.status);
132 else
133 put_field(proc, "status", "&..");
134 put_flags(proc, "options", wait4_options, COUNT(wait4_options),
135 "0x%x", m_out->m_lc_pm_wait4.options);
136 put_struct_rusage(proc, "rusage", failed, m_out->m_lc_pm_wait4.addr);
137 put_equals(proc);
138 put_result(proc);
139 }
140
141 static void
142 pm_getpid_in(struct trace_proc * proc, const message * __unused m_out,
143 const message * m_in, int failed)
144 {
145
146 put_result(proc);
147 if (!failed) {
148 put_open(proc, NULL, 0, "(", ", ");
149 put_value(proc, "ppid", "%d", m_in->m_pm_lc_getpid.parent_pid);
150 put_close(proc, ")");
151 }
152 }
153
154 /* This function is shared between setuid and seteuid. */
155 static int
156 pm_setuid_out(struct trace_proc * proc, const message * m_out)
157 {
158
159 put_value(proc, "uid", "%u", m_out->m_lc_pm_setuid.uid);
160
161 return CT_DONE;
162 }
163
164 static void
165 pm_getuid_in(struct trace_proc * proc, const message * __unused m_out,
166 const message * m_in, int failed)
167 {
168
169 put_result(proc);
170 if (!failed) {
171 put_open(proc, NULL, 0, "(", ", ");
172 put_value(proc, "euid", "%u", m_in->m_pm_lc_getuid.euid);
173 put_close(proc, ")");
174 }
175 }
176
177 static int
178 pm_stime_out(struct trace_proc * proc, const message * m_out)
179 {
180
181 put_time(proc, "time", m_out->m_lc_pm_time.sec);
182
183 return CT_DONE;
184 }
185
186 static void
187 put_signal(struct trace_proc * proc, const char * name, int sig)
188 {
189 const char *signame;
190
191 if (!valuesonly && (signame = get_signal_name(sig)) != NULL)
192 put_field(proc, name, signame);
193 else
194 put_value(proc, name, "%d", sig);
195 }
196
197 static void
198 put_ptrace_req(struct trace_proc * proc, const char * name, int req)
199 {
200 const char *text = NULL;
201
202 if (!valuesonly) {
203 switch (req) {
204 TEXT(T_STOP);
205 TEXT(T_OK);
206 TEXT(T_ATTACH);
207 TEXT(T_DETACH);
208 TEXT(T_RESUME);
209 TEXT(T_STEP);
210 TEXT(T_SYSCALL);
211 TEXT(T_EXIT);
212 TEXT(T_GETINS);
213 TEXT(T_GETDATA);
214 TEXT(T_GETUSER);
215 TEXT(T_SETINS);
216 TEXT(T_SETDATA);
217 TEXT(T_SETUSER);
218 TEXT(T_SETOPT);
219 TEXT(T_GETRANGE);
220 TEXT(T_SETRANGE);
221 TEXT(T_READB_INS);
222 TEXT(T_WRITEB_INS);
223 }
224 }
225
226 if (text != NULL)
227 put_field(proc, name, text);
228 else
229 put_value(proc, name, "%d", req);
230 }
231
232 static void
233 put_struct_ptrace_range(struct trace_proc * proc, const char * name, int flags,
234 vir_bytes addr)
235 {
236 struct ptrace_range pr;
237
238 if (!put_open_struct(proc, name, flags, addr, &pr, sizeof(pr)))
239 return;
240
241 if (!valuesonly && pr.pr_space == TS_INS)
242 put_field(proc, "pr_space", "TS_INS");
243 else if (!valuesonly && pr.pr_space == TS_DATA)
244 put_field(proc, "pr_space", "TS_DATA");
245 else
246 put_value(proc, "pr_space", "%d", pr.pr_space);
247 put_value(proc, "pr_addr", "0x%lx", pr.pr_addr);
248 put_ptr(proc, "pr_ptr", (vir_bytes)pr.pr_ptr);
249 put_value(proc, "pr_size", "%zu", pr.pr_size);
250
251 put_close_struct(proc, TRUE /*all*/);
252 }
253
254 static int
255 pm_ptrace_out(struct trace_proc * proc, const message * m_out)
256 {
257
258 put_ptrace_req(proc, "req", m_out->m_lc_pm_ptrace.req);
259 put_value(proc, "pid", "%d", m_out->m_lc_pm_ptrace.pid);
260
261 switch (m_out->m_lc_pm_ptrace.req) {
262 case T_GETINS:
263 case T_GETDATA:
264 case T_GETUSER:
265 case T_READB_INS:
266 put_value(proc, "addr", "0x%lx", m_out->m_lc_pm_ptrace.addr);
267 put_value(proc, "data", "%ld", m_out->m_lc_pm_ptrace.data);
268 break;
269 case T_SETINS:
270 case T_SETDATA:
271 case T_SETUSER:
272 case T_WRITEB_INS:
273 put_value(proc, "addr", "0x%lx", m_out->m_lc_pm_ptrace.addr);
274 put_value(proc, "data", "0x%lx", m_out->m_lc_pm_ptrace.data);
275 break;
276 case T_RESUME:
277 case T_STEP:
278 case T_SYSCALL:
279 put_value(proc, "addr", "%ld", m_out->m_lc_pm_ptrace.addr);
280 put_signal(proc, "data", m_out->m_lc_pm_ptrace.data);
281 break;
282 case T_GETRANGE:
283 case T_SETRANGE:
284 put_struct_ptrace_range(proc, "addr", 0,
285 m_out->m_lc_pm_ptrace.addr);
286 put_value(proc, "data", "%ld", m_out->m_lc_pm_ptrace.data);
287 break;
288 default:
289 put_value(proc, "addr", "%ld", m_out->m_lc_pm_ptrace.addr);
290 put_value(proc, "data", "%ld", m_out->m_lc_pm_ptrace.data);
291 break;
292 }
293
294 return CT_DONE;
295 }
296
297 static void
298 pm_ptrace_in(struct trace_proc * proc, const message * m_out,
299 const message * m_in, int failed)
300 {
301
302 if (!failed) {
303 switch (m_out->m_lc_pm_ptrace.req) {
304 case T_GETINS:
305 case T_GETDATA:
306 case T_GETUSER:
307 case T_READB_INS:
308 put_value(proc, NULL, "0x%lx",
309 m_in->m_pm_lc_ptrace.data);
310 return;
311 }
312 }
313
314 put_result(proc);
315 }
316
317 void
318 put_groups(struct trace_proc * proc, const char * name, int flags,
319 vir_bytes addr, int count)
320 {
321 gid_t groups[NGROUPS_MAX];
322 int i;
323
324 if ((flags & PF_FAILED) || valuesonly || count < 0 ||
325 count > NGROUPS_MAX || (count > 0 && mem_get_data(proc->pid, addr,
326 groups, count * sizeof(groups[0])) < 0)) {
327 if (flags & PF_LOCADDR)
328 put_field(proc, name, "&..");
329 else
330 put_ptr(proc, name, addr);
331
332 return;
333 }
334
335 put_open(proc, name, PF_NONAME, "[", ", ");
336 for (i = 0; i < count; i++)
337 put_value(proc, NULL, "%u", groups[i]);
338 put_close(proc, "]");
339 }
340
341 static int
342 pm_setgroups_out(struct trace_proc * proc, const message * m_out)
343 {
344
345 put_value(proc, "ngroups", "%d", m_out->m_lc_pm_groups.num);
346 put_groups(proc, "grouplist", 0, m_out->m_lc_pm_groups.ptr,
347 m_out->m_lc_pm_groups.num);
348
349 return CT_DONE;
350 }
351
352 static int
353 pm_getgroups_out(struct trace_proc * proc, const message * m_out)
354 {
355
356 put_value(proc, "ngroups", "%d", m_out->m_lc_pm_groups.num);
357
358 return CT_NOTDONE;
359 }
360
361 static void
362 pm_getgroups_in(struct trace_proc * proc, const message * m_out,
363 const message * m_in, int failed)
364 {
365
366 put_groups(proc, "grouplist", failed, m_out->m_lc_pm_groups.ptr,
367 m_in->m_type);
368 put_equals(proc);
369 put_result(proc);
370 }
371
372 static int
373 pm_kill_out(struct trace_proc * proc, const message * m_out)
374 {
375
376 put_value(proc, "pid", "%d", m_out->m_lc_pm_sig.pid);
377 put_signal(proc, "sig", m_out->m_lc_pm_sig.nr);
378
379 return CT_DONE;
380 }
381
382 /* This function is shared between setgid and setegid. */
383 static int
384 pm_setgid_out(struct trace_proc * proc, const message * m_out)
385 {
386
387 put_value(proc, "gid", "%u", m_out->m_lc_pm_setgid.gid);
388
389 return CT_DONE;
390 }
391
392 static void
393 pm_getgid_in(struct trace_proc * proc, const message * __unused m_out,
394 const message * m_in, int failed)
395 {
396
397 put_result(proc);
398 if (!failed) {
399 put_open(proc, NULL, 0, "(", ", ");
400 put_value(proc, "egid", "%u", m_in->m_pm_lc_getgid.egid);
401 put_close(proc, ")");
402 }
403 }
404
405 static int
406 put_frame_string(struct trace_proc * proc, vir_bytes frame, size_t len,
407 vir_bytes addr)
408 {
409 vir_bytes stacktop, offset;
410
411 /*
412 * The addresses in the frame assume that the process has already been
413 * changed, and the top of the frame is now located at the new process
414 * stack top, which is a hardcoded system-global value. In order to
415 * print the strings, we must convert back each address to its location
416 * within the given frame.
417 */
418 stacktop = kernel_get_stacktop();
419
420 if (addr >= stacktop)
421 return FALSE;
422 offset = stacktop - addr;
423 if (offset >= len)
424 return FALSE;
425 addr = frame + len - offset;
426
427 /*
428 * TODO: while using put_buf() is highly convenient, it does require at
429 * least one copy operation per printed string. The strings are very
430 * likely to be consecutive in memory, so copying in larger chunks at
431 * once would be preferable. Also, if copying from the frame fails,
432 * put_buf() will print the string address as we corrected it above,
433 * rather than the address as found in the frame. A copy failure would
434 * always be a case of malice on the traced process's behalf, though.
435 */
436 put_buf(proc, NULL, PF_STRING, addr, len - offset);
437
438 return TRUE;
439 }
440
441 /*
442 * Print the contents of the exec frame, which includes both pointers and
443 * actual string data for the arguments and environment variables to be used.
444 * Even though we know that the entire frame is not going to exceed ARG_MAX
445 * bytes, this is too large a size for a static buffer, and we'd like to avoid
446 * allocating large dynamic buffers as well. The situation is complicated by
447 * the fact that any string in the frame may run up to the end of the frame.
448 */
449 static void
450 put_exec_frame(struct trace_proc * proc, vir_bytes addr, size_t len)
451 {
452 void *argv[64];
453 size_t off, chunk;
454 unsigned int i, count, max, argv_max, envp_max;
455 int first, ok, nulls;
456
457 if (valuesonly) {
458 put_ptr(proc, "frame", addr);
459 put_value(proc, "framelen", "%zu", len);
460
461 return;
462 }
463
464 if (verbose == 0) {
465 argv_max = 16;
466 envp_max = 0;
467 } else if (verbose == 1)
468 argv_max = envp_max = 64;
469 else
470 argv_max = envp_max = INT_MAX;
471
472 off = sizeof(int); /* skip 'argc' at the start of the frame */
473 first = TRUE;
474 ok = TRUE;
475 nulls = 0;
476 count = 0;
477 max = argv_max;
478
479 do {
480 chunk = sizeof(argv);
481 if (chunk > len - off)
482 chunk = len - off;
483
484 if (mem_get_data(proc->pid, addr + off, argv, chunk) != 0)
485 break;
486
487 if (first) {
488 put_open(proc, "argv", PF_NONAME, "[", ", ");
489
490 first = FALSE;
491 }
492
493 for (i = 0; i < chunk / sizeof(void *) && ok; i++) {
494 if (argv[i] == NULL) {
495 if (count > max)
496 put_tail(proc, count, max);
497 put_close(proc, "]");
498 if (nulls++ == 0) {
499 put_open(proc, "envp", PF_NONAME, "[",
500 ", ");
501 count = 0;
502 max = envp_max;
503 } else
504 break; /* two NULL pointers: done! */
505 } else if (count++ < max)
506 ok = put_frame_string(proc, addr, len,
507 (vir_bytes)argv[i]);
508 }
509
510 off += chunk;
511 } while (nulls < 2 && ok);
512
513 /*
514 * Handle failure cases, implied by not reaching the second NULL
515 * in the array. Successful completion is handled in the loop above.
516 * Note that 'ok' is not always cleared on failure, as it is used only
517 * to break out of the outer loop.
518 */
519 if (first) {
520 put_ptr(proc, "argv", addr + off);
521 put_field(proc, "envp", "&..");
522 } else if (nulls < 2) {
523 put_tail(proc, 0, 0);
524 put_close(proc, "]");
525 if (nulls < 1) {
526 put_open(proc, "envp", PF_NONAME, "[", ", ");
527 put_tail(proc, 0, 0);
528 put_close(proc, "]");
529 }
530 }
531 }
532
533 static int
534 pm_exec_out(struct trace_proc * proc, const message * m_out)
535 {
536
537 put_buf(proc, "path", PF_PATH, m_out->m_lc_pm_exec.name,
538 m_out->m_lc_pm_exec.namelen);
539 put_exec_frame(proc, m_out->m_lc_pm_exec.frame,
540 m_out->m_lc_pm_exec.framelen);
541
542 return CT_NORETURN;
543 }
544
545 /* The idea is that this function may one day print a human-readable time. */
546 void
547 put_time(struct trace_proc * proc, const char * name, time_t time)
548 {
549
550 put_value(proc, name, "%"PRId64, time);
551 }
552
553 void
554 put_struct_timeval(struct trace_proc * proc, const char * name, int flags,
555 vir_bytes addr)
556 {
557 struct timeval tv;
558
559 /* No field names; they just make things harder to read. */
560 if (!put_open_struct(proc, name, flags | PF_NONAME, addr, &tv,
561 sizeof(tv)))
562 return;
563
564 if (flags & PF_ALT)
565 put_time(proc, "tv_sec", tv.tv_sec);
566 else
567 put_value(proc, "tv_sec", "%"PRId64, tv.tv_sec);
568 put_value(proc, "tv_usec", "%d", tv.tv_usec);
569
570 put_close_struct(proc, TRUE /*all*/);
571 }
572
573 static void
574 put_struct_itimerval(struct trace_proc * proc, const char * name, int flags,
575 vir_bytes addr)
576 {
577 struct itimerval it;
578
579 /*
580 * This used to pass PF_NONAME, but the layout may not be clear enough
581 * without names. It does turn simple alarm(1) calls into rather
582 * lengthy output, though.
583 */
584 if (!put_open_struct(proc, name, flags, addr, &it, sizeof(it)))
585 return;
586
587 put_struct_timeval(proc, "it_interval", PF_LOCADDR,
588 (vir_bytes)&it.it_interval);
589 put_struct_timeval(proc, "it_value", PF_LOCADDR,
590 (vir_bytes)&it.it_value);
591
592 put_close_struct(proc, TRUE /*all*/);
593 }
594
595 static void
596 put_itimer_which(struct trace_proc * proc, const char * name, int which)
597 {
598 const char *text = NULL;
599
600 if (!valuesonly) {
601 switch (which) {
602 TEXT(ITIMER_REAL);
603 TEXT(ITIMER_VIRTUAL);
604 TEXT(ITIMER_PROF);
605 TEXT(ITIMER_MONOTONIC);
606 }
607 }
608
609 if (text != NULL)
610 put_field(proc, name, text);
611 else
612 put_value(proc, name, "%d", which);
613 }
614
615 static const char *
616 pm_itimer_name(const message * m_out)
617 {
618
619 return (m_out->m_lc_pm_itimer.value != 0) ? "setitimer" : "getitimer";
620 }
621
622 static int
623 pm_itimer_out(struct trace_proc * proc, const message * m_out)
624 {
625
626 put_itimer_which(proc, "which", m_out->m_lc_pm_itimer.which);
627 if (m_out->m_lc_pm_itimer.value != 0) {
628 put_struct_itimerval(proc, "value", 0,
629 m_out->m_lc_pm_itimer.value);
630
631 /*
632 * If there will be no old values to print, finish the call
633 * now. For setitimer only; getitimer may not pass NULL.
634 */
635 if (m_out->m_lc_pm_itimer.ovalue == 0) {
636 put_ptr(proc, "ovalue", 0);
637
638 return CT_DONE;
639 }
640 }
641
642 return CT_NOTDONE;
643 }
644
645 static void
646 pm_itimer_in(struct trace_proc * proc, const message * m_out,
647 const message * __unused m_in, int failed)
648 {
649
650 if (m_out->m_lc_pm_itimer.value == 0 ||
651 m_out->m_lc_pm_itimer.ovalue != 0) {
652 put_struct_itimerval(proc,
653 (m_out->m_lc_pm_itimer.value != 0) ? "ovalue" : "value",
654 failed, m_out->m_lc_pm_itimer.ovalue);
655 put_equals(proc);
656 }
657 put_result(proc);
658 }
659
660 static void
661 put_struct_mcontext(struct trace_proc * proc, const char * name, int flags,
662 vir_bytes addr)
663 {
664 mcontext_t ctx;
665
666 if (!put_open_struct(proc, name, flags, addr, &ctx, sizeof(ctx)))
667 return;
668
669 /*
670 * TODO: print actual fields. Then again, the ones that are saved and
671 * restored (FPU state) are hardly interesting enough to print..
672 */
673
674 put_close_struct(proc, FALSE /*all*/);
675 }
676
677 static int
678 pm_getmcontext_out(struct trace_proc * proc, const message * m_out)
679 {
680
681 return CT_NOTDONE;
682 }
683
684 static void
685 pm_getmcontext_in(struct trace_proc * proc, const message * m_out,
686 const message * m_in, int failed)
687 {
688
689 put_struct_mcontext(proc, "mcp", failed, m_out->m_lc_pm_mcontext.ctx);
690 put_equals(proc);
691 put_result(proc);
692 }
693
694 static int
695 pm_setmcontext_out(struct trace_proc * proc, const message * m_out)
696 {
697
698 put_struct_mcontext(proc, "mcp", 0, m_out->m_lc_pm_mcontext.ctx);
699
700 return CT_DONE;
701 }
702
703 static void
704 put_sigset(struct trace_proc * proc, const char * name, sigset_t set)
705 {
706 const char *signame;
707 unsigned int count, unknown;
708 int sig, invert;
709
710 /*
711 * First decide whether we should print a normal or an inverted mask.
712 * Unfortunately, depending on the place, a filled set may or may not
713 * have bits outside the 1..NSIG range set. Therefore, we ignore the
714 * bits outside this range entirely, and use simple heuristics to
715 * decide whether to show an inverted set. If we know all the signal
716 * names for either set and not the other, show that one; otherwise,
717 * show an inverted mask if at least 3/4th of the bits are set.
718 */
719 count = 0;
720 unknown = 0;
721 for (sig = 1; sig < NSIG; sig++) {
722 if (sigismember(&set, sig))
723 count++;
724 if (get_signal_name(sig) == NULL)
725 unknown |= 1 << !!sigismember(&set, sig);
726 }
727 if (unknown == 1 /*for unset bit*/ || unknown == 2 /*for set bit*/)
728 invert = unknown - 1;
729 else
730 invert = (count >= (NSIG - 1) * 3 / 4);
731
732 put_open(proc, name, PF_NONAME, invert ? "~[" : "[", " ");
733
734 for (sig = 1; sig < NSIG; sig++) {
735 /* Note that sigismember() may not strictly return 0 or 1.. */
736 if (!sigismember(&set, sig) != invert)
737 continue;
738
739 if ((signame = get_signal_name(sig)) != NULL) {
740 /* Skip the "SIG" prefix for brevity. */
741 if (!strncmp(signame, "SIG", 3))
742 put_field(proc, NULL, &signame[3]);
743 else
744 put_field(proc, NULL, signame);
745 } else
746 put_value(proc, NULL, "%d", sig);
747 }
748
749 put_close(proc, "]");
750 }
751
752 static const struct flags sa_flags[] = {
753 FLAG(SA_ONSTACK),
754 FLAG(SA_RESTART),
755 FLAG(SA_RESETHAND),
756 FLAG(SA_NODEFER),
757 FLAG(SA_NOCLDSTOP),
758 FLAG(SA_NOCLDWAIT),
759 #ifdef SA_SIGINFO
760 FLAG(SA_SIGINFO),
761 #endif
762 FLAG(SA_NOKERNINFO)
763 };
764
765 static void
766 put_sa_handler(struct trace_proc * proc, const char * name, vir_bytes handler)
767 {
768 const char *text = NULL;
769
770 if (!valuesonly) {
771 switch ((int)handler) {
772 case (int)SIG_DFL: text = "SIG_DFL"; break;
773 case (int)SIG_IGN: text = "SIG_IGN"; break;
774 case (int)SIG_HOLD: text = "SIG_HOLD"; break;
775 }
776 }
777
778 if (text != NULL)
779 put_field(proc, name, text);
780 else
781 put_ptr(proc, name, handler);
782 }
783
784 static void
785 put_struct_sigaction(struct trace_proc * proc, const char * name, int flags,
786 vir_bytes addr)
787 {
788 struct sigaction sa;
789
790 if (!put_open_struct(proc, name, flags, addr, &sa, sizeof(sa)))
791 return;
792
793 put_sa_handler(proc, "sa_handler", (vir_bytes)sa.sa_handler);
794
795 if (verbose > 1)
796 put_sigset(proc, "sa_mask", sa.sa_mask);
797
798 /* A somewhat lame attempt to reduce noise a bit. */
799 if ((sa.sa_flags & ~(SA_ONSTACK | SA_RESTART | SA_RESETHAND |
800 SA_NODEFER)) != 0 || sa.sa_handler != SIG_DFL || verbose > 0)
801 put_flags(proc, "sa_flags", sa_flags, COUNT(sa_flags), "0x%x",
802 sa.sa_flags);
803
804 put_close_struct(proc, verbose > 1);
805 }
806
807 static int
808 pm_sigaction_out(struct trace_proc * proc, const message * m_out)
809 {
810
811 put_signal(proc, "signal", m_out->m_lc_pm_sig.nr);
812 put_struct_sigaction(proc, "act", 0, m_out->m_lc_pm_sig.act);
813
814 /* If there will be no old values to print, finish the call now. */
815 if (m_out->m_lc_pm_sig.oact == 0) {
816 put_ptr(proc, "oact", 0);
817 return CT_DONE;
818 } else
819 return CT_NOTDONE;
820 }
821
822 static void
823 pm_sigaction_in(struct trace_proc * proc, const message * m_out,
824 const message * __unused m_in, int failed)
825 {
826
827 if (m_out->m_lc_pm_sig.oact != 0) {
828 put_struct_sigaction(proc, "oact", failed,
829 m_out->m_lc_pm_sig.oact);
830 put_equals(proc);
831 }
832 put_result(proc);
833 }
834
835 static int
836 pm_sigsuspend_out(struct trace_proc * proc, const message * m_out)
837 {
838
839 put_sigset(proc, "set", m_out->m_lc_pm_sigset.set);
840
841 return CT_DONE;
842 }
843
844 static int
845 pm_sigpending_out(struct trace_proc * __unused proc,
846 const message * __unused m_out)
847 {
848
849 return CT_NOTDONE;
850 }
851
852 static void
853 pm_sigpending_in(struct trace_proc * proc, const message * __unused m_out,
854 const message * m_in, int failed)
855 {
856
857 if (!failed)
858 put_sigset(proc, "set", m_in->m_pm_lc_sigset.set);
859 else
860 put_field(proc, "set", "&..");
861 put_equals(proc);
862 put_result(proc);
863 }
864
865 static void
866 put_sigprocmask_how(struct trace_proc * proc, const char * name, int how)
867 {
868 const char *text = NULL;
869
870 if (!valuesonly) {
871 switch (how) {
872 case SIG_INQUIRE: /* pseudocode, print something else */
873 TEXT(SIG_BLOCK);
874 TEXT(SIG_UNBLOCK);
875 TEXT(SIG_SETMASK);
876 }
877 }
878
879 if (text != NULL)
880 put_field(proc, name, text);
881 else
882 put_value(proc, name, "%d", how);
883 }
884
885 static int
886 pm_sigprocmask_out(struct trace_proc * proc, const message * m_out)
887 {
888
889 put_sigprocmask_how(proc, "how", m_out->m_lc_pm_sigset.how);
890 if (m_out->m_lc_pm_sigset.how == SIG_INQUIRE)
891 put_ptr(proc, "set", 0);
892 else
893 put_sigset(proc, "set", m_out->m_lc_pm_sigset.set);
894
895 return CT_NOTDONE;
896 }
897
898 static void
899 pm_sigprocmask_in(struct trace_proc * proc, const message * __unused m_out,
900 const message * m_in, int failed)
901 {
902
903 if (!failed)
904 put_sigset(proc, "oset", m_in->m_pm_lc_sigset.set);
905 else
906 put_field(proc, "oset", "&..");
907 put_equals(proc);
908 put_result(proc);
909 }
910
911 static int
912 pm_sigreturn_out(struct trace_proc * proc, const message * m_out)
913 {
914 struct sigcontext scp;
915
916 if (put_open_struct(proc, "scp", 0, m_out->m_lc_pm_sigset.ctx, &scp,
917 sizeof(scp))) {
918 if (verbose == 1) {
919 #if defined(__i386__)
920 put_ptr(proc, "sc_eip", scp.sc_eip);
921 put_ptr(proc, "sc_esp", scp.sc_esp);
922 #elif defined(__arm__)
923 put_ptr(proc, "sc_pc", scp.sc_pc);
924 put_ptr(proc, "sc_usr_sp", scp.sc_usr_sp);
925 #endif
926 }
927
928 /*
929 * We deliberately print the signal set from the message rather
930 * than from the structure, since in theory they may be
931 * different and PM uses the one from the message only.
932 */
933 put_sigset(proc, "sc_mask", m_out->m_lc_pm_sigset.set);
934
935 /*
936 * TODO: print some other fields, although it is probably not
937 * useful to print all registers even with verbose > 1?
938 */
939 put_close_struct(proc, FALSE /*all*/);
940 }
941
942 return CT_NORETURN;
943 }
944
945 static void
946 pm_sigreturn_in(struct trace_proc * proc, const message * __unused m_out,
947 const message * __unused m_in, int failed)
948 {
949
950 if (failed) {
951 put_equals(proc);
952 put_result(proc);
953 }
954 }
955
956 static void
957 put_priority_which(struct trace_proc * proc, const char * name, int which)
958 {
959 const char *text = NULL;
960
961 if (!valuesonly) {
962 switch (which) {
963 TEXT(PRIO_PROCESS);
964 TEXT(PRIO_PGRP);
965 TEXT(PRIO_USER);
966 }
967 }
968
969 if (text != NULL)
970 put_field(proc, name, text);
971 else
972 put_value(proc, name, "%d", which);
973 }
974
975 static int
976 pm_getpriority_out(struct trace_proc * proc, const message * m_out)
977 {
978
979 put_priority_which(proc, "which", m_out->m_lc_pm_priority.which);
980 put_value(proc, "who", "%d", m_out->m_lc_pm_priority.who);
981
982 return CT_DONE;
983 }
984
985 static void
986 pm_getpriority_in(struct trace_proc * proc, const message * __unused m_out,
987 const message * m_in, int failed)
988 {
989
990 if (!failed)
991 put_value(proc, NULL, "%d", m_in->m_type + PRIO_MIN);
992 else
993 put_result(proc);
994 }
995
996 static int
997 pm_setpriority_out(struct trace_proc * proc, const message * m_out)
998 {
999
1000 put_priority_which(proc, "which", m_out->m_lc_pm_priority.which);
1001 put_value(proc, "who", "%d", m_out->m_lc_pm_priority.who);
1002 put_value(proc, "prio", "%d", m_out->m_lc_pm_priority.prio);
1003
1004 return CT_DONE;
1005 }
1006
1007 static int
1008 pm_gettimeofday_out(struct trace_proc * __unused proc,
1009 const message * __unused m_out)
1010 {
1011
1012 return CT_NOTDONE;
1013 }
1014
1015 static void
1016 put_timespec_as_timeval(struct trace_proc * proc, const char * name,
1017 time_t sec, long nsec)
1018 {
1019
1020 /* No field names within the structure. */
1021 put_open(proc, name, PF_NONAME, "{", ", ");
1022
1023 put_time(proc, "tv_sec", sec);
1024 put_value(proc, "tv_usec", "%ld", nsec / 1000);
1025
1026 put_close(proc, "}");
1027 }
1028
1029 static void
1030 pm_gettimeofday_in(struct trace_proc * proc, const message * __unused m_out,
1031 const message * m_in, int failed)
1032 {
1033
1034 if (!failed) {
1035 /*
1036 * The system call returns values which do not match the call
1037 * being made, so just like libc, we have to correct..
1038 */
1039 put_timespec_as_timeval(proc, "tp", m_in->m_pm_lc_time.sec,
1040 m_in->m_pm_lc_time.nsec);
1041 } else
1042 put_field(proc, "tp", "&..");
1043 put_ptr(proc, "tzp", 0); /* not part of the system call (yet) */
1044
1045 put_equals(proc);
1046 put_result(proc);
1047 }
1048
1049 static int
1050 pm_getsid_out(struct trace_proc * proc, const message * m_out)
1051 {
1052
1053 put_value(proc, "pid", "%d", m_out->m_lc_pm_getsid.pid);
1054
1055 return CT_DONE;
1056 }
1057
1058 static void
1059 put_clockid(struct trace_proc * proc, const char * name, clockid_t clock_id)
1060 {
1061 const char *text = NULL;
1062
1063 if (!valuesonly) {
1064 switch (clock_id) {
1065 TEXT(CLOCK_REALTIME);
1066 #ifdef CLOCK_VIRTUAL
1067 TEXT(CLOCK_VIRTUAL);
1068 #endif
1069 #ifdef CLOCK_PROF
1070 TEXT(CLOCK_PROF);
1071 #endif
1072 TEXT(CLOCK_MONOTONIC);
1073 }
1074 }
1075
1076 if (text != NULL)
1077 put_field(proc, name, text);
1078 else
1079 put_value(proc, name, "%d", clock_id);
1080 }
1081
1082 static void
1083 put_clock_timespec(struct trace_proc * proc, const char * name, int flags,
1084 time_t sec, long nsec)
1085 {
1086
1087 if (flags & PF_FAILED) {
1088 put_field(proc, name, "&..");
1089
1090 return;
1091 }
1092
1093 /* No field names within the structure. */
1094 put_open(proc, name, PF_NONAME, "{", ", ");
1095
1096 if (flags & PF_ALT)
1097 put_time(proc, "tv_sec", sec);
1098 else
1099 put_value(proc, "tv_sec", "%"PRId64, sec);
1100 put_value(proc, "tv_nsec", "%ld", nsec);
1101
1102 put_close(proc, "}");
1103 }
1104
1105 /* This function is shared between clock_getres and clock_gettime. */
1106 static int
1107 pm_clock_get_out(struct trace_proc * proc, const message * m_out)
1108 {
1109
1110 put_clockid(proc, "clock_id", m_out->m_lc_pm_time.clk_id);
1111
1112 return CT_NOTDONE;
1113 }
1114
1115 static void
1116 pm_clock_getres_in(struct trace_proc * proc, const message * __unused m_out,
1117 const message * m_in, int failed)
1118 {
1119
1120 put_clock_timespec(proc, "res", failed, m_in->m_pm_lc_time.sec,
1121 m_in->m_pm_lc_time.nsec);
1122 put_equals(proc);
1123 put_result(proc);
1124 }
1125
1126 /*
1127 * Same as pm_clock_getres_in, but different field name and the option to print
1128 * at least some results as time strings (in the future).
1129 */
1130 static void
1131 pm_clock_gettime_in(struct trace_proc * proc, const message * m_out,
1132 const message * m_in, int failed)
1133 {
1134 int flags;
1135
1136 flags = failed;
1137 if (m_out->m_lc_pm_time.clk_id == CLOCK_REALTIME)
1138 flags |= PF_ALT; /* TODO: make this print a time string. */
1139
1140 put_clock_timespec(proc, "tp", flags, m_in->m_pm_lc_time.sec,
1141 m_in->m_pm_lc_time.nsec);
1142 put_equals(proc);
1143 put_result(proc);
1144 }
1145
1146 static const char *
1147 pm_clock_settime_name(const message * m_out)
1148 {
1149
1150 if (m_out->m_lc_pm_time.now == 0)
1151 return "adjtime";
1152 else
1153 return "clock_settime";
1154 }
1155
1156 static int
1157 pm_clock_settime_out(struct trace_proc * proc, const message * m_out)
1158 {
1159 int flags;
1160
1161 /* These two calls just look completely different.. */
1162 if (m_out->m_lc_pm_time.now == 0) {
1163 put_timespec_as_timeval(proc, "delta", m_out->m_lc_pm_time.sec,
1164 m_out->m_lc_pm_time.nsec);
1165 put_ptr(proc, "odelta", 0); /* not supported on MINIX3 */
1166 } else {
1167 flags = 0;
1168 if (m_out->m_lc_pm_time.clk_id == CLOCK_REALTIME)
1169 flags |= PF_ALT;
1170 put_clockid(proc, "clock_id", m_out->m_lc_pm_time.clk_id);
1171 put_clock_timespec(proc, "tp", flags, m_out->m_lc_pm_time.sec,
1172 m_out->m_lc_pm_time.nsec);
1173 }
1174
1175 return CT_DONE;
1176 }
1177
1178 static int
1179 pm_getrusage_out(struct trace_proc * proc, const message * m_out)
1180 {
1181
1182 if (!valuesonly && m_out->m_lc_pm_rusage.who == RUSAGE_SELF)
1183 put_field(proc, "who", "RUSAGE_SELF");
1184 else if (!valuesonly && m_out->m_lc_pm_rusage.who == RUSAGE_CHILDREN)
1185 put_field(proc, "who", "RUSAGE_CHILDREN");
1186 else
1187 put_value(proc, "who", "%d", m_out->m_lc_pm_rusage.who);
1188
1189 return CT_NOTDONE;
1190 }
1191
1192 static void
1193 pm_getrusage_in(struct trace_proc * proc, const message * m_out,
1194 const message * __unused m_in, int failed)
1195 {
1196
1197 put_struct_rusage(proc, "rusage", failed, m_out->m_lc_pm_rusage.addr);
1198 put_equals(proc);
1199 put_result(proc);
1200 }
1201
1202 static const struct flags reboot_flags[] = {
1203 FLAG_ZERO(RB_AUTOBOOT),
1204 FLAG(RB_ASKNAME),
1205 FLAG(RB_DUMP),
1206 FLAG_MASK(RB_POWERDOWN, RB_HALT),
1207 FLAG(RB_POWERDOWN),
1208 FLAG(RB_INITNAME),
1209 FLAG(RB_KDB),
1210 FLAG(RB_NOSYNC),
1211 FLAG(RB_RDONLY),
1212 FLAG(RB_SINGLE),
1213 FLAG(RB_STRING),
1214 FLAG(RB_USERCONF),
1215 };
1216
1217 static int
1218 pm_reboot_out(struct trace_proc * proc, const message * m_out)
1219 {
1220
1221 put_flags(proc, "how", reboot_flags, COUNT(reboot_flags), "0x%x",
1222 m_out->m_lc_pm_reboot.how);
1223 put_ptr(proc, "bootstr", 0); /* not supported on MINIX3 */
1224
1225 return CT_DONE;
1226 }
1227
1228 static int
1229 pm_svrctl_out(struct trace_proc * proc, const message * m_out)
1230 {
1231
1232 put_ioctl_req(proc, "request", m_out->m_lc_svrctl.request,
1233 TRUE /*is_svrctl*/);
1234 return put_ioctl_arg_out(proc, "arg", m_out->m_lc_svrctl.request,
1235 m_out->m_lc_svrctl.arg, TRUE /*is_svrctl*/);
1236 }
1237
1238 static void
1239 pm_svrctl_in(struct trace_proc * proc, const message * m_out,
1240 const message * __unused m_in, int failed)
1241 {
1242
1243 put_ioctl_arg_in(proc, "arg", failed, m_out->m_lc_svrctl.request,
1244 m_out->m_lc_svrctl.arg, TRUE /*is_svrctl*/);
1245 }
1246
1247 static int
1248 pm_sprof_out(struct trace_proc * proc, const message * m_out)
1249 {
1250 int freq;
1251
1252 if (!valuesonly && m_out->m_lc_pm_sprof.action == PROF_START)
1253 put_field(proc, "action", "PROF_START");
1254 else if (!valuesonly && m_out->m_lc_pm_sprof.action == PROF_STOP)
1255 put_field(proc, "action", "PROF_STOP");
1256 else
1257 put_value(proc, "action", "%d", m_out->m_lc_pm_sprof.action);
1258
1259 put_value(proc, "size", "%zu", m_out->m_lc_pm_sprof.mem_size);
1260
1261 freq = m_out->m_lc_pm_sprof.freq;
1262 if (!valuesonly && freq >= 3 && freq <= 15) /* no constants.. */
1263 put_value(proc, "freq", "%u /*%uHz*/", freq, 1 << (16 - freq));
1264 else
1265 put_value(proc, "freq", "%u", freq);
1266
1267 if (!valuesonly && m_out->m_lc_pm_sprof.intr_type == PROF_RTC)
1268 put_field(proc, "type", "PROF_RTC");
1269 else if (!valuesonly && m_out->m_lc_pm_sprof.intr_type == PROF_NMI)
1270 put_field(proc, "type", "PROF_NMI");
1271 else
1272 put_value(proc, "type", "%d", m_out->m_lc_pm_sprof.intr_type);
1273
1274 put_ptr(proc, "ctl_ptr", m_out->m_lc_pm_sprof.ctl_ptr);
1275 put_ptr(proc, "mem_ptr", m_out->m_lc_pm_sprof.mem_ptr);
1276
1277 return CT_DONE;
1278 }
1279
1280 #define PM_CALL(c) [((PM_ ## c) - PM_BASE)]
1281
1282 static const struct call_handler pm_map[] = {
1283 PM_CALL(EXIT) = HANDLER("exit", pm_exit_out, default_in),
1284 PM_CALL(FORK) = HANDLER("fork", default_out, default_in),
1285 PM_CALL(WAIT4) = HANDLER("wait4", pm_wait4_out, pm_wait4_in),
1286 PM_CALL(GETPID) = HANDLER("getpid", default_out, pm_getpid_in),
1287 PM_CALL(SETUID) = HANDLER("setuid", pm_setuid_out, default_in),
1288 PM_CALL(GETUID) = HANDLER("getuid", default_out, pm_getuid_in),
1289 PM_CALL(STIME) = HANDLER("stime", pm_stime_out, default_in),
1290 PM_CALL(PTRACE) = HANDLER("ptrace", pm_ptrace_out, pm_ptrace_in),
1291 PM_CALL(SETGROUPS) = HANDLER("setgroups", pm_setgroups_out,
1292 default_in),
1293 PM_CALL(GETGROUPS) = HANDLER("getgroups", pm_getgroups_out,
1294 pm_getgroups_in),
1295 PM_CALL(KILL) = HANDLER("kill", pm_kill_out, default_in),
1296 PM_CALL(SETGID) = HANDLER("setgid", pm_setgid_out, default_in),
1297 PM_CALL(GETGID) = HANDLER("getgid", default_out, pm_getgid_in),
1298 PM_CALL(EXEC) = HANDLER("execve", pm_exec_out, default_in),
1299 PM_CALL(SETSID) = HANDLER("setsid", default_out, default_in),
1300 PM_CALL(GETPGRP) = HANDLER("getpgrp", default_out, default_in),
1301 PM_CALL(ITIMER) = HANDLER_NAME(pm_itimer_name, pm_itimer_out,
1302 pm_itimer_in),
1303 PM_CALL(GETMCONTEXT) = HANDLER("getmcontext", pm_getmcontext_out,
1304 pm_getmcontext_in),
1305 PM_CALL(SETMCONTEXT) = HANDLER("setmcontext", pm_setmcontext_out,
1306 default_in),
1307 PM_CALL(SIGACTION) = HANDLER("sigaction", pm_sigaction_out,
1308 pm_sigaction_in),
1309 PM_CALL(SIGSUSPEND) = HANDLER("sigsuspend", pm_sigsuspend_out,
1310 default_in),
1311 PM_CALL(SIGPENDING) = HANDLER("sigpending", pm_sigpending_out,
1312 pm_sigpending_in),
1313 PM_CALL(SIGPROCMASK) = HANDLER("sigprocmask", pm_sigprocmask_out,
1314 pm_sigprocmask_in),
1315 PM_CALL(SIGRETURN) = HANDLER("sigreturn", pm_sigreturn_out,
1316 pm_sigreturn_in),
1317 PM_CALL(GETPRIORITY) = HANDLER("getpriority", pm_getpriority_out,
1318 pm_getpriority_in),
1319 PM_CALL(SETPRIORITY) = HANDLER("setpriority", pm_setpriority_out,
1320 default_in),
1321 PM_CALL(GETTIMEOFDAY) = HANDLER("gettimeofday", pm_gettimeofday_out,
1322 pm_gettimeofday_in),
1323 PM_CALL(SETEUID) = HANDLER("seteuid", pm_setuid_out, default_in),
1324 PM_CALL(SETEGID) = HANDLER("setegid", pm_setgid_out, default_in),
1325 PM_CALL(ISSETUGID) = HANDLER("issetugid", default_out, default_in),
1326 PM_CALL(GETSID) = HANDLER("getsid", pm_getsid_out, default_in),
1327 PM_CALL(CLOCK_GETRES) = HANDLER("clock_getres", pm_clock_get_out,
1328 pm_clock_getres_in),
1329 PM_CALL(CLOCK_GETTIME) = HANDLER("clock_gettime", pm_clock_get_out,
1330 pm_clock_gettime_in),
1331 PM_CALL(CLOCK_SETTIME) = HANDLER_NAME(pm_clock_settime_name,
1332 pm_clock_settime_out, default_in),
1333 PM_CALL(GETRUSAGE) = HANDLER("getrusage", pm_getrusage_out,
1334 pm_getrusage_in),
1335 PM_CALL(REBOOT) = HANDLER("reboot", pm_reboot_out, default_in),
1336 PM_CALL(SVRCTL) = HANDLER("pm_svrctl", pm_svrctl_out, pm_svrctl_in),
1337 PM_CALL(SPROF) = HANDLER("sprofile", pm_sprof_out, default_in),
1338 };
1339
1340 const struct calls pm_calls = {
1341 .endpt = PM_PROC_NR,
1342 .base = PM_BASE,
1343 .map = pm_map,
1344 .count = COUNT(pm_map)
1345 };
MINIX 3 (repo.or.cz mirror)