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

   1 /*
   2  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
   3  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
   4  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
   5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  *      $Id$
  31  */
  32
  33 #include "defs.h"
  34
  35 #include <fcntl.h>
  36 #include <sys/file.h>
  37 #ifdef LINUX
  38 #include <inttypes.h>
  39 #endif
  40 #ifdef HAVE_SYS_EPOLL_H
  41 #include <sys/epoll.h>
  42 #endif
  43 #ifdef HAVE_LIBAIO_H
  44 #include <libaio.h>
  45 #endif
  46
  47 #if HAVE_LONG_LONG_OFF_T
  48 /*
  49  * Hacks for systems that have a long long off_t
  50  */
  51 #define flock64 flock           /* Horrid hack */
  52 #define printflock printflock64 /* Horrider hack */
  53 #endif
  54
  55
  56 static const struct xlat fcntlcmds[] = {
  57         { F_DUPFD,      "F_DUPFD"       },
  58         { F_GETFD,      "F_GETFD"       },
  59         { F_SETFD,      "F_SETFD"       },
  60         { F_GETFL,      "F_GETFL"       },
  61         { F_SETFL,      "F_SETFL"       },
  62         { F_GETLK,      "F_GETLK"       },
  63         { F_SETLK,      "F_SETLK"       },
  64         { F_SETLKW,     "F_SETLKW"      },
  65         { F_GETOWN,     "F_GETOWN"      },
  66         { F_SETOWN,     "F_SETOWN"      },
  67 #ifdef F_RSETLK
  68         { F_RSETLK,     "F_RSETLK"      },
  69 #endif
  70 #ifdef F_RSETLKW
  71         { F_RSETLKW,    "F_RSETLKW"     },
  72 #endif
  73 #ifdef F_RGETLK
  74         { F_RGETLK,     "F_RGETLK"      },
  75 #endif
  76 #ifdef F_CNVT
  77         { F_CNVT,       "F_CNVT"        },
  78 #endif
  79 #ifdef F_SETSIG
  80         { F_SETSIG,     "F_SETSIG"      },
  81 #endif
  82 #ifdef F_GETSIG
  83         { F_GETSIG,     "F_GETSIG"      },
  84 #endif
  85 #ifdef F_CHKFL
  86         { F_CHKFL,      "F_CHKFL"       },
  87 #endif
  88 #ifdef F_DUP2FD
  89         { F_DUP2FD,     "F_DUP2FD"      },
  90 #endif
  91 #ifdef F_ALLOCSP
  92         { F_ALLOCSP,    "F_ALLOCSP"     },
  93 #endif
  94 #ifdef F_ISSTREAM
  95         { F_ISSTREAM,   "F_ISSTREAM"    },
  96 #endif
  97 #ifdef F_PRIV
  98         { F_PRIV,       "F_PRIV"        },
  99 #endif
 100 #ifdef F_NPRIV
 101         { F_NPRIV,      "F_NPRIV"       },
 102 #endif
 103 #ifdef F_QUOTACL
 104         { F_QUOTACL,    "F_QUOTACL"     },
 105 #endif
 106 #ifdef F_BLOCKS
 107         { F_BLOCKS,     "F_BLOCKS"      },
 108 #endif
 109 #ifdef F_BLKSIZE
 110         { F_BLKSIZE,    "F_BLKSIZE"     },
 111 #endif
 112 #ifdef F_GETOWN
 113         { F_GETOWN,     "F_GETOWN"      },
 114 #endif
 115 #ifdef F_SETOWN
 116         { F_SETOWN,     "F_SETOWN"      },
 117 #endif
 118 #ifdef F_REVOKE
 119         { F_REVOKE,     "F_REVOKE"      },
 120 #endif
 121 #ifdef F_SETLK
 122         { F_SETLK,      "F_SETLK"       },
 123 #endif
 124 #ifdef F_SETLKW
 125         { F_SETLKW,     "F_SETLKW"      },
 126 #endif
 127 #ifdef F_FREESP
 128         { F_FREESP,     "F_FREESP"      },
 129 #endif
 130 #ifdef F_GETLK
 131         { F_GETLK,      "F_GETLK"       },
 132 #endif
 133 #ifdef F_SETLK64
 134         { F_SETLK64,    "F_SETLK64"     },
 135 #endif
 136 #ifdef F_SETLKW64
 137         { F_SETLKW64,   "F_SETLKW64"    },
 138 #endif
 139 #ifdef F_FREESP64
 140         { F_FREESP64,   "F_FREESP64"    },
 141 #endif
 142 #ifdef F_GETLK64
 143         { F_GETLK64,    "F_GETLK64"     },
 144 #endif
 145 #ifdef F_SHARE
 146         { F_SHARE,      "F_SHARE"       },
 147 #endif
 148 #ifdef F_UNSHARE
 149         { F_UNSHARE,    "F_UNSHARE"     },
 150 #endif
 151 #ifdef F_SETLEASE
 152         { F_SETLEASE,   "F_SETLEASE"    },
 153 #endif
 154 #ifdef F_GETLEASE
 155         { F_GETLEASE,   "F_GETLEASE"    },
 156 #endif
 157 #ifdef F_NOTIFY
 158         { F_NOTIFY,     "F_NOTIFY"      },
 159 #endif
 160 #ifdef F_DUPFD_CLOEXEC
 161         { F_DUPFD_CLOEXEC,"F_DUPFD_CLOEXEC"},
 162 #endif
 163         { 0,            NULL            },
 164 };
 165
 166 static const struct xlat fdflags[] = {
 167 #ifdef FD_CLOEXEC
 168         { FD_CLOEXEC,   "FD_CLOEXEC"    },
 169 #endif
 170         { 0,            NULL            },
 171 };
 172
 173 #ifdef LOCK_SH
 174
 175 static const struct xlat flockcmds[] = {
 176         { LOCK_SH,      "LOCK_SH"       },
 177         { LOCK_EX,      "LOCK_EX"       },
 178         { LOCK_NB,      "LOCK_NB"       },
 179         { LOCK_UN,      "LOCK_UN"       },
 180         { 0,            NULL            },
 181 };
 182
 183 #endif /* LOCK_SH */
 184
 185 static const struct xlat lockfcmds[] = {
 186         { F_RDLCK,      "F_RDLCK"       },
 187         { F_WRLCK,      "F_WRLCK"       },
 188         { F_UNLCK,      "F_UNLCK"       },
 189 #ifdef F_EXLCK
 190         { F_EXLCK,      "F_EXLCK"       },
 191 #endif
 192 #ifdef F_SHLCK
 193         { F_SHLCK,      "F_SHLCK"       },
 194 #endif
 195         { 0,            NULL            },
 196 };
 197
 198 #ifdef F_NOTIFY
 199 static const struct xlat notifyflags[] = {
 200 #ifdef DN_ACCESS
 201         { DN_ACCESS,    "DN_ACCESS"     },
 202 #endif
 203 #ifdef DN_MODIFY
 204         { DN_MODIFY,    "DN_MODIFY"     },
 205 #endif
 206 #ifdef DN_CREATE
 207         { DN_CREATE,    "DN_CREATE"     },
 208 #endif
 209 #ifdef DN_DELETE
 210         { DN_DELETE,    "DN_DELETE"     },
 211 #endif
 212 #ifdef DN_RENAME
 213         { DN_RENAME,    "DN_RENAME"     },
 214 #endif
 215 #ifdef DN_ATTRIB
 216         { DN_ATTRIB,    "DN_ATTRIB"     },
 217 #endif
 218 #ifdef DN_MULTISHOT
 219         { DN_MULTISHOT, "DN_MULTISHOT"  },
 220 #endif
 221         { 0,            NULL            },
 222 };
 223 #endif
 224
 225 static const struct xlat whence[] = {
 226         { SEEK_SET,     "SEEK_SET"      },
 227         { SEEK_CUR,     "SEEK_CUR"      },
 228         { SEEK_END,     "SEEK_END"      },
 229         { 0,            NULL            },
 230 };
 231
 232 #ifndef HAVE_LONG_LONG_OFF_T
 233 /* fcntl/lockf */
 234 static void
 235 printflock(struct tcb *tcp, long addr, int getlk)
 236 {
 237         struct flock fl;
 238
 239 #if SUPPORTED_PERSONALITIES > 1
 240         if (personality_wordsize[current_personality] != sizeof(fl.l_start)) {
 241                 if (personality_wordsize[current_personality] == 4) {
 242                         /* 32-bit x86 app on x86_64 and similar cases */
 243                         struct {
 244                                 short int l_type;
 245                                 short int l_whence;
 246                                 int32_t l_start; /* off_t */
 247                                 int32_t l_len; /* off_t */
 248                                 int32_t l_pid; /* pid_t */
 249                         } fl32;
 250                         if (umove(tcp, addr, &fl32) < 0) {
 251                                 tprints("{...}");
 252                                 return;
 253                         }
 254                         fl.l_type = fl32.l_type;
 255                         fl.l_whence = fl32.l_whence;
 256                         fl.l_start = fl32.l_start;
 257                         fl.l_len = fl32.l_len;
 258                         fl.l_pid = fl32.l_pid;
 259                 } else {
 260                         /* let people know we have a problem here */
 261                         tprintf("{ <decode error: unsupported wordsize %d> }",
 262                                 personality_wordsize[current_personality]);
 263                         return;
 264                 }
 265         } else
 266 #endif
 267         {
 268                 if (umove(tcp, addr, &fl) < 0) {
 269                         tprints("{...}");
 270                         return;
 271                 }
 272         }
 273         tprints("{type=");
 274         printxval(lockfcmds, fl.l_type, "F_???");
 275         tprints(", whence=");
 276         printxval(whence, fl.l_whence, "SEEK_???");
 277         tprintf(", start=%ld, len=%ld", fl.l_start, fl.l_len);
 278         if (getlk)
 279                 tprintf(", pid=%lu}", (unsigned long) fl.l_pid);
 280         else
 281                 tprints("}");
 282 }
 283 #endif
 284
 285 #if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
 286 /* fcntl/lockf */
 287 static void
 288 printflock64(struct tcb *tcp, long addr, int getlk)
 289 {
 290         struct flock64 fl;
 291
 292         if (umove(tcp, addr, &fl) < 0) {
 293                 tprints("{...}");
 294                 return;
 295         }
 296         tprints("{type=");
 297         printxval(lockfcmds, fl.l_type, "F_???");
 298         tprints(", whence=");
 299         printxval(whence, fl.l_whence, "SEEK_???");
 300         tprintf(", start=%lld, len=%lld", (long long) fl.l_start, (long long) fl.l_len);
 301         if (getlk)
 302                 tprintf(", pid=%lu}", (unsigned long) fl.l_pid);
 303         else
 304                 tprints("}");
 305 }
 306 #endif
 307
 308 int
 309 sys_fcntl(struct tcb *tcp)
 310 {
 311         if (entering(tcp)) {
 312                 printfd(tcp, tcp->u_arg[0]);
 313                 tprints(", ");
 314                 printxval(fcntlcmds, tcp->u_arg[1], "F_???");
 315                 switch (tcp->u_arg[1]) {
 316                 case F_SETFD:
 317                         tprints(", ");
 318                         printflags(fdflags, tcp->u_arg[2], "FD_???");
 319                         break;
 320                 case F_SETOWN: case F_DUPFD:
 321 #ifdef F_DUPFD_CLOEXEC
 322                 case F_DUPFD_CLOEXEC:
 323 #endif
 324                         tprintf(", %ld", tcp->u_arg[2]);
 325                         break;
 326                 case F_SETFL:
 327                         tprints(", ");
 328                         tprint_open_modes(tcp->u_arg[2]);
 329                         break;
 330                 case F_SETLK: case F_SETLKW:
 331 #ifdef F_FREESP
 332                 case F_FREESP:
 333 #endif
 334                         tprints(", ");
 335                         printflock(tcp, tcp->u_arg[2], 0);
 336                         break;
 337 #if _LFS64_LARGEFILE
 338 #ifdef F_FREESP64
 339                 case F_FREESP64:
 340 #endif
 341                 /* Linux glibc defines SETLK64 as SETLK,
 342                    even though the kernel has different values - as does Solaris. */
 343 #if defined(F_SETLK64) && F_SETLK64 + 0 != F_SETLK
 344                 case F_SETLK64:
 345 #endif
 346 #if defined(F_SETLKW64) && F_SETLKW64 + 0 != F_SETLKW
 347                 case F_SETLKW64:
 348 #endif
 349                         tprints(", ");
 350                         printflock64(tcp, tcp->u_arg[2], 0);
 351                         break;
 352 #endif
 353 #ifdef F_NOTIFY
 354                 case F_NOTIFY:
 355                         tprints(", ");
 356                         printflags(notifyflags, tcp->u_arg[2], "DN_???");
 357                         break;
 358 #endif
 359 #ifdef F_SETLEASE
 360                 case F_SETLEASE:
 361                         tprints(", ");
 362                         printxval(lockfcmds, tcp->u_arg[2], "F_???");
 363                         break;
 364 #endif
 365                 }
 366         }
 367         else {
 368                 switch (tcp->u_arg[1]) {
 369                 case F_DUPFD:
 370 #ifdef F_DUPFD_CLOEXEC
 371                 case F_DUPFD_CLOEXEC:
 372 #endif
 373                 case F_SETFD: case F_SETFL:
 374                 case F_SETLK: case F_SETLKW:
 375                 case F_SETOWN: case F_GETOWN:
 376 #ifdef F_NOTIFY
 377                 case F_NOTIFY:
 378 #endif
 379 #ifdef F_SETLEASE
 380                 case F_SETLEASE:
 381 #endif
 382                         break;
 383                 case F_GETFD:
 384                         if (syserror(tcp) || tcp->u_rval == 0)
 385                                 return 0;
 386                         tcp->auxstr = sprintflags("flags ", fdflags, tcp->u_rval);
 387                         return RVAL_HEX|RVAL_STR;
 388                 case F_GETFL:
 389                         if (syserror(tcp))
 390                                 return 0;
 391                         tcp->auxstr = sprint_open_modes(tcp->u_rval);
 392                         return RVAL_HEX|RVAL_STR;
 393                 case F_GETLK:
 394                         tprints(", ");
 395                         printflock(tcp, tcp->u_arg[2], 1);
 396                         break;
 397 #if _LFS64_LARGEFILE
 398 #if defined(F_GETLK64) && F_GETLK64+0 != F_GETLK
 399                 case F_GETLK64:
 400 #endif
 401                         tprints(", ");
 402                         printflock64(tcp, tcp->u_arg[2], 1);
 403                         break;
 404 #endif
 405 #ifdef F_GETLEASE
 406                 case F_GETLEASE:
 407                         if (syserror(tcp))
 408                                 return 0;
 409                         tcp->auxstr = xlookup(lockfcmds, tcp->u_rval);
 410                         return RVAL_HEX|RVAL_STR;
 411 #endif
 412                 default:
 413                         tprintf(", %#lx", tcp->u_arg[2]);
 414                         break;
 415                 }
 416         }
 417         return 0;
 418 }
 419
 420 #ifdef LOCK_SH
 421
 422 int
 423 sys_flock(struct tcb *tcp)
 424 {
 425         if (entering(tcp)) {
 426                 printfd(tcp, tcp->u_arg[0]);
 427                 tprints(", ");
 428                 printflags(flockcmds, tcp->u_arg[1], "LOCK_???");
 429         }
 430         return 0;
 431 }
 432 #endif /* LOCK_SH */
 433
 434 int
 435 sys_close(struct tcb *tcp)
 436 {
 437         if (entering(tcp)) {
 438                 printfd(tcp, tcp->u_arg[0]);
 439         }
 440         return 0;
 441 }
 442
 443 int
 444 sys_dup(struct tcb *tcp)
 445 {
 446         if (entering(tcp)) {
 447                 printfd(tcp, tcp->u_arg[0]);
 448         }
 449         return 0;
 450 }
 451
 452 static int
 453 do_dup2(struct tcb *tcp, int flags_arg)
 454 {
 455         if (entering(tcp)) {
 456                 printfd(tcp, tcp->u_arg[0]);
 457                 tprints(", ");
 458                 printfd(tcp, tcp->u_arg[1]);
 459                 if (flags_arg >= 0) {
 460                         tprints(", ");
 461                         printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
 462                 }
 463         }
 464         return 0;
 465 }
 466
 467 int
 468 sys_dup2(struct tcb *tcp)
 469 {
 470         return do_dup2(tcp, -1);
 471 }
 472
 473 #ifdef LINUX
 474 int
 475 sys_dup3(struct tcb *tcp)
 476 {
 477         return do_dup2(tcp, 2);
 478 }
 479 #endif
 480
 481 #if defined(ALPHA) || defined(FREEBSD) || defined(SUNOS4)
 482 int
 483 sys_getdtablesize(struct tcb *tcp)
 484 {
 485         return 0;
 486 }
 487 #endif /* ALPHA || FREEBSD || SUNOS4 */
 488
 489 static int
 490 decode_select(struct tcb *tcp, long *args, enum bitness_t bitness)
 491 {
 492         int i, j;
 493         unsigned nfds, fdsize;
 494         fd_set *fds;
 495         const char *sep;
 496         long arg;
 497
 498         fdsize = args[0];
 499         /* Beware of select(2^31-1, NULL, NULL, NULL) and similar... */
 500         if (args[0] > 1024*1024)
 501                 fdsize = 1024*1024;
 502         if (args[0] < 0)
 503                 fdsize = 0;
 504         fdsize = (((fdsize + 7) / 8) + sizeof(long)-1) & -sizeof(long);
 505
 506         if (entering(tcp)) {
 507                 fds = malloc(fdsize);
 508                 if (!fds)
 509                         die_out_of_memory();
 510                 nfds = args[0];
 511                 tprintf("%d", nfds);
 512                 for (i = 0; i < 3; i++) {
 513                         arg = args[i+1];
 514                         if (arg == 0) {
 515                                 tprints(", NULL");
 516                                 continue;
 517                         }
 518                         if (!verbose(tcp)) {
 519                                 tprintf(", %#lx", arg);
 520                                 continue;
 521                         }
 522                         if (umoven(tcp, arg, fdsize, (char *) fds) < 0) {
 523                                 tprints(", [?]");
 524                                 continue;
 525                         }
 526                         tprints(", [");
 527                         for (j = 0, sep = ""; j < nfds; j++) {
 528                                 if (FD_ISSET(j, fds)) {
 529                                         tprints(sep);
 530                                         printfd(tcp, j);
 531                                         sep = " ";
 532                                 }
 533                         }
 534                         tprints("]");
 535                 }
 536                 free(fds);
 537                 tprints(", ");
 538                 printtv_bitness(tcp, args[4], bitness, 0);
 539         }
 540         else {
 541                 static char outstr[1024];
 542                 char *outptr;
 543 #define end_outstr (outstr + sizeof(outstr))
 544                 const char *sep;
 545
 546                 if (syserror(tcp))
 547                         return 0;
 548
 549                 nfds = tcp->u_rval;
 550                 if (nfds == 0) {
 551                         tcp->auxstr = "Timeout";
 552                         return RVAL_STR;
 553                 }
 554
 555                 fds = malloc(fdsize);
 556                 if (!fds)
 557                         die_out_of_memory();
 558
 559                 outptr = outstr;
 560                 sep = "";
 561                 for (i = 0; i < 3; i++) {
 562                         int first = 1;
 563
 564                         arg = args[i+1];
 565                         if (!arg || umoven(tcp, arg, fdsize, (char *) fds) < 0)
 566                                 continue;
 567                         for (j = 0; j < args[0]; j++) {
 568                                 if (FD_ISSET(j, fds)) {
 569                                         /* +2 chars needed at the end: ']',NUL */
 570                                         if (outptr < end_outstr - (sizeof(", except [") + sizeof(int)*3 + 2)) {
 571                                                 if (first) {
 572                                                         outptr += sprintf(outptr, "%s%s [%u",
 573                                                                 sep,
 574                                                                 i == 0 ? "in" : i == 1 ? "out" : "except",
 575                                                                 j
 576                                                         );
 577                                                         first = 0;
 578                                                         sep = ", ";
 579                                                 }
 580                                                 else {
 581                                                         outptr += sprintf(outptr, " %u", j);
 582                                                 }
 583                                         }
 584                                         nfds--;
 585                                 }
 586                         }
 587                         if (outptr != outstr)
 588                                 *outptr++ = ']';
 589                         if (nfds == 0)
 590                                 break;
 591                 }
 592                 free(fds);
 593 #ifdef LINUX
 594                 /* This contains no useful information on SunOS.  */
 595                 if (args[4]) {
 596                         if (outptr < end_outstr - 128) {
 597                                 outptr += sprintf(outptr, "%sleft ", sep);
 598                                 outptr = sprinttv(tcp, args[4], bitness, outptr);
 599                         }
 600                 }
 601 #endif /* LINUX */
 602                 *outptr = '\0';
 603                 tcp->auxstr = outstr;
 604                 return RVAL_STR;
 605 #undef end_outstr
 606         }
 607         return 0;
 608 }
 609
 610 #ifdef LINUX
 611
 612 int
 613 sys_oldselect(struct tcb *tcp)
 614 {
 615         long args[5];
 616
 617         if (umoven(tcp, tcp->u_arg[0], sizeof args, (char *) args) < 0) {
 618                 tprints("[...]");
 619                 return 0;
 620         }
 621         return decode_select(tcp, args, BITNESS_CURRENT);
 622 }
 623
 624 #ifdef ALPHA
 625 int
 626 sys_osf_select(struct tcb *tcp)
 627 {
 628         long *args = tcp->u_arg;
 629         return decode_select(tcp, args, BITNESS_32);
 630 }
 631 #endif
 632
 633 static const struct xlat epollctls[] = {
 634 #ifdef EPOLL_CTL_ADD
 635         { EPOLL_CTL_ADD,        "EPOLL_CTL_ADD" },
 636 #endif
 637 #ifdef EPOLL_CTL_MOD
 638         { EPOLL_CTL_MOD,        "EPOLL_CTL_MOD" },
 639 #endif
 640 #ifdef EPOLL_CTL_DEL
 641         { EPOLL_CTL_DEL,        "EPOLL_CTL_DEL" },
 642 #endif
 643         { 0,                    NULL            }
 644 };
 645
 646 static const struct xlat epollevents[] = {
 647 #ifdef EPOLLIN
 648         { EPOLLIN,      "EPOLLIN"       },
 649 #endif
 650 #ifdef EPOLLPRI
 651         { EPOLLPRI,     "EPOLLPRI"      },
 652 #endif
 653 #ifdef EPOLLOUT
 654         { EPOLLOUT,     "EPOLLOUT"      },
 655 #endif
 656 #ifdef EPOLLRDNORM
 657         { EPOLLRDNORM,  "EPOLLRDNORM"   },
 658 #endif
 659 #ifdef EPOLLRDBAND
 660         { EPOLLRDBAND,  "EPOLLRDBAND"   },
 661 #endif
 662 #ifdef EPOLLWRNORM
 663         { EPOLLWRNORM,  "EPOLLWRNORM"   },
 664 #endif
 665 #ifdef EPOLLWRBAND
 666         { EPOLLWRBAND,  "EPOLLWRBAND"   },
 667 #endif
 668 #ifdef EPOLLMSG
 669         { EPOLLMSG,     "EPOLLMSG"      },
 670 #endif
 671 #ifdef EPOLLERR
 672         { EPOLLERR,     "EPOLLERR"      },
 673 #endif
 674 #ifdef EPOLLHUP
 675         { EPOLLHUP,     "EPOLLHUP"      },
 676 #endif
 677 #ifdef EPOLLRDHUP
 678         { EPOLLRDHUP,   "EPOLLRDHUP"    },
 679 #endif
 680 #ifdef EPOLLONESHOT
 681         { EPOLLONESHOT, "EPOLLONESHOT"  },
 682 #endif
 683 #ifdef EPOLLET
 684         { EPOLLET,      "EPOLLET"       },
 685 #endif
 686         { 0,            NULL            }
 687 };
 688
 689 int
 690 sys_epoll_create(struct tcb *tcp)
 691 {
 692         if (entering(tcp))
 693                 tprintf("%ld", tcp->u_arg[0]);
 694         return 0;
 695 }
 696
 697 static const struct xlat epollflags[] = {
 698 #ifdef EPOLL_CLOEXEC
 699         { EPOLL_CLOEXEC,        "EPOLL_CLOEXEC" },
 700 #endif
 701 #ifdef EPOLL_NONBLOCK
 702         { EPOLL_NONBLOCK,       "EPOLL_NONBLOCK"        },
 703 #endif
 704         { 0,            NULL            }
 705 };
 706
 707 int
 708 sys_epoll_create1(struct tcb *tcp)
 709 {
 710         if (entering(tcp))
 711                 printflags(epollflags, tcp->u_arg[0], "EPOLL_???");
 712         return 0;
 713 }
 714
 715 #ifdef HAVE_SYS_EPOLL_H
 716 static void
 717 print_epoll_event(struct epoll_event *ev)
 718 {
 719         tprints("{");
 720         printflags(epollevents, ev->events, "EPOLL???");
 721         /* We cannot know what format the program uses, so print u32 and u64
 722            which will cover every value.  */
 723         tprintf(", {u32=%" PRIu32 ", u64=%" PRIu64 "}}",
 724                 ev->data.u32, ev->data.u64);
 725 }
 726 #endif
 727
 728 int
 729 sys_epoll_ctl(struct tcb *tcp)
 730 {
 731         if (entering(tcp)) {
 732                 printfd(tcp, tcp->u_arg[0]);
 733                 tprints(", ");
 734                 printxval(epollctls, tcp->u_arg[1], "EPOLL_CTL_???");
 735                 tprints(", ");
 736                 printfd(tcp, tcp->u_arg[2]);
 737                 tprints(", ");
 738                 if (tcp->u_arg[3] == 0)
 739                         tprints("NULL");
 740                 else {
 741 #ifdef HAVE_SYS_EPOLL_H
 742                         struct epoll_event ev;
 743                         if (umove(tcp, tcp->u_arg[3], &ev) == 0)
 744                                 print_epoll_event(&ev);
 745                         else
 746 #endif
 747                                 tprints("{...}");
 748                 }
 749         }
 750         return 0;
 751 }
 752
 753 static void
 754 epoll_wait_common(struct tcb *tcp)
 755 {
 756         if (entering(tcp)) {
 757                 printfd(tcp, tcp->u_arg[0]);
 758                 tprints(", ");
 759         } else {
 760                 if (syserror(tcp))
 761                         tprintf("%lx", tcp->u_arg[1]);
 762                 else if (tcp->u_rval == 0)
 763                         tprints("{}");
 764                 else {
 765 #ifdef HAVE_SYS_EPOLL_H
 766                         struct epoll_event ev, *start, *cur, *end;
 767                         int failed = 0;
 768
 769                         tprints("{");
 770                         start = (struct epoll_event *) tcp->u_arg[1];
 771                         end = start + tcp->u_rval;
 772                         for (cur = start; cur < end; ++cur) {
 773                                 if (cur > start)
 774                                         tprints(", ");
 775                                 if (umove(tcp, (long) cur, &ev) == 0)
 776                                         print_epoll_event(&ev);
 777                                 else {
 778                                         tprints("?");
 779                                         failed = 1;
 780                                         break;
 781                                 }
 782                         }
 783                         tprints("}");
 784                         if (failed)
 785                                 tprintf(" %#lx", (long) start);
 786 #else
 787                         tprints("{...}");
 788 #endif
 789                 }
 790                 tprintf(", %d, %d", (int) tcp->u_arg[2], (int) tcp->u_arg[3]);
 791         }
 792 }
 793
 794 int
 795 sys_epoll_wait(struct tcb *tcp)
 796 {
 797         epoll_wait_common(tcp);
 798         return 0;
 799 }
 800
 801 int
 802 sys_epoll_pwait(struct tcb *tcp)
 803 {
 804         epoll_wait_common(tcp);
 805         if (exiting(tcp)) {
 806                 tprints(", ");
 807                 print_sigset(tcp, tcp->u_arg[4], 0);
 808         }
 809         return 0;
 810 }
 811
 812 int
 813 sys_io_setup(struct tcb *tcp)
 814 {
 815         if (entering(tcp))
 816                 tprintf("%ld, ", tcp->u_arg[0]);
 817         else {
 818                 if (syserror(tcp))
 819                         tprintf("0x%0lx", tcp->u_arg[1]);
 820                 else {
 821                         unsigned long user_id;
 822                         if (umove(tcp, tcp->u_arg[1], &user_id) == 0)
 823                                 tprintf("{%lu}", user_id);
 824                         else
 825                                 tprints("{...}");
 826                 }
 827         }
 828         return 0;
 829 }
 830
 831 int
 832 sys_io_destroy(struct tcb *tcp)
 833 {
 834         if (entering(tcp))
 835                 tprintf("%lu", tcp->u_arg[0]);
 836         return 0;
 837 }
 838
 839 #ifdef HAVE_LIBAIO_H
 840
 841 enum iocb_sub {
 842         SUB_NONE, SUB_COMMON, SUB_POLL, SUB_VECTOR
 843 };
 844
 845 static const char *
 846 iocb_cmd_lookup(unsigned cmd, enum iocb_sub *sub)
 847 {
 848         static char buf[sizeof("%u /* SUB_??? */") + sizeof(int)*3];
 849         static const struct {
 850                 const char *name;
 851                 enum iocb_sub sub;
 852         } cmds[] = {
 853                 { "pread", SUB_COMMON },
 854                 { "pwrite", SUB_COMMON },
 855                 { "fsync", SUB_NONE },
 856                 { "fdsync", SUB_NONE },
 857                 { "op4", SUB_NONE },
 858                 { "poll", SUB_POLL },
 859                 { "noop", SUB_NONE },
 860                 { "preadv", SUB_VECTOR },
 861                 { "pwritev", SUB_VECTOR },
 862         };
 863
 864         if (cmd < ARRAY_SIZE(cmds)) {
 865                 *sub = cmds[cmd].sub;
 866                 return cmds[cmd].name;
 867         }
 868         *sub = SUB_NONE;
 869         sprintf(buf, "%u /* SUB_??? */", cmd);
 870         return buf;
 871 }
 872
 873 /* Not defined in libaio.h */
 874 #ifndef IOCB_RESFD
 875 # define IOCB_RESFD (1 << 0)
 876 #endif
 877
 878 static void
 879 print_common_flags(struct iocb *iocb)
 880 {
 881         if (iocb->u.c.flags & IOCB_RESFD)
 882                 tprintf("resfd=%d, ", iocb->u.c.resfd);
 883         if (iocb->u.c.flags & ~IOCB_RESFD)
 884                 tprintf("flags=%x, ", iocb->u.c.flags);
 885 }
 886
 887 #endif /* HAVE_LIBAIO_H */
 888
 889 int
 890 sys_io_submit(struct tcb *tcp)
 891 {
 892         long nr;
 893         if (entering(tcp)) {
 894                 tprintf("%lu, %ld, ", tcp->u_arg[0], tcp->u_arg[1]);
 895                 nr = tcp->u_arg[1];
 896                 /* and if nr is negative? */
 897                 if (nr == 0)
 898                         tprints("{}");
 899                 else {
 900 #ifdef HAVE_LIBAIO_H
 901                         long i;
 902                         struct iocb *iocbp, **iocbs = (void *)tcp->u_arg[2];
 903
 904                         for (i = 0; i < nr; i++, iocbs++) {
 905                                 enum iocb_sub sub;
 906                                 struct iocb iocb;
 907                                 if (i == 0)
 908                                         tprints("{");
 909                                 else
 910                                         tprints(", ");
 911
 912                                 if (umove(tcp, (unsigned long)iocbs, &iocbp) ||
 913                                     umove(tcp, (unsigned long)iocbp, &iocb)) {
 914                                         tprints("{...}");
 915                                         continue;
 916                                 }
 917                                 tprints("{");
 918                                 if (iocb.data)
 919                                         tprintf("data:%p, ", iocb.data);
 920                                 if (iocb.key)
 921                                         tprintf("key:%u, ", iocb.key);
 922                                 tprintf("%s, ", iocb_cmd_lookup(iocb.aio_lio_opcode, &sub));
 923                                 if (iocb.aio_reqprio)
 924                                         tprintf("reqprio:%d, ", iocb.aio_reqprio);
 925                                 tprintf("filedes:%d", iocb.aio_fildes);
 926                                 switch (sub) {
 927                                 case SUB_COMMON:
 928                                         if (iocb.aio_lio_opcode == IO_CMD_PWRITE) {
 929                                                 tprints(", str:");
 930                                                 printstr(tcp, (unsigned long)iocb.u.c.buf,
 931                                                          iocb.u.c.nbytes);
 932                                         } else {
 933                                                 tprintf(", buf:%p", iocb.u.c.buf);
 934                                         }
 935                                         tprintf(", nbytes:%lu, offset:%llx",
 936                                                 iocb.u.c.nbytes,
 937                                                 iocb.u.c.offset);
 938                                         print_common_flags(&iocb);
 939                                         break;
 940                                 case SUB_VECTOR:
 941                                         tprintf(", %llx, ", iocb.u.v.offset);
 942                                         print_common_flags(&iocb);
 943                                         tprint_iov(tcp, iocb.u.v.nr,
 944                                                    (unsigned long)iocb.u.v.vec,
 945                                                    iocb.aio_lio_opcode == IO_CMD_PWRITEV);
 946                                         break;
 947                                 case SUB_POLL:
 948                                         tprintf(", %x", iocb.u.poll.events);
 949                                         break;
 950                                 case SUB_NONE:
 951                                         break;
 952                                 }
 953                                 tprints("}");
 954                         }
 955                         if (i)
 956                                 tprints("}");
 957 #else
 958 #warning "libaio-devel is not available => no io_submit decoding"
 959                         tprintf("%#lx", tcp->u_arg[2]);
 960 #endif
 961                 }
 962         }
 963         return 0;
 964 }
 965
 966 int
 967 sys_io_cancel(struct tcb *tcp)
 968 {
 969         if (entering(tcp)) {
 970 #ifdef HAVE_LIBAIO_H
 971                 struct iocb iocb;
 972 #endif
 973                 tprintf("%lu, ", tcp->u_arg[0]);
 974 #ifdef HAVE_LIBAIO_H
 975                 if (umove(tcp, tcp->u_arg[1], &iocb) == 0) {
 976                         tprintf("{%p, %u, %hu, %hu, %d}, ",
 977                                 iocb.data, iocb.key,
 978                                 iocb.aio_lio_opcode,
 979                                 iocb.aio_reqprio, iocb.aio_fildes);
 980                 } else
 981 #endif
 982                         tprints("{...}, ");
 983         } else {
 984                 if (tcp->u_rval < 0)
 985                         tprints("{...}");
 986                 else {
 987 #ifdef HAVE_LIBAIO_H
 988                         struct io_event event;
 989                         if (umove(tcp, tcp->u_arg[2], &event) == 0)
 990                                 tprintf("{%p, %p, %ld, %ld}",
 991                                         event.data, event.obj,
 992                                         event.res, event.res2);
 993                         else
 994 #endif
 995                                 tprints("{...}");
 996                 }
 997         }
 998         return 0;
 999 }
