test-iov.c (17646B)
1 #include "qemu/osdep.h" 2 #include "qemu/iov.h" 3 #include "qemu/sockets.h" 4 5 /* create a randomly-sized iovec with random vectors */ 6 static void iov_random(struct iovec **iovp, unsigned *iov_cntp) 7 { 8 unsigned niov = g_test_rand_int_range(3,8); 9 struct iovec *iov = g_malloc(niov * sizeof(*iov)); 10 unsigned i; 11 for (i = 0; i < niov; ++i) { 12 iov[i].iov_len = g_test_rand_int_range(5,20); 13 iov[i].iov_base = g_malloc(iov[i].iov_len); 14 } 15 *iovp = iov; 16 *iov_cntp = niov; 17 } 18 19 static void iov_free(struct iovec *iov, unsigned niov) 20 { 21 unsigned i; 22 for (i = 0; i < niov; ++i) { 23 g_free(iov[i].iov_base); 24 } 25 g_free(iov); 26 } 27 28 static bool iov_equals(const struct iovec *a, const struct iovec *b, 29 unsigned niov) 30 { 31 return memcmp(a, b, sizeof(a[0]) * niov) == 0; 32 } 33 34 static void test_iov_bytes(struct iovec *iov, unsigned niov, 35 size_t offset, size_t bytes) 36 { 37 unsigned i; 38 size_t j, o; 39 unsigned char *b; 40 o = 0; 41 42 /* we walk over all elements, */ 43 for (i = 0; i < niov; ++i) { 44 b = iov[i].iov_base; 45 /* over each char of each element, */ 46 for (j = 0; j < iov[i].iov_len; ++j) { 47 /* counting each of them and 48 * verifying that the ones within [offset,offset+bytes) 49 * range are equal to the position number (o) */ 50 if (o >= offset && o < offset + bytes) { 51 g_assert(b[j] == (o & 255)); 52 } else { 53 g_assert(b[j] == 0xff); 54 } 55 ++o; 56 } 57 } 58 } 59 60 static void test_to_from_buf_1(void) 61 { 62 unsigned niov; 63 struct iovec *iov; 64 size_t sz; 65 unsigned char *ibuf, *obuf; 66 unsigned i, j, n; 67 68 iov_random(&iov, &niov); 69 70 sz = iov_size(iov, niov); 71 72 ibuf = g_malloc(sz + 8) + 4; 73 memcpy(ibuf-4, "aaaa", 4); memcpy(ibuf + sz, "bbbb", 4); 74 obuf = g_malloc(sz + 8) + 4; 75 memcpy(obuf-4, "xxxx", 4); memcpy(obuf + sz, "yyyy", 4); 76 77 /* fill in ibuf with 0123456... */ 78 for (i = 0; i < sz; ++i) { 79 ibuf[i] = i & 255; 80 } 81 82 for (i = 0; i <= sz; ++i) { 83 84 /* Test from/to buf for offset(i) in [0..sz] up to the end of buffer. 85 * For last iteration with offset == sz, the procedure should 86 * skip whole vector and process exactly 0 bytes */ 87 88 /* first set bytes [i..sz) to some "random" value */ 89 n = iov_memset(iov, niov, 0, 0xff, sz); 90 g_assert(n == sz); 91 92 /* next copy bytes [i..sz) from ibuf to iovec */ 93 n = iov_from_buf(iov, niov, i, ibuf + i, sz - i); 94 g_assert(n == sz - i); 95 96 /* clear part of obuf */ 97 memset(obuf + i, 0, sz - i); 98 /* and set this part of obuf to values from iovec */ 99 n = iov_to_buf(iov, niov, i, obuf + i, sz - i); 100 g_assert(n == sz - i); 101 102 /* now compare resulting buffers */ 103 g_assert(memcmp(ibuf, obuf, sz) == 0); 104 105 /* test just one char */ 106 n = iov_to_buf(iov, niov, i, obuf + i, 1); 107 g_assert(n == (i < sz)); 108 if (n) { 109 g_assert(obuf[i] == (i & 255)); 110 } 111 112 for (j = i; j <= sz; ++j) { 113 /* now test num of bytes cap up to byte no. j, 114 * with j in [i..sz]. */ 115 116 /* clear iovec */ 117 n = iov_memset(iov, niov, 0, 0xff, sz); 118 g_assert(n == sz); 119 120 /* copy bytes [i..j) from ibuf to iovec */ 121 n = iov_from_buf(iov, niov, i, ibuf + i, j - i); 122 g_assert(n == j - i); 123 124 /* clear part of obuf */ 125 memset(obuf + i, 0, j - i); 126 127 /* copy bytes [i..j) from iovec to obuf */ 128 n = iov_to_buf(iov, niov, i, obuf + i, j - i); 129 g_assert(n == j - i); 130 131 /* verify result */ 132 g_assert(memcmp(ibuf, obuf, sz) == 0); 133 134 /* now actually check if the iovec contains the right data */ 135 test_iov_bytes(iov, niov, i, j - i); 136 } 137 } 138 g_assert(!memcmp(ibuf-4, "aaaa", 4) && !memcmp(ibuf+sz, "bbbb", 4)); 139 g_free(ibuf-4); 140 g_assert(!memcmp(obuf-4, "xxxx", 4) && !memcmp(obuf+sz, "yyyy", 4)); 141 g_free(obuf-4); 142 iov_free(iov, niov); 143 } 144 145 static void test_to_from_buf(void) 146 { 147 int x; 148 for (x = 0; x < 4; ++x) { 149 test_to_from_buf_1(); 150 } 151 } 152 153 static void test_io(void) 154 { 155 #ifndef _WIN32 156 /* socketpair(PF_UNIX) which does not exist on windows */ 157 158 int sv[2]; 159 int r; 160 unsigned i, j, k, s; 161 fd_set fds; 162 unsigned niov; 163 struct iovec *iov, *siov; 164 unsigned char *buf; 165 size_t sz; 166 167 iov_random(&iov, &niov); 168 sz = iov_size(iov, niov); 169 buf = g_malloc(sz); 170 for (i = 0; i < sz; ++i) { 171 buf[i] = i & 255; 172 } 173 iov_from_buf(iov, niov, 0, buf, sz); 174 175 siov = g_memdup2(iov, sizeof(*iov) * niov); 176 177 if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) < 0) { 178 perror("socketpair"); 179 exit(1); 180 } 181 182 FD_ZERO(&fds); 183 184 if (fork() == 0) { 185 /* writer */ 186 187 close(sv[0]); 188 FD_SET(sv[1], &fds); 189 g_unix_set_fd_nonblocking(sv[1], true, NULL); 190 r = g_test_rand_int_range(sz / 2, sz); 191 setsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &r, sizeof(r)); 192 193 for (i = 0; i <= sz; ++i) { 194 for (j = i; j <= sz; ++j) { 195 k = i; 196 do { 197 s = g_test_rand_int_range(0, j - k + 1); 198 r = iov_send(sv[1], iov, niov, k, s); 199 g_assert(memcmp(iov, siov, sizeof(*iov)*niov) == 0); 200 if (r >= 0) { 201 k += r; 202 usleep(g_test_rand_int_range(0, 30)); 203 } else if (errno == EAGAIN) { 204 select(sv[1]+1, NULL, &fds, NULL, NULL); 205 continue; 206 } else { 207 perror("send"); 208 exit(1); 209 } 210 } while(k < j); 211 } 212 } 213 iov_free(iov, niov); 214 g_free(buf); 215 g_free(siov); 216 exit(0); 217 218 } else { 219 /* reader & verifier */ 220 221 close(sv[1]); 222 FD_SET(sv[0], &fds); 223 g_unix_set_fd_nonblocking(sv[0], true, NULL); 224 r = g_test_rand_int_range(sz / 2, sz); 225 setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &r, sizeof(r)); 226 usleep(500000); 227 228 for (i = 0; i <= sz; ++i) { 229 for (j = i; j <= sz; ++j) { 230 k = i; 231 iov_memset(iov, niov, 0, 0xff, sz); 232 do { 233 s = g_test_rand_int_range(0, j - k + 1); 234 r = iov_recv(sv[0], iov, niov, k, s); 235 g_assert(memcmp(iov, siov, sizeof(*iov)*niov) == 0); 236 if (r > 0) { 237 k += r; 238 } else if (!r) { 239 if (s) { 240 break; 241 } 242 } else if (errno == EAGAIN) { 243 select(sv[0]+1, &fds, NULL, NULL, NULL); 244 continue; 245 } else { 246 perror("recv"); 247 exit(1); 248 } 249 } while(k < j); 250 test_iov_bytes(iov, niov, i, j - i); 251 } 252 } 253 254 iov_free(iov, niov); 255 g_free(buf); 256 g_free(siov); 257 } 258 #endif 259 } 260 261 static void test_discard_front(void) 262 { 263 struct iovec *iov; 264 struct iovec *iov_tmp; 265 unsigned int iov_cnt; 266 unsigned int iov_cnt_tmp; 267 void *old_base; 268 size_t size; 269 size_t ret; 270 271 /* Discard zero bytes */ 272 iov_random(&iov, &iov_cnt); 273 iov_tmp = iov; 274 iov_cnt_tmp = iov_cnt; 275 ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, 0); 276 g_assert(ret == 0); 277 g_assert(iov_tmp == iov); 278 g_assert(iov_cnt_tmp == iov_cnt); 279 iov_free(iov, iov_cnt); 280 281 /* Discard more bytes than vector size */ 282 iov_random(&iov, &iov_cnt); 283 iov_tmp = iov; 284 iov_cnt_tmp = iov_cnt; 285 size = iov_size(iov, iov_cnt); 286 ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size + 1); 287 g_assert(ret == size); 288 g_assert(iov_cnt_tmp == 0); 289 iov_free(iov, iov_cnt); 290 291 /* Discard entire vector */ 292 iov_random(&iov, &iov_cnt); 293 iov_tmp = iov; 294 iov_cnt_tmp = iov_cnt; 295 size = iov_size(iov, iov_cnt); 296 ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size); 297 g_assert(ret == size); 298 g_assert(iov_cnt_tmp == 0); 299 iov_free(iov, iov_cnt); 300 301 /* Discard within first element */ 302 iov_random(&iov, &iov_cnt); 303 iov_tmp = iov; 304 iov_cnt_tmp = iov_cnt; 305 old_base = iov->iov_base; 306 size = g_test_rand_int_range(1, iov->iov_len); 307 ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size); 308 g_assert(ret == size); 309 g_assert(iov_tmp == iov); 310 g_assert(iov_cnt_tmp == iov_cnt); 311 g_assert(iov_tmp->iov_base == old_base + size); 312 iov_tmp->iov_base = old_base; /* undo before g_free() */ 313 iov_free(iov, iov_cnt); 314 315 /* Discard entire first element */ 316 iov_random(&iov, &iov_cnt); 317 iov_tmp = iov; 318 iov_cnt_tmp = iov_cnt; 319 ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, iov->iov_len); 320 g_assert(ret == iov->iov_len); 321 g_assert(iov_tmp == iov + 1); 322 g_assert(iov_cnt_tmp == iov_cnt - 1); 323 iov_free(iov, iov_cnt); 324 325 /* Discard within second element */ 326 iov_random(&iov, &iov_cnt); 327 iov_tmp = iov; 328 iov_cnt_tmp = iov_cnt; 329 old_base = iov[1].iov_base; 330 size = iov->iov_len + g_test_rand_int_range(1, iov[1].iov_len); 331 ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size); 332 g_assert(ret == size); 333 g_assert(iov_tmp == iov + 1); 334 g_assert(iov_cnt_tmp == iov_cnt - 1); 335 g_assert(iov_tmp->iov_base == old_base + (size - iov->iov_len)); 336 iov_tmp->iov_base = old_base; /* undo before g_free() */ 337 iov_free(iov, iov_cnt); 338 } 339 340 static void test_discard_front_undo(void) 341 { 342 IOVDiscardUndo undo; 343 struct iovec *iov; 344 struct iovec *iov_tmp; 345 struct iovec *iov_orig; 346 unsigned int iov_cnt; 347 unsigned int iov_cnt_tmp; 348 size_t size; 349 350 /* Discard zero bytes */ 351 iov_random(&iov, &iov_cnt); 352 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 353 iov_tmp = iov; 354 iov_cnt_tmp = iov_cnt; 355 iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, 0, &undo); 356 iov_discard_undo(&undo); 357 assert(iov_equals(iov, iov_orig, iov_cnt)); 358 g_free(iov_orig); 359 iov_free(iov, iov_cnt); 360 361 /* Discard more bytes than vector size */ 362 iov_random(&iov, &iov_cnt); 363 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 364 iov_tmp = iov; 365 iov_cnt_tmp = iov_cnt; 366 size = iov_size(iov, iov_cnt); 367 iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, size + 1, &undo); 368 iov_discard_undo(&undo); 369 assert(iov_equals(iov, iov_orig, iov_cnt)); 370 g_free(iov_orig); 371 iov_free(iov, iov_cnt); 372 373 /* Discard entire vector */ 374 iov_random(&iov, &iov_cnt); 375 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 376 iov_tmp = iov; 377 iov_cnt_tmp = iov_cnt; 378 size = iov_size(iov, iov_cnt); 379 iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, size, &undo); 380 iov_discard_undo(&undo); 381 assert(iov_equals(iov, iov_orig, iov_cnt)); 382 g_free(iov_orig); 383 iov_free(iov, iov_cnt); 384 385 /* Discard within first element */ 386 iov_random(&iov, &iov_cnt); 387 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 388 iov_tmp = iov; 389 iov_cnt_tmp = iov_cnt; 390 size = g_test_rand_int_range(1, iov->iov_len); 391 iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, size, &undo); 392 iov_discard_undo(&undo); 393 assert(iov_equals(iov, iov_orig, iov_cnt)); 394 g_free(iov_orig); 395 iov_free(iov, iov_cnt); 396 397 /* Discard entire first element */ 398 iov_random(&iov, &iov_cnt); 399 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 400 iov_tmp = iov; 401 iov_cnt_tmp = iov_cnt; 402 iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, iov->iov_len, &undo); 403 iov_discard_undo(&undo); 404 assert(iov_equals(iov, iov_orig, iov_cnt)); 405 g_free(iov_orig); 406 iov_free(iov, iov_cnt); 407 408 /* Discard within second element */ 409 iov_random(&iov, &iov_cnt); 410 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 411 iov_tmp = iov; 412 iov_cnt_tmp = iov_cnt; 413 size = iov->iov_len + g_test_rand_int_range(1, iov[1].iov_len); 414 iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, size, &undo); 415 iov_discard_undo(&undo); 416 assert(iov_equals(iov, iov_orig, iov_cnt)); 417 g_free(iov_orig); 418 iov_free(iov, iov_cnt); 419 } 420 421 static void test_discard_back(void) 422 { 423 struct iovec *iov; 424 unsigned int iov_cnt; 425 unsigned int iov_cnt_tmp; 426 void *old_base; 427 size_t size; 428 size_t ret; 429 430 /* Discard zero bytes */ 431 iov_random(&iov, &iov_cnt); 432 iov_cnt_tmp = iov_cnt; 433 ret = iov_discard_back(iov, &iov_cnt_tmp, 0); 434 g_assert(ret == 0); 435 g_assert(iov_cnt_tmp == iov_cnt); 436 iov_free(iov, iov_cnt); 437 438 /* Discard more bytes than vector size */ 439 iov_random(&iov, &iov_cnt); 440 iov_cnt_tmp = iov_cnt; 441 size = iov_size(iov, iov_cnt); 442 ret = iov_discard_back(iov, &iov_cnt_tmp, size + 1); 443 g_assert(ret == size); 444 g_assert(iov_cnt_tmp == 0); 445 iov_free(iov, iov_cnt); 446 447 /* Discard entire vector */ 448 iov_random(&iov, &iov_cnt); 449 iov_cnt_tmp = iov_cnt; 450 size = iov_size(iov, iov_cnt); 451 ret = iov_discard_back(iov, &iov_cnt_tmp, size); 452 g_assert(ret == size); 453 g_assert(iov_cnt_tmp == 0); 454 iov_free(iov, iov_cnt); 455 456 /* Discard within last element */ 457 iov_random(&iov, &iov_cnt); 458 iov_cnt_tmp = iov_cnt; 459 old_base = iov[iov_cnt - 1].iov_base; 460 size = g_test_rand_int_range(1, iov[iov_cnt - 1].iov_len); 461 ret = iov_discard_back(iov, &iov_cnt_tmp, size); 462 g_assert(ret == size); 463 g_assert(iov_cnt_tmp == iov_cnt); 464 g_assert(iov[iov_cnt - 1].iov_base == old_base); 465 iov_free(iov, iov_cnt); 466 467 /* Discard entire last element */ 468 iov_random(&iov, &iov_cnt); 469 iov_cnt_tmp = iov_cnt; 470 old_base = iov[iov_cnt - 1].iov_base; 471 size = iov[iov_cnt - 1].iov_len; 472 ret = iov_discard_back(iov, &iov_cnt_tmp, size); 473 g_assert(ret == size); 474 g_assert(iov_cnt_tmp == iov_cnt - 1); 475 iov_free(iov, iov_cnt); 476 477 /* Discard within second-to-last element */ 478 iov_random(&iov, &iov_cnt); 479 iov_cnt_tmp = iov_cnt; 480 old_base = iov[iov_cnt - 2].iov_base; 481 size = iov[iov_cnt - 1].iov_len + 482 g_test_rand_int_range(1, iov[iov_cnt - 2].iov_len); 483 ret = iov_discard_back(iov, &iov_cnt_tmp, size); 484 g_assert(ret == size); 485 g_assert(iov_cnt_tmp == iov_cnt - 1); 486 g_assert(iov[iov_cnt - 2].iov_base == old_base); 487 iov_free(iov, iov_cnt); 488 } 489 490 static void test_discard_back_undo(void) 491 { 492 IOVDiscardUndo undo; 493 struct iovec *iov; 494 struct iovec *iov_orig; 495 unsigned int iov_cnt; 496 unsigned int iov_cnt_tmp; 497 size_t size; 498 499 /* Discard zero bytes */ 500 iov_random(&iov, &iov_cnt); 501 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 502 iov_cnt_tmp = iov_cnt; 503 iov_discard_back_undoable(iov, &iov_cnt_tmp, 0, &undo); 504 iov_discard_undo(&undo); 505 assert(iov_equals(iov, iov_orig, iov_cnt)); 506 g_free(iov_orig); 507 iov_free(iov, iov_cnt); 508 509 /* Discard more bytes than vector size */ 510 iov_random(&iov, &iov_cnt); 511 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 512 iov_cnt_tmp = iov_cnt; 513 size = iov_size(iov, iov_cnt); 514 iov_discard_back_undoable(iov, &iov_cnt_tmp, size + 1, &undo); 515 iov_discard_undo(&undo); 516 assert(iov_equals(iov, iov_orig, iov_cnt)); 517 g_free(iov_orig); 518 iov_free(iov, iov_cnt); 519 520 /* Discard entire vector */ 521 iov_random(&iov, &iov_cnt); 522 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 523 iov_cnt_tmp = iov_cnt; 524 size = iov_size(iov, iov_cnt); 525 iov_discard_back_undoable(iov, &iov_cnt_tmp, size, &undo); 526 iov_discard_undo(&undo); 527 assert(iov_equals(iov, iov_orig, iov_cnt)); 528 g_free(iov_orig); 529 iov_free(iov, iov_cnt); 530 531 /* Discard within last element */ 532 iov_random(&iov, &iov_cnt); 533 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 534 iov_cnt_tmp = iov_cnt; 535 size = g_test_rand_int_range(1, iov[iov_cnt - 1].iov_len); 536 iov_discard_back_undoable(iov, &iov_cnt_tmp, size, &undo); 537 iov_discard_undo(&undo); 538 assert(iov_equals(iov, iov_orig, iov_cnt)); 539 g_free(iov_orig); 540 iov_free(iov, iov_cnt); 541 542 /* Discard entire last element */ 543 iov_random(&iov, &iov_cnt); 544 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 545 iov_cnt_tmp = iov_cnt; 546 size = iov[iov_cnt - 1].iov_len; 547 iov_discard_back_undoable(iov, &iov_cnt_tmp, size, &undo); 548 iov_discard_undo(&undo); 549 assert(iov_equals(iov, iov_orig, iov_cnt)); 550 g_free(iov_orig); 551 iov_free(iov, iov_cnt); 552 553 /* Discard within second-to-last element */ 554 iov_random(&iov, &iov_cnt); 555 iov_orig = g_memdup2(iov, sizeof(iov[0]) * iov_cnt); 556 iov_cnt_tmp = iov_cnt; 557 size = iov[iov_cnt - 1].iov_len + 558 g_test_rand_int_range(1, iov[iov_cnt - 2].iov_len); 559 iov_discard_back_undoable(iov, &iov_cnt_tmp, size, &undo); 560 iov_discard_undo(&undo); 561 assert(iov_equals(iov, iov_orig, iov_cnt)); 562 g_free(iov_orig); 563 iov_free(iov, iov_cnt); 564 } 565 566 int main(int argc, char **argv) 567 { 568 g_test_init(&argc, &argv, NULL); 569 g_test_rand_int(); 570 g_test_add_func("/basic/iov/from-to-buf", test_to_from_buf); 571 g_test_add_func("/basic/iov/io", test_io); 572 g_test_add_func("/basic/iov/discard-front", test_discard_front); 573 g_test_add_func("/basic/iov/discard-back", test_discard_back); 574 g_test_add_func("/basic/iov/discard-front-undo", test_discard_front_undo); 575 g_test_add_func("/basic/iov/discard-back-undo", test_discard_back_undo); 576 return g_test_run(); 577 }