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

   1 /*
   2 #ifdef LINUX
   3  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
   4  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
   5  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
   6  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. The name of the author may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  *      $Id$
  32  */
  33
  34 #include "defs.h"
  35
  36 #include <dirent.h>
  37 #ifdef LINUX
  38 #define dirent kernel_dirent
  39 #define dirent64 kernel_dirent64
  40 #include <linux/types.h>
  41 #include <linux/dirent.h>
  42 #undef dirent
  43 #undef dirent64
  44 #else
  45 #define kernel_dirent dirent
  46 #endif
  47
  48 #ifdef LINUX
  49 #  ifdef LINUXSPARC
  50 struct stat {
  51         unsigned short  st_dev;
  52         unsigned int    st_ino;
  53         unsigned short  st_mode;
  54         short           st_nlink;
  55         unsigned short  st_uid;
  56         unsigned short  st_gid;
  57         unsigned short  st_rdev;
  58         unsigned int    st_size;
  59         int             st_atime;
  60         unsigned int    __unused1;
  61         int             st_mtime;
  62         unsigned int    __unused2;
  63         int             st_ctime;
  64         unsigned int    __unused3;
  65         int             st_blksize;
  66         int             st_blocks;
  67         unsigned int    __unused4[2];
  68 };
  69 #    define stat kernel_stat
  70 #    include <asm/stat.h>
  71 #    undef stat
  72 #  else
  73 #    undef dev_t
  74 #    undef ino_t
  75 #    undef mode_t
  76 #    undef nlink_t
  77 #    undef uid_t
  78 #    undef gid_t
  79 #    undef off_t
  80 #    undef loff_t
  81
  82 #    define dev_t __kernel_dev_t
  83 #    define ino_t __kernel_ino_t
  84 #    define mode_t __kernel_mode_t
  85 #    define nlink_t __kernel_nlink_t
  86 #    define uid_t __kernel_uid_t
  87 #    define gid_t __kernel_gid_t
  88 #    define off_t __kernel_off_t
  89 #    define loff_t __kernel_loff_t
  90
  91 #    include <asm/stat.h>
  92
  93 #    undef dev_t
  94 #    undef ino_t
  95 #    undef mode_t
  96 #    undef nlink_t
  97 #    undef uid_t
  98 #    undef gid_t
  99 #    undef off_t
 100 #    undef loff_t
 101
 102 #    define dev_t dev_t
 103 #    define ino_t ino_t
 104 #    define mode_t mode_t
 105 #    define nlink_t nlink_t
 106 #    define uid_t uid_t
 107 #    define gid_t gid_t
 108 #    define off_t off_t
 109 #    define loff_t loff_t
 110 #  endif
 111 #  ifdef HPPA   /* asm-parisc/stat.h defines stat64 */
 112 #    undef stat64
 113 #  endif
 114 #  define stat libc_stat
 115 #  define stat64 libc_stat64
 116 #  include <sys/stat.h>
 117 #  undef stat
 118 #  undef stat64
 119    /* These might be macros. */
 120 #  undef st_atime
 121 #  undef st_mtime
 122 #  undef st_ctime
 123 #  ifdef HPPA
 124 #    define stat64 hpux_stat64
 125 #  endif
 126 #else
 127 #  include <sys/stat.h>
 128 #endif
 129
 130 #include <fcntl.h>
 131
 132 #ifdef SVR4
 133 #  include <sys/cred.h>
 134 #endif /* SVR4 */
 135
 136 #ifdef HAVE_SYS_VFS_H
 137 #include <sys/vfs.h>
 138 #endif
 139
 140 #ifdef HAVE_LINUX_XATTR_H
 141 #include <linux/xattr.h>
 142 #elif defined linux
 143 #define XATTR_CREATE 1
 144 #define XATTR_REPLACE 2
 145 #endif
 146
 147 #ifdef FREEBSD
 148 #include <sys/param.h>
 149 #include <sys/mount.h>
 150 #include <sys/stat.h>
 151 #endif
 152
 153 #if HAVE_LONG_LONG_OFF_T
 154 /*
 155  * Ugly hacks for systems that have typedef long long off_t
 156  */
 157
 158 #define stat64 stat
 159 #define HAVE_STAT64 1   /* Ugly hack */
 160
 161 #define sys_stat64      sys_stat
 162 #define sys_fstat64     sys_fstat
 163 #define sys_lstat64     sys_lstat
 164 #define sys_lseek64     sys_lseek
 165 #define sys_truncate64  sys_truncate
 166 #define sys_ftruncate64 sys_ftruncate
 167 #endif
 168
 169 #ifdef MAJOR_IN_SYSMACROS
 170 #include <sys/sysmacros.h>
 171 #endif
 172
 173 #ifdef MAJOR_IN_MKDEV
 174 #include <sys/mkdev.h>
 175 #endif
 176
 177 #ifdef HAVE_SYS_ASYNCH_H
 178 #include <sys/asynch.h>
 179 #endif
 180
 181 #ifdef SUNOS4
 182 #include <ustat.h>
 183 #endif
 184
 185 /*
 186  * This is a really dirty trick but it should always work.  Traditional
 187  * Unix says r/w/rw are 0/1/2, so we make them true flags 1/2/3 by
 188  * adding 1.  Just remember to add 1 to any arg decoded with openmodes.
 189  */
 190 struct xlat openmodes[] = {
 191         { O_RDWR+1,     "O_RDWR"        },
 192         { O_RDONLY+1,   "O_RDONLY"      },
 193         { O_WRONLY+1,   "O_WRONLY"      },
 194         { O_NONBLOCK,   "O_NONBLOCK"    },
 195         { O_APPEND,     "O_APPEND"      },
 196         { O_CREAT,      "O_CREAT"       },
 197         { O_TRUNC,      "O_TRUNC"       },
 198         { O_EXCL,       "O_EXCL"        },
 199         { O_NOCTTY,     "O_NOCTTY"      },
 200 #ifdef O_SYNC
 201         { O_SYNC,       "O_SYNC"        },
 202 #endif
 203 #ifdef O_ASYNC
 204         { O_ASYNC,      "O_ASYNC"       },
 205 #endif
 206 #ifdef O_DSYNC
 207         { O_DSYNC,      "O_DSYNC"       },
 208 #endif
 209 #ifdef O_RSYNC
 210         { O_RSYNC,      "O_RSYNC"       },
 211 #endif
 212 #ifdef O_NDELAY
 213         { O_NDELAY,     "O_NDELAY"      },
 214 #endif
 215 #ifdef O_PRIV
 216         { O_PRIV,       "O_PRIV"        },
 217 #endif
 218 #ifdef O_DIRECT
 219         { O_DIRECT,     "O_DIRECT"      },
 220 #endif
 221 #ifdef O_LARGEFILE
 222         { O_LARGEFILE,  "O_LARGEFILE"   },
 223 #endif
 224 #ifdef O_DIRECTORY
 225         { O_DIRECTORY,  "O_DIRECTORY"   },
 226 #endif
 227 #ifdef O_NOFOLLOW
 228         { O_NOFOLLOW,   "O_NOFOLLOW"    },
 229 #endif
 230
 231 #ifdef FNDELAY
 232         { FNDELAY,      "FNDELAY"       },
 233 #endif
 234 #ifdef FAPPEND
 235         { FAPPEND,      "FAPPEND"       },
 236 #endif
 237 #ifdef FMARK
 238         { FMARK,        "FMARK"         },
 239 #endif
 240 #ifdef FDEFER
 241         { FDEFER,       "FDEFER"        },
 242 #endif
 243 #ifdef FASYNC
 244         { FASYNC,       "FASYNC"        },
 245 #endif
 246 #ifdef FSHLOCK
 247         { FSHLOCK,      "FSHLOCK"       },
 248 #endif
 249 #ifdef FEXLOCK
 250         { FEXLOCK,      "FEXLOCK"       },
 251 #endif
 252 #ifdef FCREAT
 253         { FCREAT,       "FCREAT"        },
 254 #endif
 255 #ifdef FTRUNC
 256         { FTRUNC,       "FTRUNC"        },
 257 #endif
 258 #ifdef FEXCL
 259         { FEXCL,        "FEXCL"         },
 260 #endif
 261 #ifdef FNBIO
 262         { FNBIO,        "FNBIO"         },
 263 #endif
 264 #ifdef FSYNC
 265         { FSYNC,        "FSYNC"         },
 266 #endif
 267 #ifdef FNOCTTY
 268         { FNOCTTY,      "FNOCTTY"       },
 269 #endif
 270 #ifdef O_SHLOCK
 271         { O_SHLOCK,     "O_SHLOCK"      },
 272 #endif
 273 #ifdef O_EXLOCK
 274         { O_EXLOCK,     "O_EXLOCK"      },
 275 #endif
 276         { 0,            NULL            },
 277 };
 278
 279 int
 280 sys_open(tcp)
 281 struct tcb *tcp;
 282 {
 283         if (entering(tcp)) {
 284                 printpath(tcp, tcp->u_arg[0]);
 285                 tprintf(", ");
 286                 /* flags */
 287                 printflags(openmodes, tcp->u_arg[1] + 1);
 288                 if (tcp->u_arg[1] & O_CREAT) {
 289                         /* mode */
 290                         tprintf(", %#lo", tcp->u_arg[2]);
 291                 }
 292         }
 293         return 0;
 294 }
 295
 296 #ifdef LINUXSPARC
 297 struct xlat openmodessol[] = {
 298         { 0,            "O_RDWR"        },
 299         { 1,            "O_RDONLY"      },
 300         { 2,            "O_WRONLY"      },
 301         { 0x80,         "O_NONBLOCK"    },
 302         { 8,            "O_APPEND"      },
 303         { 0x100,        "O_CREAT"       },
 304         { 0x200,        "O_TRUNC"       },
 305         { 0x400,        "O_EXCL"        },
 306         { 0x800,        "O_NOCTTY"      },
 307         { 0x10,         "O_SYNC"        },
 308         { 0x40,         "O_DSYNC"       },
 309         { 0x8000,       "O_RSYNC"       },
 310         { 4,            "O_NDELAY"      },
 311         { 0x1000,       "O_PRIV"        },
 312         { 0,            NULL            },
 313 };
 314
 315 int
 316 solaris_open(tcp)
 317 struct tcb *tcp;
 318 {
 319         if (entering(tcp)) {
 320                 printpath(tcp, tcp->u_arg[0]);
 321                 tprintf(", ");
 322                 /* flags */
 323                 printflags(openmodessol, tcp->u_arg[1] + 1);
 324                 if (tcp->u_arg[1] & 0x100) {
 325                         /* mode */
 326                         tprintf(", %#lo", tcp->u_arg[2]);
 327                 }
 328         }
 329         return 0;
 330 }
 331
 332 #endif
 333
 334 int
 335 sys_creat(tcp)
 336 struct tcb *tcp;
 337 {
 338         if (entering(tcp)) {
 339                 printpath(tcp, tcp->u_arg[0]);
 340                 tprintf(", %#lo", tcp->u_arg[1]);
 341         }
 342         return 0;
 343 }
 344
 345 static struct xlat access_flags[] = {
 346         { F_OK,         "F_OK",         },
 347         { R_OK,         "R_OK"          },
 348         { W_OK,         "W_OK"          },
 349         { X_OK,         "X_OK"          },
 350 #ifdef EFF_ONLY_OK
 351         { EFF_ONLY_OK,  "EFF_ONLY_OK"   },
 352 #endif
 353 #ifdef EX_OK
 354         { EX_OK,        "EX_OK"         },
 355 #endif
 356         { 0,            NULL            },
 357 };
 358
 359 int
 360 sys_access(tcp)
 361 struct tcb *tcp;
 362 {
 363         if (entering(tcp)) {
 364                 printpath(tcp, tcp->u_arg[0]);
 365                 tprintf(", ");
 366                 printflags(access_flags, tcp->u_arg[1]);
 367         }
 368         return 0;
 369 }
 370
 371 int
 372 sys_umask(tcp)
 373 struct tcb *tcp;
 374 {
 375         if (entering(tcp)) {
 376                 tprintf("%#lo", tcp->u_arg[0]);
 377         }
 378         return RVAL_OCTAL;
 379 }
 380
 381 static struct xlat whence[] = {
 382         { SEEK_SET,     "SEEK_SET"      },
 383         { SEEK_CUR,     "SEEK_CUR"      },
 384         { SEEK_END,     "SEEK_END"      },
 385         { 0,            NULL            },
 386 };
 387
 388 #ifndef HAVE_LONG_LONG_OFF_T
 389 int
 390 sys_lseek(tcp)
 391 struct tcb *tcp;
 392 {
 393         off_t offset;
 394         int _whence;
 395
 396         if (entering(tcp)) {
 397                 tprintf("%ld, ", tcp->u_arg[0]);
 398                 offset = tcp->u_arg[1];
 399                 _whence = tcp->u_arg[2];
 400                 if (_whence == SEEK_SET)
 401                         tprintf("%lu, ", offset);
 402                 else
 403                         tprintf("%ld, ", offset);
 404                 printxval(whence, _whence, "SEEK_???");
 405         }
 406         return RVAL_UDECIMAL;
 407 }
 408 #endif
 409
 410 #ifdef LINUX
 411 int
 412 sys_llseek (tcp)
 413 struct tcb *tcp;
 414 {
 415     if (entering(tcp)) {
 416         if (tcp->u_arg[4] == SEEK_SET)
 417             tprintf("%ld, %llu, ", tcp->u_arg[0],
 418                     (((long long int) tcp->u_arg[1]) << 32
 419                      | (unsigned long long) (unsigned) tcp->u_arg[2]));
 420         else
 421             tprintf("%ld, %lld, ", tcp->u_arg[0],
 422                     (((long long int) tcp->u_arg[1]) << 32
 423                      | (unsigned long long) (unsigned) tcp->u_arg[2]));
 424     }
 425     else {
 426         long long int off;
 427         if (syserror(tcp) || umove(tcp, tcp->u_arg[3], &off) < 0)
 428             tprintf("%#lx, ", tcp->u_arg[3]);
 429         else
 430             tprintf("[%llu], ", off);
 431         printxval(whence, tcp->u_arg[4], "SEEK_???");
 432     }
 433     return 0;
 434 }
 435
 436 int
 437 sys_readahead (tcp)
 438 struct tcb *tcp;
 439 {
 440     if (entering(tcp)) {
 441         tprintf("%ld, %lld, %ld", tcp->u_arg[0],
 442 # if defined IA64 || defined X86_64 || defined ALPHA
 443                 (long long int) tcp->u_arg[1], tcp->u_arg[2]
 444 # else
 445                 (((long long int) tcp->u_arg[1]) << 32
 446                  | ((unsigned long *) tcp->u_arg)[2]),
 447                 tcp->u_arg[3]
 448 # endif
 449                 );
 450     }
 451     return 0;
 452 }
 453 #endif
 454
 455 #if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
 456 int
 457 sys_lseek64 (tcp)
 458 struct tcb *tcp;
 459 {
 460         if (entering(tcp)) {
 461                 long long offset;
 462                 ALIGN64 (tcp, 1);       /* FreeBSD aligns off_t args */
 463                 offset = LONG_LONG(tcp->u_arg [1], tcp->u_arg[2]);
 464                 if (tcp->u_arg[3] == SEEK_SET)
 465                         tprintf("%ld, %llu, ", tcp->u_arg[0], offset);
 466                 else
 467                         tprintf("%ld, %lld, ", tcp->u_arg[0], offset);
 468                 printxval(whence, tcp->u_arg[3], "SEEK_???");
 469         }
 470         return RVAL_LUDECIMAL;
 471 }
 472 #endif
 473
 474 #ifndef HAVE_LONG_LONG_OFF_T
 475 int
 476 sys_truncate(tcp)
 477 struct tcb *tcp;
 478 {
 479         if (entering(tcp)) {
 480                 printpath(tcp, tcp->u_arg[0]);
 481                 tprintf(", %lu", tcp->u_arg[1]);
 482         }
 483         return 0;
 484 }
 485 #endif
 486
 487 #if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
 488 int
 489 sys_truncate64(tcp)
 490 struct tcb *tcp;
 491 {
 492         if (entering(tcp)) {
 493                 ALIGN64 (tcp, 1);
 494                 printpath(tcp, tcp->u_arg[0]);
 495                 tprintf(", %llu", LONG_LONG(tcp->u_arg[1],tcp->u_arg[2]));
 496         }
 497         return 0;
 498 }
 499 #endif
 500
 501 #ifndef HAVE_LONG_LONG_OFF_T
 502 int
 503 sys_ftruncate(tcp)
 504 struct tcb *tcp;
 505 {
 506         if (entering(tcp)) {
 507                 tprintf("%ld, %lu", tcp->u_arg[0], tcp->u_arg[1]);
 508         }
 509         return 0;
 510 }
 511 #endif
 512
 513 #if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
 514 int
 515 sys_ftruncate64(tcp)
 516 struct tcb *tcp;
 517 {
 518         if (entering(tcp)) {
 519                 ALIGN64 (tcp, 1);
 520                 tprintf("%ld, %llu", tcp->u_arg[0],
 521                         LONG_LONG(tcp->u_arg[1] ,tcp->u_arg[2]));
 522         }
 523         return 0;
 524 }
 525 #endif
 526
 527 /* several stats */
 528
 529 static struct xlat modetypes[] = {
 530         { S_IFREG,      "S_IFREG"       },
 531         { S_IFSOCK,     "S_IFSOCK"      },
 532         { S_IFIFO,      "S_IFIFO"       },
 533         { S_IFLNK,      "S_IFLNK"       },
 534         { S_IFDIR,      "S_IFDIR"       },
 535         { S_IFBLK,      "S_IFBLK"       },
 536         { S_IFCHR,      "S_IFCHR"       },
 537         { 0,            NULL            },
 538 };
 539
 540 static char *
 541 sprintmode(mode)
 542 int mode;
 543 {
 544         static char buf[64];
 545         char *s;
 546
 547         if ((mode & S_IFMT) == 0)
 548                 s = "";
 549         else if ((s = xlookup(modetypes, mode & S_IFMT)) == NULL) {
 550                 sprintf(buf, "%#o", mode);
 551                 return buf;
 552         }
 553         sprintf(buf, "%s%s%s%s", s,
 554                 (mode & S_ISUID) ? "|S_ISUID" : "",
 555                 (mode & S_ISGID) ? "|S_ISGID" : "",
 556                 (mode & S_ISVTX) ? "|S_ISVTX" : "");
 557         mode &= ~(S_IFMT|S_ISUID|S_ISGID|S_ISVTX);
 558         if (mode)
 559                 sprintf(buf + strlen(buf), "|%#o", mode);
 560         s = (*buf == '|') ? buf + 1 : buf;
 561         return *s ? s : "0";
 562 }
 563
 564 static char *
 565 sprinttime(t)
 566 time_t t;
 567 {
 568         struct tm *tmp;
 569         static char buf[32];
 570
 571         if (t == 0) {
 572                 sprintf(buf, "0");
 573                 return buf;
 574         }
 575         tmp = localtime(&t);
 576         sprintf(buf, "%02d/%02d/%02d-%02d:%02d:%02d",
 577                 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
 578                 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
 579         return buf;
 580 }
 581
 582 #ifdef LINUXSPARC
 583 typedef struct {
 584         int     tv_sec;
 585         int     tv_nsec;
 586 } timestruct_t;
 587
 588 struct solstat {
 589         unsigned        st_dev;
 590         int             st_pad1[3];     /* network id */
 591         unsigned        st_ino;
 592         unsigned        st_mode;
 593         unsigned        st_nlink;
 594         unsigned        st_uid;
 595         unsigned        st_gid;
 596         unsigned        st_rdev;
 597         int             st_pad2[2];
 598         int             st_size;
 599         int             st_pad3;        /* st_size, off_t expansion */
 600         timestruct_t    st_atime;
 601         timestruct_t    st_mtime;
 602         timestruct_t    st_ctime;
 603         int             st_blksize;
 604         int             st_blocks;
 605         char            st_fstype[16];
 606         int             st_pad4[8];     /* expansion area */
 607 };
 608
 609 static void
 610 printstatsol(tcp, addr)
 611 struct tcb *tcp;
 612 long addr;
 613 {
 614         struct solstat statbuf;
 615
 616         if (!addr) {
 617                 tprintf("NULL");
 618                 return;
 619         }
 620         if (syserror(tcp) || !verbose(tcp)) {
 621                 tprintf("%#lx", addr);
 622                 return;
 623         }
 624         if (umove(tcp, addr, &statbuf) < 0) {
 625                 tprintf("{...}");
 626                 return;
 627         }
 628         if (!abbrev(tcp)) {
 629                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
 630                         (unsigned long) ((statbuf.st_dev >> 18) & 0x3fff),
 631                         (unsigned long) (statbuf.st_dev & 0x3ffff),
 632                         (unsigned long) statbuf.st_ino,
 633                         sprintmode(statbuf.st_mode));
 634                 tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
 635                         (unsigned long) statbuf.st_nlink,
 636                         (unsigned long) statbuf.st_uid,
 637                         (unsigned long) statbuf.st_gid);
 638                 tprintf("st_blksize=%lu, ", (unsigned long) statbuf.st_blksize);
 639                 tprintf("st_blocks=%lu, ", (unsigned long) statbuf.st_blocks);
 640         }
 641         else
 642                 tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
 643         switch (statbuf.st_mode & S_IFMT) {
 644         case S_IFCHR: case S_IFBLK:
 645                 tprintf("st_rdev=makedev(%lu, %lu), ",
 646                         (unsigned long) ((statbuf.st_rdev >> 18) & 0x3fff),
 647                         (unsigned long) (statbuf.st_rdev & 0x3ffff));
 648                 break;
 649         default:
 650                 tprintf("st_size=%u, ", statbuf.st_size);
 651                 break;
 652         }
 653         if (!abbrev(tcp)) {
 654                 tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
 655                 tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
 656                 tprintf("st_ctime=%s}", sprinttime(statbuf.st_ctime));
 657         }
 658         else
 659                 tprintf("...}");
 660 }
 661 #endif /* LINUXSPARC */
 662
 663 struct xlat fileflags[] = {
 664 #ifdef FREEBSD
 665         { UF_NODUMP,    "UF_NODUMP"     },
 666         { UF_IMMUTABLE, "UF_IMMUTABLE"  },
 667         { UF_APPEND,    "UF_APPEND"     },
 668         { UF_OPAQUE,    "UF_OPAQUE"     },
 669         { UF_NOUNLINK,  "UF_NOUNLINK"   },
 670         { SF_ARCHIVED,  "SF_ARCHIVED"   },
 671         { SF_IMMUTABLE, "SF_IMMUTABLE"  },
 672         { SF_APPEND,    "SF_APPEND"     },
 673         { SF_NOUNLINK,  "SF_NOUNLINK"   },
 674 #elif UNIXWARE >= 2
 675 #ifdef  _S_ISMLD
 676         { _S_ISMLD,     "_S_ISMLD"      },
 677 #endif
 678 #ifdef  _S_ISMOUNTED
 679         { _S_ISMOUNTED, "_S_ISMOUNTED"  },
 680 #endif
 681 #endif
 682         { 0,            NULL            },
 683 };
 684
 685 #ifdef FREEBSD
 686 int
 687 sys_chflags(tcp)
 688 struct tcb *tcp;
 689 {
 690         if (entering(tcp)) {
 691                 printpath(tcp, tcp->u_arg[0]);
 692                 tprintf(", ");
 693                 if (tcp->u_arg[1])
 694                         printflags(fileflags, tcp->u_arg[1]);
 695                 else
 696                         tprintf("0");
 697         }
 698         return 0;
 699 }
 700
 701 int
 702 sys_fchflags(tcp)
 703 struct tcb *tcp;
 704 {
 705         if (entering(tcp)) {
 706                 tprintf("%ld, ", tcp->u_arg[0]);
 707                 if (tcp->u_arg[1])
 708                         printflags(fileflags, tcp->u_arg[1]);
 709                 else
 710                         tprintf("0");
 711         }
 712         return 0;
 713 }
 714 #endif
 715
 716 #ifndef HAVE_LONG_LONG_OFF_T
 717 static void
 718 realprintstat(tcp, statbuf)
 719 struct tcb *tcp;
 720 struct stat *statbuf;
 721 {
 722     if (!abbrev(tcp)) {
 723             tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
 724                     (unsigned long) major(statbuf->st_dev),
 725                     (unsigned long) minor(statbuf->st_dev),
 726                     (unsigned long) statbuf->st_ino,
 727                     sprintmode(statbuf->st_mode));
 728             tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
 729                     (unsigned long) statbuf->st_nlink,
 730                     (unsigned long) statbuf->st_uid,
 731                     (unsigned long) statbuf->st_gid);
 732 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
 733             tprintf("st_blksize=%lu, ", (unsigned long) statbuf->st_blksize);
 734 #endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */
 735 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
 736             tprintf("st_blocks=%lu, ", (unsigned long) statbuf->st_blocks);
 737 #endif /* HAVE_STRUCT_STAT_ST_BLOCKS */
 738     }
 739     else
 740             tprintf("{st_mode=%s, ", sprintmode(statbuf->st_mode));
 741     switch (statbuf->st_mode & S_IFMT) {
 742     case S_IFCHR: case S_IFBLK:
 743 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 744             tprintf("st_rdev=makedev(%lu, %lu), ",
 745                     (unsigned long) major(statbuf->st_rdev),
 746                     (unsigned long) minor(statbuf->st_rdev));
 747 #else /* !HAVE_STRUCT_STAT_ST_RDEV */
 748             tprintf("st_size=makedev(%lu, %lu), ",
 749                     (unsigned long) major(statbuf->st_size),
 750                     (unsigned long) minor(statbuf->st_size));
 751 #endif /* !HAVE_STRUCT_STAT_ST_RDEV */
 752             break;
 753     default:
 754             tprintf("st_size=%lu, ", statbuf->st_size);
 755             break;
 756     }
 757     if (!abbrev(tcp)) {
 758             tprintf("st_atime=%s, ", sprinttime(statbuf->st_atime));
 759             tprintf("st_mtime=%s, ", sprinttime(statbuf->st_mtime));
 760             tprintf("st_ctime=%s", sprinttime(statbuf->st_ctime));
 761 #if HAVE_STRUCT_STAT_ST_FLAGS
 762                 tprintf(", st_flags=");
 763                 if (statbuf->st_flags) {
 764                         printflags(fileflags, statbuf->st_flags);
 765                 } else
 766                         tprintf("0");
 767 #endif
 768 #if HAVE_STRUCT_STAT_ST_ACLCNT
 769                 tprintf(", st_aclcnt=%d", statbuf->st_aclcnt);
 770 #endif
 771 #if HAVE_STRUCT_STAT_ST_LEVEL
 772                 tprintf(", st_level=%ld", statbuf->st_level);
 773 #endif
 774 #if HAVE_STRUCT_STAT_ST_FSTYPE
 775                 tprintf(", st_fstype=%.*s",
 776                         (int) sizeof statbuf->st_fstype, statbuf->st_fstype);
 777 #endif
 778 #if HAVE_STRUCT_STAT_ST_GEN
 779                 tprintf(", st_gen=%u", statbuf->st_gen);
 780 #endif
 781                 tprintf("}");
 782     }
 783     else
 784             tprintf("...}");
 785 }
 786
 787
 788 static void
 789 printstat(tcp, addr)
 790 struct tcb *tcp;
 791 long addr;
 792 {
 793         struct stat statbuf;
 794
 795 #ifdef LINUXSPARC
 796         if (current_personality == 1) {
 797                 printstatsol(tcp, addr);
 798                 return;
 799         }
 800 #endif /* LINUXSPARC */
 801
 802         if (!addr) {
 803                 tprintf("NULL");
 804                 return;
 805         }
 806         if (syserror(tcp) || !verbose(tcp)) {
 807                 tprintf("%#lx", addr);
 808                 return;
 809         }
 810         if (umove(tcp, addr, &statbuf) < 0) {
 811                 tprintf("{...}");
 812                 return;
 813         }
 814
 815         realprintstat(tcp, &statbuf);
 816 }
 817 #endif  /* !HAVE_LONG_LONG_OFF_T */
 818
 819 #ifdef HAVE_STAT64
 820 static void
 821 printstat64(tcp, addr)
 822 struct tcb *tcp;
 823 long addr;
 824 {
 825         struct stat64 statbuf;
 826
 827 #ifdef LINUXSPARC
 828         if (current_personality == 1) {
 829                 printstatsol(tcp, addr);
 830                 return;
 831         }
 832 #endif /* LINUXSPARC */
 833
 834         if (!addr) {
 835                 tprintf("NULL");
 836                 return;
 837         }
 838         if (syserror(tcp) || !verbose(tcp)) {
 839                 tprintf("%#lx", addr);
 840                 return;
 841         }
 842         if (umove(tcp, addr, &statbuf) < 0) {
 843                 tprintf("{...}");
 844                 return;
 845         }
 846
 847         if (!abbrev(tcp)) {
 848 #ifdef HAVE_LONG_LONG
 849                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%llu, st_mode=%s, ",
 850 #else
 851                 tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
 852 #endif
 853                         (unsigned long) major(statbuf.st_dev),
 854                         (unsigned long) minor(statbuf.st_dev),
 855 #ifdef HAVE_LONG_LONG
 856                         (unsigned long long) statbuf.st_ino,
 857 #else
 858                         (unsigned long) statbuf.st_ino,
 859 #endif
 860                         sprintmode(statbuf.st_mode));
 861                 tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
 862                         (unsigned long) statbuf.st_nlink,
 863                         (unsigned long) statbuf.st_uid,
 864                         (unsigned long) statbuf.st_gid);
 865 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
 866                 tprintf("st_blksize=%lu, ",
 867                         (unsigned long) statbuf.st_blksize);
 868 #endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */
 869 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
 870                 tprintf("st_blocks=%lu, ", (unsigned long) statbuf.st_blocks);
 871 #endif /* HAVE_STRUCT_STAT_ST_BLOCKS */
 872         }
 873         else
 874                 tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
 875         switch (statbuf.st_mode & S_IFMT) {
 876         case S_IFCHR: case S_IFBLK:
 877 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 878                 tprintf("st_rdev=makedev(%lu, %lu), ",
 879                         (unsigned long) major(statbuf.st_rdev),
 880                         (unsigned long) minor(statbuf.st_rdev));
 881 #else /* !HAVE_STRUCT_STAT_ST_RDEV */
 882                 tprintf("st_size=makedev(%lu, %lu), ",
 883                         (unsigned long) major(statbuf.st_size),
 884                         (unsigned long) minor(statbuf.st_size));
 885 #endif /* !HAVE_STRUCT_STAT_ST_RDEV */
 886                 break;
 887         default:
 888                 tprintf("st_size=%llu, ", statbuf.st_size);
 889                 break;
 890         }
 891         if (!abbrev(tcp)) {
 892                 tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
 893                 tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
 894                 tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
 895 #if HAVE_STRUCT_STAT_ST_FLAGS
 896                 tprintf(", st_flags=");
 897                 if (statbuf.st_flags) {
 898                         printflags(fileflags, statbuf.st_flags);
 899                 } else
 900                         tprintf("0");
 901 #endif
 902 #if HAVE_STRUCT_STAT_ST_ACLCNT
 903                 tprintf(", st_aclcnt=%d", statbuf.st_aclcnt);
 904 #endif
 905 #if HAVE_STRUCT_STAT_ST_LEVEL
 906                 tprintf(", st_level=%ld", statbuf.st_level);
 907 #endif
 908 #if HAVE_STRUCT_STAT_ST_FSTYPE
 909                 tprintf(", st_fstype=%.*s",
 910                         (int) sizeof statbuf.st_fstype, statbuf.st_fstype);
 911 #endif
 912 #if HAVE_STRUCT_STAT_ST_GEN
 913                 tprintf(", st_gen=%u", statbuf.st_gen);
 914 #endif
 915                 tprintf("}");
 916         }
 917         else
 918                 tprintf("...}");
 919 }
 920 #endif /* HAVE_STAT64 */
 921
 922 #if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT)
 923 static void
 924 convertoldstat(oldbuf, newbuf)
 925 const struct __old_kernel_stat *oldbuf;
 926 struct stat *newbuf;
 927 {
 928     newbuf->st_dev=oldbuf->st_dev;
 929     newbuf->st_ino=oldbuf->st_ino;
 930     newbuf->st_mode=oldbuf->st_mode;
 931     newbuf->st_nlink=oldbuf->st_nlink;
 932     newbuf->st_uid=oldbuf->st_uid;
 933     newbuf->st_gid=oldbuf->st_gid;
 934     newbuf->st_rdev=oldbuf->st_rdev;
 935     newbuf->st_size=oldbuf->st_size;
 936     newbuf->st_atime=oldbuf->st_atime;
 937     newbuf->st_mtime=oldbuf->st_mtime;
 938     newbuf->st_ctime=oldbuf->st_ctime;
 939     newbuf->st_blksize=0;       /* not supported in old_stat */
 940     newbuf->st_blocks=0;                /* not supported in old_stat */
 941 }
 942
 943
 944 static void
 945 printoldstat(tcp, addr)
 946 struct tcb *tcp;
 947 long addr;
 948 {
 949         struct __old_kernel_stat statbuf;
 950         struct stat newstatbuf;
 951
 952 #ifdef LINUXSPARC
 953         if (current_personality == 1) {
 954                 printstatsol(tcp, addr);
 955                 return;
 956         }
 957 #endif /* LINUXSPARC */
 958
 959         if (!addr) {
 960                 tprintf("NULL");
 961                 return;
 962         }
 963         if (syserror(tcp) || !verbose(tcp)) {
 964                 tprintf("%#lx", addr);
 965                 return;
 966         }
 967         if (umove(tcp, addr, &statbuf) < 0) {
 968                 tprintf("{...}");
 969                 return;
 970         }
 971
 972         convertoldstat(&statbuf, &newstatbuf);
 973         realprintstat(tcp, &newstatbuf);
 974 }
 975 #endif /* LINUX && !IA64 && !HPPA && !X86_64 && !S390 && !S390X */
 976
 977 #ifndef HAVE_LONG_LONG_OFF_T
 978 int
 979 sys_stat(tcp)
 980 struct tcb *tcp;
 981 {
 982         if (entering(tcp)) {
 983                 printpath(tcp, tcp->u_arg[0]);
 984                 tprintf(", ");
 985         } else {
 986                 printstat(tcp, tcp->u_arg[1]);
 987         }
 988         return 0;
 989 }
 990 #endif
 991
 992 int
 993 sys_stat64(tcp)
 994 struct tcb *tcp;
 995 {
 996 #ifdef HAVE_STAT64
 997         if (entering(tcp)) {
 998                 printpath(tcp, tcp->u_arg[0]);
 999                 tprintf(", ");
1000         } else {
1001                 printstat64(tcp, tcp->u_arg[1]);
1002         }
1003         return 0;
1004 #else
1005         return printargs(tcp);
1006 #endif
1007 }
1008
1009 #if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT)
1010 int
1011 sys_oldstat(tcp)
1012 struct tcb *tcp;
1013 {
1014         if (entering(tcp)) {
1015                 printpath(tcp, tcp->u_arg[0]);
1016                 tprintf(", ");
1017         } else {
1018                 printoldstat(tcp, tcp->u_arg[1]);
1019         }
1020         return 0;
1021 }
1022 #endif /* LINUX && HAVE_STRUCT___OLD_KERNEL_STAT */
1023
1024 #ifndef HAVE_LONG_LONG_OFF_T
1025 int
1026 sys_fstat(tcp)
1027 struct tcb *tcp;
1028 {
1029         if (entering(tcp))
1030                 tprintf("%ld, ", tcp->u_arg[0]);
1031         else {
1032                 printstat(tcp, tcp->u_arg[1]);
1033         }
1034         return 0;
1035 }
1036 #endif
1037
1038 int
1039 sys_fstat64(tcp)
1040 struct tcb *tcp;
1041 {
1042 #ifdef HAVE_STAT64
1043         if (entering(tcp))
1044                 tprintf("%ld, ", tcp->u_arg[0]);
1045         else {
1046                 printstat64(tcp, tcp->u_arg[1]);
1047         }
1048         return 0;
1049 #else
1050         return printargs(tcp);
1051 #endif
1052 }
1053
1054 #if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT)
1055 int
1056 sys_oldfstat(tcp)
1057 struct tcb *tcp;
1058 {
1059         if (entering(tcp))
1060                 tprintf("%ld, ", tcp->u_arg[0]);
1061         else {
1062                 printoldstat(tcp, tcp->u_arg[1]);
1063         }
1064         return 0;
1065 }
1066 #endif /* LINUX && HAVE_STRUCT___OLD_KERNEL_STAT */
1067
1068 #ifndef HAVE_LONG_LONG_OFF_T
1069 int
1070 sys_lstat(tcp)
1071 struct tcb *tcp;
1072 {
1073         if (entering(tcp)) {
1074                 printpath(tcp, tcp->u_arg[0]);
1075                 tprintf(", ");
1076         } else {
1077                 printstat(tcp, tcp->u_arg[1]);
1078         }
1079         return 0;
1080 }
1081 #endif
1082
1083 int
1084 sys_lstat64(tcp)
1085 struct tcb *tcp;
1086 {
1087 #ifdef HAVE_STAT64
1088         if (entering(tcp)) {
1089                 printpath(tcp, tcp->u_arg[0]);
1090                 tprintf(", ");
1091         } else {
1092                 printstat64(tcp, tcp->u_arg[1]);
1093         }
1094         return 0;
1095 #else
1096         return printargs(tcp);
1097 #endif
1098 }
1099
1100 #if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT)
1101 int
1102 sys_oldlstat(tcp)
1103 struct tcb *tcp;
1104 {
1105         if (entering(tcp)) {
1106                 printpath(tcp, tcp->u_arg[0]);
1107                 tprintf(", ");
1108         } else {
1109                 printoldstat(tcp, tcp->u_arg[1]);
1110         }
1111         return 0;
1112 }
1113 #endif /* LINUX && HAVE_STRUCT___OLD_KERNEL_STAT */
1114
1115
1116 #if defined(SVR4) || defined(LINUXSPARC)
1117
1118 int
1119 sys_xstat(tcp)
1120 struct tcb *tcp;
1121 {
1122         if (entering(tcp)) {
1123                 tprintf("%ld, ", tcp->u_arg[0]);
1124                 printpath(tcp, tcp->u_arg[1]);
1125                 tprintf(", ");
1126         } else {
1127 #ifdef _STAT64_VER
1128                 if (tcp->u_arg[0] == _STAT64_VER)
1129                         printstat64 (tcp, tcp->u_arg[2]);
1130                 else
1131 #endif
1132                 printstat(tcp, tcp->u_arg[2]);
1133         }
1134         return 0;
1135 }
1136
1137 int
1138 sys_fxstat(tcp)
1139 struct tcb *tcp;
1140 {
1141         if (entering(tcp))
1142                 tprintf("%ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1]);
1143         else {
1144 #ifdef _STAT64_VER
1145                 if (tcp->u_arg[0] == _STAT64_VER)
1146                         printstat64 (tcp, tcp->u_arg[2]);
1147                 else
1148 #endif
1149                 printstat(tcp, tcp->u_arg[2]);
1150         }
1151         return 0;
1152 }
1153
1154 int
1155 sys_lxstat(tcp)
1156 struct tcb *tcp;
1157 {
1158         if (entering(tcp)) {
1159                 tprintf("%ld, ", tcp->u_arg[0]);
1160                 printpath(tcp, tcp->u_arg[1]);
1161                 tprintf(", ");
1162         } else {
1163 #ifdef _STAT64_VER
1164                 if (tcp->u_arg[0] == _STAT64_VER)
1165                         printstat64 (tcp, tcp->u_arg[2]);
1166                 else
1167 #endif
1168                 printstat(tcp, tcp->u_arg[2]);
1169         }
1170         return 0;
1171 }
1172
1173 int
1174 sys_xmknod(tcp)
1175 struct tcb *tcp;
1176 {
1177         int mode = tcp->u_arg[2];
1178
1179         if (entering(tcp)) {
1180                 tprintf("%ld, ", tcp->u_arg[0]);
1181                 printpath(tcp, tcp->u_arg[1]);
1182                 tprintf(", %s", sprintmode(mode));
1183                 switch (mode & S_IFMT) {
1184                 case S_IFCHR: case S_IFBLK:
1185 #ifdef LINUXSPARC
1186                         tprintf(", makedev(%lu, %lu)",
1187                                 (unsigned long) ((tcp->u_arg[3] >> 18) & 0x3fff),
1188                                 (unsigned long) (tcp->u_arg[3] & 0x3ffff));
1189 #else
1190                         tprintf(", makedev(%lu, %lu)",
1191                                 (unsigned long) major(tcp->u_arg[3]),
1192                                 (unsigned long) minor(tcp->u_arg[3]));
1193 #endif
1194                         break;
1195                 default:
1196                         break;
1197                 }
1198         }
1199         return 0;
1200 }
1201
1202 #ifdef HAVE_SYS_ACL_H
1203
1204 #include <sys/acl.h>
1205
1206 struct xlat aclcmds[] = {
1207 #ifdef SETACL
1208         { SETACL,       "SETACL"        },
1209 #endif
1210 #ifdef GETACL
1211         { GETACL,       "GETACL"        },
1212 #endif
1213 #ifdef GETACLCNT
1214         { GETACLCNT,    "GETACLCNT"     },
1215 #endif
1216 #ifdef ACL_GET
1217         { ACL_GET,      "ACL_GET"       },
1218 #endif
1219 #ifdef ACL_SET
1220         { ACL_SET,      "ACL_SET"       },
1221 #endif
1222 #ifdef ACL_CNT
1223         { ACL_CNT,      "ACL_CNT"       },
1224 #endif
1225         { 0,            NULL            },
1226 };
1227
1228 int
1229 sys_acl(tcp)
1230 struct tcb *tcp;
1231 {
1232         if (entering(tcp)) {
1233                 printpath(tcp, tcp->u_arg[0]);
1234                 tprintf(", ");
1235                 printxval(aclcmds, tcp->u_arg[1], "???ACL???");
1236                 tprintf(", %ld", tcp->u_arg[2]);
1237                 /*
1238                  * FIXME - dump out the list of aclent_t's pointed to
1239                  * by "tcp->u_arg[3]" if it's not NULL.
1240                  */
1241                 if (tcp->u_arg[3])
1242                         tprintf(", %#lx", tcp->u_arg[3]);
1243                 else
1244                         tprintf(", NULL");
1245         }
1246         return 0;
1247 }
1248
1249
1250 int
1251 sys_facl(tcp)
1252 struct tcb *tcp;
1253 {
1254         if (entering(tcp)) {
1255                 tprintf("%ld, ", tcp->u_arg[0]);
1256                 printxval(aclcmds, tcp->u_arg[1], "???ACL???");
1257                 tprintf(", %ld", tcp->u_arg[2]);
1258                 /*
1259                  * FIXME - dump out the list of aclent_t's pointed to
1260                  * by "tcp->u_arg[3]" if it's not NULL.
1261                  */
1262                 if (tcp->u_arg[3])
1263                         tprintf(", %#lx", tcp->u_arg[3]);
1264                 else
1265                         tprintf(", NULL");
1266         }
1267         return 0;
1268 }
1269
1270
1271 struct xlat aclipc[] = {
1272 #ifdef IPC_SHM
1273         { IPC_SHM,      "IPC_SHM"       },
1274 #endif
1275 #ifdef IPC_SEM
1276         { IPC_SEM,      "IPC_SEM"       },
1277 #endif
1278 #ifdef IPC_MSG
1279         { IPC_MSG,      "IPC_MSG"       },
1280 #endif
1281         { 0,            NULL            },
1282 };
1283
1284
1285 int
1286 sys_aclipc(tcp)
1287 struct tcb *tcp;
1288 {
1289         if (entering(tcp)) {
1290                 printxval(aclipc, tcp->u_arg[0], "???IPC???");
1291                 tprintf(", %#lx, ", tcp->u_arg[1]);
1292                 printxval(aclcmds, tcp->u_arg[2], "???ACL???");
1293                 tprintf(", %ld", tcp->u_arg[3]);
1294                 /*
1295                  * FIXME - dump out the list of aclent_t's pointed to
1296                  * by "tcp->u_arg[4]" if it's not NULL.
1297                  */
1298                 if (tcp->u_arg[4])
1299                         tprintf(", %#lx", tcp->u_arg[4]);
1300                 else
1301                         tprintf(", NULL");
1302         }
1303         return 0;
1304 }
1305
1306
1307
1308 #endif /* HAVE_SYS_ACL_H */
1309
1310 #endif /* SVR4 || LINUXSPARC */
1311
1312 #ifdef LINUX
1313
1314 static struct xlat fsmagic[] = {
1315         { 0x73757245,   "CODA_SUPER_MAGIC"      },
1316         { 0x012ff7b7,   "COH_SUPER_MAGIC"       },
1317         { 0x1373,       "DEVFS_SUPER_MAGIC"     },
1318         { 0x1cd1,       "DEVPTS_SUPER_MAGIC"    },
1319         { 0x414A53,     "EFS_SUPER_MAGIC"       },
1320         { 0xef51,       "EXT2_OLD_SUPER_MAGIC"  },
1321         { 0xef53,       "EXT2_SUPER_MAGIC"      },
1322         { 0x137d,       "EXT_SUPER_MAGIC"       },
1323         { 0xf995e849,   "HPFS_SUPER_MAGIC"      },
1324         { 0x9660,       "ISOFS_SUPER_MAGIC"     },
1325         { 0x137f,       "MINIX_SUPER_MAGIC"     },
1326         { 0x138f,       "MINIX_SUPER_MAGIC2"    },
1327         { 0x2468,       "MINIX2_SUPER_MAGIC"    },
1328         { 0x2478,       "MINIX2_SUPER_MAGIC2"   },
1329         { 0x4d44,       "MSDOS_SUPER_MAGIC"     },
1330         { 0x564c,       "NCP_SUPER_MAGIC"       },
1331         { 0x6969,       "NFS_SUPER_MAGIC"       },
1332         { 0x9fa0,       "PROC_SUPER_MAGIC"      },
1333         { 0x002f,       "QNX4_SUPER_MAGIC"      },
1334         { 0x52654973,   "REISERFS_SUPER_MAGIC"  },
1335         { 0x02011994,   "SHMFS_SUPER_MAGIC"     },
1336         { 0x517b,       "SMB_SUPER_MAGIC"       },
1337         { 0x012ff7b6,   "SYSV2_SUPER_MAGIC"     },
1338         { 0x012ff7b5,   "SYSV4_SUPER_MAGIC"     },
1339         { 0x00011954,   "UFS_MAGIC"             },
1340         { 0x54190100,   "UFS_CIGAM"             },
1341         { 0x012ff7b4,   "XENIX_SUPER_MAGIC"     },
1342         { 0x012fd16d,   "XIAFS_SUPER_MAGIC"     },
1343         { 0x62656572,   "SYSFS_MAGIC"           },
1344         { 0,            NULL                    },
1345 };
1346
1347 #endif /* LINUX */
1348
1349 #ifndef SVR4
1350
1351 static char *
1352 sprintfstype(magic)
1353 int magic;
1354 {
1355         static char buf[32];
1356 #ifdef LINUX
1357         char *s;
1358
1359         s = xlookup(fsmagic, magic);
1360         if (s) {
1361                 sprintf(buf, "\"%s\"", s);
1362                 return buf;
1363         }
1364 #endif /* LINUX */
1365         sprintf(buf, "%#x", magic);
1366         return buf;
1367 }
1368
1369 static void
1370 printstatfs(tcp, addr)
1371 struct tcb *tcp;
1372 long addr;
1373 {
1374         struct statfs statbuf;
1375
1376         if (syserror(tcp) || !verbose(tcp)) {
1377                 tprintf("%#lx", addr);
1378                 return;
1379         }
1380         if (umove(tcp, addr, &statbuf) < 0) {
1381                 tprintf("{...}");
1382                 return;
1383         }
1384 #ifdef ALPHA
1385
1386         tprintf("{f_type=%s, f_fbsize=%u, f_blocks=%u, f_bfree=%u, ",
1387                 sprintfstype(statbuf.f_type),
1388                 statbuf.f_bsize, statbuf.f_blocks, statbuf.f_bfree);
1389         tprintf("f_bavail=%u, f_files=%u, f_ffree=%u, f_fsid={%d, %d}, f_namelen=%u",
1390                 statbuf.f_bavail,statbuf.f_files, statbuf.f_ffree,
1391                 statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1],
1392                 statbuf.f_namelen);
1393 #else /* !ALPHA */
1394         tprintf("{f_type=%s, f_bsize=%lu, f_blocks=%lu, f_bfree=%lu, ",
1395                 sprintfstype(statbuf.f_type),
1396                 (unsigned long)statbuf.f_bsize,
1397                 (unsigned long)statbuf.f_blocks,
1398                 (unsigned long)statbuf.f_bfree);
1399         tprintf("f_bavail=%lu, f_files=%lu, f_ffree=%lu, f_fsid={%d, %d}",
1400                 (unsigned long)statbuf.f_bavail,
1401                 (unsigned long)statbuf.f_files,
1402                 (unsigned long)statbuf.f_ffree,
1403                 statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1]);
1404 #ifdef LINUX
1405         tprintf(", f_namelen=%lu", (unsigned long)statbuf.f_namelen);
1406 #endif /* LINUX */
1407 #endif /* !ALPHA */
1408 #ifdef _STATFS_F_FRSIZE
1409         tprintf(", f_frsize=%lu", (unsigned long)statbuf.f_frsize);
1410 #endif
1411         tprintf("}");
1412 }
1413
1414 int
1415 sys_statfs(tcp)
1416 struct tcb *tcp;
1417 {
1418         if (entering(tcp)) {
1419                 printpath(tcp, tcp->u_arg[0]);
1420                 tprintf(", ");
1421         } else {
1422                 printstatfs(tcp, tcp->u_arg[1]);
1423         }
1424         return 0;
1425 }
1426
1427 int
1428 sys_fstatfs(tcp)
1429 struct tcb *tcp;
1430 {
1431         if (entering(tcp)) {
1432                 tprintf("%lu, ", tcp->u_arg[0]);
1433         } else {
1434                 printstatfs(tcp, tcp->u_arg[1]);
1435         }
1436         return 0;
1437 }
1438
1439 #ifdef LINUX
1440 static void
1441 printstatfs64(tcp, addr)
1442 struct tcb *tcp;
1443 long addr;
1444 {
1445         struct statfs64 statbuf;
1446
1447         if (syserror(tcp) || !verbose(tcp)) {
1448                 tprintf("%#lx", addr);
1449                 return;
1450         }
1451         if (umove(tcp, addr, &statbuf) < 0) {
1452                 tprintf("{...}");
1453                 return;
1454         }
1455 #ifdef ALPHA
1456
1457         tprintf("{f_type=%s, f_fbsize=%u, f_blocks=%u, f_bfree=%u, ",
1458                 sprintfstype(statbuf.f_type),
1459                 statbuf.f_bsize, statbuf.f_blocks, statbuf.f_bfree);
1460         tprintf("f_bavail=%u, f_files=%u, f_ffree=%u, f_fsid={%d, %d}, f_namelen=%u",
1461                 statbuf.f_bavail,statbuf.f_files, statbuf.f_ffree,
1462                 statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1],
1463                 statbuf.f_namelen);
1464 #else /* !ALPHA */
1465         tprintf("{f_type=%s, f_bsize=%lu, f_blocks=%lu, f_bfree=%lu, ",
1466                 sprintfstype(statbuf.f_type),
1467                 (unsigned long)statbuf.f_bsize,
1468                 (unsigned long)statbuf.f_blocks,
1469                 (unsigned long)statbuf.f_bfree);
1470         tprintf("f_bavail=%lu, f_files=%lu, f_ffree=%lu, f_fsid={%d, %d}",
1471                 (unsigned long)statbuf.f_bavail,
1472                 (unsigned long)statbuf.f_files,
1473                 (unsigned long)statbuf.f_ffree,
1474                 statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1]);
1475         tprintf(", f_namelen=%lu", (unsigned long)statbuf.f_namelen);
1476 #endif /* !ALPHA */
1477 #ifdef _STATFS_F_FRSIZE
1478         tprintf(", f_frsize=%lu", (unsigned long)statbuf.f_frsize);
1479 #endif
1480         tprintf("}");
1481 }
1482
1483 int
1484 sys_statfs64(tcp)
1485 struct tcb *tcp;
1486 {
1487         if (entering(tcp)) {
1488                 printpath(tcp, tcp->u_arg[0]);
1489                 tprintf(", %lu, ", tcp->u_arg[1]);
1490         } else {
1491                 if (tcp->u_arg[1] == sizeof (struct statfs64))
1492                         printstatfs64(tcp, tcp->u_arg[2]);
1493                 else
1494                         tprintf("{???}");
1495         }
1496         return 0;
1497 }
1498
1499 int
1500 sys_fstatfs64(tcp)
1501 struct tcb *tcp;
1502 {
1503         if (entering(tcp)) {
1504                 tprintf("%lu, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
1505         } else {
1506                 if (tcp->u_arg[1] == sizeof (struct statfs64))
1507                         printstatfs64(tcp, tcp->u_arg[2]);
1508                 else
1509                         tprintf("{???}");
1510         }
1511         return 0;
1512 }
1513 #endif
1514
1515 #if defined(LINUX) && defined(__alpha)
1516
1517 int
1518 osf_statfs(tcp)
1519 struct tcb *tcp;
1520 {
1521         if (entering(tcp)) {
1522                 printpath(tcp, tcp->u_arg[0]);
1523                 tprintf(", ");
1524         } else {
1525                 printstatfs(tcp, tcp->u_arg[1]);
1526                 tprintf(", %lu", tcp->u_arg[2]);
1527         }
1528         return 0;
1529 }
1530
1531 int
1532 osf_fstatfs(tcp)
1533 struct tcb *tcp;
1534 {
1535         if (entering(tcp)) {
1536                 tprintf("%lu, ", tcp->u_arg[0]);
1537         } else {
1538                 printstatfs(tcp, tcp->u_arg[1]);
1539                 tprintf(", %lu", tcp->u_arg[2]);
1540         }
1541         return 0;
1542 }
1543 #endif /* LINUX && __alpha */
1544
1545 #endif /* !SVR4 */
1546
1547 #ifdef SUNOS4
1548
1549 int
1550 sys_ustat(tcp)
1551 struct tcb *tcp;
1552 {
1553         struct ustat statbuf;
1554
1555         if (entering(tcp)) {
1556                 tprintf("makedev(%lu, %lu), ",
1557                                 (long) major(tcp->u_arg[0]),
1558                                 (long) minor(tcp->u_arg[0]));
1559         }
1560         else {
1561                 if (syserror(tcp) || !verbose(tcp))
1562                         tprintf("%#lx", tcp->u_arg[1]);
1563                 else if (umove(tcp, tcp->u_arg[1], &statbuf) < 0)
1564                         tprintf("{...}");
1565                 else {
1566                         tprintf("{f_tfree=%lu, f_tinode=%lu, ",
1567                                 statbuf.f_tfree, statbuf.f_tinode);
1568                         tprintf("f_fname=\"%.*s\", ",
1569                                 (int) sizeof(statbuf.f_fname),
1570                                 statbuf.f_fname);
1571                         tprintf("f_fpack=\"%.*s\"}",
1572                                 (int) sizeof(statbuf.f_fpack),
1573                                 statbuf.f_fpack);
1574                 }
1575         }
1576         return 0;
1577 }
1578
1579 #endif /* SUNOS4 */
1580
1581 int
1582 sys_pivotroot(tcp)
1583 struct tcb *tcp;
1584 {
1585         if (entering(tcp)) {
1586                 printpath(tcp, tcp->u_arg[0]);
1587                 tprintf(", ");
1588                 printpath(tcp, tcp->u_arg[1]);
1589         }
1590         return 0;
1591 }
1592
1593
1594 /* directory */
1595 int
1596 sys_chdir(tcp)
1597 struct tcb *tcp;
1598 {
1599         if (entering(tcp)) {
1600                 printpath(tcp, tcp->u_arg[0]);
1601         }
1602         return 0;
1603 }
1604
1605 int
1606 sys_mkdir(tcp)
1607 struct tcb *tcp;
1608 {
1609         if (entering(tcp)) {
1610                 printpath(tcp, tcp->u_arg[0]);
1611                 tprintf(", %#lo", tcp->u_arg[1]);
1612         }
1613         return 0;
1614 }
1615
1616 int
1617 sys_rmdir(tcp)
1618 struct tcb *tcp;
1619 {
1620         if (entering(tcp)) {
1621                 printpath(tcp, tcp->u_arg[0]);
1622         }
1623         return 0;
1624 }
1625
1626 int
1627 sys_fchdir(tcp)
1628 struct tcb *tcp;
1629 {
1630         if (entering(tcp)) {
1631                 tprintf("%ld", tcp->u_arg[0]);
1632         }
1633         return 0;
1634 }
1635
1636 int
1637 sys_chroot(tcp)
1638 struct tcb *tcp;
1639 {
1640         if (entering(tcp)) {
1641                 printpath(tcp, tcp->u_arg[0]);
1642         }
1643         return 0;
1644 }
1645
1646 int
1647 sys_fchroot(tcp)
1648 struct tcb *tcp;
1649 {
1650         if (entering(tcp)) {
1651                 tprintf("%ld", tcp->u_arg[0]);
1652         }
1653         return 0;
1654 }
1655
1656 int
1657 sys_link(tcp)
1658 struct tcb *tcp;
1659 {
1660         if (entering(tcp)) {
1661                 printpath(tcp, tcp->u_arg[0]);
1662                 tprintf(", ");
1663                 printpath(tcp, tcp->u_arg[1]);
1664         }
1665         return 0;
1666 }
1667
1668 int
1669 sys_unlink(tcp)
1670 struct tcb *tcp;
1671 {
1672         if (entering(tcp)) {
1673                 printpath(tcp, tcp->u_arg[0]);
1674         }
1675         return 0;
1676 }
1677
1678 int
1679 sys_symlink(tcp)
1680 struct tcb *tcp;
1681 {
1682         if (entering(tcp)) {
1683                 printpath(tcp, tcp->u_arg[0]);
1684                 tprintf(", ");
1685                 printpath(tcp, tcp->u_arg[1]);
1686         }
1687         return 0;
1688 }
1689
1690 int
1691 sys_readlink(tcp)
1692 struct tcb *tcp;
1693 {
1694         if (entering(tcp)) {
1695                 printpath(tcp, tcp->u_arg[0]);
1696                 tprintf(", ");
1697         } else {
1698                 if (syserror(tcp))
1699                         tprintf("%#lx", tcp->u_arg[1]);
1700                 else
1701                         printpathn(tcp, tcp->u_arg[1], tcp->u_rval);
1702                 tprintf(", %lu", tcp->u_arg[2]);
1703         }
1704         return 0;
1705 }
1706
1707 int
1708 sys_rename(tcp)
1709 struct tcb *tcp;
1710 {
1711         if (entering(tcp)) {
1712                 printpath(tcp, tcp->u_arg[0]);
1713                 tprintf(", ");
1714                 printpath(tcp, tcp->u_arg[1]);
1715         }
1716         return 0;
1717 }
1718
1719 int
1720 sys_chown(tcp)
1721 struct tcb *tcp;
1722 {
1723         if (entering(tcp)) {
1724                 printpath(tcp, tcp->u_arg[0]);
1725                 printuid(", ", tcp->u_arg[1]);
1726                 printuid(", ", tcp->u_arg[2]);
1727         }
1728         return 0;
1729 }
1730
1731 int
1732 sys_fchown(tcp)
1733 struct tcb *tcp;
1734 {
1735         if (entering(tcp)) {
1736                 tprintf("%ld", tcp->u_arg[0]);
1737                 printuid(", ", tcp->u_arg[1]);
1738                 printuid(", ", tcp->u_arg[2]);
1739         }
1740         return 0;
1741 }
1742
1743 int
1744 sys_chmod(tcp)
1745 struct tcb *tcp;
1746 {
1747         if (entering(tcp)) {
1748                 printpath(tcp, tcp->u_arg[0]);
1749                 tprintf(", %#lo", tcp->u_arg[1]);
1750         }
1751         return 0;
1752 }
1753
1754 int
1755 sys_fchmod(tcp)
1756 struct tcb *tcp;
1757 {
1758         if (entering(tcp)) {
1759                 tprintf("%ld, %#lo", tcp->u_arg[0], tcp->u_arg[1]);
1760         }
1761         return 0;
1762 }
1763
1764 #ifdef ALPHA
1765 int
1766 sys_osf_utimes(tcp)
1767 struct tcb *tcp;
1768 {
1769     if (entering(tcp)) {
1770         printpath(tcp, tcp->u_arg[0]);
1771         tprintf(", ");
1772         printtv32(tcp, tcp->u_arg[1]);
1773     }
1774     return 0;
1775 }
1776 #endif
1777
1778 int
1779 sys_utimes(tcp)
1780 struct tcb *tcp;
1781 {
1782         if (entering(tcp)) {
1783                 printpath(tcp, tcp->u_arg[0]);
1784                 tprintf(", ");
1785                 printtv(tcp, tcp->u_arg[1]);
1786         }
1787         return 0;
1788 }
1789
1790 int
1791 sys_utime(tcp)
1792 struct tcb *tcp;
1793 {
1794         long ut[2];
1795
1796         if (entering(tcp)) {
1797                 printpath(tcp, tcp->u_arg[0]);
1798                 tprintf(", ");
1799                 if (!tcp->u_arg[1])
1800                         tprintf("NULL");
1801                 else if (!verbose(tcp))
1802                         tprintf("%#lx", tcp->u_arg[1]);
1803                 else if (umoven(tcp, tcp->u_arg[1], sizeof ut,
1804                     (char *) ut) < 0)
1805                         tprintf("[?, ?]");
1806                 else {
1807                         tprintf("[%s,", sprinttime(ut[0]));
1808                         tprintf(" %s]", sprinttime(ut[1]));
1809                 }
1810         }
1811         return 0;
1812 }
1813
1814 int
1815 sys_mknod(tcp)
1816 struct tcb *tcp;
1817 {
1818         int mode = tcp->u_arg[1];
1819
1820         if (entering(tcp)) {
1821                 printpath(tcp, tcp->u_arg[0]);
1822                 tprintf(", %s", sprintmode(mode));
1823                 switch (mode & S_IFMT) {
1824                 case S_IFCHR: case S_IFBLK:
1825 #ifdef LINUXSPARC
1826                         if (current_personality == 1)
1827                         tprintf(", makedev(%lu, %lu)",
1828                                 (unsigned long) ((tcp->u_arg[2] >> 18) & 0x3fff),
1829                                 (unsigned long) (tcp->u_arg[2] & 0x3ffff));
1830                         else
1831 #endif
1832                         tprintf(", makedev(%lu, %lu)",
1833                                 (unsigned long) major(tcp->u_arg[2]),
1834                                 (unsigned long) minor(tcp->u_arg[2]));
1835                         break;
1836                 default:
1837                         break;
1838                 }
1839         }
1840         return 0;
1841 }
1842
1843 int
1844 sys_mkfifo(tcp)
1845 struct tcb *tcp;
1846 {
1847         if (entering(tcp)) {
1848                 printpath(tcp, tcp->u_arg[0]);
1849                 tprintf(", %#lo", tcp->u_arg[1]);
1850         }
1851         return 0;
1852 }
1853
1854 int
1855 sys_fsync(tcp)
1856 struct tcb *tcp;
1857 {
1858         if (entering(tcp)) {
1859                 tprintf("%ld", tcp->u_arg[0]);
1860         }
1861         return 0;
1862 }
1863
1864 #ifdef LINUX
1865
1866 static void
1867 printdir(tcp, addr)
1868 struct tcb *tcp;
1869 long addr;
1870 {
1871         struct dirent d;
1872
1873         if (!verbose(tcp)) {
1874                 tprintf("%#lx", addr);
1875                 return;
1876         }
1877         if (umove(tcp, addr, &d) < 0) {
1878                 tprintf("{...}");
1879                 return;
1880         }
1881         tprintf("{d_ino=%ld, ", (unsigned long) d.d_ino);
1882         tprintf("d_name=");
1883         printpathn(tcp, (long) ((struct dirent *) addr)->d_name, d.d_reclen);
1884         tprintf("}");
1885 }
1886
1887 int
1888 sys_readdir(tcp)
1889 struct tcb *tcp;
1890 {
1891         if (entering(tcp)) {
1892                 tprintf("%lu, ", tcp->u_arg[0]);
1893         } else {
1894                 if (syserror(tcp) || tcp->u_rval == 0 || !verbose(tcp))
1895                         tprintf("%#lx", tcp->u_arg[1]);
1896                 else
1897                         printdir(tcp, tcp->u_arg[1]);
1898                 /* Not much point in printing this out, it is always 1. */
1899                 if (tcp->u_arg[2] != 1)
1900                         tprintf(", %lu", tcp->u_arg[2]);
1901         }
1902         return 0;
1903 }
1904
1905 #endif /* LINUX */
1906
1907 #if defined FREEBSD || defined LINUX
1908 struct xlat direnttypes[] = {
1909         { DT_UNKNOWN,   "DT_UNKNOWN"    },
1910         { DT_FIFO,      "DT_FIFO"       },
1911         { DT_CHR,       "DT_CHR"        },
1912         { DT_DIR,       "DT_DIR"        },
1913         { DT_BLK,       "DT_BLK"        },
1914         { DT_REG,       "DT_REG"        },
1915         { DT_LNK,       "DT_LNK"        },
1916         { DT_SOCK,      "DT_SOCK"       },
1917         { DT_WHT,       "DT_WHT"        },
1918         { 0,            NULL            },
1919 };
1920
1921 #endif
1922
1923 int
1924 sys_getdents(tcp)
1925 struct tcb *tcp;
1926 {
1927         int i, len, dents = 0;
1928         char *buf;
1929
1930         if (entering(tcp)) {
1931                 tprintf("%lu, ", tcp->u_arg[0]);
1932                 return 0;
1933         }
1934         if (syserror(tcp) || !verbose(tcp)) {
1935                 tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
1936                 return 0;
1937         }
1938         len = tcp->u_rval;
1939         if ((buf = malloc(len)) == NULL) {
1940                 tprintf("out of memory\n");
1941                 return 0;
1942         }
1943         if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
1944                 tprintf("{...}, %lu", tcp->u_arg[2]);
1945                 free(buf);
1946                 return 0;
1947         }
1948         if (!abbrev(tcp))
1949                 tprintf("{");
1950         for (i = 0; i < len;) {
1951                 struct kernel_dirent *d = (struct kernel_dirent *) &buf[i];
1952 #ifdef LINUX
1953                 if (!abbrev(tcp)) {
1954                         tprintf("%s{d_ino=%lu, d_off=%lu, ",
1955                                 i ? " " : "", d->d_ino, d->d_off);
1956                         tprintf("d_reclen=%u, d_name=\"%s\"}",
1957                                 d->d_reclen, d->d_name);
1958                 }
1959 #endif /* LINUX */
1960 #ifdef SVR4
1961                 if (!abbrev(tcp)) {
1962                         tprintf("%s{d_ino=%lu, d_off=%lu, ",
1963                                 i ? " " : "",
1964                                 (unsigned long) d->d_ino,
1965                                 (unsigned long) d->d_off);
1966                         tprintf("d_reclen=%u, d_name=\"%s\"}",
1967                                 d->d_reclen, d->d_name);
1968                 }
1969 #endif /* SVR4 */
1970 #ifdef SUNOS4
1971                 if (!abbrev(tcp)) {
1972                         tprintf("%s{d_off=%lu, d_fileno=%lu, d_reclen=%u, ",
1973                                 i ? " " : "", d->d_off, d->d_fileno,
1974                                 d->d_reclen);
1975                         tprintf("d_namlen=%u, d_name=\"%.*s\"}",
1976                                 d->d_namlen, d->d_namlen, d->d_name);
1977                 }
1978 #endif /* SUNOS4 */
1979 #ifdef FREEBSD
1980                 if (!abbrev(tcp)) {
1981                         tprintf("%s{d_fileno=%u, d_reclen=%u, d_type=",
1982                                 i ? " " : "", d->d_fileno, d->d_reclen);
1983                         printxval(direnttypes, d->d_type, "DT_???");
1984                         tprintf(", d_namlen=%u, d_name=\"%.*s\"}",
1985                                 d->d_namlen, d->d_namlen, d->d_name);
1986                 }
1987 #endif /* FREEBSD */
1988                 if (!d->d_reclen) {
1989                         tprintf("/* d_reclen == 0, problem here */");
1990                         break;
1991                 }
1992                 i += d->d_reclen;
1993                 dents++;
1994         }
1995         if (!abbrev(tcp))
1996                 tprintf("}");
1997         else
1998                 tprintf("/* %u entries */", dents);
1999         tprintf(", %lu", tcp->u_arg[2]);
2000         free(buf);
2001         return 0;
2002 }
2003
2004
2005 #if _LFS64_LARGEFILE
2006 int
2007 sys_getdents64(tcp)
2008 struct tcb *tcp;
2009 {
2010         int i, len, dents = 0;
2011         char *buf;
2012
2013         if (entering(tcp)) {
2014                 tprintf("%lu, ", tcp->u_arg[0]);
2015                 return 0;
2016         }
2017         if (syserror(tcp) || !verbose(tcp)) {
2018                 tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
2019                 return 0;
2020         }
2021         len = tcp->u_rval;
2022         if ((buf = malloc(len)) == NULL) {
2023                 tprintf("out of memory\n");
2024                 return 0;
2025         }
2026         if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
2027                 tprintf("{...}, %lu", tcp->u_arg[2]);
2028                 free(buf);
2029                 return 0;
2030         }
2031         if (!abbrev(tcp))
2032                 tprintf("{");
2033         for (i = 0; i < len;) {
2034                 struct dirent64 *d = (struct dirent64 *) &buf[i];
2035 #if defined(LINUX) || defined(SVR4)
2036                 if (!abbrev(tcp)) {
2037                         tprintf("%s{d_ino=%llu, d_off=%llu, ",
2038                                 i ? " " : "",
2039                                 d->d_ino,
2040                                 d->d_off);
2041 #ifdef LINUX
2042                         tprintf("d_type=");
2043                         printxval(direnttypes, d->d_type, "DT_???");
2044                         tprintf(", ");
2045 #endif
2046                         tprintf("d_reclen=%u, d_name=\"%s\"}",
2047                                 d->d_reclen, d->d_name);
2048                 }
2049 #endif /* LINUX || SVR4 */
2050 #ifdef SUNOS4
2051                 if (!abbrev(tcp)) {
2052                         tprintf("%s{d_off=%lu, d_fileno=%lu, d_reclen=%u, ",
2053                                 i ? " " : "", d->d_off, d->d_fileno,
2054                                 d->d_reclen);
2055                         tprintf("d_namlen=%u, d_name=\"%.*s\"}",
2056                                 d->d_namlen, d->d_namlen, d->d_name);
2057                 }
2058 #endif /* SUNOS4 */
2059                 i += d->d_reclen;
2060                 dents++;
2061         }
2062         if (!abbrev(tcp))
2063                 tprintf("}");
2064         else
2065                 tprintf("/* %u entries */", dents);
2066         tprintf(", %lu", tcp->u_arg[2]);
2067         free(buf);
2068         return 0;
2069 }
2070 #endif
2071
2072 #ifdef FREEBSD
2073 int
2074 sys_getdirentries(tcp)
2075 struct tcb * tcp;
2076 {
2077         int i, len, dents = 0;
2078         long basep;
2079         char *buf;
2080
2081         if (entering(tcp)) {
2082                 tprintf("%lu, ", tcp->u_arg[0]);
2083                 return 0;
2084         }
2085         if (syserror(tcp) || !verbose(tcp)) {
2086                 tprintf("%#lx, %lu, %#lx", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
2087                 return 0;
2088         }
2089         len = tcp->u_rval;
2090         if ((buf = malloc(len)) == NULL) {
2091                 tprintf("out of memory\n");
2092                 return 0;
2093         }
2094         if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
2095                 tprintf("{...}, %lu, %#lx", tcp->u_arg[2], tcp->u_arg[3]);
2096                 free(buf);
2097                 return 0;
2098         }
2099         if (!abbrev(tcp))
2100                 tprintf("{");
2101         for (i = 0; i < len;) {
2102                 struct kernel_dirent *d = (struct kernel_dirent *) &buf[i];
2103                 if (!abbrev(tcp)) {
2104                         tprintf("%s{d_fileno=%u, d_reclen=%u, d_type=",
2105                                 i ? " " : "", d->d_fileno, d->d_reclen);
2106                         printxval(direnttypes, d->d_type, "DT_???");
2107                         tprintf(", d_namlen=%u, d_name=\"%.*s\"}",
2108                                 d->d_namlen, d->d_namlen, d->d_name);
2109                 }
2110                 i += d->d_reclen;
2111                 dents++;
2112         }
2113         if (!abbrev(tcp))
2114                 tprintf("}");
2115         else
2116                 tprintf("/* %u entries */", dents);
2117         free(buf);
2118         tprintf(", %lu", tcp->u_arg[2]);
2119         if (umove(tcp, tcp->u_arg[3], &basep) < 0)
2120                 tprintf(", %#lx", tcp->u_arg[3]);
2121         else
2122                 tprintf(", [%lu]", basep);
2123         return 0;
2124 }
2125 #endif
2126
2127 #ifdef LINUX
2128 int
2129 sys_getcwd(tcp)
2130 struct tcb *tcp;
2131 {
2132     if (exiting(tcp)) {
2133         if (syserror(tcp))
2134             tprintf("%#lx", tcp->u_arg[0]);
2135         else
2136             printpathn(tcp, tcp->u_arg[0], tcp->u_rval - 1);
2137         tprintf(", %lu", tcp->u_arg[1]);
2138     }
2139     return 0;
2140 }
2141 #endif /* LINUX */
2142
2143 #ifdef FREEBSD
2144 int
2145 sys___getcwd(tcp)
2146 struct tcb *tcp;
2147 {
2148     if (exiting(tcp)) {
2149         if (syserror(tcp))
2150             tprintf("%#lx", tcp->u_arg[0]);
2151         else
2152             printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
2153         tprintf(", %lu", tcp->u_arg[1]);
2154     }
2155     return 0;
2156 }
2157 #endif
2158
2159 #ifdef HAVE_SYS_ASYNCH_H
2160
2161 int
2162 sys_aioread(tcp)
2163 struct tcb *tcp;
2164 {
2165         struct aio_result_t res;
2166
2167         if (entering(tcp)) {
2168                 tprintf("%lu, ", tcp->u_arg[0]);
2169         } else {
2170                 if (syserror(tcp))
2171                         tprintf("%#lx", tcp->u_arg[1]);
2172                 else
2173                         printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
2174                 tprintf(", %lu, %lu, ", tcp->u_arg[2], tcp->u_arg[3]);
2175                 printxval(whence, tcp->u_arg[4], "L_???");
2176                 if (syserror(tcp) || tcp->u_arg[5] == 0
2177                     || umove(tcp, tcp->u_arg[5], &res) < 0)
2178                         tprintf(", %#lx", tcp->u_arg[5]);
2179                 else
2180                         tprintf(", {aio_return %d aio_errno %d}",
2181                                 res.aio_return, res.aio_errno);
2182         }
2183         return 0;
2184 }
2185
2186 int
2187 sys_aiowrite(tcp)
2188 struct tcb *tcp;
2189 {
2190         struct aio_result_t res;
2191
2192         if (entering(tcp)) {
2193                 tprintf("%lu, ", tcp->u_arg[0]);
2194                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
2195                 tprintf(", %lu, %lu, ", tcp->u_arg[2], tcp->u_arg[3]);
2196                 printxval(whence, tcp->u_arg[4], "L_???");
2197         }
2198         else {
2199                 if (tcp->u_arg[5] == 0)
2200                         tprintf(", NULL");
2201                 else if (syserror(tcp)
2202                     || umove(tcp, tcp->u_arg[5], &res) < 0)
2203                         tprintf(", %#lx", tcp->u_arg[5]);
2204                 else
2205                         tprintf(", {aio_return %d aio_errno %d}",
2206                                 res.aio_return, res.aio_errno);
2207         }
2208         return 0;
2209 }
2210
2211 int
2212 sys_aiowait(tcp)
2213 struct tcb *tcp;
2214 {
2215         if (entering(tcp))
2216                 printtv(tcp, tcp->u_arg[0]);
2217         return 0;
2218 }
2219
2220 int
2221 sys_aiocancel(tcp)
2222 struct tcb *tcp;
2223 {
2224         struct aio_result_t res;
2225
2226         if (exiting(tcp)) {
2227                 if (tcp->u_arg[0] == 0)
2228                         tprintf("NULL");
2229                 else if (syserror(tcp)
2230                     || umove(tcp, tcp->u_arg[0], &res) < 0)
2231                         tprintf("%#lx", tcp->u_arg[0]);
2232                 else
2233                         tprintf("{aio_return %d aio_errno %d}",
2234                                 res.aio_return, res.aio_errno);
2235         }
2236         return 0;
2237 }
2238
2239 #endif /* HAVE_SYS_ASYNCH_H */
2240
2241 struct xlat xattrflags[] = {
2242 #ifdef XATTR_CREATE
2243         { XATTR_CREATE,  "XATTR_CREATE" },
2244         { XATTR_REPLACE, "XATTR_REPLACE" },
2245 #endif
2246         { 0,             NULL }
2247 };
2248
2249 int
2250 sys_setxattr(tcp)
2251 struct tcb *tcp;
2252 {
2253     if (entering(tcp)) {
2254         printpath(tcp, tcp->u_arg[0]);
2255         tprintf(", ");
2256         printstr(tcp, tcp->u_arg[1], -1);
2257         /* XXX Print value in format */
2258         tprintf(", %p, %ld, ", (void *) tcp->u_arg[2], tcp->u_arg[3]);
2259         printflags(xattrflags, tcp->u_arg[4]);
2260     }
2261     return 0;
2262 }
2263
2264 int
2265 sys_fsetxattr(tcp)
2266 struct tcb *tcp;
2267 {
2268     if (entering(tcp)) {
2269         tprintf("%ld, ", tcp->u_arg[0]);
2270         printstr(tcp, tcp->u_arg[1], -1);
2271         /* XXX Print value in format */
2272         tprintf(", %p, %ld, ", (void *) tcp->u_arg[2], tcp->u_arg[3]);
2273         printflags(xattrflags, tcp->u_arg[4]);
2274     }
2275     return 0;
2276 }
2277
2278 int
2279 sys_getxattr(tcp)
2280 struct tcb *tcp;
2281 {
2282     if (entering(tcp)) {
2283         printpath(tcp, tcp->u_arg[0]);
2284         tprintf(", ");
2285         printstr(tcp, tcp->u_arg[1], -1);
2286     } else {
2287         /* XXX Print value in format */
2288         tprintf(", %p, %ld", (void *) tcp->u_arg[2], tcp->u_arg[3]);
2289     }
2290     return 0;
2291 }
2292
2293 int
2294 sys_fgetxattr(tcp)
2295 struct tcb *tcp;
2296 {
2297     if (entering(tcp)) {
2298         tprintf("%ld, ", tcp->u_arg[0]);
2299         printstr(tcp, tcp->u_arg[1], -1);
2300     } else {
2301         /* XXX Print value in format */
2302         tprintf(", %p, %ld", (void *) tcp->u_arg[2], tcp->u_arg[3]);
2303     }
2304     return 0;
2305 }
2306
2307 int
2308 sys_listxattr(tcp)
2309 struct tcb *tcp;
2310 {
2311     if (entering(tcp)) {
2312         printpath(tcp, tcp->u_arg[0]);
2313     } else {
2314         /* XXX Print value in format */
2315         tprintf(", %p, %lu", (void *) tcp->u_arg[1], tcp->u_arg[2]);
2316     }
2317     return 0;
2318 }
2319
2320 int
2321 sys_flistxattr(tcp)
2322 struct tcb *tcp;
2323 {
2324     if (entering(tcp)) {
2325         tprintf("%ld", tcp->u_arg[0]);
2326     } else {
2327         /* XXX Print value in format */
2328         tprintf(", %p, %lu", (void *) tcp->u_arg[1], tcp->u_arg[2]);
2329     }
2330     return 0;
2331 }
2332
2333 int
2334 sys_removexattr(tcp)
2335 struct tcb *tcp;
2336 {
2337     if (entering(tcp)) {
2338         printpath(tcp, tcp->u_arg[0]);
2339         tprintf(", ");
2340         printstr(tcp, tcp->u_arg[1], -1);
2341     }
2342     return 0;
2343 }
2344
2345 int
2346 sys_fremovexattr(tcp)
2347 struct tcb *tcp;
2348 {
2349     if (entering(tcp)) {
2350         tprintf("%ld, ", tcp->u_arg[0]);
2351         printstr(tcp, tcp->u_arg[1], -1);
2352     }
2353     return 0;
2354 }