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