xref: /openbmc/qemu/tests/unit/test-iov.c (revision d2dfe0b5) 
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 }
578