| /* |
| * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl> |
| * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl> |
| * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com> |
| * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl> |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "defs.h" |
| |
| /* --- Copied from libaio-0.3.109/src/libaio.h --- |
| * Why keep a copy instead of using external libaio.h? |
| * Because we want to properly decode 32-bit aio calls |
| * by 64-bit strace. For that, we need more definitions than |
| * libaio.h provides. (TODO). |
| * Keeping our local 32-bit compat defs in sync with libaio.h |
| * _without seeing libaio structs_ is hard/more bug-prone. |
| * A smaller benefit is that we don't need libaio installed. |
| */ |
| #define HAVE_LIBAIO_H 1 |
| typedef enum io_iocb_cmd { |
| IO_CMD_PREAD = 0, |
| IO_CMD_PWRITE = 1, |
| |
| IO_CMD_FSYNC = 2, |
| IO_CMD_FDSYNC = 3, |
| |
| IO_CMD_POLL = 5, /* Never implemented in mainline, see io_prep_poll */ |
| IO_CMD_NOOP = 6, |
| IO_CMD_PREADV = 7, |
| IO_CMD_PWRITEV = 8, |
| } io_iocb_cmd_t; |
| |
| #if defined(__i386__) /* little endian, 32 bits */ |
| #define PADDED(x, y) x; unsigned y |
| #define PADDEDptr(x, y) x; unsigned y |
| #define PADDEDul(x, y) unsigned long x; unsigned y |
| #elif defined(__ia64__) || defined(__x86_64__) || defined(__alpha__) |
| #define PADDED(x, y) x, y |
| #define PADDEDptr(x, y) x |
| #define PADDEDul(x, y) unsigned long x |
| #elif defined(__powerpc64__) /* big endian, 64 bits */ |
| #define PADDED(x, y) unsigned y; x |
| #define PADDEDptr(x,y) x |
| #define PADDEDul(x, y) unsigned long x |
| #elif defined(__PPC__) /* big endian, 32 bits */ |
| #define PADDED(x, y) unsigned y; x |
| #define PADDEDptr(x, y) unsigned y; x |
| #define PADDEDul(x, y) unsigned y; unsigned long x |
| #elif defined(__s390x__) /* big endian, 64 bits */ |
| #define PADDED(x, y) unsigned y; x |
| #define PADDEDptr(x,y) x |
| #define PADDEDul(x, y) unsigned long x |
| #elif defined(__s390__) /* big endian, 32 bits */ |
| #define PADDED(x, y) unsigned y; x |
| #define PADDEDptr(x, y) unsigned y; x |
| #define PADDEDul(x, y) unsigned y; unsigned long x |
| #elif defined(__arm__) |
| # if defined (__ARMEB__) /* big endian, 32 bits */ |
| #define PADDED(x, y) unsigned y; x |
| #define PADDEDptr(x, y) unsigned y; x |
| #define PADDEDul(x, y) unsigned y; unsigned long x |
| # else /* little endian, 32 bits */ |
| #define PADDED(x, y) x; unsigned y |
| #define PADDEDptr(x, y) x; unsigned y |
| #define PADDEDul(x, y) unsigned long x; unsigned y |
| # endif |
| #else |
| # warning No AIO definitions for this architecture => no io_submit decoding |
| # undef HAVE_LIBAIO_H |
| #endif |
| |
| #ifdef HAVE_LIBAIO_H |
| struct io_iocb_poll { |
| PADDED(int events, __pad1); |
| }; /* result code is the set of result flags or -'ve errno */ |
| |
| struct io_iocb_sockaddr { |
| struct sockaddr *addr; |
| int len; |
| }; /* result code is the length of the sockaddr, or -'ve errno */ |
| |
| struct io_iocb_common { |
| PADDEDptr(void *buf, __pad1); |
| PADDEDul(nbytes, __pad2); |
| long long offset; |
| long long __pad3; |
| unsigned flags; |
| unsigned resfd; |
| }; /* result code is the amount read or -'ve errno */ |
| |
| struct io_iocb_vector { |
| const struct iovec *vec; |
| int nr; |
| long long offset; |
| }; /* result code is the amount read or -'ve errno */ |
| |
| struct iocb { |
| PADDEDptr(void *data, __pad1); /* Return in the io completion event */ |
| PADDED(unsigned key, __pad2); /* For use in identifying io requests */ |
| |
| short aio_lio_opcode; |
| short aio_reqprio; |
| int aio_fildes; |
| |
| union { |
| struct io_iocb_common c; |
| struct io_iocb_vector v; |
| struct io_iocb_poll poll; |
| struct io_iocb_sockaddr saddr; |
| } u; |
| }; |
| |
| struct io_event { |
| PADDEDptr(void *data, __pad1); |
| PADDEDptr(struct iocb *obj, __pad2); |
| PADDEDul(res, __pad3); |
| PADDEDul(res2, __pad4); |
| }; |
| |
| #undef PADDED |
| #undef PADDEDptr |
| #undef PADDEDul |
| |
| #endif /* HAVE_LIBAIO_H */ |
| |
| /* --- End of a chunk of libaio.h --- */ |
| /* Not defined in libaio.h */ |
| #ifndef IOCB_RESFD |
| # define IOCB_RESFD (1 << 0) |
| #endif |
| |
| int |
| sys_io_setup(struct tcb *tcp) |
| { |
| if (entering(tcp)) |
| tprintf("%ld, ", tcp->u_arg[0]); |
| else { |
| if (syserror(tcp)) |
| tprintf("0x%0lx", tcp->u_arg[1]); |
| else { |
| unsigned long user_id; |
| if (umove(tcp, tcp->u_arg[1], &user_id) == 0) |
| tprintf("{%lu}", user_id); |
| else |
| tprints("{...}"); |
| } |
| } |
| return 0; |
| } |
| |
| int |
| sys_io_destroy(struct tcb *tcp) |
| { |
| if (entering(tcp)) |
| tprintf("%lu", tcp->u_arg[0]); |
| return 0; |
| } |
| |
| #ifdef HAVE_LIBAIO_H |
| |
| enum iocb_sub { |
| SUB_NONE, SUB_COMMON, SUB_POLL, SUB_VECTOR |
| }; |
| |
| static enum iocb_sub |
| tprint_lio_opcode(unsigned cmd) |
| { |
| static const struct { |
| const char *name; |
| enum iocb_sub sub; |
| } cmds[] = { |
| { "pread", SUB_COMMON }, |
| { "pwrite", SUB_COMMON }, |
| { "fsync", SUB_NONE }, |
| { "fdsync", SUB_NONE }, |
| { "op4", SUB_NONE }, |
| { "poll", SUB_POLL }, |
| { "noop", SUB_NONE }, |
| { "preadv", SUB_VECTOR }, |
| { "pwritev", SUB_VECTOR }, |
| }; |
| |
| if (cmd < ARRAY_SIZE(cmds)) { |
| tprints(cmds[cmd].name); |
| return cmds[cmd].sub; |
| } |
| tprintf("%u /* SUB_??? */", cmd); |
| return SUB_NONE; |
| } |
| |
| static void |
| print_common_flags(struct iocb *iocb) |
| { |
| if (iocb->u.c.flags & IOCB_RESFD) |
| tprintf(", resfd=%d", iocb->u.c.resfd); |
| if (iocb->u.c.flags & ~IOCB_RESFD) |
| tprintf(", flags=%x", iocb->u.c.flags); |
| } |
| |
| #endif /* HAVE_LIBAIO_H */ |
| |
| int |
| sys_io_submit(struct tcb *tcp) |
| { |
| if (entering(tcp)) { |
| #ifdef HAVE_LIBAIO_H |
| long nr = tcp->u_arg[1]; |
| /* if nr <= 0, we end up printing just "{}" */ |
| tprintf("%lu, %ld, {", tcp->u_arg[0], tcp->u_arg[1]); |
| { |
| long i; |
| struct iocb **iocbs = (void *)tcp->u_arg[2]; |
| //FIXME: decoding of 32-bit call by 64-bit strace |
| |
| for (i = 0; i < nr; i++, iocbs++) { |
| enum iocb_sub sub; |
| struct iocb *iocbp; |
| struct iocb iocb; |
| if (i) |
| tprints(", "); |
| |
| if (umove(tcp, (unsigned long)iocbs, &iocbp)) { |
| tprintf("%#lx", (unsigned long)iocbs); |
| /* No point in trying to read iocbs+1 etc */ |
| /* (nr can be ridiculously large): */ |
| break; |
| } |
| if (umove(tcp, (unsigned long)iocbp, &iocb)) { |
| tprintf("{%#lx}", (unsigned long)iocbp); |
| continue; |
| } |
| tprints("{"); |
| if (iocb.data) |
| tprintf("data:%p, ", iocb.data); |
| if (iocb.key) |
| tprintf("key:%u, ", iocb.key); |
| sub = tprint_lio_opcode(iocb.aio_lio_opcode); |
| if (iocb.aio_reqprio) |
| tprintf(", reqprio:%d", iocb.aio_reqprio); |
| tprintf(", filedes:%d", iocb.aio_fildes); |
| switch (sub) { |
| case SUB_COMMON: |
| if (iocb.aio_lio_opcode == IO_CMD_PWRITE) { |
| tprints(", str:"); |
| printstr(tcp, (unsigned long)iocb.u.c.buf, |
| iocb.u.c.nbytes); |
| } else |
| tprintf(", buf:%p", iocb.u.c.buf); |
| tprintf(", nbytes:%lu, offset:%lld", |
| iocb.u.c.nbytes, |
| iocb.u.c.offset); |
| print_common_flags(&iocb); |
| break; |
| case SUB_VECTOR: |
| tprintf(", %lld", iocb.u.v.offset); |
| print_common_flags(&iocb); |
| tprints(", "); |
| tprint_iov(tcp, iocb.u.v.nr, |
| (unsigned long)iocb.u.v.vec, |
| iocb.aio_lio_opcode == IO_CMD_PWRITEV |
| ); |
| break; |
| case SUB_POLL: |
| tprintf(", %x", iocb.u.poll.events); |
| break; |
| case SUB_NONE: |
| break; |
| } |
| tprints("}"); |
| } |
| } |
| tprints("}"); |
| #else |
| tprintf("%lu, %ld, %#lx", tcp->u_arg[0], tcp->u_arg[1], tcp->u_arg[2]); |
| #endif |
| } |
| return 0; |
| } |
| |
| int |
| sys_io_cancel(struct tcb *tcp) |
| { |
| if (entering(tcp)) { |
| #ifdef HAVE_LIBAIO_H |
| struct iocb iocb; |
| #endif |
| tprintf("%lu, ", tcp->u_arg[0]); |
| #ifdef HAVE_LIBAIO_H |
| if (umove(tcp, tcp->u_arg[1], &iocb) == 0) { |
| tprintf("{%p, %u, %u, %u, %d}, ", |
| iocb.data, iocb.key, |
| (unsigned)iocb.aio_lio_opcode, |
| (unsigned)iocb.aio_reqprio, iocb.aio_fildes); |
| } else |
| #endif |
| tprints("{...}, "); |
| } else { |
| if (tcp->u_rval < 0) |
| tprints("{...}"); |
| else { |
| #ifdef HAVE_LIBAIO_H |
| struct io_event event; |
| if (umove(tcp, tcp->u_arg[2], &event) == 0) |
| tprintf("{%p, %p, %ld, %ld}", |
| event.data, event.obj, |
| event.res, event.res2); |
| else |
| #endif |
| tprints("{...}"); |
| } |
| } |
| return 0; |
| } |
| |
| int |
| sys_io_getevents(struct tcb *tcp) |
| { |
| if (entering(tcp)) { |
| tprintf("%ld, %ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1], |
| tcp->u_arg[2]); |
| } else { |
| if (tcp->u_rval == 0) { |
| tprints("{}"); |
| } else { |
| #ifdef HAVE_LIBAIO_H |
| struct io_event *events = (void *)tcp->u_arg[3]; |
| long i, nr = tcp->u_rval; |
| |
| for (i = 0; i < nr; i++, events++) { |
| struct io_event event; |
| |
| if (i == 0) |
| tprints("{"); |
| else |
| tprints(", "); |
| |
| if (umove(tcp, (unsigned long)events, &event) != 0) { |
| tprints("{...}"); |
| continue; |
| } |
| tprintf("{%p, %p, %ld, %ld}", event.data, |
| event.obj, event.res, event.res2); |
| } |
| tprints("}, "); |
| #else |
| tprints("{...}"); |
| #endif |
| } |
| |
| print_timespec(tcp, tcp->u_arg[4]); |
| } |
| return 0; |
| } |