granicus.if.org Git - strace/blob - file.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 <dirent.h>
  33 #include <sys/swap.h>
  34
  35 #if defined(SPARC) || defined(SPARC64)
  36 struct stat {
  37         unsigned short  st_dev;
  38         unsigned int    st_ino;
  39         unsigned short  st_mode;
  40         short           st_nlink;
  41         unsigned short  st_uid;
  42         unsigned short  st_gid;
  43         unsigned short  st_rdev;
  44         unsigned int    st_size;
  45         int             st_atime;
  46         unsigned int    __unused1;
  47         int             st_mtime;
  48         unsigned int    __unused2;
  49         int             st_ctime;
  50         unsigned int    __unused3;
  51         int             st_blksize;
  52         int             st_blocks;
  53         unsigned int    __unused4[2];
  54 };
  55 # if defined(SPARC64)
  56 struct stat_sparc64 {
  57         unsigned int    st_dev;
  58         unsigned long   st_ino;
  59         unsigned int    st_mode;
  60         unsigned int    st_nlink;
  61         unsigned int    st_uid;
  62         unsigned int    st_gid;
  63         unsigned int    st_rdev;
  64         long            st_size;
  65         long            st_atime;
  66         long            st_mtime;
  67         long            st_ctime;
  68         long            st_blksize;
  69         long            st_blocks;
  70         unsigned long   __unused4[2];
  71 };
  72 # endif /* SPARC64 */
  73 # define stat kernel_stat
  74 # include <asm/stat.h>
  75 # undef stat
  76 #elif defined(X32)
  77 struct stat {
  78         unsigned long long      st_dev;
  79         unsigned long long      st_ino;
  80         unsigned long long      st_nlink;
  81
  82         unsigned int            st_mode;
  83         unsigned int            st_uid;
  84         unsigned int            st_gid;
  85         unsigned int            __pad0;
  86         unsigned long long      st_rdev;
  87         long long               st_size;
  88         long long               st_blksize;
  89         long long               st_blocks;
  90
  91         unsigned long long      st_atime;
  92         unsigned long long      st_atime_nsec;
  93         unsigned long long      st_mtime;
  94         unsigned long long      st_mtime_nsec;
  95         unsigned long long      st_ctime;
  96         unsigned long long      st_ctime_nsec;
  97         long long               __unused[3];
  98 };
  99
 100 struct stat64 {
 101         unsigned long long      st_dev;
 102         unsigned char           __pad0[4];
 103         unsigned long           __st_ino;
 104         unsigned int            st_mode;
 105         unsigned int            st_nlink;
 106         unsigned long           st_uid;
 107         unsigned long           st_gid;
 108         unsigned long long      st_rdev;
 109         unsigned char           __pad3[4];
 110         long long               st_size;
 111         unsigned long           st_blksize;
 112         unsigned long long      st_blocks;
 113         unsigned long           st_atime;
 114         unsigned long           st_atime_nsec;
 115         unsigned long           st_mtime;
 116         unsigned int            st_mtime_nsec;
 117         unsigned long           st_ctime;
 118         unsigned long           st_ctime_nsec;
 119         unsigned long long      st_ino;
 120 };
 121 #else
 122 # undef dev_t
 123 # undef ino_t
 124 # undef mode_t
 125 # undef nlink_t
 126 # undef uid_t
 127 # undef gid_t
 128 # undef off_t
 129 # undef loff_t
 130 # define dev_t __kernel_dev_t
 131 # define ino_t __kernel_ino_t
 132 # define mode_t __kernel_mode_t
 133 # define nlink_t __kernel_nlink_t
 134 # define uid_t __kernel_uid_t
 135 # define gid_t __kernel_gid_t
 136 # define off_t __kernel_off_t
 137 # define loff_t __kernel_loff_t
 138
 139 # include <asm/stat.h>
 140
 141 # undef dev_t
 142 # undef ino_t
 143 # undef mode_t
 144 # undef nlink_t
 145 # undef uid_t
 146 # undef gid_t
 147 # undef off_t
 148 # undef loff_t
 149 # define dev_t dev_t
 150 # define ino_t ino_t
 151 # define mode_t mode_t
 152 # define nlink_t nlink_t
 153 # define uid_t uid_t
 154 # define gid_t gid_t
 155 # define off_t off_t
 156 # define loff_t loff_t
 157 #endif
 158
 159 #ifdef HPPA     /* asm-parisc/stat.h defines stat64 */
 160 # undef stat64
 161 #endif
 162 #define stat libc_stat
 163 #define stat64 libc_stat64
 164 #include <sys/stat.h>
 165 #undef stat
 166 #undef stat64
 167 /* These might be macros. */
 168 #undef st_atime
 169 #undef st_mtime
 170 #undef st_ctime
 171 #ifdef HPPA
 172 # define stat64 hpux_stat64
 173 #endif
 174
 175 #include <fcntl.h>
 176 #ifdef HAVE_SYS_VFS_H
 177 # include <sys/vfs.h>
 178 #endif
 179 #ifdef HAVE_LINUX_XATTR_H
 180 # include <linux/xattr.h>
 181 #else
 182 # define XATTR_CREATE 1
 183 # define XATTR_REPLACE 2
 184 #endif
 185
 186 #if HAVE_LONG_LONG_OFF_T
 187 /*
 188  * Ugly hacks for systems that have typedef long long off_t
 189  */
 190 # define stat64 stat
 191 # define HAVE_STAT64 1  /* Ugly hack */
 192 # define sys_stat64     sys_stat
 193 # define sys_fstat64    sys_fstat
 194 # define sys_lstat64    sys_lstat
 195 # define sys_truncate64 sys_truncate
 196 # define sys_ftruncate64        sys_ftruncate
 197 #endif
 198
 199 #ifdef MAJOR_IN_SYSMACROS
 200 # include <sys/sysmacros.h>
 201 #endif
 202
 203 #ifdef MAJOR_IN_MKDEV
 204 # include <sys/mkdev.h>
 205 #endif
 206
 207 #ifdef HAVE_SYS_ASYNCH_H
 208 # include <sys/asynch.h>
 209 #endif
 210
 211 struct kernel_dirent {
 212         unsigned long   d_ino;
 213         unsigned long   d_off;
 214         unsigned short  d_reclen;
 215         char            d_name[1];
 216 };
 217
 218 const struct xlat open_access_modes[] = {
 219         { O_RDONLY,     "O_RDONLY"      },
 220         { O_WRONLY,     "O_WRONLY"      },
 221         { O_RDWR,       "O_RDWR"        },
 222 #ifdef O_ACCMODE
 223         { O_ACCMODE,    "O_ACCMODE"     },
 224 #endif
 225         { 0,            NULL            },
 226 };
 227
 228 const struct xlat open_mode_flags[] = {
 229         { O_CREAT,      "O_CREAT"       },
 230         { O_EXCL,       "O_EXCL"        },
 231         { O_NOCTTY,     "O_NOCTTY"      },
 232         { O_TRUNC,      "O_TRUNC"       },
 233         { O_APPEND,     "O_APPEND"      },
 234         { O_NONBLOCK,   "O_NONBLOCK"    },
 235 #ifdef O_SYNC
 236         { O_SYNC,       "O_SYNC"        },
 237 #endif
 238 #ifdef O_ASYNC
 239         { O_ASYNC,      "O_ASYNC"       },
 240 #endif
 241 #ifdef O_DSYNC
 242         { O_DSYNC,      "O_DSYNC"       },
 243 #endif
 244 #ifdef O_RSYNC
 245         { O_RSYNC,      "O_RSYNC"       },
 246 #endif
 247 #if defined(O_NDELAY) && (O_NDELAY != O_NONBLOCK)
 248         { O_NDELAY,     "O_NDELAY"      },
 249 #endif
 250 #ifdef O_PRIV
 251         { O_PRIV,       "O_PRIV"        },
 252 #endif
 253 #ifdef O_DIRECT
 254         { O_DIRECT,     "O_DIRECT"      },
 255 #endif
 256 #ifdef O_LARGEFILE
 257 # if O_LARGEFILE == 0           /* biarch platforms in 64-bit mode */
 258 #  undef O_LARGEFILE
 259 #  ifdef SPARC64
 260 #   define O_LARGEFILE  0x40000
 261 #  elif defined X86_64 || defined S390X
 262 #   define O_LARGEFILE  0100000
 263 #  endif
 264 # endif
 265 # ifdef O_LARGEFILE
 266         { O_LARGEFILE,  "O_LARGEFILE"   },
 267 # endif
 268 #endif
 269 #ifdef O_DIRECTORY
 270         { O_DIRECTORY,  "O_DIRECTORY"   },
 271 #endif
 272 #ifdef O_NOFOLLOW
 273         { O_NOFOLLOW,   "O_NOFOLLOW"    },
 274 #endif
 275 #ifdef O_NOATIME
 276         { O_NOATIME,    "O_NOATIME"     },
 277 #endif
 278 #ifdef O_CLOEXEC
 279         { O_CLOEXEC,    "O_CLOEXEC"     },
 280 #endif
 281 #ifdef FNDELAY
 282         { FNDELAY,      "FNDELAY"       },
 283 #endif
 284 #ifdef FAPPEND
 285         { FAPPEND,      "FAPPEND"       },
 286 #endif
 287 #ifdef FMARK
 288         { FMARK,        "FMARK"         },
 289 #endif
 290 #ifdef FDEFER
 291         { FDEFER,       "FDEFER"        },
 292 #endif
 293 #ifdef FASYNC
 294         { FASYNC,       "FASYNC"        },
 295 #endif
 296 #ifdef FSHLOCK
 297         { FSHLOCK,      "FSHLOCK"       },
 298 #endif
 299 #ifdef FEXLOCK
 300         { FEXLOCK,      "FEXLOCK"       },
 301 #endif
 302 #ifdef FCREAT
 303         { FCREAT,       "FCREAT"        },
 304 #endif
 305 #ifdef FTRUNC
 306         { FTRUNC,       "FTRUNC"        },
 307 #endif
 308 #ifdef FEXCL
 309         { FEXCL,        "FEXCL"         },
 310 #endif
 311 #ifdef FNBIO
 312         { FNBIO,        "FNBIO"         },
 313 #endif
 314 #ifdef FSYNC
 315         { FSYNC,        "FSYNC"         },
 316 #endif
 317 #ifdef FNOCTTY
 318         { FNOCTTY,      "FNOCTTY"       },
 319 #endif
 320 #ifdef O_SHLOCK
 321         { O_SHLOCK,     "O_SHLOCK"      },
 322 #endif
 323 #ifdef O_EXLOCK
 324         { O_EXLOCK,     "O_EXLOCK"      },
 325 #endif
 326         { 0,            NULL            },
 327 };
 328
 329 #ifndef AT_FDCWD
 330 # define AT_FDCWD                -100
 331 #endif
 332
 333 /* The fd is an "int", so when decoding x86 on x86_64, we need to force sign
 334  * extension to get the right value.  We do this by declaring fd as int here.
 335  */
 336 static void
 337 print_dirfd(struct tcb *tcp, int fd)
 338 {
 339         if (fd == AT_FDCWD)
 340                 tprints("AT_FDCWD, ");
 341         else {
 342                 printfd(tcp, fd);
 343                 tprints(", ");
 344         }
 345 }
 346
 347 /*
 348  * low bits of the open(2) flags define access mode,
 349  * other bits are real flags.
 350  */
 351 const char *
 352 sprint_open_modes(mode_t flags)
 353 {
 354         static char outstr[(1 + ARRAY_SIZE(open_mode_flags)) * sizeof("O_LARGEFILE")];
 355         char *p;
 356         char sep;
 357         const char *str;
 358         const struct xlat *x;
 359
 360         sep = ' ';
 361         p = stpcpy(outstr, "flags");
 362         str = xlookup(open_access_modes, flags & 3);
 363         if (str) {
 364                 *p++ = sep;
 365                 p = stpcpy(p, str);
 366                 flags &= ~3;
 367                 if (!flags)
 368                         return outstr;
 369                 sep = '|';
 370         }
 371
 372         for (x = open_mode_flags; x->str; x++) {
 373                 if ((flags & x->val) == x->val) {
 374                         *p++ = sep;
 375                         p = stpcpy(p, x->str);
 376                         flags &= ~x->val;
 377                         if (!flags)
 378                                 return outstr;
 379                         sep = '|';
 380                 }
 381         }
 382         /* flags is still nonzero */
 383         *p++ = sep;
 384         sprintf(p, "%#x", flags);
 385         return outstr;
 386 }
 387
 388 void
 389 tprint_open_modes(mode_t flags)
 390 {
 391         tprints(sprint_open_modes(flags) + sizeof("flags"));
 392 }
 393
 394 static int
 395 decode_open(struct tcb *tcp, int offset)
 396 {
 397         if (entering(tcp)) {
 398                 printpath(tcp, tcp->u_arg[offset]);
 399                 tprints(", ");
 400                 /* flags */
 401                 tprint_open_modes(tcp->u_arg[offset + 1]);
 402                 if (tcp->u_arg[offset + 1] & O_CREAT) {
 403                         /* mode */
 404                         tprintf(", %#lo", tcp->u_arg[offset + 2]);
 405                 }
 406         }
 407         return 0;
 408 }
 409
 410 int
 411 sys_open(struct tcb *tcp)
 412 {
 413         return decode_open(tcp, 0);
 414 }
 415
 416 int
 417 sys_openat(struct tcb *tcp)
 418 {
 419         if (entering(tcp))
 420                 print_dirfd(tcp, tcp->u_arg[0]);
 421         return decode_open(tcp, 1);
 422 }
 423
 424 #if defined(SPARC) || defined(SPARC64)
 425 static const struct xlat openmodessol[] = {
 426         { 0,            "O_RDWR"        },
 427         { 1,            "O_RDONLY"      },
 428         { 2,            "O_WRONLY"      },
 429         { 0x80,         "O_NONBLOCK"    },
 430         { 8,            "O_APPEND"      },
 431         { 0x100,        "O_CREAT"       },
 432         { 0x200,        "O_TRUNC"       },
 433         { 0x400,        "O_EXCL"        },
 434         { 0x800,        "O_NOCTTY"      },
 435         { 0x10,         "O_SYNC"        },
 436         { 0x40,         "O_DSYNC"       },
 437         { 0x8000,       "O_RSYNC"       },
 438         { 4,            "O_NDELAY"      },
 439         { 0x1000,       "O_PRIV"        },
 440         { 0,            NULL            },
 441 };
 442
 443 int
 444 solaris_open(struct tcb *tcp)
 445 {
 446         if (entering(tcp)) {
 447                 printpath(tcp, tcp->u_arg[0]);
 448                 tprints(", ");
 449                 /* flags */
 450                 printflags(openmodessol, tcp->u_arg[1] + 1, "O_???");
 451                 if (tcp->u_arg[1] & 0x100) {
 452                         /* mode */
 453                         tprintf(", %#lo", tcp->u_arg[2]);
 454                 }
 455         }
 456         return 0;
 457 }
 458
 459 #endif
 460
 461 int
 462 sys_creat(struct tcb *tcp)
 463 {
 464         if (entering(tcp)) {
 465                 printpath(tcp, tcp->u_arg[0]);
 466                 tprintf(", %#lo", tcp->u_arg[1]);
 467         }
 468         return 0;
 469 }
 470
 471 static const struct xlat access_flags[] = {
 472         { F_OK,         "F_OK",         },
 473         { R_OK,         "R_OK"          },
 474         { W_OK,         "W_OK"          },
 475         { X_OK,         "X_OK"          },
 476 #ifdef EFF_ONLY_OK
 477         { EFF_ONLY_OK,  "EFF_ONLY_OK"   },
 478 #endif
 479 #ifdef EX_OK
 480         { EX_OK,        "EX_OK"         },
 481 #endif
 482         { 0,            NULL            },
 483 };
 484
 485 static int
 486 decode_access(struct tcb *tcp, int offset)
 487 {
 488         if (entering(tcp)) {
 489                 printpath(tcp, tcp->u_arg[offset]);
 490                 tprints(", ");
 491                 printflags(access_flags, tcp->u_arg[offset + 1], "?_OK");
 492         }
 493         return 0;
 494 }
 495
 496 int
 497 sys_access(struct tcb *tcp)
 498 {
 499         return decode_access(tcp, 0);
 500 }
 501
 502 int
 503 sys_faccessat(struct tcb *tcp)
 504 {
 505         if (entering(tcp))
 506                 print_dirfd(tcp, tcp->u_arg[0]);
 507         return decode_access(tcp, 1);
 508 }
 509
 510 int
 511 sys_umask(struct tcb *tcp)
 512 {
 513         if (entering(tcp)) {
 514                 tprintf("%#lo", tcp->u_arg[0]);
 515         }
 516         return RVAL_OCTAL;
 517 }
 518
 519 static const struct xlat whence[] = {
 520         { SEEK_SET,     "SEEK_SET"      },
 521         { SEEK_CUR,     "SEEK_CUR"      },
 522         { SEEK_END,     "SEEK_END"      },
 523         { 0,            NULL            },
 524 };
 525
 526 /* Linux kernel has exactly one version of lseek:
 527  * fs/read_write.c::SYSCALL_DEFINE3(lseek, unsigned, fd, off_t, offset, unsigned, origin)
 528  * In kernel, off_t is always the same as (kernel's) long
 529  * (see include/uapi/asm-generic/posix_types.h),
 530  * which means that on x32 we need to use tcp->ext_arg[N] to get offset argument.
 531  */
 532 #if defined(LINUX_MIPSN32) || defined(X32)
 533 int
 534 sys_lseek(struct tcb *tcp)
 535 {
 536         long long offset;
 537         int whence;
 538
 539         if (entering(tcp)) {
 540                 printfd(tcp, tcp->u_arg[0]);
 541                 offset = tcp->ext_arg[1];
 542                 whence = tcp->u_arg[2];
 543                 if (whence == SEEK_SET)
 544                         tprintf(", %llu, ", offset);
 545                 else
 546                         tprintf(", %lld, ", offset);
 547                 printxval(whence, whence, "SEEK_???");
 548         }
 549         return RVAL_LUDECIMAL;
 550 }
 551
 552 # if defined(X32)
 553 int
 554 sys_lseek32(struct tcb *tcp)
 555 {
 556         long offset;
 557         int whence;
 558
 559         if (entering(tcp)) {
 560                 printfd(tcp, tcp->u_arg[0]);
 561                 offset = tcp->u_arg[1];
 562                 whence = tcp->u_arg[2];
 563                 if (whence == SEEK_SET)
 564                         tprintf(", %lu, ", offset);
 565                 else
 566                         tprintf(", %ld, ", offset);
 567                 printxval(whence, whence, "SEEK_???");
 568         }
 569         return RVAL_UDECIMAL;
 570 }
 571 # endif
 572 #else
 573 int
 574 sys_lseek(struct tcb *tcp)
 575 {
 576         off_t offset;
 577         int whence;
 578
 579         if (entering(tcp)) {
 580                 printfd(tcp, tcp->u_arg[0]);
 581                 offset = tcp->u_arg[1];
 582                 whence = tcp->u_arg[2];
 583                 if (whence == SEEK_SET)
 584                         tprintf(", %lu, ", offset);
 585                 else
 586                         tprintf(", %ld, ", offset);
 587                 printxval(whence, whence, "SEEK_???");
 588         }
 589         return RVAL_UDECIMAL;
 590 }
 591 #endif
 592
 593 /* llseek syscall takes explicitly two ulong arguments hi, lo,
 594  * rather than one 64-bit argument for which LONG_LONG works
 595  * appropriate for the native byte order.
 596  *
 597  * See kernel's fs/read_write.c::SYSCALL_DEFINE5(llseek, ...)
 598  *
 599  * hi,lo are "unsigned longs" and combined exactly this way in kernel:
 600  * ((loff_t) hi << 32) | lo
 601  * Note that for architectures with kernel's long wider than userspace longs
 602  * (such as x32), combining code will use *kernel's*, i.e. *wide* longs
 603  * for hi and lo. You may need to use tcp->ext_arg[N]!
 604  */
 605 int
 606 sys_llseek(struct tcb *tcp)
 607 {
 608         if (entering(tcp)) {
 609                 printfd(tcp, tcp->u_arg[0]);
 610                 if (tcp->u_arg[4] == SEEK_SET)
 611                         tprintf(", %llu, ",
 612                                 ((long long) tcp->u_arg[1]) << 32 |
 613                                 (unsigned long long) (unsigned) tcp->u_arg[2]);
 614                 else
 615                         tprintf(", %lld, ",
 616                                 ((long long) tcp->u_arg[1]) << 32 |
 617                                 (unsigned long long) (unsigned) tcp->u_arg[2]);
 618         }
 619         else {
 620                 long long off;
 621                 if (syserror(tcp) || umove(tcp, tcp->u_arg[3], &off) < 0)
 622                         tprintf("%#lx, ", tcp->u_arg[3]);
 623                 else
 624                         tprintf("[%llu], ", off);
 625                 printxval(whence, tcp->u_arg[4], "SEEK_???");
 626         }
 627         return 0;
 628 }
 629
 630 int
 631 sys_readahead(struct tcb *tcp)
 632 {
 633         if (entering(tcp)) {
 634                 int argn;
 635                 printfd(tcp, tcp->u_arg[0]);
 636                 argn = printllval(tcp, ", %lld", 1);
 637                 tprintf(", %ld", tcp->u_arg[argn]);
 638         }
 639         return 0;
 640 }
 641
 642 #ifndef HAVE_LONG_LONG_OFF_T
 643 int
 644 sys_truncate(struct tcb *tcp)
 645 {
 646         if (entering(tcp)) {
 647                 printpath(tcp, tcp->u_arg[0]);
 648                 tprintf(", %lu", tcp->u_arg[1]);
 649         }
 650         return 0;
 651 }
 652 #endif
 653
 654 #if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
 655 int
 656 sys_truncate64(struct tcb *tcp)
 657 {
 658         if (entering(tcp)) {
 659                 printpath(tcp, tcp->u_arg[0]);
 660                 printllval(tcp, ", %llu", 1);
 661         }
 662         return 0;
 663 }
 664 #endif
 665
 666 #ifndef HAVE_LONG_LONG_OFF_T
 667 int
 668 sys_ftruncate(struct tcb *tcp)
 669 {
 670         if (entering(tcp)) {
 671                 printfd(tcp, tcp->u_arg[0]);
 672                 tprintf(", %lu", tcp->u_arg[1]);
 673         }
 674         return 0;
 675 }
 676 #endif
 677
 678 #if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
 679 int
 680 sys_ftruncate64(struct tcb *tcp)
 681 {
 682         if (entering(tcp)) {
 683                 printfd(tcp, tcp->u_arg[0]);
 684                 printllval(tcp, ", %llu", 1);
 685         }
 686         return 0;
 687 }
 688 #endif
 689
 690 /* several stats */
 691
 692 static const struct xlat modetypes[] = {
 693         { S_IFREG,      "S_IFREG"       },
 694         { S_IFSOCK,     "S_IFSOCK"      },
 695         { S_IFIFO,      "S_IFIFO"       },
 696         { S_IFLNK,      "S_IFLNK"       },
 697         { S_IFDIR,      "S_IFDIR"       },
 698         { S_IFBLK,      "S_IFBLK"       },
 699         { S_IFCHR,      "S_IFCHR"       },
 700         { 0,            NULL            },
 701 };
 702
 703 static const char *
 704 sprintmode(int mode)
 705 {
 706         static char buf[sizeof("S_IFSOCK|S_ISUID|S_ISGID|S_ISVTX|%o")
 707                         + sizeof(int)*3
 708                         + /*paranoia:*/ 8];
 709         const char *s;
 710
 711         if ((mode & S_IFMT) == 0)
 712                 s = "";
 713         else if ((s = xlookup(modetypes, mode & S_IFMT)) == NULL) {
 714                 sprintf(buf, "%#o", mode);
 715                 return buf;
 716         }
 717         s = buf + sprintf(buf, "%s%s%s%s", s,
 718                 (mode & S_ISUID) ? "|S_ISUID" : "",
 719                 (mode & S_ISGID) ? "|S_ISGID" : "",
 720                 (mode & S_ISVTX) ? "|S_ISVTX" : "");
 721         mode &= ~(S_IFMT|S_ISUID|S_ISGID|S_ISVTX);
 722         if (mode)
 723                 sprintf((char*)s, "|%#o", mode);
 724         s = (*buf == '|') ? buf + 1 : buf;
 725         return *s ? s : "0";
 726 }
 727
 728 static char *
 729 sprinttime(time_t t)
 730 {
 731         struct tm *tmp;
 732         static char buf[sizeof("yyyy/mm/dd-hh:mm:ss")];
 733
 734         if (t == 0) {
 735                 strcpy(buf, "0");
 736                 return buf;
 737         }
 738         tmp = localtime(&t);
 739         if (tmp)
 740                 snprintf(buf, sizeof buf, "%02d/%02d/%02d-%02d:%02d:%02d",
 741                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
 742                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
 743         else
 744                 snprintf(buf, sizeof buf, "%lu", (unsigned long) t);
 745
 746         return buf;
 747 }
 748
 749 #if defined(SPARC) || defined(SPARC64)
 750 typedef struct {
 751         int     tv_sec;
 752         int     tv_nsec;
 753 } timestruct_t;
 754
 755 struct solstat {
 756         unsigned        st_dev;
 757         int             st_pad1[3];     /* network id */
 758         unsigned        st_ino;
 759         unsigned        st_mode;
 760         unsigned        st_nlink;
 761         unsigned        st_uid;
 762         unsigned        st_gid;
 763         unsigned        st_rdev;
 764         int             st_pad2[2];
 765         int             st_size;
 766         int             st_pad3;        /* st_size, off_t expansion */
 767         timestruct_t    st_atime;
 768         timestruct_t    st_mtime;
 769         timestruct_t    st_ctime;
 770         int             st_blksize;
 771         int             st_blocks;
 772         char            st_fstype[16];
 773         int             st_pad4[8];     /* expansion area */
 774 };
 775
 776 static void
 777 printstatsol(struct tcb *tcp, long addr)
 778 {
 779         struct solstat statbuf;
 780
 781         if (umove(tcp, addr, &statbuf) < 0) {
 782                 tprints("{...}");
 783                 return;
 784         }
 785         if (!abbrev(tcp)) {
 786                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
 787                         (unsigned long) ((statbuf.st_dev >> 18) & 0x3fff),
 788                         (unsigned long) (statbuf.st_dev & 0x3ffff),
 789                         (unsigned long) statbuf.st_ino,
 790                         sprintmode(statbuf.st_mode));
 791                 tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
 792                         (unsigned long) statbuf.st_nlink,
 793                         (unsigned long) statbuf.st_uid,
 794                         (unsigned long) statbuf.st_gid);
 795                 tprintf("st_blksize=%lu, ", (unsigned long) statbuf.st_blksize);
 796                 tprintf("st_blocks=%lu, ", (unsigned long) statbuf.st_blocks);
 797         }
 798         else
 799                 tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
 800         switch (statbuf.st_mode & S_IFMT) {
 801         case S_IFCHR: case S_IFBLK:
 802                 tprintf("st_rdev=makedev(%lu, %lu), ",
 803                         (unsigned long) ((statbuf.st_rdev >> 18) & 0x3fff),
 804                         (unsigned long) (statbuf.st_rdev & 0x3ffff));
 805                 break;
 806         default:
 807                 tprintf("st_size=%u, ", statbuf.st_size);
 808                 break;
 809         }
 810         if (!abbrev(tcp)) {
 811                 tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime.tv_sec));
 812                 tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime.tv_sec));
 813                 tprintf("st_ctime=%s}", sprinttime(statbuf.st_ctime.tv_sec));
 814         }
 815         else
 816                 tprints("...}");
 817 }
 818
 819 # if defined(SPARC64)
 820 static void
 821 printstat_sparc64(struct tcb *tcp, long addr)
 822 {
 823         struct stat_sparc64 statbuf;
 824
 825         if (umove(tcp, addr, &statbuf) < 0) {
 826                 tprints("{...}");
 827                 return;
 828         }
 829
 830         if (!abbrev(tcp)) {
 831                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
 832                         (unsigned long) major(statbuf.st_dev),
 833                         (unsigned long) minor(statbuf.st_dev),
 834                         (unsigned long) statbuf.st_ino,
 835                         sprintmode(statbuf.st_mode));
 836                 tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
 837                         (unsigned long) statbuf.st_nlink,
 838                         (unsigned long) statbuf.st_uid,
 839                         (unsigned long) statbuf.st_gid);
 840                 tprintf("st_blksize=%lu, ",
 841                         (unsigned long) statbuf.st_blksize);
 842                 tprintf("st_blocks=%lu, ",
 843                         (unsigned long) statbuf.st_blocks);
 844         }
 845         else
 846                 tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
 847         switch (statbuf.st_mode & S_IFMT) {
 848         case S_IFCHR: case S_IFBLK:
 849                 tprintf("st_rdev=makedev(%lu, %lu), ",
 850                         (unsigned long) major(statbuf.st_rdev),
 851                         (unsigned long) minor(statbuf.st_rdev));
 852                 break;
 853         default:
 854                 tprintf("st_size=%lu, ", statbuf.st_size);
 855                 break;
 856         }
 857         if (!abbrev(tcp)) {
 858                 tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
 859                 tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
 860                 tprintf("st_ctime=%s}", sprinttime(statbuf.st_ctime));
 861         }
 862         else
 863                 tprints("...}");
 864 }
 865 # endif /* SPARC64 */
 866 #endif /* SPARC[64] */
 867
 868 #if defined POWERPC64
 869 struct stat_powerpc32 {
 870         unsigned int    st_dev;
 871         unsigned int    st_ino;
 872         unsigned int    st_mode;
 873         unsigned short  st_nlink;
 874         unsigned int    st_uid;
 875         unsigned int    st_gid;
 876         unsigned int    st_rdev;
 877         unsigned int    st_size;
 878         unsigned int    st_blksize;
 879         unsigned int    st_blocks;
 880         unsigned int    st_atime;
 881         unsigned int    st_atime_nsec;
 882         unsigned int    st_mtime;
 883         unsigned int    st_mtime_nsec;
 884         unsigned int    st_ctime;
 885         unsigned int    st_ctime_nsec;
 886         unsigned int    __unused4;
 887         unsigned int    __unused5;
 888 };
 889
 890 static void
 891 printstat_powerpc32(struct tcb *tcp, long addr)
 892 {
 893         struct stat_powerpc32 statbuf;
 894
 895         if (umove(tcp, addr, &statbuf) < 0) {
 896                 tprints("{...}");
 897                 return;
 898         }
 899
 900         if (!abbrev(tcp)) {
 901                 tprintf("{st_dev=makedev(%u, %u), st_ino=%u, st_mode=%s, ",
 902                         major(statbuf.st_dev), minor(statbuf.st_dev),
 903                         statbuf.st_ino,
 904                         sprintmode(statbuf.st_mode));
 905                 tprintf("st_nlink=%u, st_uid=%u, st_gid=%u, ",
 906                         statbuf.st_nlink, statbuf.st_uid, statbuf.st_gid);
 907                 tprintf("st_blksize=%u, ", statbuf.st_blksize);
 908                 tprintf("st_blocks=%u, ", statbuf.st_blocks);
 909         }
 910         else
 911                 tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
 912         switch (statbuf.st_mode & S_IFMT) {
 913         case S_IFCHR: case S_IFBLK:
 914                 tprintf("st_rdev=makedev(%lu, %lu), ",
 915                         (unsigned long) major(statbuf.st_rdev),
 916                         (unsigned long) minor(statbuf.st_rdev));
 917                 break;
 918         default:
 919                 tprintf("st_size=%u, ", statbuf.st_size);
 920                 break;
 921         }
 922         if (!abbrev(tcp)) {
 923                 tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
 924                 tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
 925                 tprintf("st_ctime=%s}", sprinttime(statbuf.st_ctime));
 926         }
 927         else
 928                 tprints("...}");
 929 }
 930 #endif /* POWERPC64 */
 931
 932 static const struct xlat fileflags[] = {
 933         { 0,            NULL            },
 934 };
 935
 936 #ifndef HAVE_LONG_LONG_OFF_T
 937 static void
 938 realprintstat(struct tcb *tcp, struct stat *statbuf)
 939 {
 940         if (!abbrev(tcp)) {
 941                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
 942                         (unsigned long) major(statbuf->st_dev),
 943                         (unsigned long) minor(statbuf->st_dev),
 944                         (unsigned long) statbuf->st_ino,
 945                         sprintmode(statbuf->st_mode));
 946                 tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
 947                         (unsigned long) statbuf->st_nlink,
 948                         (unsigned long) statbuf->st_uid,
 949                         (unsigned long) statbuf->st_gid);
 950 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
 951                 tprintf("st_blksize=%lu, ", (unsigned long) statbuf->st_blksize);
 952 #endif
 953 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
 954                 tprintf("st_blocks=%lu, ", (unsigned long) statbuf->st_blocks);
 955 #endif
 956         }
 957         else
 958                 tprintf("{st_mode=%s, ", sprintmode(statbuf->st_mode));
 959         switch (statbuf->st_mode & S_IFMT) {
 960         case S_IFCHR: case S_IFBLK:
 961 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 962                 tprintf("st_rdev=makedev(%lu, %lu), ",
 963                         (unsigned long) major(statbuf->st_rdev),
 964                         (unsigned long) minor(statbuf->st_rdev));
 965 #else /* !HAVE_STRUCT_STAT_ST_RDEV */
 966                 tprintf("st_size=makedev(%lu, %lu), ",
 967                         (unsigned long) major(statbuf->st_size),
 968                         (unsigned long) minor(statbuf->st_size));
 969 #endif /* !HAVE_STRUCT_STAT_ST_RDEV */
 970                 break;
 971         default:
 972                 tprintf("st_size=%lu, ", (unsigned long) statbuf->st_size);
 973                 break;
 974         }
 975         if (!abbrev(tcp)) {
 976                 tprintf("st_atime=%s, ", sprinttime(statbuf->st_atime));
 977                 tprintf("st_mtime=%s, ", sprinttime(statbuf->st_mtime));
 978                 tprintf("st_ctime=%s", sprinttime(statbuf->st_ctime));
 979 #if HAVE_STRUCT_STAT_ST_FLAGS
 980                 tprints(", st_flags=");
 981                 printflags(fileflags, statbuf->st_flags, "UF_???");
 982 #endif
 983 #if HAVE_STRUCT_STAT_ST_ACLCNT
 984                 tprintf(", st_aclcnt=%d", statbuf->st_aclcnt);
 985 #endif
 986 #if HAVE_STRUCT_STAT_ST_LEVEL
 987                 tprintf(", st_level=%ld", statbuf->st_level);
 988 #endif
 989 #if HAVE_STRUCT_STAT_ST_FSTYPE
 990                 tprintf(", st_fstype=%.*s",
 991                         (int) sizeof statbuf->st_fstype, statbuf->st_fstype);
 992 #endif
 993 #if HAVE_STRUCT_STAT_ST_GEN
 994                 tprintf(", st_gen=%u", statbuf->st_gen);
 995 #endif
 996                 tprints("}");
 997         }
 998         else
 999                 tprints("...}");
