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

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