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