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         int 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];
  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         if (c->decode_iov) {
  83                 unsigned long len = iov[1];
  84                 if (len > c->data_size)
  85                         len = c->data_size;
  86                 c->data_size -= len;
  87                 printstr(tcp, iov[0], len);
  88         } else {
  89                 printaddr(iov[0]);
  90         }
  91
  92         tprintf(", %lu}", iov[1]);
  93
  94         return true;
  95 }
  96
  97 /*
  98  * data_size limits the cumulative size of printed data.
  99  * Example: recvmsg returing a short read.
 100  */
 101 void
 102 tprint_iov_upto(struct tcb *tcp, unsigned long len, unsigned long addr,
 103                 int decode_iov, unsigned long data_size)
 104 {
 105         unsigned long iov[2];
 106         struct print_iovec_config config =
 107                 { .decode_iov = decode_iov, .data_size = data_size };
 108
 109         print_array(tcp, addr, len, iov, current_wordsize * 2,
 110                     umoven_or_printaddr, print_iovec, &config);
 111 }
 112
 113 void
 114 tprint_iov(struct tcb *tcp, unsigned long len, unsigned long addr, int decode_iov)
 115 {
 116         tprint_iov_upto(tcp, len, addr, decode_iov, (unsigned long) -1L);
 117 }
 118
 119 SYS_FUNC(readv)
 120 {
 121         if (entering(tcp)) {
 122                 printfd(tcp, tcp->u_arg[0]);
 123                 tprints(", ");
 124         } else {
 125                 tprint_iov_upto(tcp, tcp->u_arg[2], tcp->u_arg[1], 1,
 126                                 tcp->u_rval);
 127                 tprintf(", %lu", tcp->u_arg[2]);
 128         }
 129         return 0;
 130 }
 131
 132 SYS_FUNC(writev)
 133 {
 134         printfd(tcp, tcp->u_arg[0]);
 135         tprints(", ");
 136         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], 1);
 137         tprintf(", %lu", tcp->u_arg[2]);
 138
 139         return RVAL_DECODED;
 140 }
 141
 142 /* The SH4 ABI does allow long longs in odd-numbered registers, but
 143    does not allow them to be split between registers and memory - and
 144    there are only four argument registers for normal functions.  As a
 145    result pread takes an extra padding argument before the offset.  This
 146    was changed late in the 2.4 series (around 2.4.20).  */
 147 #if defined(SH)
 148 #define PREAD_OFFSET_ARG 4
 149 #else
 150 #define PREAD_OFFSET_ARG 3
 151 #endif
 152
 153 SYS_FUNC(pread)
 154 {
 155         if (entering(tcp)) {
 156                 printfd(tcp, tcp->u_arg[0]);
 157                 tprints(", ");
 158         } else {
 159                 if (syserror(tcp))
 160                         printaddr(tcp->u_arg[1]);
 161                 else
 162                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 163                 tprintf(", %lu, ", tcp->u_arg[2]);
 164                 printllval(tcp, "%lld", PREAD_OFFSET_ARG);
 165         }
 166         return 0;
 167 }
 168
 169 SYS_FUNC(pwrite)
 170 {
 171         printfd(tcp, tcp->u_arg[0]);
 172         tprints(", ");
 173         printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 174         tprintf(", %lu, ", tcp->u_arg[2]);
 175         printllval(tcp, "%lld", PREAD_OFFSET_ARG);
 176
 177         return RVAL_DECODED;
 178 }
 179
 180 static void
 181 print_lld_from_low_high_val(struct tcb *tcp, int arg)
 182 {
 183 #if SIZEOF_LONG == SIZEOF_LONG_LONG
 184 # if SUPPORTED_PERSONALITIES > 1
 185 #  ifdef X86_64
 186         if (current_personality != 1)
 187 #  else
 188         if (current_wordsize == sizeof(long))
 189 #  endif
 190 # endif
 191                 tprintf("%ld", tcp->u_arg[arg]);
 192 # if SUPPORTED_PERSONALITIES > 1
 193         else
 194                 tprintf("%ld",
 195                         ((unsigned long) tcp->u_arg[arg + 1] << current_wordsize * 8)
 196                         | (unsigned long) tcp->u_arg[arg]);
 197 # endif
 198 #else
 199 # ifdef X32
 200         if (current_personality == 0)
 201                 tprintf("%lld", tcp->ext_arg[arg]);
 202         else
 203 # endif
 204         tprintf("%lld",
 205                 ((unsigned long long) (unsigned long) tcp->u_arg[arg + 1] << sizeof(long) * 8)
 206                 | (unsigned long long) (unsigned long) tcp->u_arg[arg]);
 207 #endif
 208 }
 209
 210 SYS_FUNC(preadv)
 211 {
 212         if (entering(tcp)) {
 213                 printfd(tcp, tcp->u_arg[0]);
 214                 tprints(", ");
 215         } else {
 216                 tprint_iov_upto(tcp, tcp->u_arg[2], tcp->u_arg[1], 1,
 217                                 tcp->u_rval);
 218                 tprintf(", %lu, ", tcp->u_arg[2]);
 219                 print_lld_from_low_high_val(tcp, 3);
 220         }
 221         return 0;
 222 }
 223
 224 SYS_FUNC(pwritev)
 225 {
 226         printfd(tcp, tcp->u_arg[0]);
 227         tprints(", ");
 228         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], 1);
 229         tprintf(", %lu, ", tcp->u_arg[2]);
 230         print_lld_from_low_high_val(tcp, 3);
 231
 232         return RVAL_DECODED;
 233 }
 234
 235 #include "xlat/splice_flags.h"
 236
 237 SYS_FUNC(tee)
 238 {
 239         /* int fd_in */
 240         printfd(tcp, tcp->u_arg[0]);
 241         tprints(", ");
 242         /* int fd_out */
 243         printfd(tcp, tcp->u_arg[1]);
 244         tprints(", ");
 245         /* size_t len */
 246         tprintf("%lu, ", tcp->u_arg[2]);
 247         /* unsigned int flags */
 248         printflags(splice_flags, tcp->u_arg[3], "SPLICE_F_???");
 249
 250         return RVAL_DECODED;
 251 }
 252
 253 SYS_FUNC(splice)
 254 {
 255         /* int fd_in */
 256         printfd(tcp, tcp->u_arg[0]);
 257         tprints(", ");
 258         /* loff_t *off_in */
 259         printnum_int64(tcp, tcp->u_arg[1], "%" PRId64);
 260         tprints(", ");
 261         /* int fd_out */
 262         printfd(tcp, tcp->u_arg[2]);
 263         tprints(", ");
 264         /* loff_t *off_out */
 265         printnum_int64(tcp, tcp->u_arg[3], "%" PRId64);
 266         tprints(", ");
 267         /* size_t len */
 268         tprintf("%lu, ", tcp->u_arg[4]);
 269         /* unsigned int flags */
 270         printflags(splice_flags, tcp->u_arg[5], "SPLICE_F_???");
 271
 272         return RVAL_DECODED;
 273 }
 274
 275 SYS_FUNC(vmsplice)
 276 {
 277         /* int fd */
 278         printfd(tcp, tcp->u_arg[0]);
 279         tprints(", ");
 280         /* const struct iovec *iov, unsigned long nr_segs */
 281         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], 1);
 282         tprintf(", %lu, ", tcp->u_arg[2]);
 283         /* unsigned int flags */
 284         printflags(splice_flags, tcp->u_arg[3], "SPLICE_F_???");
 285
 286         return RVAL_DECODED;
 287 }