granicus.if.org Git - strace/blob - tests/preadv-pwritev.c

   1 /*
   2  * Check decoding of preadv and pwritev syscalls.
   3  *
   4  * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "tests.h"
  31
  32 #if defined HAVE_PREADV && defined HAVE_PWRITEV
  33
  34 # include <fcntl.h>
  35 # include <stdio.h>
  36 # include <sys/uio.h>
  37 # include <unistd.h>
  38
  39 int
  40 main(void)
  41 {
  42         tprintf("%s", "");
  43
  44         static char tmp[] = "preadv-pwritev-tmpfile";
  45         if (open(tmp, O_CREAT|O_RDONLY|O_TRUNC, 0600) != 0)
  46                 perror_msg_and_fail("creat: %s", tmp);
  47         if (open(tmp, O_WRONLY) != 1)
  48                 perror_msg_and_fail("open: %s", tmp);
  49         if (unlink(tmp))
  50                 perror_msg_and_fail("unlink: %s", tmp);
  51
  52         static const char w0_c[] = "012";
  53         const char *w0_d = hexdump_strdup(w0_c);
  54         void *w0 = tail_memdup(w0_c, LENGTH_OF(w0_c));
  55
  56         const void *efault = w0 + LENGTH_OF(w0_c);
  57
  58         static const char w1_c[] = "34567";
  59         const char *w1_d = hexdump_strdup(w1_c);
  60         void *w1 = tail_memdup(w1_c, LENGTH_OF(w1_c));
  61
  62         static const char w2_c[] = "89abcde";
  63         const char *w2_d = hexdump_strdup(w2_c);
  64         void *w2 = tail_memdup(w2_c, LENGTH_OF(w2_c));
  65
  66         long rc;
  67
  68         rc = pwritev(1, efault, 42, 0);
  69         tprintf("pwritev(1, %p, 42, 0) = %ld %s (%m)\n",
  70                 efault, rc, errno2name());
  71
  72         rc = preadv(0, efault, 42, 0);
  73         tprintf("preadv(0, %p, 42, 0) = %ld %s (%m)\n",
  74                 efault, rc, errno2name());
  75
  76         static const char r0_c[] = "01234567";
  77         const char *r0_d = hexdump_strdup(r0_c);
  78         static const char r1_c[] = "89abcde";
  79         const char *r1_d = hexdump_strdup(r1_c);
  80
  81         const struct iovec w_iov_[] = {
  82                 {
  83                         .iov_base = w0,
  84                         .iov_len = LENGTH_OF(w0_c)
  85                 }, {
  86                         .iov_base = w1,
  87                         .iov_len = LENGTH_OF(w1_c)
  88                 }, {
  89                         .iov_base = w2,
  90                         .iov_len = LENGTH_OF(w2_c)
  91                 }
  92         };
  93         const struct iovec *w_iov = tail_memdup(w_iov_, sizeof(w_iov_));
  94
  95         rc = pwritev(1, w_iov, 0, 0);
  96         if (rc)
  97                 perror_msg_and_fail("pwritev: expected 0, returned %ld", rc);
  98         tprintf("pwritev(1, [], 0, 0) = 0\n");
  99
 100         rc = pwritev(1, w_iov + ARRAY_SIZE(w_iov_) - 1, 2, 0);
 101         tprintf("pwritev(1, [{iov_base=\"%s\", iov_len=%u}, %p], 2, 0)"
 102                 " = %ld %s (%m)\n",
 103                 w2_c, LENGTH_OF(w2_c), w_iov + ARRAY_SIZE(w_iov_),
 104                 rc, errno2name());
 105
 106         const unsigned int w_len =
 107                 LENGTH_OF(w0_c) + LENGTH_OF(w1_c) + LENGTH_OF(w2_c);
 108
 109         rc = pwritev(1, w_iov, ARRAY_SIZE(w_iov_), 0);
 110         if (rc != (int) w_len)
 111                 perror_msg_and_fail("pwritev: expected %u, returned %ld",
 112                                     w_len, rc);
 113         close(1);
 114         tprintf("pwritev(1, [{iov_base=\"%s\", iov_len=%u}"
 115                 ", {iov_base=\"%s\", iov_len=%u}"
 116                 ", {iov_base=\"%s\", iov_len=%u}], %u, 0) = %u\n"
 117                 " * %u bytes in buffer 0\n"
 118                 " | 00000 %-49s  %-16s |\n"
 119                 " * %u bytes in buffer 1\n"
 120                 " | 00000 %-49s  %-16s |\n"
 121                 " * %u bytes in buffer 2\n"
 122                 " | 00000 %-49s  %-16s |\n",
 123                 w0_c, LENGTH_OF(w0_c), w1_c, LENGTH_OF(w1_c),
 124                 w2_c, LENGTH_OF(w2_c), ARRAY_SIZE(w_iov_), w_len,
 125                 LENGTH_OF(w0_c), w0_d, w0_c,
 126                 LENGTH_OF(w1_c), w1_d, w1_c, LENGTH_OF(w2_c), w2_d, w2_c);
 127
 128         const unsigned int r_len = (w_len + 1) / 2;
 129         void *r0 = tail_alloc(r_len);
 130         const struct iovec r0_iov_[] = {
 131                 {
 132                         .iov_base = r0,
 133                         .iov_len = r_len
 134                 }
 135         };
 136         const struct iovec *r_iov = tail_memdup(r0_iov_, sizeof(r0_iov_));
 137
 138         rc = preadv(0, r_iov, ARRAY_SIZE(r0_iov_), 0);
 139         if (rc != (int) r_len)
 140                 perror_msg_and_fail("preadv: expected %u, returned %ld",
 141                                     r_len, rc);
 142         tprintf("preadv(0, [{iov_base=\"%s\", iov_len=%u}], %u, 0) = %u\n"
 143                 " * %u bytes in buffer 0\n"
 144                 " | 00000 %-49s  %-16s |\n",
 145                 r0_c, r_len, ARRAY_SIZE(r0_iov_), r_len, r_len, r0_d, r0_c);
 146
 147         void *r1 = tail_alloc(r_len);
 148         void *r2 = tail_alloc(w_len);
 149         const struct iovec r1_iov_[] = {
 150                 {
 151                         .iov_base = r1,
 152                         .iov_len = r_len
 153                 },
 154                 {
 155                         .iov_base = r2,
 156                         .iov_len = w_len
 157                 }
 158         };
 159         r_iov = tail_memdup(r1_iov_, sizeof(r1_iov_));
 160
 161         rc = preadv(0, r_iov, ARRAY_SIZE(r1_iov_), r_len);
 162         if (rc != (int) w_len - (int) r_len)
 163                 perror_msg_and_fail("preadv: expected %d, returned %ld",
 164                                     (int) w_len - r_len, rc);
 165         tprintf("preadv(0, [{iov_base=\"%s\", iov_len=%u}"
 166                 ", {iov_base=\"\", iov_len=%u}], %u, %u) = %u\n"
 167                 " * %u bytes in buffer 0\n"
 168                 " | 00000 %-49s  %-16s |\n",
 169                 r1_c, r_len, w_len, ARRAY_SIZE(r1_iov_),
 170                 r_len, w_len - r_len,
 171                 w_len - r_len, r1_d, r1_c);
 172         close(0);
 173
 174         tprintf("+++ exited with 0 +++\n");
 175         return 0;
 176 }
 177
 178 #else
 179
 180 SKIP_MAIN_UNDEFINED("HAVE_PREADV && HAVE_PWRITEV")
 181
 182 #endif