granicus.if.org Git - strace/blob - io.c

   1 /*
   2  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
   3  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
   4  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
   5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  *      $Id$
  31  */
  32
  33 #include "defs.h"
  34
  35 #include <fcntl.h>
  36 #if HAVE_SYS_UIO_H
  37 #include <sys/uio.h>
  38 #endif
  39
  40 #ifdef HAVE_LONG_LONG_OFF_T
  41 /*
  42  * Hacks for systems that have a long long off_t
  43  */
  44
  45 #define sys_pread64     sys_pread
  46 #define sys_pwrite64    sys_pwrite
  47 #endif
  48
  49 int
  50 sys_read(tcp)
  51 struct tcb *tcp;
  52 {
  53         if (entering(tcp)) {
  54                 tprintf("%ld, ", tcp->u_arg[0]);
  55         } else {
  56                 if (syserror(tcp))
  57                         tprintf("%#lx", tcp->u_arg[1]);
  58                 else
  59                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
  60                 tprintf(", %lu", tcp->u_arg[2]);
  61         }
  62         return 0;
  63 }
  64
  65 int
  66 sys_write(tcp)
  67 struct tcb *tcp;
  68 {
  69         if (entering(tcp)) {
  70                 tprintf("%ld, ", tcp->u_arg[0]);
  71                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
  72                 tprintf(", %lu", tcp->u_arg[2]);
  73         }
  74         return 0;
  75 }
  76
  77 #if HAVE_SYS_UIO_H
  78 void
  79 tprint_iov(tcp, len, addr)
  80 struct tcb * tcp;
  81 int len;
  82 long addr;
  83 {
  84         struct iovec *iov;
  85         int i;
  86
  87
  88         if (!len) {
  89                 tprintf("[]");
  90                 return;
  91         }
  92
  93         if ((iov = (struct iovec *) malloc(len * sizeof *iov)) == NULL) {
  94                 fprintf(stderr, "No memory");
  95                 return;
  96         }
  97         if (umoven(tcp, addr,
  98                    len * sizeof *iov, (char *) iov) < 0) {
  99                 tprintf("%#lx", tcp->u_arg[1]);
 100         } else {
 101                 tprintf("[");
 102                 for (i = 0; i < len; i++) {
 103                         if (i)
 104                                 tprintf(", ");
 105                         tprintf("{");
 106                         printstr(tcp, (long) iov[i].iov_base,
 107                                 iov[i].iov_len);
 108                         tprintf(", %lu}", (unsigned long)iov[i].iov_len);
 109                 }
 110                 tprintf("]");
 111         }
 112         free((char *) iov);
 113 }
 114
 115 int
 116 sys_readv(tcp)
 117 struct tcb *tcp;
 118 {
 119         if (entering(tcp)) {
 120                 tprintf("%ld, ", tcp->u_arg[0]);
 121         } else {
 122                 if (syserror(tcp)) {
 123                         tprintf("%#lx, %lu",
 124                                         tcp->u_arg[1], tcp->u_arg[2]);
 125                         return 0;
 126                 }
 127                 tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
 128                 tprintf(", %lu", tcp->u_arg[2]);
 129         }
 130         return 0;
 131 }
 132
 133 int
 134 sys_writev(tcp)
 135 struct tcb *tcp;
 136 {
 137         if (entering(tcp)) {
 138                 tprintf("%ld, ", tcp->u_arg[0]);
 139                 tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
 140                 tprintf(", %lu", tcp->u_arg[2]);
 141         }
 142         return 0;
 143 }
 144 #endif
 145
 146 #if defined(SVR4)
 147
 148 int
 149 sys_pread(tcp)
 150 struct tcb *tcp;
 151 {
 152         if (entering(tcp)) {
 153                 tprintf("%ld, ", tcp->u_arg[0]);
 154         } else {
 155                 if (syserror(tcp))
 156                         tprintf("%#lx", tcp->u_arg[1]);
 157                 else
 158                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 159 #if UNIXWARE
 160                 /* off_t is signed int */
 161                 tprintf(", %lu, %ld", tcp->u_arg[2], tcp->u_arg[3]);
 162 #else
 163                 tprintf(", %lu, %llu", tcp->u_arg[2],
 164                                 (((unsigned long long) tcp->u_arg[4]) << 32
 165                                  | (unsigned) tcp->u_arg[3]));
 166 #endif
 167         }
 168         return 0;
 169 }
 170
 171 int
 172 sys_pwrite(tcp)
 173 struct tcb *tcp;
 174 {
 175         if (entering(tcp)) {
 176                 tprintf("%ld, ", tcp->u_arg[0]);
 177                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 178 #if UNIXWARE
 179                 /* off_t is signed int */
 180                 tprintf(", %lu, %ld", tcp->u_arg[2], tcp->u_arg[3]);
 181 #else
 182                 tprintf(", %lu, %llu", tcp->u_arg[2],
 183                                 (((unsigned long long) tcp->u_arg[4]) << 32
 184                                  | (unsigned) tcp->u_arg[3]));
 185 #endif
 186         }
 187         return 0;
 188 }
 189 #endif /* SVR4 */
 190
 191 #ifdef FREEBSD
 192 #include <sys/types.h>
 193 #include <sys/socket.h>
 194
 195 int
 196 sys_sendfile(tcp)
 197 struct tcb *tcp;
 198 {
 199         if (entering(tcp)) {
 200                 tprintf("%ld, %ld, %llu, %lu", tcp->u_arg[0], tcp->u_arg[1],
 201                         (((unsigned long long) tcp->u_arg[3]) << 32 |
 202                          (unsigned) tcp->u_arg[2]), tcp->u_arg[4]);
 203         } else {
 204                 off_t offset;
 205
 206                 if (!tcp->u_arg[5])
 207                         tprintf(", NULL");
 208                 else {
 209                         struct sf_hdtr hdtr;
 210
 211                         if (umove(tcp, tcp->u_arg[5], &hdtr) < 0)
 212                                 tprintf(", %#lx", tcp->u_arg[5]);
 213                         else {
 214                                 tprintf(", { ");
 215                                 tprint_iov(tcp, hdtr.hdr_cnt, hdtr.headers);
 216                                 tprintf(", %u, ", hdtr.hdr_cnt);
 217                                 tprint_iov(tcp, hdtr.trl_cnt, hdtr.trailers);
 218                                 tprintf(", %u }", hdtr.hdr_cnt);
 219                         }
 220                 }
 221                 if (!tcp->u_arg[6])
 222                         tprintf(", NULL");
 223                 else if (umove(tcp, tcp->u_arg[6], &offset) < 0)
 224                         tprintf(", %#lx", tcp->u_arg[6]);
 225                 else
 226                         tprintf(", [%llu]", offset);
 227                 tprintf(", %lu", tcp->u_arg[7]);
 228         }
 229         return 0;
 230 }
 231 #endif /* FREEBSD */
 232
 233 #ifdef LINUX
 234
 235 /* The SH4 ABI does allow long longs in odd-numbered registers, but
 236    does not allow them to be split between registers and memory - and
 237    there are only four argument registers for normal functions.  As a
 238    result pread takes an extra padding argument before the offset.  This
 239    was changed late in the 2.4 series (around 2.4.20).  */
 240 #if defined(SH)
 241 #define PREAD_OFFSET_ARG 4
 242 #else
 243 #define PREAD_OFFSET_ARG 3
 244 #endif
 245
 246 int
 247 sys_pread(tcp)
 248 struct tcb *tcp;
 249 {
 250         if (entering(tcp)) {
 251                 tprintf("%ld, ", tcp->u_arg[0]);
 252         } else {
 253                 if (syserror(tcp))
 254                         tprintf("%#lx", tcp->u_arg[1]);
 255                 else
 256                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 257                 ALIGN64 (tcp, PREAD_OFFSET_ARG); /* PowerPC alignment restriction */
 258                 tprintf(", %lu, %llu", tcp->u_arg[2],
 259                         *(unsigned long long *)&tcp->u_arg[PREAD_OFFSET_ARG]);
 260         }
 261         return 0;
 262 }
 263
 264 int
 265 sys_pwrite(tcp)
 266 struct tcb *tcp;
 267 {
 268         if (entering(tcp)) {
 269                 tprintf("%ld, ", tcp->u_arg[0]);
 270                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 271                 ALIGN64 (tcp, PREAD_OFFSET_ARG); /* PowerPC alignment restriction */
 272                 tprintf(", %lu, %llu", tcp->u_arg[2],
 273                         *(unsigned long long *)&tcp->u_arg[PREAD_OFFSET_ARG]);
 274         }
 275         return 0;
 276 }
 277
 278 int
 279 sys_sendfile(tcp)
 280 struct tcb *tcp;
 281 {
 282         if (entering(tcp)) {
 283                 off_t offset;
 284
 285                 tprintf("%ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1]);
 286                 if (!tcp->u_arg[2])
 287                         tprintf("NULL");
 288                 else if (umove(tcp, tcp->u_arg[2], &offset) < 0)
 289                         tprintf("%#lx", tcp->u_arg[2]);
 290                 else
 291                         tprintf("[%lu]", offset);
 292                 tprintf(", %lu", tcp->u_arg[3]);
 293         }
 294         return 0;
 295 }
 296
 297 int
 298 sys_sendfile64(tcp)
 299 struct tcb *tcp;
 300 {
 301         if (entering(tcp)) {
 302                 loff_t offset;
 303
 304                 tprintf("%ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1]);
 305                 if (!tcp->u_arg[2])
 306                         tprintf("NULL");
 307                 else if (umove(tcp, tcp->u_arg[2], &offset) < 0)
 308                         tprintf("%#lx", tcp->u_arg[2]);
 309                 else
 310                         tprintf("[%llu]", (unsigned long long int) offset);
 311                 tprintf(", %lu", tcp->u_arg[3]);
 312         }
 313         return 0;
 314 }
 315
 316 #endif /* LINUX */
 317
 318 #if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
 319 int
 320 sys_pread64(tcp)
 321 struct tcb *tcp;
 322 {
 323         if (entering(tcp)) {
 324                 tprintf("%ld, ", tcp->u_arg[0]);
 325         } else {
 326                 ALIGN64 (tcp, 3);
 327                 if (syserror(tcp))
 328                         tprintf("%#lx", tcp->u_arg[1]);
 329                 else
 330                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 331                 tprintf(", %lu, %#llx", tcp->u_arg[2],
 332                         LONG_LONG(tcp->u_arg[3], tcp->u_arg[4]));
 333         }
 334         return 0;
 335 }
 336
 337 int
 338 sys_pwrite64(tcp)
 339 struct tcb *tcp;
 340 {
 341         if (entering(tcp)) {
 342                 ALIGN64 (tcp, 3);
 343                 tprintf("%ld, ", tcp->u_arg[0]);
 344                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 345                 tprintf(", %lu, %#llx", tcp->u_arg[2],
 346                         LONG_LONG(tcp->u_arg[3], tcp->u_arg[4]));
 347         }
 348         return 0;
 349 }
 350 #endif
 351
 352 int
 353 sys_ioctl(tcp)
 354 struct tcb *tcp;
 355 {
 356         char *symbol;
 357
 358         if (entering(tcp)) {
 359                 tprintf("%ld, ", tcp->u_arg[0]);
 360                 symbol = ioctl_lookup(tcp->u_arg[1]);
 361                 if (symbol)
 362                         tprintf("%s", symbol);
 363                 else
 364                         tprintf("%#lx", tcp->u_arg[1]);
 365                 ioctl_decode(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 366         }
 367         else {
 368                 int ret;
 369                 if (!(ret = ioctl_decode(tcp, tcp->u_arg[1], tcp->u_arg[2])))
 370                         tprintf(", %#lx", tcp->u_arg[2]);
 371                 else
 372                         return ret - 1;
 373         }
 374         return 0;
 375 }