granicus.if.org Git - strace/blob - wait.c

   1 /*
   2  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
   3  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
   4  * Copyright (c) 1993-1996 Rick Sladkey <jrs@world.std.com>
   5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   6  * Copyright (c) 2002-2004 Roland McGrath <roland@redhat.com>
   7  * Copyright (c) 2004 Ulrich Drepper <drepper@redhat.com>
   8  * Copyright (c) 2009-2013 Denys Vlasenko <dvlasenk@redhat.com>
   9  * Copyright (c) 2014-2015 Dmitry V. Levin <ldv@altlinux.org>
  10  * Copyright (c) 2014-2017 The strace developers.
  11  * All rights reserved.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. The name of the author may not be used to endorse or promote products
  22  *    derived from this software without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  25  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  27  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  28  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  29  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  33  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include "defs.h"
  37
  38 #include <sys/wait.h>
  39
  40 #include "xlat/wait4_options.h"
  41
  42 #if !defined WCOREFLAG && defined WCOREFLG
  43 # define WCOREFLAG WCOREFLG
  44 #endif
  45 #ifndef WCOREFLAG
  46 # define WCOREFLAG 0x80
  47 #endif
  48 #ifndef WCOREDUMP
  49 # define WCOREDUMP(status)  ((status) & 0200)
  50 #endif
  51 #ifndef W_STOPCODE
  52 # define W_STOPCODE(sig)  ((sig) << 8 | 0x7f)
  53 #endif
  54 #ifndef W_EXITCODE
  55 # define W_EXITCODE(ret, sig)  ((ret) << 8 | (sig))
  56 #endif
  57 #ifndef W_CONTINUED
  58 # define W_CONTINUED 0xffff
  59 #endif
  60
  61 #include "ptrace.h"
  62 #include "xlat/ptrace_events.h"
  63
  64 static int
  65 printstatus(int status)
  66 {
  67         int exited = 0;
  68
  69         /*
  70          * Here is a tricky presentation problem.  This solution
  71          * is still not entirely satisfactory but since there
  72          * are no wait status constructors it will have to do.
  73          */
  74         if (WIFSTOPPED(status)) {
  75                 int sig = WSTOPSIG(status);
  76                 tprintf("[{WIFSTOPPED(s) && WSTOPSIG(s) == %s%s}",
  77                         signame(sig & 0x7f),
  78                         sig & 0x80 ? " | 0x80" : "");
  79                 status &= ~W_STOPCODE(sig);
  80         }
  81         else if (WIFSIGNALED(status)) {
  82                 tprintf("[{WIFSIGNALED(s) && WTERMSIG(s) == %s%s}",
  83                         signame(WTERMSIG(status)),
  84                         WCOREDUMP(status) ? " && WCOREDUMP(s)" : "");
  85                 status &= ~(W_EXITCODE(0, WTERMSIG(status)) | WCOREFLAG);
  86         }
  87         else if (WIFEXITED(status)) {
  88                 tprintf("[{WIFEXITED(s) && WEXITSTATUS(s) == %d}",
  89                         WEXITSTATUS(status));
  90                 exited = 1;
  91                 status &= ~W_EXITCODE(WEXITSTATUS(status), 0);
  92         }
  93 #ifdef WIFCONTINUED
  94         else if (WIFCONTINUED(status)) {
  95                 tprints("[{WIFCONTINUED(s)}");
  96                 status &= ~W_CONTINUED;
  97         }
  98 #endif
  99         else {
 100                 tprintf("[%#x]", status);
 101                 return 0;
 102         }
 103
 104         if (status) {
 105                 unsigned int event = (unsigned int) status >> 16;
 106                 if (event) {
 107                         tprints(" | ");
 108                         printxval(ptrace_events, event, "PTRACE_EVENT_???");
 109                         tprints(" << 16");
 110                         status &= 0xffff;
 111                 }
 112                 if (status)
 113                         tprintf(" | %#x", status);
 114         }
 115         tprints("]");
 116
 117         return exited;
 118 }
 119
 120 static int
 121 printwaitn(struct tcb *const tcp,
 122            void (*const print_rusage)(struct tcb *, kernel_ulong_t))
 123 {
 124         if (entering(tcp)) {
 125                 /* On Linux, kernel-side pid_t is typedef'ed to int
 126                  * on all arches. Also, glibc-2.8 truncates wait3 and wait4
 127                  * pid argument to int on 64bit arches, producing,
 128                  * for example, wait4(4294967295, ...) instead of -1
 129                  * in strace. We have to use int here, not long.
 130                  */
 131                 int pid = tcp->u_arg[0];
 132                 tprintf("%d, ", pid);
 133         } else {
 134                 int status;
 135
 136                 /* status */
 137                 if (tcp->u_rval == 0)
 138                         printaddr(tcp->u_arg[1]);
 139                 else if (!umove_or_printaddr(tcp, tcp->u_arg[1], &status))
 140                         printstatus(status);
 141                 /* options */
 142                 tprints(", ");
 143                 printflags(wait4_options, tcp->u_arg[2], "W???");
 144                 if (print_rusage) {
 145                         /* usage */
 146                         tprints(", ");
 147                         if (tcp->u_rval > 0)
 148                                 print_rusage(tcp, tcp->u_arg[3]);
 149                         else
 150                                 printaddr(tcp->u_arg[3]);
 151                 }
 152         }
 153         return 0;
 154 }
 155
 156 SYS_FUNC(waitpid)
 157 {
 158         return printwaitn(tcp, NULL);
 159 }
 160
 161 SYS_FUNC(wait4)
 162 {
 163         return printwaitn(tcp, printrusage);
 164 }
 165
 166 #ifdef ALPHA
 167 SYS_FUNC(osf_wait4)
 168 {
 169         return printwaitn(tcp, printrusage32);
 170 }
 171 #endif
 172
 173 #include "xlat/waitid_types.h"
 174
 175 SYS_FUNC(waitid)
 176 {
 177         if (entering(tcp)) {
 178                 printxval(waitid_types, tcp->u_arg[0], "P_???");
 179                 int pid = tcp->u_arg[1];
 180                 tprintf(", %d, ", pid);
 181         } else {
 182                 /* siginfo */
 183                 printsiginfo_at(tcp, tcp->u_arg[2]);
 184                 /* options */
 185                 tprints(", ");
 186                 printflags(wait4_options, tcp->u_arg[3], "W???");
 187                 /* usage */
 188                 tprints(", ");
 189                 printrusage(tcp, tcp->u_arg[4]);
 190         }
 191         return 0;
 192 }