LCOV - code coverage report
Current view: top level - strace - syscall.c (source / functions) Hit Total Coverage
Test: strace-4.18.0.129.97bbb Code Coverage Lines: 314 337 93.2 %
Date: 2017-07-31 03:46:08 Functions: 24 24 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 204 250 81.6 %

           Branch data     Line data    Source code
       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, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
       5                 :            :  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
       6                 :            :  * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
       7                 :            :  *                     Linux for s390 port by D.J. Barrow
       8                 :            :  *                    <barrow_dj@mail.yahoo.com,djbarrow@de.ibm.com>
       9                 :            :  * Copyright (c) 1999-2017 The strace developers.
      10                 :            :  * All rights reserved.
      11                 :            :  *
      12                 :            :  * Redistribution and use in source and binary forms, with or without
      13                 :            :  * modification, are permitted provided that the following conditions
      14                 :            :  * are met:
      15                 :            :  * 1. Redistributions of source code must retain the above copyright
      16                 :            :  *    notice, this list of conditions and the following disclaimer.
      17                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      18                 :            :  *    notice, this list of conditions and the following disclaimer in the
      19                 :            :  *    documentation and/or other materials provided with the distribution.
      20                 :            :  * 3. The name of the author may not be used to endorse or promote products
      21                 :            :  *    derived from this software without specific prior written permission.
      22                 :            :  *
      23                 :            :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
      24                 :            :  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
      25                 :            :  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
      26                 :            :  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
      27                 :            :  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
      28                 :            :  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      29                 :            :  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      30                 :            :  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      31                 :            :  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
      32                 :            :  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      33                 :            :  */
      34                 :            : 
      35                 :            : #include "defs.h"
      36                 :            : #include "native_defs.h"
      37                 :            : #include "nsig.h"
      38                 :            : #include <sys/param.h>
      39                 :            : 
      40                 :            : /* for struct iovec */
      41                 :            : #include <sys/uio.h>
      42                 :            : 
      43                 :            : /* for __X32_SYSCALL_BIT */
      44                 :            : #include <asm/unistd.h>
      45                 :            : 
      46                 :            : #include "regs.h"
      47                 :            : #include "ptrace.h"
      48                 :            : 
      49                 :            : #if defined(SPARC64)
      50                 :            : # undef PTRACE_GETREGS
      51                 :            : # define PTRACE_GETREGS PTRACE_GETREGS64
      52                 :            : # undef PTRACE_SETREGS
      53                 :            : # define PTRACE_SETREGS PTRACE_SETREGS64
      54                 :            : #endif
      55                 :            : 
      56                 :            : #if defined SPARC64
      57                 :            : # include <asm/psrcompat.h>
      58                 :            : #elif defined SPARC
      59                 :            : # include <asm/psr.h>
      60                 :            : #endif
      61                 :            : 
      62                 :            : #ifdef IA64
      63                 :            : # include <asm/rse.h>
      64                 :            : #endif
      65                 :            : 
      66                 :            : #ifndef NT_PRSTATUS
      67                 :            : # define NT_PRSTATUS 1
      68                 :            : #endif
      69                 :            : 
      70                 :            : #include "syscall.h"
      71                 :            : 
      72                 :            : /* Define these shorthand notations to simplify the syscallent files. */
      73                 :            : #define TD TRACE_DESC
      74                 :            : #define TF TRACE_FILE
      75                 :            : #define TI TRACE_IPC
      76                 :            : #define TN TRACE_NETWORK
      77                 :            : #define TP TRACE_PROCESS
      78                 :            : #define TS TRACE_SIGNAL
      79                 :            : #define TM TRACE_MEMORY
      80                 :            : #define TST TRACE_STAT
      81                 :            : #define TLST TRACE_LSTAT
      82                 :            : #define TFST TRACE_FSTAT
      83                 :            : #define TSTA TRACE_STAT_LIKE
      84                 :            : #define TSF TRACE_STATFS
      85                 :            : #define TFSF TRACE_FSTATFS
      86                 :            : #define TSFA TRACE_STATFS_LIKE
      87                 :            : #define NF SYSCALL_NEVER_FAILS
      88                 :            : #define MA MAX_ARGS
      89                 :            : #define SI STACKTRACE_INVALIDATE_CACHE
      90                 :            : #define SE STACKTRACE_CAPTURE_ON_ENTER
      91                 :            : #define CST COMPAT_SYSCALL_TYPES
      92                 :            : 
      93                 :            : #define SEN(syscall_name) SEN_ ## syscall_name, SYS_FUNC_NAME(sys_ ## syscall_name)
      94                 :            : 
      95                 :            : const struct_sysent sysent0[] = {
      96                 :            : #include "syscallent.h"
      97                 :            : };
      98                 :            : 
      99                 :            : #if SUPPORTED_PERSONALITIES > 1
     100                 :            : # include PERSONALITY1_INCLUDE_FUNCS
     101                 :            : static const struct_sysent sysent1[] = {
     102                 :            : # include "syscallent1.h"
     103                 :            : };
     104                 :            : #endif
     105                 :            : 
     106                 :            : #if SUPPORTED_PERSONALITIES > 2
     107                 :            : # include PERSONALITY2_INCLUDE_FUNCS
     108                 :            : static const struct_sysent sysent2[] = {
     109                 :            : # include "syscallent2.h"
     110                 :            : };
     111                 :            : #endif
     112                 :            : 
     113                 :            : /* Now undef them since short defines cause wicked namespace pollution. */
     114                 :            : #undef SEN
     115                 :            : #undef TD
     116                 :            : #undef TF
     117                 :            : #undef TI
     118                 :            : #undef TN
     119                 :            : #undef TP
     120                 :            : #undef TS
     121                 :            : #undef TM
     122                 :            : #undef TST
     123                 :            : #undef TLST
     124                 :            : #undef TFST
     125                 :            : #undef TSTA
     126                 :            : #undef TSF
     127                 :            : #undef TFSF
     128                 :            : #undef TSFA
     129                 :            : #undef NF
     130                 :            : #undef MA
     131                 :            : #undef SI
     132                 :            : #undef SE
     133                 :            : #undef CST
     134                 :            : 
     135                 :            : /*
     136                 :            :  * `ioctlent[012].h' files are automatically generated by the auxiliary
     137                 :            :  * program `ioctlsort', such that the list is sorted by the `code' field.
     138                 :            :  * This has the side-effect of resolving the _IO.. macros into
     139                 :            :  * plain integers, eliminating the need to include here everything
     140                 :            :  * in "/usr/include".
     141                 :            :  */
     142                 :            : 
     143                 :            : const char *const errnoent0[] = {
     144                 :            : #include "errnoent.h"
     145                 :            : };
     146                 :            : const char *const signalent0[] = {
     147                 :            : #include "signalent.h"
     148                 :            : };
     149                 :            : const struct_ioctlent ioctlent0[] = {
     150                 :            : #include "ioctlent0.h"
     151                 :            : };
     152                 :            : 
     153                 :            : #if SUPPORTED_PERSONALITIES > 1
     154                 :            : static const char *const errnoent1[] = {
     155                 :            : # include "errnoent1.h"
     156                 :            : };
     157                 :            : static const char *const signalent1[] = {
     158                 :            : # include "signalent1.h"
     159                 :            : };
     160                 :            : static const struct_ioctlent ioctlent1[] = {
     161                 :            : # include "ioctlent1.h"
     162                 :            : };
     163                 :            : # include PERSONALITY0_INCLUDE_PRINTERS_DECLS
     164                 :            : static const struct_printers printers0 = {
     165                 :            : # include PERSONALITY0_INCLUDE_PRINTERS_DEFS
     166                 :            : };
     167                 :            : # include PERSONALITY1_INCLUDE_PRINTERS_DECLS
     168                 :            : static const struct_printers printers1 = {
     169                 :            : # include PERSONALITY1_INCLUDE_PRINTERS_DEFS
     170                 :            : };
     171                 :            : #endif
     172                 :            : 
     173                 :            : #if SUPPORTED_PERSONALITIES > 2
     174                 :            : static const char *const errnoent2[] = {
     175                 :            : # include "errnoent2.h"
     176                 :            : };
     177                 :            : static const char *const signalent2[] = {
     178                 :            : # include "signalent2.h"
     179                 :            : };
     180                 :            : static const struct_ioctlent ioctlent2[] = {
     181                 :            : # include "ioctlent2.h"
     182                 :            : };
     183                 :            : # include PERSONALITY2_INCLUDE_PRINTERS_DECLS
     184                 :            : static const struct_printers printers2 = {
     185                 :            : # include PERSONALITY2_INCLUDE_PRINTERS_DEFS
     186                 :            : };
     187                 :            : #endif
     188                 :            : 
     189                 :            : enum {
     190                 :            :         nsyscalls0 = ARRAY_SIZE(sysent0)
     191                 :            : #if SUPPORTED_PERSONALITIES > 1
     192                 :            :         , nsyscalls1 = ARRAY_SIZE(sysent1)
     193                 :            : # if SUPPORTED_PERSONALITIES > 2
     194                 :            :         , nsyscalls2 = ARRAY_SIZE(sysent2)
     195                 :            : # endif
     196                 :            : #endif
     197                 :            : };
     198                 :            : 
     199                 :            : const char *const *errnoent_vec[SUPPORTED_PERSONALITIES] = {
     200                 :            :         errnoent0,
     201                 :            : #if SUPPORTED_PERSONALITIES > 1
     202                 :            :         errnoent1,
     203                 :            : # if SUPPORTED_PERSONALITIES > 2
     204                 :            :         errnoent2,
     205                 :            : # endif
     206                 :            : #endif
     207                 :            : };
     208                 :            : 
     209                 :            : enum {
     210                 :            :         nerrnos0 = ARRAY_SIZE(errnoent0)
     211                 :            : #if SUPPORTED_PERSONALITIES > 1
     212                 :            :         , nerrnos1 = ARRAY_SIZE(errnoent1)
     213                 :            : # if SUPPORTED_PERSONALITIES > 2
     214                 :            :         , nerrnos2 = ARRAY_SIZE(errnoent2)
     215                 :            : # endif
     216                 :            : #endif
     217                 :            : };
     218                 :            : 
     219                 :            : const unsigned int nerrnoent_vec[] = {
     220                 :            :         nerrnos0,
     221                 :            : #if SUPPORTED_PERSONALITIES > 1
     222                 :            :         nerrnos1,
     223                 :            : # if SUPPORTED_PERSONALITIES > 2
     224                 :            :         nerrnos2,
     225                 :            : # endif
     226                 :            : #endif
     227                 :            : };
     228                 :            : 
     229                 :            : enum {
     230                 :            :         nsignals0 = ARRAY_SIZE(signalent0)
     231                 :            : #if SUPPORTED_PERSONALITIES > 1
     232                 :            :         , nsignals1 = ARRAY_SIZE(signalent1)
     233                 :            : # if SUPPORTED_PERSONALITIES > 2
     234                 :            :         , nsignals2 = ARRAY_SIZE(signalent2)
     235                 :            : # endif
     236                 :            : #endif
     237                 :            : };
     238                 :            : 
     239                 :            : const char *const *signalent_vec[SUPPORTED_PERSONALITIES] = {
     240                 :            :         signalent0,
     241                 :            : #if SUPPORTED_PERSONALITIES > 1
     242                 :            :         signalent1,
     243                 :            : # if SUPPORTED_PERSONALITIES > 2
     244                 :            :         signalent2,
     245                 :            : # endif
     246                 :            : #endif
     247                 :            : };
     248                 :            : 
     249                 :            : const unsigned int nsignalent_vec[] = {
     250                 :            :         nsignals0,
     251                 :            : #if SUPPORTED_PERSONALITIES > 1
     252                 :            :         nsignals1,
     253                 :            : # if SUPPORTED_PERSONALITIES > 2
     254                 :            :         nsignals2,
     255                 :            : # endif
     256                 :            : #endif
     257                 :            : };
     258                 :            : 
     259                 :            : enum {
     260                 :            :         nioctlents0 = ARRAY_SIZE(ioctlent0)
     261                 :            : #if SUPPORTED_PERSONALITIES > 1
     262                 :            :         , nioctlents1 = ARRAY_SIZE(ioctlent1)
     263                 :            : # if SUPPORTED_PERSONALITIES > 2
     264                 :            :         , nioctlents2 = ARRAY_SIZE(ioctlent2)
     265                 :            : # endif
     266                 :            : #endif
     267                 :            : };
     268                 :            : 
     269                 :            : const unsigned int nioctlent_vec[] = {
     270                 :            :         nioctlents0,
     271                 :            : #if SUPPORTED_PERSONALITIES > 1
     272                 :            :         nioctlents1,
     273                 :            : # if SUPPORTED_PERSONALITIES > 2
     274                 :            :         nioctlents2,
     275                 :            : # endif
     276                 :            : #endif
     277                 :            : };
     278                 :            : 
     279                 :            : const struct_ioctlent *const ioctlent_vec[SUPPORTED_PERSONALITIES] = {
     280                 :            :         ioctlent0,
     281                 :            : #if SUPPORTED_PERSONALITIES > 1
     282                 :            :         ioctlent1,
     283                 :            : # if SUPPORTED_PERSONALITIES > 2
     284                 :            :         ioctlent2,
     285                 :            : # endif
     286                 :            : #endif
     287                 :            : };
     288                 :            : 
     289                 :            : #if SUPPORTED_PERSONALITIES > 1
     290                 :            : const struct_sysent *sysent = sysent0;
     291                 :            : const char *const *errnoent = errnoent0;
     292                 :            : const char *const *signalent = signalent0;
     293                 :            : const struct_ioctlent *ioctlent = ioctlent0;
     294                 :            : const struct_printers *printers = &printers0;
     295                 :            : #endif
     296                 :            : 
     297                 :            : unsigned nsyscalls = nsyscalls0;
     298                 :            : unsigned nerrnos = nerrnos0;
     299                 :            : unsigned nsignals = nsignals0;
     300                 :            : unsigned nioctlents = nioctlents0;
     301                 :            : 
     302                 :            : const unsigned int nsyscall_vec[SUPPORTED_PERSONALITIES] = {
     303                 :            :         nsyscalls0,
     304                 :            : #if SUPPORTED_PERSONALITIES > 1
     305                 :            :         nsyscalls1,
     306                 :            : #endif
     307                 :            : #if SUPPORTED_PERSONALITIES > 2
     308                 :            :         nsyscalls2,
     309                 :            : #endif
     310                 :            : };
     311                 :            : const struct_sysent *const sysent_vec[SUPPORTED_PERSONALITIES] = {
     312                 :            :         sysent0,
     313                 :            : #if SUPPORTED_PERSONALITIES > 1
     314                 :            :         sysent1,
     315                 :            : #endif
     316                 :            : #if SUPPORTED_PERSONALITIES > 2
     317                 :            :         sysent2,
     318                 :            : #endif
     319                 :            : };
     320                 :            : 
     321                 :            : #if SUPPORTED_PERSONALITIES > 1
     322                 :            : unsigned current_personality;
     323                 :            : 
     324                 :            : # ifndef current_wordsize
     325                 :            : unsigned current_wordsize;
     326                 :            : static const int personality_wordsize[SUPPORTED_PERSONALITIES] = {
     327                 :            :         PERSONALITY0_WORDSIZE,
     328                 :            :         PERSONALITY1_WORDSIZE,
     329                 :            : # if SUPPORTED_PERSONALITIES > 2
     330                 :            :         PERSONALITY2_WORDSIZE,
     331                 :            : # endif
     332                 :            : };
     333                 :            : # endif
     334                 :            : 
     335                 :            : # ifndef current_klongsize
     336                 :            : unsigned current_klongsize;
     337                 :            : static const int personality_klongsize[SUPPORTED_PERSONALITIES] = {
     338                 :            :         PERSONALITY0_KLONGSIZE,
     339                 :            :         PERSONALITY1_KLONGSIZE,
     340                 :            : #  if SUPPORTED_PERSONALITIES > 2
     341                 :            :         PERSONALITY2_KLONGSIZE,
     342                 :            : #  endif
     343                 :            : };
     344                 :            : # endif
     345                 :            : 
     346                 :            : void
     347                 :      28986 : set_personality(int personality)
     348                 :            : {
     349                 :      28986 :         nsyscalls = nsyscall_vec[personality];
     350                 :      28986 :         sysent = sysent_vec[personality];
     351                 :            : 
     352   [ +  +  +  - ]:      28986 :         switch (personality) {
     353                 :            :         case 0:
     354                 :      17406 :                 errnoent = errnoent0;
     355                 :      17406 :                 nerrnos = nerrnos0;
     356                 :      17406 :                 ioctlent = ioctlent0;
     357                 :      17406 :                 nioctlents = nioctlents0;
     358                 :      17406 :                 signalent = signalent0;
     359                 :      17406 :                 nsignals = nsignals0;
     360                 :      17406 :                 printers = &printers0;
     361                 :      17406 :                 break;
     362                 :            : 
     363                 :            :         case 1:
     364                 :      11578 :                 errnoent = errnoent1;
     365                 :      11578 :                 nerrnos = nerrnos1;
     366                 :      11578 :                 ioctlent = ioctlent1;
     367                 :      11578 :                 nioctlents = nioctlents1;
     368                 :      11578 :                 signalent = signalent1;
     369                 :      11578 :                 nsignals = nsignals1;
     370                 :      11578 :                 printers = &printers1;
     371                 :      11578 :                 break;
     372                 :            : 
     373                 :            : # if SUPPORTED_PERSONALITIES > 2
     374                 :            :         case 2:
     375                 :          2 :                 errnoent = errnoent2;
     376                 :          2 :                 nerrnos = nerrnos2;
     377                 :          2 :                 ioctlent = ioctlent2;
     378                 :          2 :                 nioctlents = nioctlents2;
     379                 :          2 :                 signalent = signalent2;
     380                 :          2 :                 nsignals = nsignals2;
     381                 :          2 :                 printers = &printers2;
     382                 :          2 :                 break;
     383                 :            : # endif
     384                 :            :         }
     385                 :            : 
     386                 :      28986 :         current_personality = personality;
     387                 :            : # ifndef current_wordsize
     388                 :      28986 :         current_wordsize = personality_wordsize[personality];
     389                 :            : # endif
     390                 :            : # ifndef current_klongsize
     391                 :      28986 :         current_klongsize = personality_klongsize[personality];
     392                 :            : # endif
     393                 :      28986 : }
     394                 :            : 
     395                 :            : static void
     396                 :   75066418 : update_personality(struct tcb *tcp, unsigned int personality)
     397                 :            : {
     398         [ +  + ]:   37533209 :         if (personality == current_personality)
     399                 :            :                 return;
     400                 :      18172 :         set_personality(personality);
     401                 :            : 
     402         [ +  + ]:      18172 :         if (personality == tcp->currpers)
     403                 :            :                 return;
     404                 :       4984 :         tcp->currpers = personality;
     405                 :            : 
     406                 :            : # undef PERSONALITY_NAMES
     407                 :            : # if defined POWERPC64
     408                 :            : #  define PERSONALITY_NAMES {"64 bit", "32 bit"}
     409                 :            : # elif defined X86_64
     410                 :            : #  define PERSONALITY_NAMES {"64 bit", "32 bit", "x32"}
     411                 :            : # elif defined X32
     412                 :            : #  define PERSONALITY_NAMES {"x32", "32 bit"}
     413                 :            : # elif defined AARCH64
     414                 :            : #  define PERSONALITY_NAMES {"64 bit", "32 bit"}
     415                 :            : # elif defined TILE
     416                 :            : #  define PERSONALITY_NAMES {"64-bit", "32-bit"}
     417                 :            : # endif
     418                 :            : # ifdef PERSONALITY_NAMES
     419         [ +  + ]:       4984 :         if (!qflag) {
     420                 :            :                 static const char *const names[] = PERSONALITY_NAMES;
     421                 :          9 :                 error_msg("[ Process PID=%d runs in %s mode. ]",
     422                 :            :                           tcp->pid, names[personality]);
     423                 :            :         }
     424                 :            : # endif
     425                 :            : }
     426                 :            : #endif
     427                 :            : 
     428                 :            : #ifdef SYS_socket_subcall
     429                 :            : static void
     430                 :     192612 : decode_socket_subcall(struct tcb *tcp)
     431                 :            : {
     432                 :     192612 :         const int call = tcp->u_arg[0];
     433                 :            : 
     434         [ +  + ]:     192612 :         if (call < 1 || call >= SYS_socket_nsubcalls)
     435                 :        423 :                 return;
     436                 :            : 
     437                 :     192429 :         const kernel_ulong_t scno = SYS_socket_subcall + call;
     438                 :     192429 :         const unsigned int nargs = sysent[scno].nargs;
     439                 :     192429 :         uint64_t buf[nargs];
     440                 :            : 
     441         [ +  + ]:     192429 :         if (umoven(tcp, tcp->u_arg[1], nargs * current_wordsize, buf) < 0)
     442                 :            :                 return;
     443                 :            : 
     444                 :     192189 :         tcp->scno = scno;
     445                 :     192189 :         tcp->qual_flg = qual_flags(scno);
     446                 :     192189 :         tcp->s_ent = &sysent[scno];
     447                 :            : 
     448                 :            :         unsigned int i;
     449         [ +  + ]:     779988 :         for (i = 0; i < nargs; ++i)
     450                 :    1175598 :                 tcp->u_arg[i] = (sizeof(uint32_t) == current_wordsize)
     451         [ +  - ]:     587799 :                                 ? ((uint32_t *) (void *) buf)[i] : buf[i];
     452                 :            : }
     453                 :            : #endif
     454                 :            : 
     455                 :            : #ifdef SYS_ipc_subcall
     456                 :            : static void
     457                 :        780 : decode_ipc_subcall(struct tcb *tcp)
     458                 :            : {
     459                 :        780 :         unsigned int call = tcp->u_arg[0];
     460                 :        780 :         const unsigned int version = call >> 16;
     461                 :            : 
     462         [ +  + ]:        780 :         if (version) {
     463                 :            : # if defined S390 || defined S390X
     464                 :            :                 return;
     465                 :            : # else
     466                 :            : #  ifdef SPARC64
     467                 :            :                 if (current_wordsize == 8)
     468                 :            :                         return;
     469                 :            : #  endif
     470                 :         84 :                 set_tcb_priv_ulong(tcp, version);
     471 [ +  + ][ +  + ]:        780 :                 call &= 0xffff;
     472                 :            : # endif
     473                 :            :         }
     474                 :            : 
     475                 :            :         switch (call) {
     476                 :            :                 case  1: case  2: case  3: case  4:
     477                 :            :                 case 11: case 12: case 13: case 14:
     478                 :            :                 case 21: case 22: case 23: case 24:
     479                 :            :                         break;
     480                 :            :                 default:
     481                 :        780 :                         return;
     482                 :            :         }
     483                 :            : 
     484                 :        660 :         tcp->scno = SYS_ipc_subcall + call;
     485                 :        660 :         tcp->qual_flg = qual_flags(tcp->scno);
     486                 :        660 :         tcp->s_ent = &sysent[tcp->scno];
     487                 :            : 
     488                 :        660 :         const unsigned int n = tcp->s_ent->nargs;
     489                 :            :         unsigned int i;
     490         [ +  + ]:       3264 :         for (i = 0; i < n; i++)
     491                 :       2604 :                 tcp->u_arg[i] = tcp->u_arg[i + 1];
     492                 :            : }
     493                 :            : #endif
     494                 :            : 
     495                 :            : #ifdef LINUX_MIPSO32
     496                 :            : static void
     497                 :            : decode_mips_subcall(struct tcb *tcp)
     498                 :            : {
     499                 :            :         if (!scno_is_valid(tcp->u_arg[0]))
     500                 :            :                 return;
     501                 :            :         tcp->scno = tcp->u_arg[0];
     502                 :            :         tcp->qual_flg = qual_flags(tcp->scno);
     503                 :            :         tcp->s_ent = &sysent[tcp->scno];
     504                 :            :         memmove(&tcp->u_arg[0], &tcp->u_arg[1],
     505                 :            :                 sizeof(tcp->u_arg) - sizeof(tcp->u_arg[0]));
     506                 :            :         /*
     507                 :            :          * Fetching the last arg of 7-arg syscalls (fadvise64_64
     508                 :            :          * and sync_file_range) requires additional code,
     509                 :            :          * see linux/mips/get_syscall_args.c
     510                 :            :          */
     511                 :            :         if (tcp->s_ent->nargs == MAX_ARGS) {
     512                 :            :                 if (umoven(tcp,
     513                 :            :                            mips_REG_SP + MAX_ARGS * sizeof(tcp->u_arg[0]),
     514                 :            :                            sizeof(tcp->u_arg[0]),
     515                 :            :                            &tcp->u_arg[MAX_ARGS - 1]) < 0)
     516                 :            :                 tcp->u_arg[MAX_ARGS - 1] = 0;
     517                 :            :         }
     518                 :            : }
     519                 :            : #endif /* LINUX_MIPSO32 */
     520                 :            : 
     521                 :            : static void
     522                 :     442456 : dumpio(struct tcb *tcp)
     523                 :            : {
     524         [ +  + ]:     442456 :         if (syserror(tcp))
     525                 :            :                 return;
     526                 :            : 
     527                 :     239033 :         int fd = tcp->u_arg[0];
     528         [ +  + ]:     239033 :         if (fd < 0)
     529                 :            :                 return;
     530                 :            : 
     531         [ +  + ]:     238296 :         if (is_number_in_set(fd, &read_set)) {
     532   [ +  +  +  +  :        220 :                 switch (tcp->s_ent->sen) {
                      + ]
     533                 :            :                 case SEN_read:
     534                 :            :                 case SEN_pread:
     535                 :            :                 case SEN_recv:
     536                 :            :                 case SEN_recvfrom:
     537                 :            :                 case SEN_mq_timedreceive:
     538                 :        151 :                         dumpstr(tcp, tcp->u_arg[1], tcp->u_rval);
     539                 :        151 :                         return;
     540                 :            :                 case SEN_readv:
     541                 :            :                 case SEN_preadv:
     542                 :            :                 case SEN_preadv2:
     543                 :         36 :                         dumpiov_upto(tcp, tcp->u_arg[2], tcp->u_arg[1],
     544                 :         36 :                                      tcp->u_rval);
     545                 :         36 :                         return;
     546                 :            :                 case SEN_recvmsg:
     547                 :          4 :                         dumpiov_in_msghdr(tcp, tcp->u_arg[1], tcp->u_rval);
     548                 :          4 :                         return;
     549                 :            :                 case SEN_recvmmsg:
     550                 :          2 :                         dumpiov_in_mmsghdr(tcp, tcp->u_arg[1]);
     551                 :          2 :                         return;
     552                 :            :                 }
     553                 :            :         }
     554         [ +  + ]:     238103 :         if (is_number_in_set(fd, &write_set)) {
     555   [ +  +  +  +  :        193 :                 switch (tcp->s_ent->sen) {
                      + ]
     556                 :            :                 case SEN_write:
     557                 :            :                 case SEN_pwrite:
     558                 :            :                 case SEN_send:
     559                 :            :                 case SEN_sendto:
     560                 :            :                 case SEN_mq_timedsend:
     561                 :        147 :                         dumpstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
     562                 :        147 :                         break;
     563                 :            :                 case SEN_writev:
     564                 :            :                 case SEN_pwritev:
     565                 :            :                 case SEN_pwritev2:
     566                 :            :                 case SEN_vmsplice:
     567                 :         38 :                         dumpiov_upto(tcp, tcp->u_arg[2], tcp->u_arg[1], -1);
     568                 :         38 :                         break;
     569                 :            :                 case SEN_sendmsg:
     570                 :          2 :                         dumpiov_in_msghdr(tcp, tcp->u_arg[1], -1);
     571                 :          2 :                         break;
     572                 :            :                 case SEN_sendmmsg:
     573                 :          2 :                         dumpiov_in_mmsghdr(tcp, tcp->u_arg[1]);
     574                 :          2 :                         break;
     575                 :            :                 }
     576                 :            :         }
     577                 :            : }
     578                 :            : 
     579                 :            : /*
     580                 :            :  * Shuffle syscall numbers so that we don't have huge gaps in syscall table.
     581                 :            :  * The shuffling should be an involution: shuffle_scno(shuffle_scno(n)) == n.
     582                 :            :  */
     583                 :            : static kernel_ulong_t
     584                 :            : shuffle_scno(kernel_ulong_t scno)
     585                 :            : {
     586                 :            : #if defined(ARM) || defined(AARCH64) /* So far only 32-bit ARM needs this */
     587                 :            :         if (scno < ARM_FIRST_SHUFFLED_SYSCALL)
     588                 :            :                 return scno;
     589                 :            : 
     590                 :            :         /* __ARM_NR_cmpxchg? Swap with LAST_ORDINARY+1 */
     591                 :            :         if (scno == ARM_FIRST_SHUFFLED_SYSCALL)
     592                 :            :                 return 0x000ffff0;
     593                 :            :         if (scno == 0x000ffff0)
     594                 :            :                 return ARM_FIRST_SHUFFLED_SYSCALL;
     595                 :            : 
     596                 :            : # define ARM_SECOND_SHUFFLED_SYSCALL (ARM_FIRST_SHUFFLED_SYSCALL + 1)
     597                 :            :         /*
     598                 :            :          * Is it ARM specific syscall?
     599                 :            :          * Swap [0x000f0000, 0x000f0000 + LAST_SPECIAL] range
     600                 :            :          * with [SECOND_SHUFFLED, SECOND_SHUFFLED + LAST_SPECIAL] range.
     601                 :            :          */
     602                 :            :         if (scno >= 0x000f0000 &&
     603                 :            :             scno <= 0x000f0000 + ARM_LAST_SPECIAL_SYSCALL) {
     604                 :            :                 return scno - 0x000f0000 + ARM_SECOND_SHUFFLED_SYSCALL;
     605                 :            :         }
     606                 :            :         if (scno <= ARM_SECOND_SHUFFLED_SYSCALL + ARM_LAST_SPECIAL_SYSCALL) {
     607                 :            :                 return scno + 0x000f0000 - ARM_SECOND_SHUFFLED_SYSCALL;
     608                 :            :         }
     609                 :            : #endif /* ARM || AARCH64 */
     610                 :            : 
     611                 :            :         return scno;
     612                 :            : }
     613                 :            : 
     614                 :            : const char *
     615                 :          8 : err_name(unsigned long err)
     616                 :            : {
     617 [ +  - ][ +  - ]:     173908 :         if ((err < nerrnos) && errnoent[err])
         [ +  + ][ +  + ]
     618                 :          2 :                 return errnoent[err];
     619                 :            : 
     620                 :            :         return NULL;
     621                 :            : }
     622                 :            : 
     623                 :            : static long get_regs_error;
     624                 :            : 
     625                 :            : void
     626                 :   74236133 : clear_regs(void)
     627                 :            : {
     628                 :   74236133 :         get_regs_error = -1;
     629                 :   74236133 : }
     630                 :            : 
     631                 :            : static void get_regs(pid_t pid);
     632                 :            : static int get_syscall_args(struct tcb *);
     633                 :            : static int get_syscall_result(struct tcb *);
     634                 :            : static int arch_get_scno(struct tcb *tcp);
     635                 :            : static int arch_set_scno(struct tcb *, kernel_ulong_t);
     636                 :            : static void get_error(struct tcb *, const bool);
     637                 :            : static int arch_set_error(struct tcb *);
     638                 :            : static int arch_set_success(struct tcb *);
     639                 :            : 
     640                 :            : struct inject_opts *inject_vec[SUPPORTED_PERSONALITIES];
     641                 :            : 
     642                 :            : static struct inject_opts *
     643                 :     428345 : tcb_inject_opts(struct tcb *tcp, bool copy_if_needed)
     644                 :            : {
     645                 :            : #ifdef USE_LUAJIT
     646         [ +  + ]:     428345 :         if (tcp->flags & TCB_AD_HOC_INJECT)
     647                 :         25 :                 return tcp->ad_hoc_inject_opts;
     648                 :            : #endif
     649 [ +  + ][ +  + ]:     428320 :         if (copy_if_needed && !tcp->inject_vec[current_personality]) {
     650                 :       3120 :                 tcp->inject_vec[current_personality] =
     651                 :       3120 :                         xcalloc(nsyscalls, sizeof(**inject_vec));
     652                 :       3120 :                 memcpy(tcp->inject_vec[current_personality],
     653                 :       3120 :                        inject_vec[current_personality],
     654                 :            :                        nsyscalls * sizeof(**inject_vec));
     655                 :            :         }
     656         [ +  - ]:     856640 :         return (scno_in_range(tcp->scno) && tcp->inject_vec[current_personality])
     657         [ +  - ]:     856640 :                ? &tcp->inject_vec[current_personality][tcp->scno] : NULL;
     658                 :            : }
     659                 :            : 
     660                 :            : 
     661                 :            : static long
     662                 :     310431 : tamper_with_syscall_entering(struct tcb *tcp, unsigned int *signo)
     663                 :            : {
     664                 :     310431 :         struct inject_opts *opts = tcb_inject_opts(tcp, true);
     665                 :            : 
     666 [ +  - ][ +  + ]:     310431 :         if (!opts || opts->first == 0)
     667                 :            :                 return 0;
     668                 :            : 
     669                 :     301295 :         --opts->first;
     670                 :            : 
     671         [ +  + ]:     301295 :         if (opts->first != 0)
     672                 :            :                 return 0;
     673                 :            : 
     674                 :     117917 :         opts->first = opts->step;
     675                 :            : 
     676         [ +  + ]:     117917 :         if (opts->signo > 0)
     677                 :          8 :                 *signo = opts->signo;
     678   [ +  +  +  - ]:     235831 :         if (opts->rval != INJECT_OPTS_RVAL_DEFAULT && !arch_set_scno(tcp, -1))
     679                 :     117914 :                 tcp->flags |= TCB_TAMPERED;
     680                 :            : 
     681                 :            :         return 0;
     682                 :            : }
     683                 :            : 
     684                 :            : static long
     685                 :     117914 : tamper_with_syscall_exiting(struct tcb *tcp)
     686                 :            : {
     687                 :     117914 :         struct inject_opts *opts = tcb_inject_opts(tcp, false);
     688                 :            : 
     689         [ +  - ]:     117914 :         if (!opts)
     690                 :            :                 return 0;
     691                 :            : 
     692         [ +  + ]:     117914 :         if (opts->rval >= 0) {
     693                 :         12 :                 kernel_long_t u_rval = tcp->u_rval;
     694                 :            : 
     695                 :         12 :                 tcp->u_rval = opts->rval;
     696         [ -  + ]:         12 :                 if (arch_set_success(tcp)) {
     697                 :          0 :                         tcp->u_rval = u_rval;
     698                 :            :                 } else {
     699                 :         12 :                         tcp->u_error = 0;
     700                 :            :                 }
     701                 :            :         } else {
     702                 :     117902 :                 unsigned long new_error = -opts->rval;
     703                 :            : 
     704 [ +  + ][ +  - ]:     117902 :                 if (new_error != tcp->u_error && new_error <= MAX_ERRNO_VALUE) {
     705                 :      58950 :                         unsigned long u_error = tcp->u_error;
     706                 :            : 
     707                 :      58950 :                         tcp->u_error = new_error;
     708         [ -  + ]:      58950 :                         if (arch_set_error(tcp)) {
     709                 :          0 :                                 tcp->u_error = u_error;
     710                 :            :                         }
     711                 :            :                 }
     712                 :            :         }
     713                 :            : 
     714                 :            :         return 0;
     715                 :            : }
     716                 :            : 
     717                 :            : /*
     718                 :            :  * Returns:
     719                 :            :  * 0: "ignore this ptrace stop", bail out silently.
     720                 :            :  * 1: ok, decoded; call
     721                 :            :  *    syscall_entering_finish(tcp, syscall_entering_trace(tcp, ...)).
     722                 :            :  * other: error; call syscall_entering_finish(tcp, res), where res is the value
     723                 :            :  *    returned.
     724                 :            :  */
     725                 :            : int
     726                 :   37072629 : syscall_entering_decode(struct tcb *tcp)
     727                 :            : {
     728                 :   37072629 :         int res = get_scno(tcp);
     729         [ +  - ]:   37072629 :         if (res == 0)
     730                 :            :                 return res;
     731                 :   37072629 :         int scno_good = res;
     732 [ +  - ][ -  + ]:   37072629 :         if (res != 1 || (res = get_syscall_args(tcp)) != 1) {
     733                 :          0 :                 printleader(tcp);
     734         [ #  # ]:          0 :                 tprintf("%s(", scno_good == 1 ? tcp->s_ent->sys_name : "????");
     735                 :            :                 /*
     736                 :            :                  * " <unavailable>" will be added later by the code which
     737                 :            :                  * detects ptrace errors.
     738                 :            :                  */
     739                 :          0 :                 return res;
     740                 :            :         }
     741                 :            : 
     742                 :            : #ifdef LINUX_MIPSO32
     743                 :            :         if (SEN_syscall == tcp->s_ent->sen)
     744                 :            :                 decode_mips_subcall(tcp);
     745                 :            : #endif
     746                 :            : 
     747                 :            : #if defined(SYS_socket_subcall) || defined(SYS_ipc_subcall)
     748      [ +  +  + ]:   37072629 :         switch (tcp->s_ent->sen) {
     749                 :            : # ifdef SYS_socket_subcall
     750                 :            :                 case SEN_socketcall:
     751                 :     192612 :                         decode_socket_subcall(tcp);
     752                 :     192612 :                         break;
     753                 :            : # endif
     754                 :            : # ifdef SYS_ipc_subcall
     755                 :            :                 case SEN_ipc:
     756                 :        780 :                         decode_ipc_subcall(tcp);
     757                 :        780 :                         break;
     758                 :            : # endif
     759                 :            :         }
     760                 :            : #endif
     761                 :            : 
     762                 :            :         return 1;
     763                 :            : }
     764                 :            : 
     765                 :            : static bool
     766                 :            : syscall_ad_hoc_injected(struct tcb *tcp)
     767                 :            : {
     768 [ +  + ][ +  - ]:   73236941 :         return (tcp->qual_flg & QUAL_INJECT) && (tcp->flags & TCB_AD_HOC_INJECT);
         [ +  + ][ +  - ]
     769                 :            : }
     770                 :            : 
     771                 :            : int
     772                 :   37072626 : syscall_entering_trace(struct tcb *tcp, unsigned int *sig)
     773                 :            : {
     774                 :            :         /* Restrain from fault injection while the trace executes strace code. */
     775         [ +  + ]:   37072626 :         if (hide_log(tcp)) {
     776                 :   33637410 :                 tcp->qual_flg &= ~QUAL_INJECT;
     777                 :            :         }
     778                 :            : 
     779         [ +  + ]:   37072626 :         switch (tcp->s_ent->sen) {
     780                 :            :                 case SEN_execve:
     781                 :            :                 case SEN_execveat:
     782                 :            : #if defined SPARC || defined SPARC64
     783                 :            :                 case SEN_execv:
     784                 :            : #endif
     785                 :       9984 :                         tcp->flags &= ~TCB_HIDE_LOG;
     786                 :       9984 :                         break;
     787                 :            :         }
     788                 :            : 
     789         [ +  + ]:   37072626 :         if (!(tcp->qual_flg & QUAL_TRACE)
     790 [ +  + ][ +  + ]:    1187472 :          || (tracing_paths && !pathtrace_match(tcp))
     791                 :            :         ) {
     792                 :   36525818 :                 tcp->flags |= TCB_FILTERED;
     793                 :   36525818 :                 goto maybe_ad_hoc_tamper;
     794                 :            :         }
     795                 :            : 
     796                 :     546808 :         tcp->flags &= ~TCB_FILTERED;
     797                 :            : 
     798         [ +  + ]:     546808 :         if (hide_log(tcp)) {
     799                 :            :                 goto maybe_ad_hoc_tamper;
     800                 :            :         }
     801                 :            : 
     802         [ +  + ]:     447756 :         if (tcp->qual_flg & QUAL_INJECT)
     803                 :     310431 :                 tamper_with_syscall_entering(tcp, sig);
     804                 :            : 
     805         [ +  + ]:     447756 :         if (cflag == CFLAG_ONLY_STATS) {
     806                 :            :                 return 0;
     807                 :            :         }
     808                 :            : 
     809                 :            : #ifdef USE_LIBUNWIND
     810                 :            :         if (stack_trace_enabled) {
     811                 :            :                 if (tcp->s_ent->sys_flags & STACKTRACE_CAPTURE_ON_ENTER)
     812                 :            :                         unwind_capture_stacktrace(tcp);
     813                 :            :         }
     814                 :            : #endif
     815                 :            : 
     816                 :     442496 :         printleader(tcp);
     817                 :     442496 :         tprintf("%s(", tcp->s_ent->sys_name);
     818                 :     884992 :         int res = (tcp->qual_flg & QUAL_RAW)
     819         [ +  + ]:     442496 :                 ? printargs(tcp) : tcp->s_ent->sys_func(tcp);
     820                 :     442496 :         fflush(tcp->outf);
     821                 :     442496 :         return res;
     822                 :            : 
     823                 :            : maybe_ad_hoc_tamper:
     824         [ -  + ]:   36624870 :         if (syscall_ad_hoc_injected(tcp))
     825                 :          0 :                 tamper_with_syscall_entering(tcp, sig);
     826                 :            :         return 0;
     827                 :            : }
     828                 :            : 
     829                 :            : void
     830                 :   37072626 : syscall_entering_finish(struct tcb *tcp, int res)
     831                 :            : {
     832                 :   37072626 :         tcp->flags |= TCB_INSYSCALL;
     833                 :   37072626 :         tcp->sys_func_rval = res;
     834                 :            :         /* Measure the entrance time as late as possible to avoid errors. */
     835 [ +  + ][ +  + ]:   37072626 :         if ((Tflag || cflag) && !filtered(tcp))
                 [ +  + ]
     836                 :      40744 :                 gettimeofday(&tcp->etime, NULL);
     837                 :   37072626 : }
     838                 :            : 
     839                 :            : static bool
     840                 :            : syscall_tampered(struct tcb *tcp)
     841                 :            : {
     842                 :     647998 :         return tcp->flags & TCB_TAMPERED;
     843                 :            : }
     844                 :            : 
     845                 :            : /* Returns:
     846                 :            :  * 0: "bail out".
     847                 :            :  * 1: ok.
     848                 :            :  * -1: error in one of ptrace ops.
     849                 :            :  *
     850                 :            :  * If not 0, call syscall_exiting_trace(tcp, res), where res is the return
     851                 :            :  *    value. Anyway, call syscall_exiting_finish(tcp) then.
     852                 :            :  */
     853                 :            : int
     854                 :   37059697 : syscall_exiting_decode(struct tcb *tcp, struct timeval *ptv)
     855                 :            : {
     856                 :            :         /* Measure the exit time as early as possible to avoid errors. */
     857 [ +  + ][ +  + ]:   37059697 :         if ((Tflag || cflag) && !(filtered(tcp) || hide_log(tcp)))
                 [ +  + ]
     858                 :       5174 :                 gettimeofday(ptv, NULL);
     859                 :            : 
     860                 :            : #ifdef USE_LIBUNWIND
     861                 :            :         if (stack_trace_enabled) {
     862                 :            :                 if (tcp->s_ent->sys_flags & STACKTRACE_INVALIDATE_CACHE)
     863                 :            :                         unwind_cache_invalidate(tcp);
     864                 :            :         }
     865                 :            : #endif
     866                 :            : 
     867         [ +  + ]:   37059697 :         if ((filtered(tcp) || hide_log(tcp))
     868 [ +  - ][ -  + ]:   73224142 :          && !(tcp->qual_flg & QUAL_HOOK_EXIT) && !syscall_ad_hoc_injected(tcp))
     869                 :            :                 return 0;
     870                 :            : 
     871                 :     447626 :         get_regs(tcp->pid);
     872                 :            : #if SUPPORTED_PERSONALITIES > 1
     873                 :     447626 :         update_personality(tcp, tcp->currpers);
     874                 :            : #endif
     875         [ +  - ]:     447626 :         if (get_regs_error || get_syscall_result(tcp) == -1)
     876                 :            :                 return -1;
     877                 :            : 
     878 [ +  + ][ +  + ]:     447626 :         if (syserror(tcp) && syscall_tampered(tcp))
     879                 :     117914 :                 tamper_with_syscall_exiting(tcp);
     880                 :            : 
     881                 :            :         return 1;
     882                 :            : }
     883                 :            : 
     884                 :            : int
     885                 :     447626 : syscall_exiting_trace(struct tcb *tcp, struct timeval tv, int res)
     886                 :            : {
     887         [ +  - ]:     447626 :         if (filtered(tcp) || hide_log(tcp))
     888                 :            :                 return 0;
     889                 :            : 
     890         [ +  + ]:     447626 :         if (cflag) {
     891                 :       5172 :                 count_syscall(tcp, &tv);
     892         [ +  + ]:       5172 :                 if (cflag == CFLAG_ONLY_STATS) {
     893                 :            :                         return 0;
     894                 :            :                 }
     895                 :            :         }
     896                 :            : 
     897                 :            :         /* If not in -ff mode, and printing_tcp != tcp,
     898                 :            :          * then the log currently does not end with output
     899                 :            :          * of _our syscall entry_, but with something else.
     900                 :            :          * We need to say which syscall's return is this.
     901                 :            :          *
     902                 :            :          * Forced reprinting via TCB_REPRINT is used only by
     903                 :            :          * "strace -ff -oLOG test/threaded_execve" corner case.
     904                 :            :          * It's the only case when -ff mode needs reprinting.
     905                 :            :          */
     906 [ +  + ][ +  + ]:     442456 :         if ((followfork < 2 && printing_tcp != tcp) || (tcp->flags & TCB_REPRINT)) {
                 [ -  + ]
     907                 :          8 :                 tcp->flags &= ~TCB_REPRINT;
     908                 :          8 :                 printleader(tcp);
     909                 :          8 :                 tprintf("<... %s resumed> ", tcp->s_ent->sys_name);
     910                 :            :         }
     911                 :     442456 :         printing_tcp = tcp;
     912                 :            : 
     913                 :     442456 :         tcp->s_prev_ent = NULL;
     914         [ -  + ]:     442456 :         if (res != 1) {
     915                 :            :                 /* There was error in one of prior ptrace ops */
     916                 :          0 :                 tprints(") ");
     917                 :          0 :                 tabto();
     918                 :          0 :                 tprints("= ? <unavailable>\n");
     919                 :          0 :                 line_ended();
     920                 :          0 :                 return res;
     921                 :            :         }
     922                 :     442456 :         tcp->s_prev_ent = tcp->s_ent;
     923                 :            : 
     924                 :     442456 :         int sys_res = 0;
     925         [ +  + ]:     442456 :         if (tcp->qual_flg & QUAL_RAW) {
     926                 :            :                 /* sys_res = printargs(tcp); - but it's nop on sysexit */
     927                 :            :         } else {
     928                 :            :         /* FIXME: not_failing_only (IOW, option -z) is broken:
     929                 :            :          * failure of syscall is known only after syscall return.
     930                 :            :          * Thus we end up with something like this on, say, ENOENT:
     931                 :            :          *     open("does_not_exist", O_RDONLY <unfinished ...>
     932                 :            :          *     {next syscall decode}
     933                 :            :          * whereas the intended result is that open(...) line
     934                 :            :          * is not shown at all.
     935                 :            :          */
     936 [ -  + ][ #  # ]:     321676 :                 if (not_failing_only && tcp->u_error)
     937                 :            :                         return 0;       /* ignore failed syscalls */
     938         [ +  + ]:     321676 :                 if (tcp->sys_func_rval & RVAL_DECODED)
     939                 :            :                         sys_res = tcp->sys_func_rval;
     940                 :            :                 else
     941                 :       4913 :                         sys_res = tcp->s_ent->sys_func(tcp);
     942                 :            :         }
     943                 :            : 
     944                 :     442456 :         tprints(") ");
     945                 :     442456 :         tabto();
     946                 :     442456 :         unsigned long u_error = tcp->u_error;
     947                 :            : 
     948         [ +  + ]:     442456 :         if (tcp->qual_flg & QUAL_RAW) {
     949         [ +  + ]:     120780 :                 if (u_error) {
     950                 :      29492 :                         tprintf("= -1 (errno %lu)", u_error);
     951                 :            :                 } else {
     952                 :      91288 :                         tprintf("= %#" PRI_klx, tcp->u_rval);
     953                 :            :                 }
     954         [ +  + ]:     120780 :                 if (syscall_tampered(tcp))
     955                 :      29472 :                         tprints(" (INJECTED)");
     956 [ +  - ][ +  + ]:     321676 :         } else if (!(sys_res & RVAL_NONE) && u_error) {
     957                 :            :                 const char *u_error_str;
     958                 :            : 
     959   [ +  -  +  +  :     173931 :                 switch (u_error) {
                      + ]
     960                 :            :                 /* Blocked signals do not interrupt any syscalls.
     961                 :            :                  * In this case syscalls don't return ERESTARTfoo codes.
     962                 :            :                  *
     963                 :            :                  * Deadly signals set to SIG_DFL interrupt syscalls
     964                 :            :                  * and kill the process regardless of which of the codes below
     965                 :            :                  * is returned by the interrupted syscall.
     966                 :            :                  * In some cases, kernel forces a kernel-generated deadly
     967                 :            :                  * signal to be unblocked and set to SIG_DFL (and thus cause
     968                 :            :                  * death) if it is blocked or SIG_IGNed: for example, SIGSEGV
     969                 :            :                  * or SIGILL. (The alternative is to leave process spinning
     970                 :            :                  * forever on the faulty instruction - not useful).
     971                 :            :                  *
     972                 :            :                  * SIG_IGNed signals and non-deadly signals set to SIG_DFL
     973                 :            :                  * (for example, SIGCHLD, SIGWINCH) interrupt syscalls,
     974                 :            :                  * but kernel will always restart them.
     975                 :            :                  */
     976                 :            :                 case ERESTARTSYS:
     977                 :            :                         /* Most common type of signal-interrupted syscall exit code.
     978                 :            :                          * The system call will be restarted with the same arguments
     979                 :            :                          * if SA_RESTART is set; otherwise, it will fail with EINTR.
     980                 :            :                          */
     981                 :          2 :                         tprints("= ? ERESTARTSYS (To be restarted if SA_RESTART is set)");
     982                 :          2 :                         break;
     983                 :            :                 case ERESTARTNOINTR:
     984                 :            :                         /* Rare. For example, fork() returns this if interrupted.
     985                 :            :                          * SA_RESTART is ignored (assumed set): the restart is unconditional.
     986                 :            :                          */
     987                 :          0 :                         tprints("= ? ERESTARTNOINTR (To be restarted)");
     988                 :          0 :                         break;
     989                 :            :                 case ERESTARTNOHAND:
     990                 :            :                         /* pause(), rt_sigsuspend() etc use this code.
     991                 :            :                          * SA_RESTART is ignored (assumed not set):
     992                 :            :                          * syscall won't restart (will return EINTR instead)
     993                 :            :                          * even after signal with SA_RESTART set. However,
     994                 :            :                          * after SIG_IGN or SIG_DFL signal it will restart
     995                 :            :                          * (thus the name "restart only if has no handler").
     996                 :            :                          */
     997                 :         21 :                         tprints("= ? ERESTARTNOHAND (To be restarted if no handler)");
     998                 :         21 :                         break;
     999                 :            :                 case ERESTART_RESTARTBLOCK:
    1000                 :            :                         /* Syscalls like nanosleep(), poll() which can't be
    1001                 :            :                          * restarted with their original arguments use this
    1002                 :            :                          * code. Kernel will execute restart_syscall() instead,
    1003                 :            :                          * which changes arguments before restarting syscall.
    1004                 :            :                          * SA_RESTART is ignored (assumed not set) similarly
    1005                 :            :                          * to ERESTARTNOHAND. (Kernel can't honor SA_RESTART
    1006                 :            :                          * since restart data is saved in "restart block"
    1007                 :            :                          * in task struct, and if signal handler uses a syscall
    1008                 :            :                          * which in turn saves another such restart block,
    1009                 :            :                          * old data is lost and restart becomes impossible)
    1010                 :            :                          */
    1011                 :          8 :                         tprints("= ? ERESTART_RESTARTBLOCK (Interrupted by signal)");
    1012                 :          8 :                         break;
    1013                 :            :                 default:
    1014                 :     173900 :                         u_error_str = err_name(u_error);
    1015         [ +  - ]:     173900 :                         if (u_error_str)
    1016                 :     173900 :                                 tprintf("= -1 %s (%s)",
    1017                 :            :                                         u_error_str, strerror(u_error));
    1018                 :            :                         else
    1019                 :          0 :                                 tprintf("= -1 %lu (%s)",
    1020                 :            :                                         u_error, strerror(u_error));
    1021                 :            :                         break;
    1022                 :            :                 }
    1023         [ +  + ]:     173931 :                 if (syscall_tampered(tcp))
    1024                 :      88430 :                         tprints(" (INJECTED)");
    1025 [ -  + ][ #  # ]:     173931 :                 if ((sys_res & RVAL_STR) && tcp->auxstr)
    1026                 :          0 :                         tprintf(" (%s)", tcp->auxstr);
    1027                 :            :         } else {
    1028         [ -  + ]:     147745 :                 if (sys_res & RVAL_NONE)
    1029                 :          0 :                         tprints("= ?");
    1030                 :            :                 else {
    1031   [ +  +  +  +  :     147745 :                         switch (sys_res & RVAL_MASK) {
                   +  - ]
    1032                 :            :                         case RVAL_HEX:
    1033                 :            : #if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
    1034         [ +  + ]:        241 :                                 if (current_wordsize < sizeof(tcp->u_rval)) {
    1035                 :        119 :                                         tprintf("= %#x",
    1036                 :        119 :                                                 (unsigned int) tcp->u_rval);
    1037                 :            :                                 } else
    1038                 :            : #endif
    1039                 :            :                                 {
    1040                 :        122 :                                         tprintf("= %#" PRI_klx, tcp->u_rval);
    1041                 :            :                                 }
    1042                 :            :                                 break;
    1043                 :            :                         case RVAL_OCTAL:
    1044                 :         14 :                                 tprints("= ");
    1045                 :         14 :                                 print_numeric_long_umask(tcp->u_rval);
    1046                 :         14 :                                 break;
    1047                 :            :                         case RVAL_UDECIMAL:
    1048                 :            : #if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
    1049         [ +  + ]:        123 :                                 if (current_wordsize < sizeof(tcp->u_rval)) {
    1050                 :         82 :                                         tprintf("= %u",
    1051                 :         82 :                                                 (unsigned int) tcp->u_rval);
    1052                 :            :                                 } else
    1053                 :            : #endif
    1054                 :            :                                 {
    1055                 :         41 :                                         tprintf("= %" PRI_klu, tcp->u_rval);
    1056                 :            :                                 }
    1057                 :            :                                 break;
    1058                 :            :                         case RVAL_DECIMAL:
    1059                 :     147267 :                                 tprintf("= %" PRI_kld, tcp->u_rval);
    1060                 :     147267 :                                 break;
    1061                 :            :                         case RVAL_FD:
    1062         [ +  + ]:        100 :                                 if (show_fd_path) {
    1063                 :         28 :                                         tprints("= ");
    1064                 :         28 :                                         printfd(tcp, tcp->u_rval);
    1065                 :            :                                 } else
    1066                 :         72 :                                         tprintf("= %" PRI_kld, tcp->u_rval);
    1067                 :            :                                 break;
    1068                 :            :                         default:
    1069                 :          0 :                                 error_msg("invalid rval format");
    1070                 :          0 :                                 break;
    1071                 :            :                         }
    1072                 :            :                 }
    1073 [ +  + ][ +  + ]:     147745 :                 if ((sys_res & RVAL_STR) && tcp->auxstr)
    1074                 :        157 :                         tprintf(" (%s)", tcp->auxstr);
    1075         [ +  + ]:     147745 :                 if (syscall_tampered(tcp))
    1076                 :         12 :                         tprints(" (INJECTED)");
    1077                 :            :         }
    1078         [ +  + ]:     442456 :         if (Tflag) {
    1079                 :          2 :                 tv_sub(&tv, &tv, &tcp->etime);
    1080                 :          2 :                 tprintf(" <%ld.%06ld>",
    1081                 :            :                         (long) tv.tv_sec, (long) tv.tv_usec);
    1082                 :            :         }
    1083                 :     442456 :         tprints("\n");
    1084                 :     442456 :         dumpio(tcp);
    1085                 :     442456 :         line_ended();
    1086                 :            : 
    1087                 :            : #ifdef USE_LIBUNWIND
    1088                 :            :         if (stack_trace_enabled)
    1089                 :            :                 unwind_print_stacktrace(tcp);
    1090                 :            : #endif
    1091                 :     442456 :         return 0;
    1092                 :            : }
    1093                 :            : 
    1094                 :            : void
    1095                 :   37059697 : syscall_exiting_finish(struct tcb *tcp)
    1096                 :            : {
    1097                 :   37059697 :         tcp->flags &= ~(TCB_INSYSCALL | TCB_TAMPERED | TCB_AD_HOC_INJECT);
    1098                 :   37059697 :         tcp->sys_func_rval = 0;
    1099                 :   37059697 :         free_tcb_priv_data(tcp);
    1100                 :   37059697 : }
    1101                 :            : 
    1102                 :            : bool
    1103                 :         58 : is_erestart(struct tcb *tcp)
    1104                 :            : {
    1105 [ +  + ][ -  + ]:         58 :         switch (tcp->u_error) {
    1106                 :            :                 case ERESTARTSYS:
    1107                 :            :                 case ERESTARTNOINTR:
    1108                 :            :                 case ERESTARTNOHAND:
    1109                 :            :                 case ERESTART_RESTARTBLOCK:
    1110                 :            :                         return true;
    1111                 :            :                 default:
    1112                 :         50 :                         return false;
    1113                 :            :         }
    1114                 :            : }
    1115                 :            : 
    1116                 :            : static unsigned long saved_u_error;
    1117                 :            : 
    1118                 :            : void
    1119                 :         62 : temporarily_clear_syserror(struct tcb *tcp)
    1120                 :            : {
    1121                 :         62 :         saved_u_error = tcp->u_error;
    1122                 :         62 :         tcp->u_error = 0;
    1123                 :         62 : }
    1124                 :            : 
    1125                 :            : void
    1126                 :         62 : restore_cleared_syserror(struct tcb *tcp)
    1127                 :            : {
    1128                 :         62 :         tcp->u_error = saved_u_error;
    1129                 :         62 : }
    1130                 :            : 
    1131                 :            : #include "arch_regs.c"
    1132                 :            : 
    1133                 :            : #ifdef HAVE_GETRVAL2
    1134                 :            : # include "arch_getrval2.c"
    1135                 :            : #endif
    1136                 :            : 
    1137                 :            : void
    1138                 :         93 : print_pc(struct tcb *tcp)
    1139                 :            : {
    1140                 :            : #if defined ARCH_PC_REG
    1141                 :            : # define ARCH_GET_PC 0
    1142                 :            : #elif defined ARCH_PC_PEEK_ADDR
    1143                 :            :         kernel_ulong_t pc;
    1144                 :            : # define ARCH_PC_REG pc
    1145                 :            : # define ARCH_GET_PC upeek(tcp->pid, ARCH_PC_PEEK_ADDR, &pc)
    1146                 :            : #else
    1147                 :            : # error Neither ARCH_PC_REG nor ARCH_PC_PEEK_ADDR is defined
    1148                 :            : #endif
    1149                 :         93 :         get_regs(tcp->pid);
    1150         [ +  + ]:         93 :         if (get_regs_error || ARCH_GET_PC)
    1151         [ +  + ]:          4 :                 tprints(current_wordsize == 4 ? "[????????] "
    1152                 :            :                                               : "[????????????????] ");
    1153                 :            :         else
    1154 [ +  + ][ +  + ]:         89 :                 tprintf(current_wordsize == 4
    1155                 :            :                         ? "[%08" PRI_klx "] " : "[%016" PRI_klx "] ",
    1156                 :        131 :                         (kernel_ulong_t) ARCH_PC_REG);
    1157                 :         93 : }
    1158                 :            : 
    1159                 :            : #include "getregs_old.h"
    1160                 :            : 
    1161                 :            : #undef ptrace_getregset_or_getregs
    1162                 :            : #undef ptrace_setregset_or_setregs
    1163                 :            : #ifdef ARCH_REGS_FOR_GETREGSET
    1164                 :            : 
    1165                 :            : # define ptrace_getregset_or_getregs ptrace_getregset
    1166                 :            : static long
    1167                 :            : ptrace_getregset(pid_t pid)
    1168                 :            : {
    1169                 :            : # ifdef ARCH_IOVEC_FOR_GETREGSET
    1170                 :            :         /* variable iovec */
    1171                 :   37533217 :         ARCH_IOVEC_FOR_GETREGSET.iov_len = sizeof(ARCH_REGS_FOR_GETREGSET);
    1172                 :   37533217 :         return ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS,
    1173                 :            :                       &ARCH_IOVEC_FOR_GETREGSET);
    1174                 :            : # else
    1175                 :            :         /* constant iovec */
    1176                 :            :         static struct iovec io = {
    1177                 :            :                 .iov_base = &ARCH_REGS_FOR_GETREGSET,
    1178                 :            :                 .iov_len = sizeof(ARCH_REGS_FOR_GETREGSET)
    1179                 :            :         };
    1180                 :            :         return ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &io);
    1181                 :            : 
    1182                 :            : # endif
    1183                 :            : }
    1184                 :            : 
    1185                 :            : # ifndef HAVE_GETREGS_OLD
    1186                 :            : #  define ptrace_setregset_or_setregs ptrace_setregset
    1187                 :            : static int
    1188                 :            : ptrace_setregset(pid_t pid)
    1189                 :            : {
    1190                 :            : #  ifdef ARCH_IOVEC_FOR_GETREGSET
    1191                 :            :         /* variable iovec */
    1192                 :            :         return ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS,
    1193                 :            :                       &ARCH_IOVEC_FOR_GETREGSET);
    1194                 :            : #  else
    1195                 :            :         /* constant iovec */
    1196                 :            :         static struct iovec io = {
    1197                 :            :                 .iov_base = &ARCH_REGS_FOR_GETREGSET,
    1198                 :            :                 .iov_len = sizeof(ARCH_REGS_FOR_GETREGSET)
    1199                 :            :         };
    1200                 :            :         return ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS, &io);
    1201                 :            : #  endif
    1202                 :            : }
    1203                 :            : # endif /* !HAVE_GETREGS_OLD */
    1204                 :            : 
    1205                 :            : #elif defined ARCH_REGS_FOR_GETREGS
    1206                 :            : 
    1207                 :            : # define ptrace_getregset_or_getregs ptrace_getregs
    1208                 :            : static long
    1209                 :            : ptrace_getregs(pid_t pid)
    1210                 :            : {
    1211                 :            : # if defined SPARC || defined SPARC64
    1212                 :            :         /* SPARC systems have the meaning of data and addr reversed */
    1213                 :            :         return ptrace(PTRACE_GETREGS, pid, (void *) &ARCH_REGS_FOR_GETREGS, 0);
    1214                 :            : # else
    1215                 :            :         return ptrace(PTRACE_GETREGS, pid, NULL, &ARCH_REGS_FOR_GETREGS);
    1216                 :            : # endif
    1217                 :            : }
    1218                 :            : 
    1219                 :            : # ifndef HAVE_GETREGS_OLD
    1220                 :            : #  define ptrace_setregset_or_setregs ptrace_setregs
    1221                 :            : static int
    1222                 :            : ptrace_setregs(pid_t pid)
    1223                 :            : {
    1224                 :            : #  if defined SPARC || defined SPARC64
    1225                 :            :         /* SPARC systems have the meaning of data and addr reversed */
    1226                 :            :         return ptrace(PTRACE_SETREGS, pid, (void *) &ARCH_REGS_FOR_GETREGS, 0);
    1227                 :            : #  else
    1228                 :            :         return ptrace(PTRACE_SETREGS, pid, NULL, &ARCH_REGS_FOR_GETREGS);
    1229                 :            : #  endif
    1230                 :            : }
    1231                 :            : # endif /* !HAVE_GETREGS_OLD */
    1232                 :            : 
    1233                 :            : #endif /* ARCH_REGS_FOR_GETREGSET || ARCH_REGS_FOR_GETREGS */
    1234                 :            : 
    1235                 :            : static void
    1236                 :   37533302 : get_regs(pid_t pid)
    1237                 :            : {
    1238                 :            : #undef USE_GET_SYSCALL_RESULT_REGS
    1239                 :            : #ifdef ptrace_getregset_or_getregs
    1240                 :            : 
    1241         [ +  + ]:   37533302 :         if (get_regs_error != -1)
    1242                 :            :                 return;
    1243                 :            : 
    1244                 :            : # ifdef HAVE_GETREGS_OLD
    1245                 :            :         /*
    1246                 :            :          * Try PTRACE_GETREGSET/PTRACE_GETREGS first,
    1247                 :            :          * fallback to getregs_old.
    1248                 :            :          */
    1249                 :            :         static int use_getregs_old;
    1250         [ +  + ]:   37533217 :         if (use_getregs_old < 0) {
    1251                 :   37523729 :                 get_regs_error = ptrace_getregset_or_getregs(pid);
    1252                 :   37523729 :                 return;
    1253         [ +  - ]:       9488 :         } else if (use_getregs_old == 0) {
    1254                 :       9488 :                 get_regs_error = ptrace_getregset_or_getregs(pid);
    1255         [ +  - ]:       9488 :                 if (get_regs_error >= 0) {
    1256                 :       9488 :                         use_getregs_old = -1;
    1257                 :       9488 :                         return;
    1258                 :            :                 }
    1259         [ #  # ]:          0 :                 if (errno == EPERM || errno == ESRCH)
    1260                 :            :                         return;
    1261                 :          0 :                 use_getregs_old = 1;
    1262                 :            :         }
    1263                 :          0 :         get_regs_error = getregs_old(pid);
    1264                 :            : # else /* !HAVE_GETREGS_OLD */
    1265                 :            :         /* Assume that PTRACE_GETREGSET/PTRACE_GETREGS works. */
    1266                 :            :         get_regs_error = ptrace_getregset_or_getregs(pid);
    1267                 :            : # endif /* !HAVE_GETREGS_OLD */
    1268                 :            : 
    1269                 :            : #else /* !ptrace_getregset_or_getregs */
    1270                 :            : 
    1271                 :            : # define USE_GET_SYSCALL_RESULT_REGS 1
    1272                 :            : # warning get_regs is not implemented for this architecture yet
    1273                 :            :         get_regs_error = 0;
    1274                 :            : 
    1275                 :            : #endif /* !ptrace_getregset_or_getregs */
    1276                 :            : }
    1277                 :            : 
    1278                 :            : #ifdef ptrace_setregset_or_setregs
    1279                 :            : static int
    1280                 :            : set_regs(pid_t pid)
    1281                 :            : {
    1282                 :            :         return ptrace_setregset_or_setregs(pid);
    1283                 :            : }
    1284                 :            : #endif /* ptrace_setregset_or_setregs */
    1285                 :            : 
    1286                 :            : struct sysent_buf {
    1287                 :            :         struct tcb *tcp;
    1288                 :            :         struct_sysent ent;
    1289                 :            :         char buf[sizeof("syscall_%lu") + sizeof(kernel_ulong_t) * 3];
    1290                 :            : };
    1291                 :            : 
    1292                 :            : static void
    1293                 :          6 : free_sysent_buf(void *ptr)
    1294                 :            : {
    1295                 :          6 :         struct sysent_buf *s = ptr;
    1296                 :          6 :         s->tcp->s_prev_ent = s->tcp->s_ent = NULL;
    1297                 :          6 :         free(ptr);
    1298                 :          6 : }
    1299                 :            : 
    1300                 :            : /*
    1301                 :            :  * Returns:
    1302                 :            :  * 0: "ignore this ptrace stop", syscall_entering_decode() should return a "bail
    1303                 :            :  *    out silently" code.
    1304                 :            :  * 1: ok, continue in syscall_entering_decode().
    1305                 :            :  * other: error, syscall_entering_decode() should print error indicator
    1306                 :            :  *    ("????" etc) and return an appropriate code.
    1307                 :            :  */
    1308                 :            : int
    1309                 :   37085583 : get_scno(struct tcb *tcp)
    1310                 :            : {
    1311                 :   37085583 :         get_regs(tcp->pid);
    1312                 :            : 
    1313         [ +  - ]:   37085583 :         if (get_regs_error)
    1314                 :            :                 return -1;
    1315                 :            : 
    1316                 :   37085583 :         int rc = arch_get_scno(tcp);
    1317         [ +  - ]:   37085583 :         if (rc != 1)
    1318                 :            :                 return rc;
    1319                 :            : 
    1320         [ +  + ]:   37085583 :         if (scno_is_valid(tcp->scno)) {
    1321                 :   37085577 :                 tcp->s_ent = &sysent[tcp->scno];
    1322                 :   37085577 :                 tcp->qual_flg = qual_flags(tcp->scno);
    1323                 :            :         } else {
    1324                 :          6 :                 struct sysent_buf *s = xcalloc(1, sizeof(*s));
    1325                 :            : 
    1326                 :          6 :                 s->tcp = tcp;
    1327                 :          6 :                 s->ent.nargs = MAX_ARGS;
    1328                 :          6 :                 s->ent.sen = SEN_printargs;
    1329                 :          6 :                 s->ent.sys_func = printargs;
    1330                 :          6 :                 s->ent.sys_name = s->buf;
    1331                 :          6 :                 sprintf(s->buf, "syscall_%" PRI_klu, shuffle_scno(tcp->scno));
    1332                 :            : 
    1333                 :          6 :                 tcp->s_ent = &s->ent;
    1334                 :          6 :                 tcp->qual_flg = QUAL_RAW | DEFAULT_QUAL_FLAGS;
    1335                 :            : 
    1336                 :          6 :                 set_tcb_priv_data(tcp, s, free_sysent_buf);
    1337                 :            : 
    1338         [ -  + ]:          6 :                 if (debug_flag)
    1339                 :          0 :                         error_msg("pid %d invalid syscall %" PRI_kld,
    1340                 :            :                                   tcp->pid, tcp->scno);
    1341                 :            :         }
    1342                 :            :         return 1;
    1343                 :            : }
    1344                 :            : 
    1345                 :            : #ifdef USE_GET_SYSCALL_RESULT_REGS
    1346                 :            : static int get_syscall_result_regs(struct tcb *);
    1347                 :            : #endif
    1348                 :            : 
    1349                 :            : /* Returns:
    1350                 :            :  * 1: ok, continue in syscall_exiting_trace().
    1351                 :            :  * -1: error, syscall_exiting_trace() should print error indicator
    1352                 :            :  *    ("????" etc) and bail out.
    1353                 :            :  */
    1354                 :            : static int
    1355                 :            : get_syscall_result(struct tcb *tcp)
    1356                 :            : {
    1357                 :            : #ifdef USE_GET_SYSCALL_RESULT_REGS
    1358                 :            :         if (get_syscall_result_regs(tcp))
    1359                 :            :                 return -1;
    1360                 :            : #endif
    1361                 :     447626 :         tcp->u_error = 0;
    1362                 :     447626 :         get_error(tcp, !(tcp->s_ent->sys_flags & SYSCALL_NEVER_FAILS));
    1363                 :            : 
    1364                 :            :         return 1;
    1365                 :            : }
    1366                 :            : 
    1367                 :            : #include "get_scno.c"
    1368                 :            : #include "set_scno.c"
    1369                 :            : #include "get_syscall_args.c"
    1370                 :            : #ifdef USE_GET_SYSCALL_RESULT_REGS
    1371                 :            : # include "get_syscall_result.c"
    1372                 :            : #endif
    1373                 :            : #include "get_error.c"
    1374                 :            : #include "set_error.c"
    1375                 :            : #ifdef HAVE_GETREGS_OLD
    1376                 :            : # include "getregs_old.c"
    1377                 :            : #endif
    1378                 :            : 
    1379                 :            : const char *
    1380                 :          4 : syscall_name(kernel_ulong_t scno)
    1381                 :            : {
    1382                 :            : #if defined X32_PERSONALITY_NUMBER && defined __X32_SYSCALL_BIT
    1383         [ -  + ]:          4 :         if (current_personality == X32_PERSONALITY_NUMBER)
    1384                 :          0 :                 scno &= ~__X32_SYSCALL_BIT;
    1385                 :            : #endif
    1386         [ +  + ]:          4 :         return scno_is_valid(scno) ? sysent[scno].sys_name : NULL;
    1387                 :            : }

Generated by: LCOV version 1.11