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