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