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("{iov_base=");
  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                         if (c->data_size != -1UL)
  89                                 c->data_size -= len;
  90                         printstr(tcp, iov[0], len);
  91                         break;
  92                 case IOV_DECODE_NETLINK:
  93                         if (len > c->data_size)
  94                                 len = c->data_size;
  95                         if (c->data_size != -1UL)
  96                                 c->data_size -= len;
  97                         decode_netlink(tcp, iov[0], iov[1]);
  98                         break;
  99                 default:
 100                         printaddr(iov[0]);
 101                         break;
 102         }
 103
 104         tprintf(", iov_len=%lu}", iov[1]);
 105
 106         return true;
 107 }
 108
 109 /*
 110  * data_size limits the cumulative size of printed data.
 111  * Example: recvmsg returing a short read.
 112  */
 113 void
 114 tprint_iov_upto(struct tcb *tcp, unsigned long len, unsigned long addr,
 115                 enum iov_decode decode_iov, unsigned long data_size)
 116 {
 117         unsigned long iov[2];
 118         struct print_iovec_config config =
 119                 { .decode_iov = decode_iov, .data_size = data_size };
 120
 121         print_array(tcp, addr, len, iov, current_wordsize * 2,
 122                     umoven_or_printaddr_ignore_syserror, print_iovec, &config);
 123 }
 124
 125 void
 126 tprint_iov(struct tcb *tcp, unsigned long len, unsigned long addr,
 127            enum iov_decode decode_iov)
 128 {
 129         tprint_iov_upto(tcp, len, addr, decode_iov, -1UL);
 130 }
 131
 132 SYS_FUNC(readv)
 133 {
 134         if (entering(tcp)) {
 135                 printfd(tcp, tcp->u_arg[0]);
 136                 tprints(", ");
 137         } else {
 138                 tprint_iov_upto(tcp, tcp->u_arg[2], tcp->u_arg[1],
 139                                 syserror(tcp) ? IOV_DECODE_ADDR :
 140                                 IOV_DECODE_STR, tcp->u_rval);
 141                 tprintf(", %lu", tcp->u_arg[2]);
 142         }
 143         return 0;
 144 }
 145
 146 SYS_FUNC(writev)
 147 {
 148         printfd(tcp, tcp->u_arg[0]);
 149         tprints(", ");
 150         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], IOV_DECODE_STR);
 151         tprintf(", %lu", tcp->u_arg[2]);
 152
 153         return RVAL_DECODED;
 154 }
 155
 156 SYS_FUNC(pread)
 157 {
 158         if (entering(tcp)) {
 159                 printfd(tcp, tcp->u_arg[0]);
 160                 tprints(", ");
 161         } else {
 162                 if (syserror(tcp))
 163                         printaddr(tcp->u_arg[1]);
 164                 else
 165                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 166                 tprintf(", %lu, ", tcp->u_arg[2]);
 167                 printllval(tcp, "%lld", 3);
 168         }
 169         return 0;
 170 }
 171
 172 SYS_FUNC(pwrite)
 173 {
 174         printfd(tcp, tcp->u_arg[0]);
 175         tprints(", ");
 176         printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 177         tprintf(", %lu, ", tcp->u_arg[2]);
 178         printllval(tcp, "%lld", 3);
 179
 180         return RVAL_DECODED;
 181 }
 182
 183 static void
 184 print_lld_from_low_high_val(struct tcb *tcp, int arg)
 185 {
 186 #if SIZEOF_LONG > 4 && SIZEOF_LONG == SIZEOF_LONG_LONG
 187 # if SUPPORTED_PERSONALITIES > 1
 188 #  ifdef X86_64
 189         if (current_personality != 1)
 190 #  else
 191         if (current_wordsize == sizeof(long))
 192 #  endif
 193 # endif
 194                 tprintf("%ld", tcp->u_arg[arg]);
 195 # if SUPPORTED_PERSONALITIES > 1
 196         else
 197                 tprintf("%ld",
 198                         ((unsigned long) tcp->u_arg[arg + 1] << current_wordsize * 8)
 199                         | (unsigned long) tcp->u_arg[arg]);
 200 # endif
 201 #elif SIZEOF_LONG > 4
 202 # error Unsupported configuration: SIZEOF_LONG > 4 && SIZEOF_LONG_LONG > SIZEOF_LONG
 203 #elif HAVE_STRUCT_TCB_EXT_ARG
 204 # if SUPPORTED_PERSONALITIES > 1
 205         if (current_personality == 1) {
 206                 tprintf("%lld",
 207                         (zero_extend_signed_to_ull(tcp->u_arg[arg + 1]) << sizeof(long) * 8)
 208                         | zero_extend_signed_to_ull(tcp->u_arg[arg]));
 209         } else
 210 # endif
 211         {
 212                 tprintf("%lld", tcp->ext_arg[arg]);
 213         }
 214 #else /* SIZEOF_LONG_LONG > SIZEOF_LONG && !HAVE_STRUCT_TCB_EXT_ARG */
 215         tprintf("%lld",
 216                 (zero_extend_signed_to_ull(tcp->u_arg[arg + 1]) << sizeof(long) * 8)
 217                 | zero_extend_signed_to_ull(tcp->u_arg[arg]));
 218 #endif
 219 }
 220
 221 #include "xlat/rwf_flags.h"
 222
 223 static int
 224 do_preadv(struct tcb *tcp, const int flags_arg)
 225 {
 226         if (entering(tcp)) {
 227                 printfd(tcp, tcp->u_arg[0]);
 228                 tprints(", ");
 229         } else {
 230                 tprint_iov_upto(tcp, tcp->u_arg[2], tcp->u_arg[1],
 231                                 syserror(tcp) ? IOV_DECODE_ADDR :
 232                                 IOV_DECODE_STR, tcp->u_rval);
 233                 tprintf(", %lu, ", tcp->u_arg[2]);
 234                 print_lld_from_low_high_val(tcp, 3);
 235                 if (flags_arg >= 0) {
 236                         tprints(", ");
 237                         printflags(rwf_flags, tcp->u_arg[flags_arg], "RWF_???");
 238                 }
 239         }
 240         return 0;
 241 }
 242
 243 SYS_FUNC(preadv)
 244 {
 245         return do_preadv(tcp, -1);
 246 }
 247
 248 SYS_FUNC(preadv2)
 249 {
 250         return do_preadv(tcp, 5);
 251 }
 252
 253 static int
 254 do_pwritev(struct tcb *tcp, const int flags_arg)
 255 {
 256         printfd(tcp, tcp->u_arg[0]);
 257         tprints(", ");
 258         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], IOV_DECODE_STR);
 259         tprintf(", %lu, ", tcp->u_arg[2]);
 260         print_lld_from_low_high_val(tcp, 3);
 261         if (flags_arg >= 0) {
 262                 tprints(", ");
 263                 printflags(rwf_flags, tcp->u_arg[flags_arg], "RWF_???");
 264         }
 265
 266         return RVAL_DECODED;
 267 }
 268
 269 SYS_FUNC(pwritev)
 270 {
 271         return do_pwritev(tcp, -1);
 272 }
 273
 274 SYS_FUNC(pwritev2)
 275 {
 276         return do_pwritev(tcp, 5);
 277 }
 278
 279 #include "xlat/splice_flags.h"
 280
 281 SYS_FUNC(tee)
 282 {
 283         /* int fd_in */
 284         printfd(tcp, tcp->u_arg[0]);
 285         tprints(", ");
 286         /* int fd_out */
 287         printfd(tcp, tcp->u_arg[1]);
 288         tprints(", ");
 289         /* size_t len */
 290         tprintf("%lu, ", tcp->u_arg[2]);
 291         /* unsigned int flags */
 292         printflags(splice_flags, tcp->u_arg[3], "SPLICE_F_???");
 293
 294         return RVAL_DECODED;
 295 }
 296
 297 SYS_FUNC(splice)
 298 {
 299         /* int fd_in */
 300         printfd(tcp, tcp->u_arg[0]);
 301         tprints(", ");
 302         /* loff_t *off_in */
 303         printnum_int64(tcp, tcp->u_arg[1], "%" PRId64);
 304         tprints(", ");
 305         /* int fd_out */
 306         printfd(tcp, tcp->u_arg[2]);
 307         tprints(", ");
 308         /* loff_t *off_out */
 309         printnum_int64(tcp, tcp->u_arg[3], "%" PRId64);
 310         tprints(", ");
 311         /* size_t len */
 312         tprintf("%lu, ", tcp->u_arg[4]);
 313         /* unsigned int flags */
 314         printflags(splice_flags, tcp->u_arg[5], "SPLICE_F_???");
 315
 316         return RVAL_DECODED;
 317 }
 318
 319 SYS_FUNC(vmsplice)
 320 {
 321         /* int fd */
 322         printfd(tcp, tcp->u_arg[0]);
 323         tprints(", ");
 324         /* const struct iovec *iov, unsigned long nr_segs */
 325         tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], IOV_DECODE_STR);
 326         tprintf(", %lu, ", tcp->u_arg[2]);
 327         /* unsigned int flags */
 328         printflags(splice_flags, tcp->u_arg[3], "SPLICE_F_???");
 329
 330         return RVAL_DECODED;
 331 }