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