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