1000
1001 int
1002 sys_io_getevents(struct tcb *tcp)
1003 {
1004         if (entering(tcp)) {
1005                 tprintf("%ld, %ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1],
1006                         tcp->u_arg[2]);
1007         } else {
1008                 if (tcp->u_rval == 0) {
1009                         tprints("{}");
1010                 } else  {
1011 #ifdef HAVE_LIBAIO_H
1012                         struct io_event *events = (void *)tcp->u_arg[3];
1013                         long i, nr = tcp->u_rval;
1014
1015                         for (i = 0; i < nr; i++, events++) {
1016                                 struct io_event event;
1017
1018                                 if (i == 0)
1019                                         tprints("{");
1020                                 else
1021                                         tprints(", ");
1022
1023                                 if (umove(tcp, (unsigned long)events, &event) != 0) {
1024                                         tprints("{...}");
1025                                         continue;
1026                                 }
1027                                 tprintf("{%p, %p, %ld, %ld}", event.data,
1028                                         event.obj, event.res, event.res2);
1029                         }
1030                         tprints("}, ");
1031 #else
1032                                 tprints("{...}");
1033 #endif
1034                 }
1035
1036                 print_timespec(tcp, tcp->u_arg[4]);
1037         }
1038         return 0;
1039 }
1040 #endif /* LINUX */
1041
1042 int
1043 sys_select(struct tcb *tcp)
1044 {
1045         return decode_select(tcp, tcp->u_arg, BITNESS_CURRENT);
1046 }
1047
1048 #ifdef LINUX
1049 int
1050 sys_pselect6(struct tcb *tcp)
1051 {
1052         int rc = decode_select(tcp, tcp->u_arg, BITNESS_CURRENT);
1053         if (entering(tcp)) {
1054                 struct {
1055                         void *ss;
1056                         unsigned long len;
1057                 } data;
1058                 if (umove(tcp, tcp->u_arg[5], &data) < 0)
1059                         tprintf(", %#lx", tcp->u_arg[5]);
1060                 else {
1061                         tprints(", {");
1062                         if (data.len < sizeof(long))
1063                                 tprintf("%#lx", (long)data.ss);
1064                         else
1065                                 print_sigset(tcp, (long)data.ss, 0);
1066                         tprintf(", %lu}", data.len);
1067                 }
1068         }
1069         return rc;
1070 }
1071
1072 static int
1073 do_eventfd(struct tcb *tcp, int flags_arg)
1074 {
1075         if (entering(tcp)) {
1076                 tprintf("%lu", tcp->u_arg[0]);
1077                 if (flags_arg >= 0) {
1078                         tprints(", ");
1079                         printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
1080                 }
1081         }
1082         return 0;
1083 }
1084
1085 int
1086 sys_eventfd(struct tcb *tcp)
1087 {
1088         return do_eventfd(tcp, -1);
1089 }
1090
1091 int
1092 sys_eventfd2(struct tcb *tcp)
1093 {
1094         return do_eventfd(tcp, 1);
1095 }
1096 #endif