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
  31 #include "defs.h"
  32 #include <fcntl.h>
  33 #include <sys/uio.h>
  34
  35 SYS_FUNC(read)
  36 {
  37         if (entering(tcp)) {
  38                 printfd(tcp, tcp->u_arg[0]);
  39                 tprints(", ");
  40         } else {
  41                 if (syserror(tcp))
  42                         printaddr(tcp->u_arg[1]);
  43                 else
  44                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
  45                 tprintf(", %lu", tcp->u_arg[2]);
  46         }
  47         return 0;
  48 }
  49
  50 SYS_FUNC(write)
  51 {
  52         printfd(tcp, tcp->u_arg[0]);
  53         tprints(", ");
  54         printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
  55         tprintf(", %lu", tcp->u_arg[2]);
  56
  57         return RVAL_DECODED;
  58 }
  59
  60 struct print_iovec_config {
  61         enum iov_decode decode_iov;
  62         unsigned long data_size;
  63 };
  64
  65 static bool
  66 print_iovec(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
  67 {
  68         const unsigned long *iov;
  69         unsigned long iov_buf[2], len;
  70         struct print_iovec_config *c = data;
  71
  72         if (elem_size < sizeof(iov_buf)) {
  73                 iov_buf[0] = ((unsigned int *) elem_buf)[0];
  74                 iov_buf[1] = ((unsigned int *) elem_buf)[1];
  75                 iov = iov_buf;
  76         } else {
  77                 iov = elem_buf;
  78         }
  79
  80         tprints("{");
  81
  82         len = iov[1];
  83
  84         switch (c->decode_iov) {
  85                 case IOV_DECODE_STR:
  86                         if (len > c->data_size)
  87                                 len = c->data_size;
  88                         c->data_size -= len;
  89                         printstr(tcp, iov[0], len);
  90                         break;
  91                 default:
  92                         printaddr(iov[0]);
  93                         break;
  94         }
  95
  96         tprintf(", %lu}", iov[1]);
  97
  98         return true;
  99 }
 100
 101 /*
 102  * data_size limits the cumulative size of printed data.
 103  * Example: recvmsg returing a short read.
 104  */
 105 void
 106 tprint_iov_upto(struct tcb *tcp, unsigned long len, unsigned long addr,
 107                 enum iov_decode decode_iov, unsigned long data_size)
 108 {
 109         unsigned long iov[2];
 110         struct print_iovec_config config =
 111                 { .decode_iov = decode_iov, .data_size = data_size };
 112
 113         print_array(tcp, addr, len, iov, current_wordsize * 2,
 114                     umoven_or_printaddr, print_iovec, &config);
 115 }
 116
 117 void
 118 tprint_iov(struct tcb *tcp, unsigned long len, unsigned long addr,
 119            enum iov_decode decode_iov)
 120 {
 121         tprint_iov_upto(tcp, len, addr, decode_iov, (unsigned long) -1L);
 122 }
 123
 124 SYS_FUNC(readv)
 125 {
 126         if (entering(tcp)) {
 127                 printfd(tcp, tcp->u_arg[0]);
 128                 tprints(", ");
 129         } else {
 130                 tprint_iov_upto(tcp, tcp->u_arg[2], tcp->u_arg[1],
 131                                 IOV_DECODE_STR, tcp->u_rval);
 132                 tprintf(", %lu", tcp->u_arg[2]);
 133         }
 134         return 0;
 135 }
 136
 137 SYS_FUNC(writev)
 138 {
 139         printfd(tcp, tcp->u_arg[0]);
 140         tprints(", ");
 141         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], IOV_DECODE_STR);
 142         tprintf(", %lu", tcp->u_arg[2]);
 143
 144         return RVAL_DECODED;
 145 }
 146
 147 /* The SH4 ABI does allow long longs in odd-numbered registers, but
 148    does not allow them to be split between registers and memory - and
 149    there are only four argument registers for normal functions.  As a
 150    result pread takes an extra padding argument before the offset.  This
 151    was changed late in the 2.4 series (around 2.4.20).  */
 152 #if defined(SH)
 153 #define PREAD_OFFSET_ARG 4
 154 #else
 155 #define PREAD_OFFSET_ARG 3
 156 #endif
 157
 158 SYS_FUNC(pread)
 159 {
 160         if (entering(tcp)) {
 161                 printfd(tcp, tcp->u_arg[0]);
 162                 tprints(", ");
 163         } else {
 164                 if (syserror(tcp))
 165                         printaddr(tcp->u_arg[1]);
 166                 else
 167                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 168                 tprintf(", %lu, ", tcp->u_arg[2]);
 169                 printllval(tcp, "%lld", PREAD_OFFSET_ARG);
 170         }
 171         return 0;
 172 }
 173
 174 SYS_FUNC(pwrite)
 175 {
 176         printfd(tcp, tcp->u_arg[0]);
 177         tprints(", ");
 178         printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 179         tprintf(", %lu, ", tcp->u_arg[2]);
 180         printllval(tcp, "%lld", PREAD_OFFSET_ARG);
 181
 182         return RVAL_DECODED;
 183 }
 184
 185 static void
 186 print_lld_from_low_high_val(struct tcb *tcp, int arg)
 187 {
 188 #if SIZEOF_LONG > 4 && SIZEOF_LONG == SIZEOF_LONG_LONG
 189 # if SUPPORTED_PERSONALITIES > 1
 190 #  ifdef X86_64
 191         if (current_personality != 1)
 192 #  else
 193         if (current_wordsize == sizeof(long))
 194 #  endif
 195 # endif
 196                 tprintf("%ld", tcp->u_arg[arg]);
 197 # if SUPPORTED_PERSONALITIES > 1
 198         else
 199                 tprintf("%ld",
 200                         ((unsigned long) tcp->u_arg[arg + 1] << current_wordsize * 8)
 201                         | (unsigned long) tcp->u_arg[arg]);
 202 # endif
 203 #elif SIZEOF_LONG > 4
 204 # error Unsupported configuration: SIZEOF_LONG > 4 && SIZEOF_LONG_LONG > SIZEOF_LONG
 205 #elif HAVE_STRUCT_TCB_EXT_ARG
 206 # if SUPPORTED_PERSONALITIES > 1
 207         if (current_personality == 1) {
 208                 tprintf("%lld",
 209                         (widen_to_ull(tcp->u_arg[arg + 1]) << sizeof(long) * 8)
 210                         | widen_to_ull(tcp->u_arg[arg]));
 211         } else
 212 # endif
 213         {
 214                 tprintf("%lld", tcp->ext_arg[arg]);
 215         }
 216 #else /* SIZEOF_LONG_LONG > SIZEOF_LONG && !HAVE_STRUCT_TCB_EXT_ARG */
 217         tprintf("%lld",
 218                 (widen_to_ull(tcp->u_arg[arg + 1]) << sizeof(long) * 8)
 219                 | widen_to_ull(tcp->u_arg[arg]));
 220 #endif
 221 }
 222
 223 #include "xlat/rwf_flags.h"
 224
 225 static int
 226 do_preadv(struct tcb *tcp, const int flags_arg)
 227 {
 228         if (entering(tcp)) {
 229                 printfd(tcp, tcp->u_arg[0]);
 230                 tprints(", ");
 231         } else {
 232                 tprint_iov_upto(tcp, tcp->u_arg[2], tcp->u_arg[1], IOV_DECODE_STR,
 233                                 tcp->u_rval);
 234                 tprintf(", %lu, ", tcp->u_arg[2]);
 235                 print_lld_from_low_high_val(tcp, 3);
 236                 if (flags_arg >= 0) {
 237                         tprints(", ");
 238                         printflags(rwf_flags, tcp->u_arg[flags_arg], "RWF_???");
 239                 }
 240         }
 241         return 0;
 242 }
 243
 244 SYS_FUNC(preadv)
 245 {
 246         return do_preadv(tcp, -1);
 247 }
 248
 249 SYS_FUNC(preadv2)
 250 {
 251         return do_preadv(tcp, 5);
 252 }
 253
 254 static int
 255 do_pwritev(struct tcb *tcp, const int flags_arg)
 256 {
 257         printfd(tcp, tcp->u_arg[0]);
 258         tprints(", ");
 259         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], IOV_DECODE_STR);
 260         tprintf(", %lu, ", tcp->u_arg[2]);
 261         print_lld_from_low_high_val(tcp, 3);
 262         if (flags_arg >= 0) {
 263                 tprints(", ");
 264                 printflags(rwf_flags, tcp->u_arg[flags_arg], "RWF_???");
 265         }
 266
 267         return RVAL_DECODED;
 268 }
 269
 270 SYS_FUNC(pwritev)
 271 {
 272         return do_pwritev(tcp, -1);
 273 }
 274
 275 SYS_FUNC(pwritev2)
 276 {
 277         return do_pwritev(tcp, 5);
 278 }
 279
 280 #include "xlat/splice_flags.h"
 281
 282 SYS_FUNC(tee)
 283 {
 284         /* int fd_in */
 285         printfd(tcp, tcp->u_arg[0]);
 286         tprints(", ");
 287         /* int fd_out */
 288         printfd(tcp, tcp->u_arg[1]);
 289         tprints(", ");
 290         /* size_t len */
 291         tprintf("%lu, ", tcp->u_arg[2]);
 292         /* unsigned int flags */
 293         printflags(splice_flags, tcp->u_arg[3], "SPLICE_F_???");
 294
 295         return RVAL_DECODED;
 296 }
 297
 298 SYS_FUNC(splice)
 299 {
 300         /* int fd_in */
 301         printfd(tcp, tcp->u_arg[0]);
 302         tprints(", ");
 303         /* loff_t *off_in */
 304         printnum_int64(tcp, tcp->u_arg[1], "%" PRId64);
 305         tprints(", ");
 306         /* int fd_out */
 307         printfd(tcp, tcp->u_arg[2]);
 308         tprints(", ");
 309         /* loff_t *off_out */
 310         printnum_int64(tcp, tcp->u_arg[3], "%" PRId64);
 311         tprints(", ");
 312         /* size_t len */
 313         tprintf("%lu, ", tcp->u_arg[4]);
 314         /* unsigned int flags */
 315         printflags(splice_flags, tcp->u_arg[5], "SPLICE_F_???");
 316
 317         return RVAL_DECODED;
 318 }
 319
 320 SYS_FUNC(vmsplice)
 321 {
 322         /* int fd */
 323         printfd(tcp, tcp->u_arg[0]);
 324         tprints(", ");
 325         /* const struct iovec *iov, unsigned long nr_segs */
 326         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], IOV_DECODE_STR);
 327         tprintf(", %lu, ", tcp->u_arg[2]);
 328         /* unsigned int flags */
 329         printflags(splice_flags, tcp->u_arg[3], "SPLICE_F_???");
 330
 331         return RVAL_DECODED;
 332 }