granicus.if.org Git - strace/blob - aio.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 #ifdef HAVE_LIBAIO_H
  33 # include <libaio.h>
  34 #endif
  35
  36 /* Not defined in libaio.h */
  37 #ifndef IOCB_RESFD
  38 # define IOCB_RESFD (1 << 0)
  39 #endif
  40
  41 SYS_FUNC(io_setup)
  42 {
  43         if (entering(tcp))
  44                 tprintf("%ld, ", tcp->u_arg[0]);
  45         else {
  46                 if (syserror(tcp))
  47                         tprintf("0x%0lx", tcp->u_arg[1]);
  48                 else {
  49                         unsigned long user_id;
  50                         if (umove(tcp, tcp->u_arg[1], &user_id) == 0)
  51                                 tprintf("{%lu}", user_id);
  52                         else
  53                                 tprints("{...}");
  54                 }
  55         }
  56         return 0;
  57 }
  58
  59 SYS_FUNC(io_destroy)
  60 {
  61         if (entering(tcp))
  62                 tprintf("%lu", tcp->u_arg[0]);
  63         return 0;
  64 }
  65
  66 #ifdef HAVE_LIBAIO_H
  67
  68 enum iocb_sub {
  69         SUB_NONE, SUB_COMMON, SUB_POLL, SUB_VECTOR
  70 };
  71
  72 static enum iocb_sub
  73 tprint_lio_opcode(unsigned cmd)
  74 {
  75         static const struct {
  76                 const char *name;
  77                 enum iocb_sub sub;
  78         } cmds[] = {
  79                 { "pread", SUB_COMMON },
  80                 { "pwrite", SUB_COMMON },
  81                 { "fsync", SUB_NONE },
  82                 { "fdsync", SUB_NONE },
  83                 { "op4", SUB_NONE },
  84                 { "poll", SUB_POLL },
  85                 { "noop", SUB_NONE },
  86                 { "preadv", SUB_VECTOR },
  87                 { "pwritev", SUB_VECTOR },
  88         };
  89
  90         if (cmd < ARRAY_SIZE(cmds)) {
  91                 tprints(cmds[cmd].name);
  92                 return cmds[cmd].sub;
  93         }
  94         tprintf("%u /* SUB_??? */", cmd);
  95         return SUB_NONE;
  96 }
  97
  98 static void
  99 print_common_flags(struct iocb *iocb)
 100 {
 101 #if HAVE_STRUCT_IOCB_U_C_FLAGS
 102         if (iocb->u.c.flags & IOCB_RESFD)
 103                 tprintf(", resfd=%d", iocb->u.c.resfd);
 104         if (iocb->u.c.flags & ~IOCB_RESFD)
 105                 tprintf(", flags=%x", iocb->u.c.flags);
 106 #else
 107 # warning "libaio.h is too old => limited io_submit decoding"
 108 #endif
 109 }
 110
 111 #endif /* HAVE_LIBAIO_H */
 112
 113 SYS_FUNC(io_submit)
 114 {
 115         if (entering(tcp)) {
 116 #ifdef HAVE_LIBAIO_H
 117                 long nr = tcp->u_arg[1];
 118                 /* if nr <= 0, we end up printing just "{}" */
 119                 tprintf("%lu, %ld, {", tcp->u_arg[0], tcp->u_arg[1]);
 120                 {
 121                         long i;
 122                         struct iocb **iocbs = (void *)tcp->u_arg[2];
 123 //FIXME: decoding of 32-bit call by 64-bit strace
 124
 125                         for (i = 0; i < nr; i++, iocbs++) {
 126                                 enum iocb_sub sub;
 127                                 struct iocb *iocbp;
 128                                 struct iocb iocb;
 129                                 if (i)
 130                                         tprints(", ");
 131
 132                                 if (umove(tcp, (unsigned long)iocbs, &iocbp)) {
 133                                         tprintf("%#lx", (unsigned long)iocbs);
 134                                         /* No point in trying to read iocbs+1 etc */
 135                                         /* (nr can be ridiculously large): */
 136                                         break;
 137                                 }
 138                                 if (umove(tcp, (unsigned long)iocbp, &iocb)) {
 139                                         tprintf("{%#lx}", (unsigned long)iocbp);
 140                                         continue;
 141                                 }
 142                                 tprints("{");
 143                                 if (iocb.data)
 144                                         tprintf("data:%p, ", iocb.data);
 145                                 if (iocb.key)
 146                                         tprintf("key:%u, ", iocb.key);
 147                                 sub = tprint_lio_opcode(iocb.aio_lio_opcode);
 148                                 if (iocb.aio_reqprio)
 149                                         tprintf(", reqprio:%d", iocb.aio_reqprio);
 150                                 tprintf(", filedes:%d", iocb.aio_fildes);
 151                                 switch (sub) {
 152                                 case SUB_COMMON:
 153 #if HAVE_DECL_IO_CMD_PWRITE
 154                                         if (iocb.aio_lio_opcode == IO_CMD_PWRITE) {
 155                                                 tprints(", str:");
 156                                                 printstr(tcp, (unsigned long)iocb.u.c.buf,
 157                                                          iocb.u.c.nbytes);
 158                                         } else
 159 #endif
 160                                                 tprintf(", buf:%p", iocb.u.c.buf);
 161                                         tprintf(", nbytes:%lu, offset:%lld",
 162                                                 iocb.u.c.nbytes,
 163                                                 iocb.u.c.offset);
 164                                         print_common_flags(&iocb);
 165                                         break;
 166                                 case SUB_VECTOR:
 167                                         tprintf(", %lld", iocb.u.v.offset);
 168                                         print_common_flags(&iocb);
 169                                         tprints(", ");
 170                                         tprint_iov(tcp, iocb.u.v.nr,
 171                                                    (unsigned long)iocb.u.v.vec,
 172 #if HAVE_DECL_IO_CMD_PWRITEV
 173                                                    iocb.aio_lio_opcode == IO_CMD_PWRITEV
 174 #else
 175                                                    0
 176 #endif
 177                                                   );
 178                                         break;
 179                                 case SUB_POLL:
 180                                         tprintf(", %x", iocb.u.poll.events);
 181                                         break;
 182                                 case SUB_NONE:
 183                                         break;
 184                                 }
 185                                 tprints("}");
 186                         }
 187                 }
 188                 tprints("}");
 189 #else
 190 # warning "libaio.h is not available => no io_submit decoding"
 191                 tprintf("%lu, %ld, %#lx", tcp->u_arg[0], tcp->u_arg[1], tcp->u_arg[2]);
 192 #endif
 193         }
 194         return 0;
 195 }
 196
 197 SYS_FUNC(io_cancel)
 198 {
 199         if (entering(tcp)) {
 200 #ifdef HAVE_LIBAIO_H
 201                 struct iocb iocb;
 202 #endif
 203                 tprintf("%lu, ", tcp->u_arg[0]);
 204 #ifdef HAVE_LIBAIO_H
 205                 if (umove(tcp, tcp->u_arg[1], &iocb) == 0) {
 206                         tprintf("{%p, %u, %u, %u, %d}, ",
 207                                 iocb.data, iocb.key,
 208                                 (unsigned)iocb.aio_lio_opcode,
 209                                 (unsigned)iocb.aio_reqprio, iocb.aio_fildes);
 210                 } else
 211 #endif
 212                         tprints("{...}, ");
 213         } else {
 214                 if (tcp->u_rval < 0)
 215                         tprints("{...}");
 216                 else {
 217 #ifdef HAVE_LIBAIO_H
 218                         struct io_event event;
 219                         if (umove(tcp, tcp->u_arg[2], &event) == 0)
 220                                 tprintf("{%p, %p, %ld, %ld}",
 221                                         event.data, event.obj,
 222                                         event.res, event.res2);
 223                         else
 224 #endif
 225                                 tprints("{...}");
 226                 }
 227         }
 228         return 0;
 229 }
 230
 231 SYS_FUNC(io_getevents)
 232 {
 233         if (entering(tcp)) {
 234                 tprintf("%ld, %ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1],
 235                         tcp->u_arg[2]);
 236         } else {
 237                 if (tcp->u_rval == 0) {
 238                         tprints("{}");
 239                 } else {
 240 #ifdef HAVE_LIBAIO_H
 241                         struct io_event *events = (void *)tcp->u_arg[3];
 242                         long i, nr = tcp->u_rval;
 243
 244                         for (i = 0; i < nr; i++, events++) {
 245                                 struct io_event event;
 246
 247                                 if (i == 0)
 248                                         tprints("{");
 249                                 else
 250                                         tprints(", ");
 251
 252                                 if (umove(tcp, (unsigned long)events, &event) != 0) {
 253                                         tprints("{...}");
 254                                         continue;
 255                                 }
 256                                 tprintf("{%p, %p, %ld, %ld}", event.data,
 257                                         event.obj, event.res, event.res2);
 258                         }
 259                         tprints("}, ");
 260 #else
 261                         tprints("{...}");
 262 #endif
 263                 }
 264
 265                 print_timespec(tcp, tcp->u_arg[4]);
 266         }
 267         return 0;
 268 }