tests/test-iov.c

   1 #include "qemu/osdep.h"
   2 #include "qemu-common.h"
   3 #include "qemu/iov.h"
   4 #include "qemu/sockets.h"
   5
   6 /* create a randomly-sized iovec with random vectors */
   7 static void iov_random(struct iovec **iovp, unsigned *iov_cntp)
   8 {
   9      unsigned niov = g_test_rand_int_range(3,8);
  10      struct iovec *iov = g_malloc(niov * sizeof(*iov));
  11      unsigned i;
  12      for (i = 0; i < niov; ++i) {
  13          iov[i].iov_len = g_test_rand_int_range(5,20);
  14          iov[i].iov_base = g_malloc(iov[i].iov_len);
  15      }
  16      *iovp = iov;
  17      *iov_cntp = niov;
  18 }
  19
  20 static void iov_free(struct iovec *iov, unsigned niov)
  21 {
  22     unsigned i;
  23     for (i = 0; i < niov; ++i) {
  24         g_free(iov[i].iov_base);
  25     }
  26     g_free(iov);
  27 }
  28
  29 static void test_iov_bytes(struct iovec *iov, unsigned niov,
  30                            size_t offset, size_t bytes)
  31 {
  32     unsigned i;
  33     size_t j, o;
  34     unsigned char *b;
  35     o = 0;
  36
  37     /* we walk over all elements, */
  38     for (i = 0; i < niov; ++i) {
  39         b = iov[i].iov_base;
  40         /* over each char of each element, */
  41         for (j = 0; j < iov[i].iov_len; ++j) {
  42             /* counting each of them and
  43              * verifying that the ones within [offset,offset+bytes)
  44              * range are equal to the position number (o) */
  45             if (o >= offset && o < offset + bytes) {
  46                 g_assert(b[j] == (o & 255));
  47             } else {
  48                 g_assert(b[j] == 0xff);
  49             }
  50             ++o;
  51         }
  52     }
  53 }
  54
  55 static void test_to_from_buf_1(void)
  56 {
  57      unsigned niov;
  58      struct iovec *iov;
  59      size_t sz;
  60      unsigned char *ibuf, *obuf;
  61      unsigned i, j, n;
  62
  63      iov_random(&iov, &niov);
  64
  65      sz = iov_size(iov, niov);
  66
  67      ibuf = g_malloc(sz + 8) + 4;
  68      memcpy(ibuf-4, "aaaa", 4); memcpy(ibuf + sz, "bbbb", 4);
  69      obuf = g_malloc(sz + 8) + 4;
  70      memcpy(obuf-4, "xxxx", 4); memcpy(obuf + sz, "yyyy", 4);
  71
  72      /* fill in ibuf with 0123456... */
  73      for (i = 0; i < sz; ++i) {
  74          ibuf[i] = i & 255;
  75      }
  76
  77      for (i = 0; i <= sz; ++i) {
  78
  79          /* Test from/to buf for offset(i) in [0..sz] up to the end of buffer.
  80           * For last iteration with offset == sz, the procedure should
  81           * skip whole vector and process exactly 0 bytes */
  82
  83          /* first set bytes [i..sz) to some "random" value */
  84          n = iov_memset(iov, niov, 0, 0xff, -1);
  85          g_assert(n == sz);
  86
  87          /* next copy bytes [i..sz) from ibuf to iovec */
  88          n = iov_from_buf(iov, niov, i, ibuf + i, -1);
  89          g_assert(n == sz - i);
  90
  91          /* clear part of obuf */
  92          memset(obuf + i, 0, sz - i);
  93          /* and set this part of obuf to values from iovec */
  94          n = iov_to_buf(iov, niov, i, obuf + i, -1);
  95          g_assert(n == sz - i);
  96
  97          /* now compare resulting buffers */
  98          g_assert(memcmp(ibuf, obuf, sz) == 0);
  99
 100          /* test just one char */
 101          n = iov_to_buf(iov, niov, i, obuf + i, 1);
 102          g_assert(n == (i < sz));
 103          if (n) {
 104              g_assert(obuf[i] == (i & 255));
 105          }
 106
 107          for (j = i; j <= sz; ++j) {
 108              /* now test num of bytes cap up to byte no. j,
 109               * with j in [i..sz]. */
 110
 111              /* clear iovec */
 112              n = iov_memset(iov, niov, 0, 0xff, -1);
 113              g_assert(n == sz);
 114
 115              /* copy bytes [i..j) from ibuf to iovec */
 116              n = iov_from_buf(iov, niov, i, ibuf + i, j - i);
 117              g_assert(n == j - i);
 118
 119              /* clear part of obuf */
 120              memset(obuf + i, 0, j - i);
 121
 122              /* copy bytes [i..j) from iovec to obuf */
 123              n = iov_to_buf(iov, niov, i, obuf + i, j - i);
 124              g_assert(n == j - i);
 125
 126              /* verify result */
 127              g_assert(memcmp(ibuf, obuf, sz) == 0);
 128
 129              /* now actually check if the iovec contains the right data */
 130              test_iov_bytes(iov, niov, i, j - i);
 131          }
 132     }
 133     g_assert(!memcmp(ibuf-4, "aaaa", 4) && !memcmp(ibuf+sz, "bbbb", 4));
 134     g_free(ibuf-4);
 135     g_assert(!memcmp(obuf-4, "xxxx", 4) && !memcmp(obuf+sz, "yyyy", 4));
 136     g_free(obuf-4);
 137     iov_free(iov, niov);
 138 }
 139
 140 static void test_to_from_buf(void)
 141 {
 142     int x;
 143     for (x = 0; x < 4; ++x) {
 144         test_to_from_buf_1();
 145     }
 146 }
 147
 148 static void test_io(void)
 149 {
 150 #ifndef _WIN32
 151 /* socketpair(PF_UNIX) which does not exist on windows */
 152
 153     int sv[2];
 154     int r;
 155     unsigned i, j, k, s, t;
 156     fd_set fds;
 157     unsigned niov;
 158     struct iovec *iov, *siov;
 159     unsigned char *buf;
 160     size_t sz;
 161
 162     iov_random(&iov, &niov);
 163     sz = iov_size(iov, niov);
 164     buf = g_malloc(sz);
 165     for (i = 0; i < sz; ++i) {
 166         buf[i] = i & 255;
 167     }
 168     iov_from_buf(iov, niov, 0, buf, sz);
 169
 170     siov = g_malloc(sizeof(*iov) * niov);
 171     memcpy(siov, iov, sizeof(*iov) * niov);
 172
 173     if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) < 0) {
 174        perror("socketpair");
 175        exit(1);
 176     }
 177
 178     FD_ZERO(&fds);
 179
 180     t = 0;
 181     if (fork() == 0) {
 182        /* writer */
 183
 184        close(sv[0]);
 185        FD_SET(sv[1], &fds);
 186        fcntl(sv[1], F_SETFL, O_RDWR|O_NONBLOCK);
 187        r = g_test_rand_int_range(sz / 2, sz);
 188        setsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &r, sizeof(r));
 189
 190        for (i = 0; i <= sz; ++i) {
 191            for (j = i; j <= sz; ++j) {
 192                k = i;
 193                do {
 194                    s = g_test_rand_int_range(0, j - k + 1);
 195                    r = iov_send(sv[1], iov, niov, k, s);
 196                    g_assert(memcmp(iov, siov, sizeof(*iov)*niov) == 0);
 197                    if (r >= 0) {
 198                        k += r;
 199                        t += r;
 200                        usleep(g_test_rand_int_range(0, 30));
 201                    } else if (errno == EAGAIN) {
 202                        select(sv[1]+1, NULL, &fds, NULL, NULL);
 203                        continue;
 204                    } else {
 205                        perror("send");
 206                        exit(1);
 207                    }
 208                } while(k < j);
 209            }
 210        }
 211        iov_free(iov, niov);
 212        g_free(buf);
 213        g_free(siov);
 214        exit(0);
 215
 216     } else {
 217        /* reader & verifier */
 218
 219        close(sv[1]);
 220        FD_SET(sv[0], &fds);
 221        fcntl(sv[0], F_SETFL, O_RDWR|O_NONBLOCK);
 222        r = g_test_rand_int_range(sz / 2, sz);
 223        setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &r, sizeof(r));
 224        usleep(500000);
 225
 226        for (i = 0; i <= sz; ++i) {
 227            for (j = i; j <= sz; ++j) {
 228                k = i;
 229                iov_memset(iov, niov, 0, 0xff, -1);
 230                do {
 231                    s = g_test_rand_int_range(0, j - k + 1);
 232                    r = iov_recv(sv[0], iov, niov, k, s);
 233                    g_assert(memcmp(iov, siov, sizeof(*iov)*niov) == 0);
 234                    if (r > 0) {
 235                        k += r;
 236                        t += r;
 237                    } else if (!r) {
 238                        if (s) {
 239                            break;
 240                        }
 241                    } else if (errno == EAGAIN) {
 242                        select(sv[0]+1, &fds, NULL, NULL, NULL);
 243                        continue;
 244                    } else {
 245                        perror("recv");
 246                        exit(1);
 247                    }
 248                } while(k < j);
 249                test_iov_bytes(iov, niov, i, j - i);
 250            }
 251         }
 252
 253        iov_free(iov, niov);
 254        g_free(buf);
 255        g_free(siov);
 256      }
 257 #endif
 258 }
 259
 260 static void test_discard_front(void)
 261 {
 262     struct iovec *iov;
 263     struct iovec *iov_tmp;
 264     unsigned int iov_cnt;
 265     unsigned int iov_cnt_tmp;
 266     void *old_base;
 267     size_t size;
 268     size_t ret;
 269
 270     /* Discard zero bytes */
 271     iov_random(&iov, &iov_cnt);
 272     iov_tmp = iov;
 273     iov_cnt_tmp = iov_cnt;
 274     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, 0);
 275     g_assert(ret == 0);
 276     g_assert(iov_tmp == iov);
 277     g_assert(iov_cnt_tmp == iov_cnt);
 278     iov_free(iov, iov_cnt);
 279
 280     /* Discard more bytes than vector size */
 281     iov_random(&iov, &iov_cnt);
 282     iov_tmp = iov;
 283     iov_cnt_tmp = iov_cnt;
 284     size = iov_size(iov, iov_cnt);
 285     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size + 1);
 286     g_assert(ret == size);
 287     g_assert(iov_cnt_tmp == 0);
 288     iov_free(iov, iov_cnt);
 289
 290     /* Discard entire vector */
 291     iov_random(&iov, &iov_cnt);
 292     iov_tmp = iov;
 293     iov_cnt_tmp = iov_cnt;
 294     size = iov_size(iov, iov_cnt);
 295     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size);
 296     g_assert(ret == size);
 297     g_assert(iov_cnt_tmp == 0);
 298     iov_free(iov, iov_cnt);
 299
 300     /* Discard within first element */
 301     iov_random(&iov, &iov_cnt);
 302     iov_tmp = iov;
 303     iov_cnt_tmp = iov_cnt;
 304     old_base = iov->iov_base;
 305     size = g_test_rand_int_range(1, iov->iov_len);
 306     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size);
 307     g_assert(ret == size);
 308     g_assert(iov_tmp == iov);
 309     g_assert(iov_cnt_tmp == iov_cnt);
 310     g_assert(iov_tmp->iov_base == old_base + size);
 311     iov_tmp->iov_base = old_base; /* undo before g_free() */
 312     iov_free(iov, iov_cnt);
 313
 314     /* Discard entire first element */
 315     iov_random(&iov, &iov_cnt);
 316     iov_tmp = iov;
 317     iov_cnt_tmp = iov_cnt;
 318     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, iov->iov_len);
 319     g_assert(ret == iov->iov_len);
 320     g_assert(iov_tmp == iov + 1);
 321     g_assert(iov_cnt_tmp == iov_cnt - 1);
 322     iov_free(iov, iov_cnt);
 323
 324     /* Discard within second element */
 325     iov_random(&iov, &iov_cnt);
 326     iov_tmp = iov;
 327     iov_cnt_tmp = iov_cnt;
 328     old_base = iov[1].iov_base;
 329     size = iov->iov_len + g_test_rand_int_range(1, iov[1].iov_len);
 330     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size);
 331     g_assert(ret == size);
 332     g_assert(iov_tmp == iov + 1);
 333     g_assert(iov_cnt_tmp == iov_cnt - 1);
 334     g_assert(iov_tmp->iov_base == old_base + (size - iov->iov_len));
 335     iov_tmp->iov_base = old_base; /* undo before g_free() */
 336     iov_free(iov, iov_cnt);
 337 }
 338
 339 static void test_discard_back(void)
 340 {
 341     struct iovec *iov;
 342     unsigned int iov_cnt;
 343     unsigned int iov_cnt_tmp;
 344     void *old_base;
 345     size_t size;
 346     size_t ret;
 347
 348     /* Discard zero bytes */
 349     iov_random(&iov, &iov_cnt);
 350     iov_cnt_tmp = iov_cnt;
 351     ret = iov_discard_back(iov, &iov_cnt_tmp, 0);
 352     g_assert(ret == 0);
 353     g_assert(iov_cnt_tmp == iov_cnt);
 354     iov_free(iov, iov_cnt);
 355
 356     /* Discard more bytes than vector size */
 357     iov_random(&iov, &iov_cnt);
 358     iov_cnt_tmp = iov_cnt;
 359     size = iov_size(iov, iov_cnt);
 360     ret = iov_discard_back(iov, &iov_cnt_tmp, size + 1);
 361     g_assert(ret == size);
 362     g_assert(iov_cnt_tmp == 0);
 363     iov_free(iov, iov_cnt);
 364
 365     /* Discard entire vector */
 366     iov_random(&iov, &iov_cnt);
 367     iov_cnt_tmp = iov_cnt;
 368     size = iov_size(iov, iov_cnt);
 369     ret = iov_discard_back(iov, &iov_cnt_tmp, size);
 370     g_assert(ret == size);
 371     g_assert(iov_cnt_tmp == 0);
 372     iov_free(iov, iov_cnt);
 373
 374     /* Discard within last element */
 375     iov_random(&iov, &iov_cnt);
 376     iov_cnt_tmp = iov_cnt;
 377     old_base = iov[iov_cnt - 1].iov_base;
 378     size = g_test_rand_int_range(1, iov[iov_cnt - 1].iov_len);
 379     ret = iov_discard_back(iov, &iov_cnt_tmp, size);
 380     g_assert(ret == size);
 381     g_assert(iov_cnt_tmp == iov_cnt);
 382     g_assert(iov[iov_cnt - 1].iov_base == old_base);
 383     iov_free(iov, iov_cnt);
 384
 385     /* Discard entire last element */
 386     iov_random(&iov, &iov_cnt);
 387     iov_cnt_tmp = iov_cnt;
 388     old_base = iov[iov_cnt - 1].iov_base;
 389     size = iov[iov_cnt - 1].iov_len;
 390     ret = iov_discard_back(iov, &iov_cnt_tmp, size);
 391     g_assert(ret == size);
 392     g_assert(iov_cnt_tmp == iov_cnt - 1);
 393     iov_free(iov, iov_cnt);
 394
 395     /* Discard within second-to-last element */
 396     iov_random(&iov, &iov_cnt);
 397     iov_cnt_tmp = iov_cnt;
 398     old_base = iov[iov_cnt - 2].iov_base;
 399     size = iov[iov_cnt - 1].iov_len +
 400            g_test_rand_int_range(1, iov[iov_cnt - 2].iov_len);
 401     ret = iov_discard_back(iov, &iov_cnt_tmp, size);
 402     g_assert(ret == size);
 403     g_assert(iov_cnt_tmp == iov_cnt - 1);
 404     g_assert(iov[iov_cnt - 2].iov_base == old_base);
 405     iov_free(iov, iov_cnt);
 406 }
 407
 408 int main(int argc, char **argv)
 409 {
 410     g_test_init(&argc, &argv, NULL);
 411     g_test_rand_int();
 412     g_test_add_func("/basic/iov/from-to-buf", test_to_from_buf);
 413     g_test_add_func("/basic/iov/io", test_io);
 414     g_test_add_func("/basic/iov/discard-front", test_discard_front);
 415     g_test_add_func("/basic/iov/discard-back", test_discard_back);
 416     return g_test_run();
 417 }