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