1000 }
1001
1002 static void
1003 printstat(struct tcb *tcp, long addr)
1004 {
1005         struct stat statbuf;
1006
1007         if (!addr) {
1008                 tprints("NULL");
1009                 return;
1010         }
1011         if (syserror(tcp) || !verbose(tcp)) {
1012                 tprintf("%#lx", addr);
1013                 return;
1014         }
1015
1016 #if defined(SPARC) || defined(SPARC64)
1017         if (current_personality == 1) {
1018                 printstatsol(tcp, addr);
1019                 return;
1020         }
1021 #ifdef SPARC64
1022         else if (current_personality == 2) {
1023                 printstat_sparc64(tcp, addr);
1024                 return;
1025         }
1026 #endif
1027 #endif /* SPARC[64] */
1028
1029 #if defined POWERPC64
1030         if (current_personality == 1) {
1031                 printstat_powerpc32(tcp, addr);
1032                 return;
1033         }
1034 #endif
1035
1036         if (umove(tcp, addr, &statbuf) < 0) {
1037                 tprints("{...}");
1038                 return;
1039         }
1040
1041         realprintstat(tcp, &statbuf);
1042 }
1043 #endif  /* !HAVE_LONG_LONG_OFF_T */
1044
1045 #if !defined HAVE_STAT64 && defined X86_64
1046 /*
1047  * Linux x86_64 has unified `struct stat' but its i386 biarch needs
1048  * `struct stat64'.  Its <asm-i386/stat.h> definition expects 32-bit `long'.
1049  * <linux/include/asm-x86_64/ia32.h> is not in the public includes set.
1050  * __GNUC__ is needed for the required __attribute__ below.
1051  */
1052 struct stat64 {
1053         unsigned long long      st_dev;
1054         unsigned char   __pad0[4];
1055         unsigned int    __st_ino;
1056         unsigned int    st_mode;
1057         unsigned int    st_nlink;
1058         unsigned int    st_uid;
1059         unsigned int    st_gid;
1060         unsigned long long      st_rdev;
1061         unsigned char   __pad3[4];
1062         long long       st_size;
1063         unsigned int    st_blksize;
1064         unsigned long long      st_blocks;
1065         unsigned int    st_atime;
1066         unsigned int    st_atime_nsec;
1067         unsigned int    st_mtime;
1068         unsigned int    st_mtime_nsec;
1069         unsigned int    st_ctime;
1070         unsigned int    st_ctime_nsec;
1071         unsigned long long      st_ino;
1072 } __attribute__((packed));
1073 # define HAVE_STAT64    1
1074 # define STAT64_SIZE    96
1075 #endif
1076
1077 #ifdef HAVE_STAT64
1078 static void
1079 printstat64(struct tcb *tcp, long addr)
1080 {
1081         struct stat64 statbuf;
1082
1083 #ifdef STAT64_SIZE
1084         (void) sizeof(char[sizeof statbuf == STAT64_SIZE ? 1 : -1]);
1085 #endif
1086
1087         if (!addr) {
1088                 tprints("NULL");
1089                 return;
1090         }
1091         if (syserror(tcp) || !verbose(tcp)) {
1092                 tprintf("%#lx", addr);
1093                 return;
1094         }
1095
1096 #if defined(SPARC) || defined(SPARC64)
1097         if (current_personality == 1) {
1098                 printstatsol(tcp, addr);
1099                 return;
1100         }
1101 # ifdef SPARC64
1102         else if (current_personality == 2) {
1103                 printstat_sparc64(tcp, addr);
1104                 return;
1105         }
1106 # endif
1107 #endif /* SPARC[64] */
1108
1109 #if defined X86_64
1110         if (current_personality != 1) {
1111                 printstat(tcp, addr);
1112                 return;
1113         }
1114 #endif
1115
1116         if (umove(tcp, addr, &statbuf) < 0) {
1117                 tprints("{...}");
1118                 return;
1119         }
1120
1121         if (!abbrev(tcp)) {
1122 #ifdef HAVE_LONG_LONG
1123                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%llu, st_mode=%s, ",
1124 #else
1125                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
1126 #endif
1127                         (unsigned long) major(statbuf.st_dev),
1128                         (unsigned long) minor(statbuf.st_dev),
1129 #ifdef HAVE_LONG_LONG
1130                         (unsigned long long) statbuf.st_ino,
1131 #else
1132                         (unsigned long) statbuf.st_ino,
1133 #endif
1134                         sprintmode(statbuf.st_mode));
1135                 tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
1136                         (unsigned long) statbuf.st_nlink,
1137                         (unsigned long) statbuf.st_uid,
1138                         (unsigned long) statbuf.st_gid);
1139 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1140                 tprintf("st_blksize=%lu, ",
1141                         (unsigned long) statbuf.st_blksize);
1142 #endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */
1143 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1144                 tprintf("st_blocks=%lu, ", (unsigned long) statbuf.st_blocks);
1145 #endif /* HAVE_STRUCT_STAT_ST_BLOCKS */
1146         }
1147         else
1148                 tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
1149         switch (statbuf.st_mode & S_IFMT) {
1150         case S_IFCHR: case S_IFBLK:
1151 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1152                 tprintf("st_rdev=makedev(%lu, %lu), ",
1153                         (unsigned long) major(statbuf.st_rdev),
1154                         (unsigned long) minor(statbuf.st_rdev));
1155 #else /* !HAVE_STRUCT_STAT_ST_RDEV */
1156                 tprintf("st_size=makedev(%lu, %lu), ",
1157                         (unsigned long) major(statbuf.st_size),
1158                         (unsigned long) minor(statbuf.st_size));
1159 #endif /* !HAVE_STRUCT_STAT_ST_RDEV */
1160                 break;
1161         default:
1162 #ifdef HAVE_LONG_LONG
1163                 tprintf("st_size=%llu, ", (unsigned long long) statbuf.st_size);
1164 #else
1165                 tprintf("st_size=%lu, ", (unsigned long) statbuf.st_size);
1166 #endif
1167                 break;
1168         }
1169         if (!abbrev(tcp)) {
1170                 tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
1171                 tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
1172                 tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
1173 #if HAVE_STRUCT_STAT_ST_FLAGS
1174                 tprints(", st_flags=");
1175                 printflags(fileflags, statbuf.st_flags, "UF_???");
1176 #endif
1177 #if HAVE_STRUCT_STAT_ST_ACLCNT
1178                 tprintf(", st_aclcnt=%d", statbuf.st_aclcnt);
1179 #endif
1180 #if HAVE_STRUCT_STAT_ST_LEVEL
1181                 tprintf(", st_level=%ld", statbuf.st_level);
1182 #endif
1183 #if HAVE_STRUCT_STAT_ST_FSTYPE
1184                 tprintf(", st_fstype=%.*s",
1185                         (int) sizeof statbuf.st_fstype, statbuf.st_fstype);
1186 #endif
1187 #if HAVE_STRUCT_STAT_ST_GEN
1188                 tprintf(", st_gen=%u", statbuf.st_gen);
1189 #endif
1190                 tprints("}");
1191         }
1192         else
1193                 tprints("...}");
1194 }
1195 #endif /* HAVE_STAT64 */
1196
1197 #if defined(HAVE_STRUCT___OLD_KERNEL_STAT) && !defined(HAVE_LONG_LONG_OFF_T)
1198 static void
1199 convertoldstat(const struct __old_kernel_stat *oldbuf, struct stat *newbuf)
1200 {
1201         newbuf->st_dev = oldbuf->st_dev;
1202         newbuf->st_ino = oldbuf->st_ino;
1203         newbuf->st_mode = oldbuf->st_mode;
1204         newbuf->st_nlink = oldbuf->st_nlink;
1205         newbuf->st_uid = oldbuf->st_uid;
1206         newbuf->st_gid = oldbuf->st_gid;
1207         newbuf->st_rdev = oldbuf->st_rdev;
1208         newbuf->st_size = oldbuf->st_size;
1209         newbuf->st_atime = oldbuf->st_atime;
1210         newbuf->st_mtime = oldbuf->st_mtime;
1211         newbuf->st_ctime = oldbuf->st_ctime;
1212         newbuf->st_blksize = 0; /* not supported in old_stat */
1213         newbuf->st_blocks = 0; /* not supported in old_stat */
1214 }
1215
1216 static void
1217 printoldstat(struct tcb *tcp, long addr)
1218 {
1219         struct __old_kernel_stat statbuf;
1220         struct stat newstatbuf;
1221
1222         if (!addr) {
1223                 tprints("NULL");
1224                 return;
1225         }
1226         if (syserror(tcp) || !verbose(tcp)) {
1227                 tprintf("%#lx", addr);
1228                 return;
1229         }
1230
1231 # if defined(SPARC) || defined(SPARC64)
1232         if (current_personality == 1) {
1233                 printstatsol(tcp, addr);
1234                 return;
1235         }
1236 # endif
1237
1238         if (umove(tcp, addr, &statbuf) < 0) {
1239                 tprints("{...}");
1240                 return;
1241         }
1242
1243         convertoldstat(&statbuf, &newstatbuf);
1244         realprintstat(tcp, &newstatbuf);
1245 }
1246 #endif
1247
1248 #ifndef HAVE_LONG_LONG_OFF_T
1249 int
1250 sys_stat(struct tcb *tcp)
1251 {
1252         if (entering(tcp)) {
1253                 printpath(tcp, tcp->u_arg[0]);
1254                 tprints(", ");
1255         } else {
1256                 printstat(tcp, tcp->u_arg[1]);
1257         }
1258         return 0;
1259 }
1260 #endif
1261
1262 int
1263 sys_stat64(struct tcb *tcp)
1264 {
1265 #ifdef HAVE_STAT64
1266         if (entering(tcp)) {
1267                 printpath(tcp, tcp->u_arg[0]);
1268                 tprints(", ");
1269         } else {
1270                 printstat64(tcp, tcp->u_arg[1]);
1271         }
1272         return 0;
1273 #else
1274         return printargs(tcp);
1275 #endif
1276 }
1277
1278 #ifndef AT_SYMLINK_NOFOLLOW
1279 # define AT_SYMLINK_NOFOLLOW    0x100
1280 #endif
1281 #ifndef AT_REMOVEDIR
1282 # define AT_REMOVEDIR           0x200
1283 #endif
1284 #ifndef AT_SYMLINK_FOLLOW
1285 # define AT_SYMLINK_FOLLOW      0x400
1286 #endif
1287 #ifndef AT_NO_AUTOMOUNT
1288 # define AT_NO_AUTOMOUNT        0x800
1289 #endif
1290 #ifndef AT_EMPTY_PATH
1291 # define AT_EMPTY_PATH          0x1000
1292 #endif
1293
1294 static const struct xlat at_flags[] = {
1295         { AT_SYMLINK_NOFOLLOW,  "AT_SYMLINK_NOFOLLOW"   },
1296         { AT_REMOVEDIR,         "AT_REMOVEDIR"          },
1297         { AT_SYMLINK_FOLLOW,    "AT_SYMLINK_FOLLOW"     },
1298         { AT_NO_AUTOMOUNT,      "AT_NO_AUTOMOUNT"       },
1299         { AT_EMPTY_PATH,        "AT_EMPTY_PATH"         },
1300         { 0,                    NULL                    }
1301 };
1302
1303 int
1304 sys_newfstatat(struct tcb *tcp)
1305 {
1306         if (entering(tcp)) {
1307                 print_dirfd(tcp, tcp->u_arg[0]);
1308                 printpath(tcp, tcp->u_arg[1]);
1309                 tprints(", ");
1310         } else {
1311 #ifdef POWERPC64
1312                 if (current_personality == 0)
1313                         printstat(tcp, tcp->u_arg[2]);
1314                 else
1315                         printstat64(tcp, tcp->u_arg[2]);
1316 #elif defined HAVE_STAT64
1317                 printstat64(tcp, tcp->u_arg[2]);
1318 #else
1319                 printstat(tcp, tcp->u_arg[2]);
1320 #endif
1321                 tprints(", ");
1322                 printflags(at_flags, tcp->u_arg[3], "AT_???");
1323         }
1324         return 0;
1325 }
1326
1327 #if defined(HAVE_STRUCT___OLD_KERNEL_STAT) && !defined(HAVE_LONG_LONG_OFF_T)
1328 int
1329 sys_oldstat(struct tcb *tcp)
1330 {
1331         if (entering(tcp)) {
1332                 printpath(tcp, tcp->u_arg[0]);
1333                 tprints(", ");
1334         } else {
1335                 printoldstat(tcp, tcp->u_arg[1]);
1336         }
1337         return 0;
1338 }
1339 #endif
1340
1341 #ifndef HAVE_LONG_LONG_OFF_T
1342 int
1343 sys_fstat(struct tcb *tcp)
1344 {
1345         if (entering(tcp)) {
1346                 printfd(tcp, tcp->u_arg[0]);
1347                 tprints(", ");
1348         } else {
1349                 printstat(tcp, tcp->u_arg[1]);
1350         }
1351         return 0;
1352 }
1353 #endif
1354
1355 int
1356 sys_fstat64(struct tcb *tcp)
1357 {
1358 #ifdef HAVE_STAT64
1359         if (entering(tcp)) {
1360                 printfd(tcp, tcp->u_arg[0]);
1361                 tprints(", ");
1362         } else {
1363                 printstat64(tcp, tcp->u_arg[1]);
1364         }
1365         return 0;
1366 #else
1367         return printargs(tcp);
1368 #endif
1369 }
1370
1371 #if defined(HAVE_STRUCT___OLD_KERNEL_STAT) && !defined(HAVE_LONG_LONG_OFF_T)
1372 int
1373 sys_oldfstat(struct tcb *tcp)
1374 {
1375         if (entering(tcp)) {
1376                 printfd(tcp, tcp->u_arg[0]);
1377                 tprints(", ");
1378         } else {
1379                 printoldstat(tcp, tcp->u_arg[1]);
1380         }
1381         return 0;
1382 }
1383 #endif
1384
1385 #ifndef HAVE_LONG_LONG_OFF_T
1386 int
1387 sys_lstat(struct tcb *tcp)
1388 {
1389         if (entering(tcp)) {
1390                 printpath(tcp, tcp->u_arg[0]);
1391                 tprints(", ");
1392         } else {
1393                 printstat(tcp, tcp->u_arg[1]);
1394         }
1395         return 0;
1396 }
1397 #endif
1398
1399 int
1400 sys_lstat64(struct tcb *tcp)
1401 {
1402 #ifdef HAVE_STAT64
1403         if (entering(tcp)) {
1404                 printpath(tcp, tcp->u_arg[0]);
1405                 tprints(", ");
1406         } else {
1407                 printstat64(tcp, tcp->u_arg[1]);
1408         }
1409         return 0;
1410 #else
1411         return printargs(tcp);
1412 #endif
1413 }
1414
1415 #if defined(HAVE_STRUCT___OLD_KERNEL_STAT) && !defined(HAVE_LONG_LONG_OFF_T)
1416 int
1417 sys_oldlstat(struct tcb *tcp)
1418 {
1419         if (entering(tcp)) {
1420                 printpath(tcp, tcp->u_arg[0]);
1421                 tprints(", ");
1422         } else {
1423                 printoldstat(tcp, tcp->u_arg[1]);
1424         }
1425         return 0;
1426 }
1427 #endif
1428
1429 #if defined(SPARC) || defined(SPARC64)
1430
1431 int
1432 sys_xstat(struct tcb *tcp)
1433 {
1434         if (entering(tcp)) {
1435                 tprintf("%ld, ", tcp->u_arg[0]);
1436                 printpath(tcp, tcp->u_arg[1]);
1437                 tprints(", ");
1438         } else {
1439 # ifdef _STAT64_VER
1440                 if (tcp->u_arg[0] == _STAT64_VER)
1441                         printstat64(tcp, tcp->u_arg[2]);
1442                 else
1443 # endif
1444                 printstat(tcp, tcp->u_arg[2]);
1445         }
1446         return 0;
1447 }
1448
1449 int
1450 sys_fxstat(struct tcb *tcp)
1451 {
1452         if (entering(tcp))
1453                 tprintf("%ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1]);
1454         else {
1455 # ifdef _STAT64_VER
1456                 if (tcp->u_arg[0] == _STAT64_VER)
1457                         printstat64(tcp, tcp->u_arg[2]);
1458                 else
1459 # endif
1460                 printstat(tcp, tcp->u_arg[2]);
1461         }
1462         return 0;
1463 }
1464
1465 int
1466 sys_lxstat(struct tcb *tcp)
1467 {
1468         if (entering(tcp)) {
1469                 tprintf("%ld, ", tcp->u_arg[0]);
1470                 printpath(tcp, tcp->u_arg[1]);
1471                 tprints(", ");
1472         } else {
1473 # ifdef _STAT64_VER
1474                 if (tcp->u_arg[0] == _STAT64_VER)
1475                         printstat64(tcp, tcp->u_arg[2]);
1476                 else
1477 # endif
1478                 printstat(tcp, tcp->u_arg[2]);
1479         }
1480         return 0;
1481 }
1482
1483 int
1484 sys_xmknod(struct tcb *tcp)
1485 {
1486         int mode = tcp->u_arg[2];
1487
1488         if (entering(tcp)) {
1489                 tprintf("%ld, ", tcp->u_arg[0]);
1490                 printpath(tcp, tcp->u_arg[1]);
1491                 tprintf(", %s", sprintmode(mode));
1492                 switch (mode & S_IFMT) {
1493                 case S_IFCHR: case S_IFBLK:
1494                         tprintf(", makedev(%lu, %lu)",
1495                                 (unsigned long) ((tcp->u_arg[3] >> 18) & 0x3fff),
1496                                 (unsigned long) (tcp->u_arg[3] & 0x3ffff));
1497                         break;
1498                 default:
1499                         break;
1500                 }
1501         }
1502         return 0;
1503 }
1504
1505 # ifdef HAVE_SYS_ACL_H
1506
1507 #  include <sys/acl.h>
1508
1509 static const struct xlat aclcmds[] = {
1510 #  ifdef SETACL
1511         { SETACL,       "SETACL"        },
1512 #  endif
1513 #  ifdef GETACL
1514         { GETACL,       "GETACL"        },
1515 #  endif
1516 #  ifdef GETACLCNT
1517         { GETACLCNT,    "GETACLCNT"     },
1518 #  endif
1519 #  ifdef ACL_GET
1520         { ACL_GET,      "ACL_GET"       },
1521 #  endif
1522 #  ifdef ACL_SET
1523         { ACL_SET,      "ACL_SET"       },
1524 #  endif
1525 #  ifdef ACL_CNT
1526         { ACL_CNT,      "ACL_CNT"       },
1527 #  endif
1528         { 0,            NULL            },
1529 };
1530
1531 int
1532 sys_acl(struct tcb *tcp)
1533 {
1534         if (entering(tcp)) {
1535                 printpath(tcp, tcp->u_arg[0]);
1536                 tprints(", ");
1537                 printxval(aclcmds, tcp->u_arg[1], "???ACL???");
1538                 tprintf(", %ld", tcp->u_arg[2]);
1539                 /*
1540                  * FIXME - dump out the list of aclent_t's pointed to
1541                  * by "tcp->u_arg[3]" if it's not NULL.
1542                  */
1543                 if (tcp->u_arg[3])
1544                         tprintf(", %#lx", tcp->u_arg[3]);
1545                 else
1546                         tprints(", NULL");
1547         }
1548         return 0;
1549 }
1550
1551 int
1552 sys_facl(struct tcb *tcp)
1553 {
1554         if (entering(tcp)) {
1555                 tprintf("%ld, ", tcp->u_arg[0]);
1556                 printxval(aclcmds, tcp->u_arg[1], "???ACL???");
1557                 tprintf(", %ld", tcp->u_arg[2]);
1558                 /*
1559                  * FIXME - dump out the list of aclent_t's pointed to
1560                  * by "tcp->u_arg[3]" if it's not NULL.
1561                  */
1562                 if (tcp->u_arg[3])
1563                         tprintf(", %#lx", tcp->u_arg[3]);
1564                 else
1565                         tprints(", NULL");
1566         }
1567         return 0;
1568 }
1569
1570 static const struct xlat aclipc[] = {
1571 #  ifdef IPC_SHM
1572         { IPC_SHM,      "IPC_SHM"       },
1573 #  endif
1574 #  ifdef IPC_SEM
1575         { IPC_SEM,      "IPC_SEM"       },
1576 #  endif
1577 #  ifdef IPC_MSG
1578         { IPC_MSG,      "IPC_MSG"       },
1579 #  endif
1580         { 0,            NULL            },
1581 };
1582
1583 int
1584 sys_aclipc(struct tcb *tcp)
1585 {
1586         if (entering(tcp)) {
1587                 printxval(aclipc, tcp->u_arg[0], "???IPC???");
1588                 tprintf(", %#lx, ", tcp->u_arg[1]);
1589                 printxval(aclcmds, tcp->u_arg[2], "???ACL???");
1590                 tprintf(", %ld", tcp->u_arg[3]);
1591                 /*
1592                  * FIXME - dump out the list of aclent_t's pointed to
1593                  * by "tcp->u_arg[4]" if it's not NULL.
1594                  */
1595                 if (tcp->u_arg[4])
1596                         tprintf(", %#lx", tcp->u_arg[4]);
1597                 else
1598                         tprints(", NULL");
1599         }
1600         return 0;
1601 }
1602
1603 # endif /* HAVE_SYS_ACL_H */
1604
1605 #endif /* SPARC[64] */
1606
1607 static const struct xlat fsmagic[] = {
1608         { 0x73757245,   "CODA_SUPER_MAGIC"      },
1609         { 0x012ff7b7,   "COH_SUPER_MAGIC"       },
1610         { 0x1373,       "DEVFS_SUPER_MAGIC"     },
1611         { 0x1cd1,       "DEVPTS_SUPER_MAGIC"    },
1612         { 0x414A53,     "EFS_SUPER_MAGIC"       },
1613         { 0xef51,       "EXT2_OLD_SUPER_MAGIC"  },
1614         { 0xef53,       "EXT2_SUPER_MAGIC"      },
1615         { 0x137d,       "EXT_SUPER_MAGIC"       },
1616         { 0xf995e849,   "HPFS_SUPER_MAGIC"      },
1617         { 0x9660,       "ISOFS_SUPER_MAGIC"     },
1618         { 0x137f,       "MINIX_SUPER_MAGIC"     },
1619         { 0x138f,       "MINIX_SUPER_MAGIC2"    },
1620         { 0x2468,       "MINIX2_SUPER_MAGIC"    },
1621         { 0x2478,       "MINIX2_SUPER_MAGIC2"   },
1622         { 0x4d44,       "MSDOS_SUPER_MAGIC"     },
1623         { 0x564c,       "NCP_SUPER_MAGIC"       },
1624         { 0x6969,       "NFS_SUPER_MAGIC"       },
1625         { 0x9fa0,       "PROC_SUPER_MAGIC"      },
1626         { 0x002f,       "QNX4_SUPER_MAGIC"      },
1627         { 0x52654973,   "REISERFS_SUPER_MAGIC"  },
1628         { 0x02011994,   "SHMFS_SUPER_MAGIC"     },
1629         { 0x517b,       "SMB_SUPER_MAGIC"       },
1630         { 0x012ff7b6,   "SYSV2_SUPER_MAGIC"     },
1631         { 0x012ff7b5,   "SYSV4_SUPER_MAGIC"     },
1632         { 0x00011954,   "UFS_MAGIC"             },
1633         { 0x54190100,   "UFS_CIGAM"             },
1634         { 0x012ff7b4,   "XENIX_SUPER_MAGIC"     },
1635         { 0x012fd16d,   "XIAFS_SUPER_MAGIC"     },
1636         { 0x62656572,   "SYSFS_MAGIC"           },
1637         { 0,            NULL                    },
1638 };
1639
1640 static const char *
1641 sprintfstype(int magic)
1642 {
1643         static char buf[32];
1644         const char *s;
1645
1646         s = xlookup(fsmagic, magic);
1647         if (s) {
1648                 sprintf(buf, "\"%s\"", s);
1649                 return buf;
1650         }
1651         sprintf(buf, "%#x", magic);
1652         return buf;
1653 }
1654
1655 static void
1656 printstatfs(struct tcb *tcp, long addr)
1657 {
1658         struct statfs statbuf;
1659
1660         if (syserror(tcp) || !verbose(tcp)) {
1661                 tprintf("%#lx", addr);
1662                 return;
1663         }
1664         if (umove(tcp, addr, &statbuf) < 0) {
1665                 tprints("{...}");
1666                 return;
1667         }
1668 #ifdef ALPHA
1669
1670         tprintf("{f_type=%s, f_fbsize=%u, f_blocks=%u, f_bfree=%u, ",
1671                 sprintfstype(statbuf.f_type),
1672                 statbuf.f_bsize, statbuf.f_blocks, statbuf.f_bfree);
1673         tprintf("f_bavail=%u, f_files=%u, f_ffree=%u, f_fsid={%d, %d}, f_namelen=%u",
1674                 statbuf.f_bavail, statbuf.f_files, statbuf.f_ffree,
1675                 statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1],
1676                 statbuf.f_namelen);
1677 #else /* !ALPHA */
1678         tprintf("{f_type=%s, f_bsize=%lu, f_blocks=%lu, f_bfree=%lu, ",
1679                 sprintfstype(statbuf.f_type),
1680                 (unsigned long)statbuf.f_bsize,
1681                 (unsigned long)statbuf.f_blocks,
1682                 (unsigned long)statbuf.f_bfree);
1683         tprintf("f_bavail=%lu, f_files=%lu, f_ffree=%lu, f_fsid={%d, %d}",
1684                 (unsigned long)statbuf.f_bavail,
1685                 (unsigned long)statbuf.f_files,
1686                 (unsigned long)statbuf.f_ffree,
1687                 statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1]);
1688         tprintf(", f_namelen=%lu", (unsigned long)statbuf.f_namelen);
1689 #endif /* !ALPHA */
1690 #ifdef _STATFS_F_FRSIZE
1691         tprintf(", f_frsize=%lu", (unsigned long)statbuf.f_frsize);
1692 #endif
1693         tprints("}");
1694 }
1695
1696 int
1697 sys_statfs(struct tcb *tcp)
1698 {
1699         if (entering(tcp)) {
1700                 printpath(tcp, tcp->u_arg[0]);
1701                 tprints(", ");
1702         } else {
1703                 printstatfs(tcp, tcp->u_arg[1]);
1704         }
1705         return 0;
1706 }
1707
1708 int
1709 sys_fstatfs(struct tcb *tcp)
1710 {
1711         if (entering(tcp)) {
1712                 printfd(tcp, tcp->u_arg[0]);
1713                 tprints(", ");
1714         } else {
1715                 printstatfs(tcp, tcp->u_arg[1]);
1716         }
1717         return 0;
1718 }
1719
1720 #if defined HAVE_STATFS64
1721 static void
1722 printstatfs64(struct tcb *tcp, long addr)
1723 {
1724         struct statfs64 statbuf;
1725
1726         if (syserror(tcp) || !verbose(tcp)) {
1727                 tprintf("%#lx", addr);
1728                 return;
1729         }
1730         if (umove(tcp, addr, &statbuf) < 0) {
1731                 tprints("{...}");
1732                 return;
1733         }
1734         tprintf("{f_type=%s, f_bsize=%llu, f_blocks=%llu, f_bfree=%llu, ",
1735                 sprintfstype(statbuf.f_type),
1736                 (unsigned long long)statbuf.f_bsize,
1737                 (unsigned long long)statbuf.f_blocks,
1738                 (unsigned long long)statbuf.f_bfree);
1739         tprintf("f_bavail=%llu, f_files=%llu, f_ffree=%llu, f_fsid={%d, %d}",
1740                 (unsigned long long)statbuf.f_bavail,
1741                 (unsigned long long)statbuf.f_files,
1742                 (unsigned long long)statbuf.f_ffree,
1743                 statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1]);
1744         tprintf(", f_namelen=%lu", (unsigned long)statbuf.f_namelen);
1745 #ifdef _STATFS_F_FRSIZE
1746         tprintf(", f_frsize=%llu", (unsigned long long)statbuf.f_frsize);
1747 #endif
1748 #ifdef _STATFS_F_FLAGS
1749         tprintf(", f_flags=%llu", (unsigned long long)statbuf.f_flags);
1750 #endif
1751         tprints("}");
1752 }
1753
1754 struct compat_statfs64 {
1755         uint32_t f_type;
1756         uint32_t f_bsize;
1757         uint64_t f_blocks;
1758         uint64_t f_bfree;
1759         uint64_t f_bavail;
1760         uint64_t f_files;
1761         uint64_t f_ffree;
1762         fsid_t f_fsid;
1763         uint32_t f_namelen;
1764         uint32_t f_frsize;
1765         uint32_t f_flags;
1766         uint32_t f_spare[4];
1767 }
1768 #if defined(X86_64) || defined(IA64)
1769   __attribute__ ((packed, aligned(4)))
1770 #endif
1771 ;
1772
1773 static void
1774 printcompat_statfs64(struct tcb *tcp, long addr)
1775 {
1776         struct compat_statfs64 statbuf;
1777
1778         if (syserror(tcp) || !verbose(tcp)) {
1779                 tprintf("%#lx", addr);
1780                 return;
1781         }
1782         if (umove(tcp, addr, &statbuf) < 0) {
1783                 tprints("{...}");
1784                 return;
1785         }
1786         tprintf("{f_type=%s, f_bsize=%lu, f_blocks=%llu, f_bfree=%llu, ",
1787                 sprintfstype(statbuf.f_type),
1788                 (unsigned long)statbuf.f_bsize,
1789                 (unsigned long long)statbuf.f_blocks,
1790                 (unsigned long long)statbuf.f_bfree);
1791         tprintf("f_bavail=%llu, f_files=%llu, f_ffree=%llu, f_fsid={%d, %d}",
1792                 (unsigned long long)statbuf.f_bavail,
1793                 (unsigned long long)statbuf.f_files,
1794                 (unsigned long long)statbuf.f_ffree,
1795                 statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1]);
1796         tprintf(", f_namelen=%lu", (unsigned long)statbuf.f_namelen);
1797         tprintf(", f_frsize=%lu", (unsigned long)statbuf.f_frsize);
1798         tprintf(", f_flags=%lu}", (unsigned long)statbuf.f_frsize);
1799 }
1800
1801 int
1802 sys_statfs64(struct tcb *tcp)
1803 {
1804         if (entering(tcp)) {
1805                 printpath(tcp, tcp->u_arg[0]);
1806                 tprintf(", %lu, ", tcp->u_arg[1]);
1807         } else {
1808                 if (tcp->u_arg[1] == sizeof(struct statfs64))
1809                         printstatfs64(tcp, tcp->u_arg[2]);
1810                 else if (tcp->u_arg[1] == sizeof(struct compat_statfs64))
1811                         printcompat_statfs64(tcp, tcp->u_arg[2]);
1812                 else
1813                         tprints("{???}");
1814         }
1815         return 0;
1816 }
1817
1818 int
1819 sys_fstatfs64(struct tcb *tcp)
1820 {
1821         if (entering(tcp)) {
1822                 printfd(tcp, tcp->u_arg[0]);
1823                 tprintf(", %lu, ", tcp->u_arg[1]);
1824         } else {
1825                 if (tcp->u_arg[1] == sizeof(struct statfs64))
1826                         printstatfs64(tcp, tcp->u_arg[2]);
1827                 else if (tcp->u_arg[1] == sizeof(struct compat_statfs64))
1828                         printcompat_statfs64(tcp, tcp->u_arg[2]);
1829                 else
1830                         tprints("{???}");
1831         }
1832         return 0;
1833 }
1834 #endif
1835
1836 #if defined(ALPHA)
1837 int
1838 osf_statfs(struct tcb *tcp)
1839 {
1840         if (entering(tcp)) {
1841                 printpath(tcp, tcp->u_arg[0]);
1842                 tprints(", ");
1843         } else {
1844                 printstatfs(tcp, tcp->u_arg[1]);
1845                 tprintf(", %lu", tcp->u_arg[2]);
1846         }
1847         return 0;
1848 }
1849
1850 int
1851 osf_fstatfs(struct tcb *tcp)
1852 {
1853         if (entering(tcp)) {
1854                 tprintf("%lu, ", tcp->u_arg[0]);
1855         } else {
1856                 printstatfs(tcp, tcp->u_arg[1]);
1857                 tprintf(", %lu", tcp->u_arg[2]);
1858         }
1859         return 0;
1860 }
1861 #endif
1862
1863 /* directory */
1864 int
1865 sys_chdir(struct tcb *tcp)
1866 {
1867         if (entering(tcp)) {
1868                 printpath(tcp, tcp->u_arg[0]);
1869         }
1870         return 0;
1871 }
1872
1873 static int
1874 decode_mkdir(struct tcb *tcp, int offset)
1875 {
1876         if (entering(tcp)) {
1877                 printpath(tcp, tcp->u_arg[offset]);
1878                 tprintf(", %#lo", tcp->u_arg[offset + 1]);
1879         }
1880         return 0;
1881 }
1882
1883 int
1884 sys_mkdir(struct tcb *tcp)
1885 {
1886         return decode_mkdir(tcp, 0);
1887 }
1888
1889 int
1890 sys_mkdirat(struct tcb *tcp)
1891 {
1892         if (entering(tcp))
1893                 print_dirfd(tcp, tcp->u_arg[0]);
1894         return decode_mkdir(tcp, 1);
1895 }
1896
1897 int
1898 sys_link(struct tcb *tcp)
1899 {
1900         if (entering(tcp)) {
1901                 printpath(tcp, tcp->u_arg[0]);
1902                 tprints(", ");
1903                 printpath(tcp, tcp->u_arg[1]);
1904         }
1905         return 0;
1906 }
1907
1908 int
1909 sys_linkat(struct tcb *tcp)
1910 {
1911         if (entering(tcp)) {
1912                 print_dirfd(tcp, tcp->u_arg[0]);
1913                 printpath(tcp, tcp->u_arg[1]);
1914                 tprints(", ");
1915                 print_dirfd(tcp, tcp->u_arg[2]);
1916                 printpath(tcp, tcp->u_arg[3]);
1917                 tprints(", ");
1918                 printflags(at_flags, tcp->u_arg[4], "AT_???");
1919         }
1920         return 0;
1921 }
1922
1923 int
1924 sys_unlinkat(struct tcb *tcp)
1925 {
1926         if (entering(tcp)) {
1927                 print_dirfd(tcp, tcp->u_arg[0]);
1928                 printpath(tcp, tcp->u_arg[1]);
1929                 tprints(", ");
1930                 printflags(at_flags, tcp->u_arg[2], "AT_???");
1931         }
1932         return 0;
1933 }
1934
1935 int
1936 sys_symlinkat(struct tcb *tcp)
1937 {
1938         if (entering(tcp)) {
1939                 printpath(tcp, tcp->u_arg[0]);
1940                 tprints(", ");
1941                 print_dirfd(tcp, tcp->u_arg[1]);
1942                 printpath(tcp, tcp->u_arg[2]);
1943         }
1944         return 0;
1945 }
1946
1947 static int
1948 decode_readlink(struct tcb *tcp, int offset)
1949 {
1950         if (entering(tcp)) {
1951                 printpath(tcp, tcp->u_arg[offset]);
1952                 tprints(", ");
1953         } else {
1954                 if (syserror(tcp))
1955                         tprintf("%#lx", tcp->u_arg[offset + 1]);
1956                 else
1957                         /* Used to use printpathn(), but readlink
1958                          * neither includes NUL in the returned count,
1959                          * nor actually writes it into memory.
1960                          * printpathn() would decide on printing
1961                          * "..." continuation based on garbage
1962                          * past return buffer's end.
1963                          */
1964                         printstr(tcp, tcp->u_arg[offset + 1], tcp->u_rval);
1965                 tprintf(", %lu", tcp->u_arg[offset + 2]);
1966         }
1967         return 0;
1968 }
1969
1970 int
1971 sys_readlink(struct tcb *tcp)
1972 {
1973         return decode_readlink(tcp, 0);
1974 }
1975
1976 int
1977 sys_readlinkat(struct tcb *tcp)
1978 {
1979         if (entering(tcp))
1980                 print_dirfd(tcp, tcp->u_arg[0]);
1981         return decode_readlink(tcp, 1);
1982 }
1983
1984 int
1985 sys_renameat(struct tcb *tcp)
1986 {
1987         if (entering(tcp)) {
1988                 print_dirfd(tcp, tcp->u_arg[0]);
1989                 printpath(tcp, tcp->u_arg[1]);
1990                 tprints(", ");
1991                 print_dirfd(tcp, tcp->u_arg[2]);
1992                 printpath(tcp, tcp->u_arg[3]);
1993         }
1994         return 0;
1995 }
1996
1997 int
1998 sys_chown(struct tcb *tcp)
1999 {
2000         if (entering(tcp)) {
2001                 printpath(tcp, tcp->u_arg[0]);
2002                 printuid(", ", tcp->u_arg[1]);
2003                 printuid(", ", tcp->u_arg[2]);
2004         }
2005         return 0;
2006 }
2007
2008 int
2009 sys_fchownat(struct tcb *tcp)
2010 {
2011         if (entering(tcp)) {
2012                 print_dirfd(tcp, tcp->u_arg[0]);
2013                 printpath(tcp, tcp->u_arg[1]);
2014                 printuid(", ", tcp->u_arg[2]);
2015                 printuid(", ", tcp->u_arg[3]);
2016                 tprints(", ");
2017                 printflags(at_flags, tcp->u_arg[4], "AT_???");
2018         }
2019         return 0;
2020 }
2021
2022 int
2023 sys_fchown(struct tcb *tcp)
2024 {
2025         if (entering(tcp)) {
2026                 printfd(tcp, tcp->u_arg[0]);
2027                 printuid(", ", tcp->u_arg[1]);
2028                 printuid(", ", tcp->u_arg[2]);
2029         }
2030         return 0;
2031 }
2032
2033 static int
2034 decode_chmod(struct tcb *tcp, int offset)
2035 {
2036         if (entering(tcp)) {
2037                 printpath(tcp, tcp->u_arg[offset]);
2038                 tprintf(", %#lo", tcp->u_arg[offset + 1]);
2039         }
2040         return 0;
2041 }
2042
2043 int
2044 sys_chmod(struct tcb *tcp)
2045 {
2046         return decode_chmod(tcp, 0);
2047 }
2048
2049 int
2050 sys_fchmodat(struct tcb *tcp)
2051 {
2052         if (entering(tcp))
2053                 print_dirfd(tcp, tcp->u_arg[0]);
2054         return decode_chmod(tcp, 1);
2055 }
2056
2057 int
2058 sys_fchmod(struct tcb *tcp)
2059 {
2060         if (entering(tcp)) {
2061                 printfd(tcp, tcp->u_arg[0]);
2062                 tprintf(", %#lo", tcp->u_arg[1]);
2063         }
2064         return 0;
2065 }
2066
2067 #ifdef ALPHA
2068 int
2069 sys_osf_utimes(struct tcb *tcp)
2070 {
2071         if (entering(tcp)) {
2072                 printpath(tcp, tcp->u_arg[0]);
2073                 tprints(", ");
2074                 printtv_bitness(tcp, tcp->u_arg[1], BITNESS_32,  0);
2075         }
2076         return 0;
2077 }
2078 #endif
2079
2080 static int
2081 decode_utimes(struct tcb *tcp, int offset, int special)
2082 {
2083         if (entering(tcp)) {
2084                 printpath(tcp, tcp->u_arg[offset]);
2085                 tprints(", ");
2086                 if (tcp->u_arg[offset + 1] == 0)
2087                         tprints("NULL");
2088                 else {
2089                         tprints("{");
2090                         printtv_bitness(tcp, tcp->u_arg[offset + 1],
2091                                         BITNESS_CURRENT, special);
2092                         tprints(", ");
2093                         printtv_bitness(tcp, tcp->u_arg[offset + 1]
2094                                         + sizeof(struct timeval),
2095                                         BITNESS_CURRENT, special);
2096                         tprints("}");
2097                 }
2098         }
2099         return 0;
2100 }
2101
2102 int
2103 sys_utimes(struct tcb *tcp)
2104 {
2105         return decode_utimes(tcp, 0, 0);
2106 }
2107
2108 int
2109 sys_futimesat(struct tcb *tcp)
2110 {
2111         if (entering(tcp))
2112                 print_dirfd(tcp, tcp->u_arg[0]);
2113         return decode_utimes(tcp, 1, 0);
2114 }
2115
2116 int
2117 sys_utimensat(struct tcb *tcp)
2118 {
2119         if (entering(tcp)) {
2120                 print_dirfd(tcp, tcp->u_arg[0]);
2121                 decode_utimes(tcp, 1, 1);
2122                 tprints(", ");
2123                 printflags(at_flags, tcp->u_arg[3], "AT_???");
2124         }
2125         return 0;
2126 }
2127
2128 int
2129 sys_utime(struct tcb *tcp)
2130 {
2131         union {
2132                 long utl[2];
2133                 int uti[2];
2134                 long paranoia_for_huge_wordsize[4];
2135         } u;
2136         unsigned wordsize;
2137
2138         if (entering(tcp)) {
2139                 printpath(tcp, tcp->u_arg[0]);
2140                 tprints(", ");
2141
2142                 wordsize = current_wordsize;
2143                 if (!tcp->u_arg[1])
2144                         tprints("NULL");
2145                 else if (!verbose(tcp))
2146                         tprintf("%#lx", tcp->u_arg[1]);
2147                 else if (umoven(tcp, tcp->u_arg[1], 2 * wordsize, (char *) &u) < 0)
2148                         tprints("[?, ?]");
2149                 else if (wordsize == sizeof u.utl[0]) {
2150                         tprintf("[%s,", sprinttime(u.utl[0]));
2151                         tprintf(" %s]", sprinttime(u.utl[1]));
2152                 }
2153                 else if (wordsize == sizeof u.uti[0]) {
2154                         tprintf("[%s,", sprinttime(u.uti[0]));
2155                         tprintf(" %s]", sprinttime(u.uti[1]));
2156                 }
2157                 else
2158                         tprintf("<decode error: unsupported wordsize %d>",
2159                                 wordsize);
2160         }
2161         return 0;
2162 }
2163
2164 static int
2165 decode_mknod(struct tcb *tcp, int offset)
2166 {
2167         int mode = tcp->u_arg[offset + 1];
2168
2169         if (entering(tcp)) {
2170                 printpath(tcp, tcp->u_arg[offset]);
2171                 tprintf(", %s", sprintmode(mode));
2172                 switch (mode & S_IFMT) {
2173                 case S_IFCHR:
2174                 case S_IFBLK:
2175 #if defined(SPARC) || defined(SPARC64)
2176                         if (current_personality == 1)
2177                                 tprintf(", makedev(%lu, %lu)",
2178                                 (unsigned long) ((tcp->u_arg[offset + 2] >> 18) & 0x3fff),
2179                                 (unsigned long) (tcp->u_arg[offset + 2] & 0x3ffff));
2180                         else
2181 #endif
2182                                 tprintf(", makedev(%lu, %lu)",
2183                                 (unsigned long) major(tcp->u_arg[offset + 2]),
2184                                 (unsigned long) minor(tcp->u_arg[offset + 2]));
2185                         break;
2186                 default:
2187                         break;
2188                 }
2189         }
2190         return 0;
2191 }
2192
2193 int
2194 sys_mknod(struct tcb *tcp)
2195 {
2196         return decode_mknod(tcp, 0);
2197 }
2198
2199 int
2200 sys_mknodat(struct tcb *tcp)
2201 {
2202         if (entering(tcp))
2203                 print_dirfd(tcp, tcp->u_arg[0]);
2204         return decode_mknod(tcp, 1);
2205 }
2206
2207 static void
2208 printdir(struct tcb *tcp, long addr)
2209 {
2210         struct dirent d;
2211
2212         if (!verbose(tcp)) {
2213                 tprintf("%#lx", addr);
2214                 return;
2215         }
2216         if (umove(tcp, addr, &d) < 0) {
2217                 tprints("{...}");
2218                 return;
2219         }
2220         tprintf("{d_ino=%ld, ", (unsigned long) d.d_ino);
2221         tprints("d_name=");
2222         printpathn(tcp, (long) ((struct dirent *) addr)->d_name, d.d_reclen);
2223         tprints("}");
2224 }
2225
2226 int
2227 sys_readdir(struct tcb *tcp)
2228 {
2229         if (entering(tcp)) {
2230                 printfd(tcp, tcp->u_arg[0]);
2231                 tprints(", ");
2232         } else {
2233                 if (syserror(tcp) || tcp->u_rval == 0 || !verbose(tcp))
2234                         tprintf("%#lx", tcp->u_arg[1]);
2235                 else
2236                         printdir(tcp, tcp->u_arg[1]);
2237                 /* Not much point in printing this out, it is always 1. */
2238                 if (tcp->u_arg[2] != 1)
2239                         tprintf(", %lu", tcp->u_arg[2]);
2240         }
2241         return 0;
2242 }
2243
2244 static const struct xlat direnttypes[] = {
2245         { DT_UNKNOWN,   "DT_UNKNOWN"    },
2246         { DT_FIFO,      "DT_FIFO"       },
2247         { DT_CHR,       "DT_CHR"        },
2248         { DT_DIR,       "DT_DIR"        },
2249         { DT_BLK,       "DT_BLK"        },
2250         { DT_REG,       "DT_REG"        },
2251         { DT_LNK,       "DT_LNK"        },
2252         { DT_SOCK,      "DT_SOCK"       },
2253         { DT_WHT,       "DT_WHT"        },
2254         { 0,            NULL            },
2255 };
2256
2257 int
2258 sys_getdents(struct tcb *tcp)
2259 {
2260         int i, len, dents = 0;
2261         char *buf;
2262
2263         if (entering(tcp)) {
2264                 printfd(tcp, tcp->u_arg[0]);
2265                 tprints(", ");
2266                 return 0;
2267         }
2268         if (syserror(tcp) || !verbose(tcp)) {
2269                 tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
2270                 return 0;
2271         }
2272         len = tcp->u_rval;
2273         /* Beware of insanely large or negative values in tcp->u_rval */
2274         if (tcp->u_rval > 1024*1024)
2275                 len = 1024*1024;
2276         if (tcp->u_rval < 0)
2277                 len = 0;
2278         buf = len ? malloc(len) : NULL;
2279         if (len && !buf)
2280                 die_out_of_memory();
2281         if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
2282                 tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
2283                 free(buf);
2284                 return 0;
2285         }
2286         if (!abbrev(tcp))
2287                 tprints("{");
2288         for (i = 0; i < len;) {
2289                 struct kernel_dirent *d = (struct kernel_dirent *) &buf[i];
2290                 if (!abbrev(tcp)) {
2291                         tprintf("%s{d_ino=%lu, d_off=%lu, ",
2292                                 i ? " " : "", d->d_ino, d->d_off);
2293                         tprintf("d_reclen=%u, d_name=\"%s\", d_type=",
2294                                 d->d_reclen, d->d_name);
2295                         printxval(direnttypes, buf[i + d->d_reclen - 1], "DT_???");
2296                         tprints("}");
2297                 }
2298                 if (!d->d_reclen) {
2299                         tprints("/* d_reclen == 0, problem here */");
2300                         break;
2301                 }
2302                 i += d->d_reclen;
2303                 dents++;
2304         }
2305         if (!abbrev(tcp))
2306                 tprints("}");
2307         else
2308                 tprintf("/* %u entries */", dents);
2309         tprintf(", %lu", tcp->u_arg[2]);
2310         free(buf);
2311         return 0;
2312 }
2313
2314 #if _LFS64_LARGEFILE
2315 int
2316 sys_getdents64(struct tcb *tcp)
2317 {
2318         int i, len, dents = 0;
2319         char *buf;
2320
2321         if (entering(tcp)) {
2322                 printfd(tcp, tcp->u_arg[0]);
2323                 tprints(", ");
2324                 return 0;
2325         }
2326         if (syserror(tcp) || !verbose(tcp)) {
2327                 tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
2328                 return 0;
2329         }
2330
2331         len = tcp->u_rval;
2332         /* Beware of insanely large or negative tcp->u_rval */
2333         if (tcp->u_rval > 1024*1024)
2334                 len = 1024*1024;
2335         if (tcp->u_rval < 0)
2336                 len = 0;
2337         buf = len ? malloc(len) : NULL;
2338         if (len && !buf)
2339                 die_out_of_memory();
2340
2341         if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
2342                 tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
2343                 free(buf);
2344                 return 0;
2345         }
2346         if (!abbrev(tcp))
2347                 tprints("{");
2348         for (i = 0; i < len;) {
2349                 struct dirent64 *d = (struct dirent64 *) &buf[i];
2350                 if (!abbrev(tcp)) {
2351                         tprintf("%s{d_ino=%" PRIu64 ", d_off=%" PRId64 ", ",
2352                                 i ? " " : "",
2353                                 d->d_ino,
2354                                 d->d_off);
2355                         tprints("d_type=");
2356                         printxval(direnttypes, d->d_type, "DT_???");
2357                         tprints(", ");
2358                         tprintf("d_reclen=%u, d_name=\"%s\"}",
2359                                 d->d_reclen, d->d_name);
2360                 }
2361                 if (!d->d_reclen) {
2362                         tprints("/* d_reclen == 0, problem here */");
2363                         break;
2364                 }
2365                 i += d->d_reclen;
2366                 dents++;
2367         }
2368         if (!abbrev(tcp))
2369                 tprints("}");
2370         else
2371                 tprintf("/* %u entries */", dents);
2372         tprintf(", %lu", tcp->u_arg[2]);
2373         free(buf);
2374         return 0;
2375 }
2376 #endif
2377
2378 int
2379 sys_getcwd(struct tcb *tcp)
2380 {
2381         if (exiting(tcp)) {
2382                 if (syserror(tcp))
2383                         tprintf("%#lx", tcp->u_arg[0]);
2384                 else
2385                         printpathn(tcp, tcp->u_arg[0], tcp->u_rval - 1);
2386                 tprintf(", %lu", tcp->u_arg[1]);
2387         }
2388         return 0;
2389 }
2390
2391 #ifdef HAVE_SYS_ASYNCH_H
2392
2393 int
2394 sys_aioread(struct tcb *tcp)
2395 {
2396         struct aio_result_t res;
2397
2398         if (entering(tcp)) {
2399                 tprintf("%lu, ", tcp->u_arg[0]);
2400         } else {
2401                 if (syserror(tcp))
2402                         tprintf("%#lx", tcp->u_arg[1]);
2403                 else
2404                         printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
2405                 tprintf(", %lu, %lu, ", tcp->u_arg[2], tcp->u_arg[3]);
2406                 printxval(whence, tcp->u_arg[4], "L_???");
2407                 if (syserror(tcp) || tcp->u_arg[5] == 0
2408                     || umove(tcp, tcp->u_arg[5], &res) < 0)
2409                         tprintf(", %#lx", tcp->u_arg[5]);
2410                 else
2411                         tprintf(", {aio_return %d aio_errno %d}",
2412                                 res.aio_return, res.aio_errno);
2413         }
2414         return 0;
2415 }
2416
2417 int
2418 sys_aiowrite(struct tcb *tcp)
2419 {
2420         struct aio_result_t res;
2421
2422         if (entering(tcp)) {
2423                 tprintf("%lu, ", tcp->u_arg[0]);
2424                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
2425                 tprintf(", %lu, %lu, ", tcp->u_arg[2], tcp->u_arg[3]);
2426                 printxval(whence, tcp->u_arg[4], "L_???");
2427         }
2428         else {
2429                 if (tcp->u_arg[5] == 0)
2430                         tprints(", NULL");
2431                 else if (syserror(tcp)
2432                     || umove(tcp, tcp->u_arg[5], &res) < 0)
2433                         tprintf(", %#lx", tcp->u_arg[5]);
2434                 else
2435                         tprintf(", {aio_return %d aio_errno %d}",
2436                                 res.aio_return, res.aio_errno);
2437         }
2438         return 0;
2439 }
2440
2441 int
2442 sys_aiowait(struct tcb *tcp)
2443 {
2444         if (entering(tcp))
2445                 printtv(tcp, tcp->u_arg[0]);
2446         return 0;
2447 }
2448
2449 int
2450 sys_aiocancel(struct tcb *tcp)
2451 {
2452         struct aio_result_t res;
2453
2454         if (exiting(tcp)) {
2455                 if (tcp->u_arg[0] == 0)
2456                         tprints("NULL");
2457                 else if (syserror(tcp)
2458                     || umove(tcp, tcp->u_arg[0], &res) < 0)
2459                         tprintf("%#lx", tcp->u_arg[0]);
2460                 else
2461                         tprintf("{aio_return %d aio_errno %d}",
2462                                 res.aio_return, res.aio_errno);
2463         }
2464         return 0;
2465 }
2466
2467 #endif /* HAVE_SYS_ASYNCH_H */
2468
2469 static const struct xlat xattrflags[] = {
2470 #ifdef XATTR_CREATE
2471         { XATTR_CREATE,  "XATTR_CREATE" },
2472         { XATTR_REPLACE, "XATTR_REPLACE" },
2473 #endif
2474         { 0,             NULL }
2475 };
2476
2477 static void
2478 print_xattr_val(struct tcb *tcp, int failed,
2479                 unsigned long arg,
2480                 unsigned long insize,
2481                 unsigned long size)
2482 {
2483         if (insize == 0)
2484                 failed = 1;
2485         if (!failed) {
2486                 unsigned long capacity = 4 * size + 1;
2487                 unsigned char *buf = (capacity < size) ? NULL : malloc(capacity);
2488                 if (buf == NULL || /* probably a bogus size argument */
2489                         umoven(tcp, arg, size, (char *) &buf[3 * size]) < 0) {
2490                         failed = 1;
2491                 }
2492                 else {
2493                         unsigned char *out = buf;
2494                         unsigned char *in = &buf[3 * size];
2495                         size_t i;
2496                         for (i = 0; i < size; ++i) {
2497                                 if (isprint(in[i]))
2498                                         *out++ = in[i];
2499                                 else {
2500 #define tohex(n) "0123456789abcdef"[n]
2501                                         *out++ = '\\';
2502                                         *out++ = 'x';
2503                                         *out++ = tohex(in[i] / 16);
2504                                         *out++ = tohex(in[i] % 16);
2505                                 }
2506                         }
2507                         /* Don't print terminating NUL if there is one.  */
2508                         if (i > 0 && in[i - 1] == '\0')
2509                                 out -= 4;
2510                         *out = '\0';
2511                         tprintf(", \"%s\", %ld", buf, insize);
2512                 }
2513                 free(buf);
2514         }
2515         if (failed)
2516                 tprintf(", 0x%lx, %ld", arg, insize);
2517 }
2518
2519 int
2520 sys_setxattr(struct tcb *tcp)
2521 {
2522         if (entering(tcp)) {
2523                 printpath(tcp, tcp->u_arg[0]);
2524                 tprints(", ");
2525                 printstr(tcp, tcp->u_arg[1], -1);
2526                 print_xattr_val(tcp, 0, tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[3]);
2527                 tprints(", ");
2528                 printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
2529         }
2530         return 0;
2531 }
2532
2533 int
2534 sys_fsetxattr(struct tcb *tcp)
2535 {
2536         if (entering(tcp)) {
2537                 printfd(tcp, tcp->u_arg[0]);
2538                 tprints(", ");
2539                 printstr(tcp, tcp->u_arg[1], -1);
2540                 print_xattr_val(tcp, 0, tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[3]);
2541                 tprints(", ");
2542                 printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
2543         }
2544         return 0;
2545 }
2546
2547 int
2548 sys_getxattr(struct tcb *tcp)
2549 {
2550         if (entering(tcp)) {
2551                 printpath(tcp, tcp->u_arg[0]);
2552                 tprints(", ");
2553                 printstr(tcp, tcp->u_arg[1], -1);
2554         } else {
2555                 print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
2556                                 tcp->u_rval);
2557         }
2558         return 0;
2559 }
2560
2561 int
2562 sys_fgetxattr(struct tcb *tcp)
2563 {
2564         if (entering(tcp)) {
2565                 printfd(tcp, tcp->u_arg[0]);
2566                 tprints(", ");
2567                 printstr(tcp, tcp->u_arg[1], -1);
2568         } else {
2569                 print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
2570                                 tcp->u_rval);
2571         }
2572         return 0;
2573 }
2574
2575 static void
2576 print_xattr_list(struct tcb *tcp, unsigned long addr, unsigned long size)
2577 {
2578         if (syserror(tcp)) {
2579                 tprintf("%#lx", addr);
2580         } else {
2581                 if (!addr) {
2582                         tprints("NULL");
2583                 } else {
2584                         unsigned long len =
2585                                 (size < tcp->u_rval) ? size : tcp->u_rval;
2586                         printstr(tcp, addr, len);
2587                 }
2588         }
2589         tprintf(", %lu", size);
2590 }
2591
2592 int
2593 sys_listxattr(struct tcb *tcp)
2594 {
2595         if (entering(tcp)) {
2596                 printpath(tcp, tcp->u_arg[0]);
2597                 tprints(", ");
2598         } else {
2599                 print_xattr_list(tcp, tcp->u_arg[1], tcp->u_arg[2]);
2600         }
2601         return 0;
2602 }
2603
2604 int
2605 sys_flistxattr(struct tcb *tcp)
2606 {
2607         if (entering(tcp)) {
2608                 printfd(tcp, tcp->u_arg[0]);
2609                 tprints(", ");
2610         } else {
2611                 print_xattr_list(tcp, tcp->u_arg[1], tcp->u_arg[2]);
2612         }
2613         return 0;
2614 }
2615
2616 int
2617 sys_removexattr(struct tcb *tcp)
2618 {
2619         if (entering(tcp)) {
2620                 printpath(tcp, tcp->u_arg[0]);
2621                 tprints(", ");
2622                 printstr(tcp, tcp->u_arg[1], -1);
2623         }
2624         return 0;
2625 }
2626
2627 int
2628 sys_fremovexattr(struct tcb *tcp)
2629 {
2630         if (entering(tcp)) {
2631                 printfd(tcp, tcp->u_arg[0]);
2632                 tprints(", ");
2633                 printstr(tcp, tcp->u_arg[1], -1);
2634         }
2635         return 0;
2636 }
2637
2638 static const struct xlat advise[] = {
2639         { POSIX_FADV_NORMAL,            "POSIX_FADV_NORMAL"     },
2640         { POSIX_FADV_RANDOM,            "POSIX_FADV_RANDOM"     },
2641         { POSIX_FADV_SEQUENTIAL,        "POSIX_FADV_SEQUENTIAL" },
2642         { POSIX_FADV_WILLNEED,          "POSIX_FADV_WILLNEED"   },
2643         { POSIX_FADV_DONTNEED,          "POSIX_FADV_DONTNEED"   },
2644         { POSIX_FADV_NOREUSE,           "POSIX_FADV_NOREUSE"    },
2645         { 0,                            NULL                    }
2646 };
2647
2648 int
2649 sys_fadvise64(struct tcb *tcp)
2650 {
2651         if (entering(tcp)) {
2652                 int argn;
2653                 printfd(tcp, tcp->u_arg[0]);
2654                 argn = printllval(tcp, ", %lld", 1);
2655                 tprintf(", %ld, ", tcp->u_arg[argn++]);
2656                 printxval(advise, tcp->u_arg[argn], "POSIX_FADV_???");
2657         }
2658         return 0;
2659 }
2660
2661 int
2662 sys_fadvise64_64(struct tcb *tcp)
2663 {
2664         if (entering(tcp)) {
2665                 int argn;
2666                 printfd(tcp, tcp->u_arg[0]);
2667 #if defined ARM || defined POWERPC
2668                 argn = printllval(tcp, ", %lld, ", 2);
2669 #else
2670                 argn = printllval(tcp, ", %lld, ", 1);
2671 #endif
2672                 argn = printllval(tcp, "%lld, ", argn);
2673 #if defined ARM || defined POWERPC
2674                 printxval(advise, tcp->u_arg[1], "POSIX_FADV_???");
2675 #else
2676                 printxval(advise, tcp->u_arg[argn], "POSIX_FADV_???");
2677 #endif
2678         }
2679         return 0;
2680 }
2681
2682 static const struct xlat inotify_modes[] = {
2683         { 0x00000001,   "IN_ACCESS"     },
2684         { 0x00000002,   "IN_MODIFY"     },
2685         { 0x00000004,   "IN_ATTRIB"     },
2686         { 0x00000008,   "IN_CLOSE_WRITE"},
2687         { 0x00000010,   "IN_CLOSE_NOWRITE"},
2688         { 0x00000020,   "IN_OPEN"       },
2689         { 0x00000040,   "IN_MOVED_FROM" },
2690         { 0x00000080,   "IN_MOVED_TO"   },
2691         { 0x00000100,   "IN_CREATE"     },
2692         { 0x00000200,   "IN_DELETE"     },
2693         { 0x00000400,   "IN_DELETE_SELF"},
2694         { 0x00000800,   "IN_MOVE_SELF"  },
2695         { 0x00002000,   "IN_UNMOUNT"    },
2696         { 0x00004000,   "IN_Q_OVERFLOW" },
2697         { 0x00008000,   "IN_IGNORED"    },
2698         { 0x01000000,   "IN_ONLYDIR"    },
2699         { 0x02000000,   "IN_DONT_FOLLOW"},
2700         { 0x20000000,   "IN_MASK_ADD"   },
2701         { 0x40000000,   "IN_ISDIR"      },
2702         { 0x80000000,   "IN_ONESHOT"    },
2703         { 0,            NULL            }
2704 };
2705
2706 static const struct xlat inotify_init_flags[] = {
2707         { 0x00000800,   "IN_NONBLOCK"   },
2708         { 0x00080000,   "IN_CLOEXEC"    },
2709         { 0,            NULL            }
2710 };
2711
2712 int
2713 sys_inotify_add_watch(struct tcb *tcp)
2714 {
2715         if (entering(tcp)) {
2716                 printfd(tcp, tcp->u_arg[0]);
2717                 tprints(", ");
2718                 printpath(tcp, tcp->u_arg[1]);
2719                 tprints(", ");
2720                 printflags(inotify_modes, tcp->u_arg[2], "IN_???");
2721         }
2722         return 0;
2723 }
2724
2725 int
2726 sys_inotify_rm_watch(struct tcb *tcp)
2727 {
2728         if (entering(tcp)) {
2729                 printfd(tcp, tcp->u_arg[0]);
2730                 tprintf(", %d", (int) tcp->u_arg[1]);
2731         }
2732         return 0;
2733 }
2734
2735 int
2736 sys_inotify_init1(struct tcb *tcp)
2737 {
2738         if (entering(tcp))
2739                 printflags(inotify_init_flags, tcp->u_arg[0], "IN_???");
2740         return 0;
2741 }
2742
2743 int
2744 sys_fallocate(struct tcb *tcp)
2745 {
2746         if (entering(tcp)) {
2747                 int argn;
2748                 printfd(tcp, tcp->u_arg[0]);            /* fd */
2749                 tprintf(", %#lo, ", tcp->u_arg[1]);     /* mode */
2750                 argn = printllval(tcp, "%llu, ", 2);    /* offset */
2751                 printllval(tcp, "%llu", argn);          /* len */
2752         }
2753         return 0;
2754 }
2755
2756 #ifndef SWAP_FLAG_PREFER
2757 # define SWAP_FLAG_PREFER 0x8000
2758 #endif
2759 #ifndef SWAP_FLAG_DISCARD
2760 # define SWAP_FLAG_DISCARD 0x10000
2761 #endif
2762 static const struct xlat swap_flags[] = {
2763         { SWAP_FLAG_PREFER,     "SWAP_FLAG_PREFER"      },
2764         { SWAP_FLAG_DISCARD,    "SWAP_FLAG_DISCARD"     },
2765         { 0,                    NULL                    }
2766 };
2767
2768 int
2769 sys_swapon(struct tcb *tcp)
2770 {
2771         if (entering(tcp)) {
2772                 int flags = tcp->u_arg[1];
2773                 printpath(tcp, tcp->u_arg[0]);
2774                 tprints(", ");
2775                 printflags(swap_flags, flags & ~SWAP_FLAG_PRIO_MASK,
2776                         "SWAP_FLAG_???");
2777                 if (flags & SWAP_FLAG_PREFER)
2778                         tprintf("|%d", flags & SWAP_FLAG_PRIO_MASK);
2779         }
2780         return 0;
2781 }
2782
2783 #ifdef X32
2784 # undef stat64
2785 # undef sys_fstat64
2786 # undef sys_stat64
2787
2788 static void
2789 realprintstat64(struct tcb *tcp, long addr)
2790 {
2791         struct stat64 statbuf;
2792
2793         if (!addr) {
2794                 tprints("NULL");
2795                 return;
2796         }
2797         if (syserror(tcp) || !verbose(tcp)) {
2798                 tprintf("%#lx", addr);
2799                 return;
2800         }
2801
2802         if (umove(tcp, addr, &statbuf) < 0) {
2803                 tprints("{...}");
2804                 return;
2805         }
2806
2807         if (!abbrev(tcp)) {
2808                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%llu, st_mode=%s, ",
2809                         (unsigned long) major(statbuf.st_dev),
2810                         (unsigned long) minor(statbuf.st_dev),
2811                         (unsigned long long) statbuf.st_ino,
2812                         sprintmode(statbuf.st_mode));
2813                 tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
2814                         (unsigned long) statbuf.st_nlink,
2815                         (unsigned long) statbuf.st_uid,
2816                         (unsigned long) statbuf.st_gid);
2817                 tprintf("st_blksize=%lu, ",
2818                         (unsigned long) statbuf.st_blksize);
2819                 tprintf("st_blocks=%lu, ", (unsigned long) statbuf.st_blocks);
2820         }
2821         else
2822                 tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
2823         switch (statbuf.st_mode & S_IFMT) {
2824         case S_IFCHR: case S_IFBLK:
2825                 tprintf("st_rdev=makedev(%lu, %lu), ",
2826                         (unsigned long) major(statbuf.st_rdev),
2827                         (unsigned long) minor(statbuf.st_rdev));
2828                 break;
2829         default:
2830                 tprintf("st_size=%llu, ", (unsigned long long) statbuf.st_size);
2831                 break;
2832         }
2833         if (!abbrev(tcp)) {
2834                 tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
2835                 tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
2836                 tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
2837                 tprints("}");
2838         }
2839         else
2840                 tprints("...}");
2841 }
2842
2843 int
2844 sys_fstat64(struct tcb *tcp)
2845 {
2846         if (entering(tcp)) {
2847                 printfd(tcp, tcp->u_arg[0]);
2848                 tprints(", ");
2849         } else {
2850                 realprintstat64(tcp, tcp->u_arg[1]);
2851         }
2852         return 0;
2853 }
2854
2855 int
2856 sys_stat64(struct tcb *tcp)
2857 {
2858         if (entering(tcp)) {
2859                 printpath(tcp, tcp->u_arg[0]);
2860                 tprints(", ");
2861         } else {
2862                 realprintstat64(tcp, tcp->u_arg[1]);
2863         }
2864         return 0;
2865 }
2866 #endif