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