Lines Matching +full:buffer +full:- +full:size
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* I/O iterator tests. This can only test kernel-backed iterator types.
35 { -1 }
54 void *buffer;
66 buffer = vmap(pages, npages, VM_MAP | VM_MAP_PUT_PAGES, PAGE_KERNEL);
67 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buffer);
69 kunit_add_action_or_reset(test, iov_kunit_unmap, buffer);
70 return buffer;
76 void *buffer, size_t bufsize,
79 size_t size = 0;
83 if (pr->from < 0)
85 KUNIT_ASSERT_GE(test, pr->to, pr->from);
86 KUNIT_ASSERT_LE(test, pr->to, bufsize);
87 kvec[i].iov_base = buffer + pr->from;
88 kvec[i].iov_len = pr->to - pr->from;
89 size += pr->to - pr->from;
91 KUNIT_ASSERT_LE(test, size, bufsize);
93 iov_iter_kvec(iter, dir, kvec, i, size);
97 * Test copying to a ITER_KVEC-type iterator.
105 u8 *scratch, *buffer;
106 size_t bufsize, npages, size, copied;
116 buffer = iov_kunit_create_buffer(test, &bpages, npages);
117 memset(buffer, 0, bufsize);
120 buffer, bufsize, kvec_test_ranges);
121 size = iter.count;
123 copied = copy_to_iter(scratch, size, &iter);
125 KUNIT_EXPECT_EQ(test, copied, size);
129 /* Build the expected image in the scratch buffer. */
132 for (pr = kvec_test_ranges; pr->from >= 0; pr++)
133 for (i = pr->from; i < pr->to; i++)
138 KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
139 if (buffer[i] != scratch[i])
147 * Test copying from a ITER_KVEC-type iterator.
155 u8 *scratch, *buffer;
156 size_t bufsize, npages, size, copied;
162 buffer = iov_kunit_create_buffer(test, &bpages, npages);
164 buffer[i] = pattern(i);
170 buffer, bufsize, kvec_test_ranges);
171 size = min(iter.count, bufsize);
173 copied = copy_from_iter(scratch, size, &iter);
175 KUNIT_EXPECT_EQ(test, copied, size);
179 /* Build the expected image in the main buffer. */
181 memset(buffer, 0, bufsize);
182 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
183 for (j = pr->from; j < pr->to; j++) {
184 buffer[i++] = pattern(j);
193 KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
194 if (scratch[i] != buffer[i])
214 { -1, -1, -1 }
225 size_t size = 0;
229 if (pr->from < 0)
231 KUNIT_ASSERT_LT(test, pr->page, npages);
232 KUNIT_ASSERT_LT(test, pr->page * PAGE_SIZE, bufsize);
233 KUNIT_ASSERT_GE(test, pr->from, 0);
234 KUNIT_ASSERT_GE(test, pr->to, pr->from);
235 KUNIT_ASSERT_LE(test, pr->to, PAGE_SIZE);
237 page = pages[pr->page];
238 if (pr->from == 0 && pr->from != pr->to && page == can_merge) {
239 i--;
240 bvec[i].bv_len += pr->to;
242 bvec_set_page(&bvec[i], page, pr->to - pr->from, pr->from);
245 size += pr->to - pr->from;
246 if ((pr->to & ~PAGE_MASK) == 0)
247 can_merge = page + pr->to / PAGE_SIZE;
252 iov_iter_bvec(iter, dir, bvec, i, size);
256 * Test copying to a ITER_BVEC-type iterator.
264 u8 *scratch, *buffer;
265 size_t bufsize, npages, size, copied;
275 buffer = iov_kunit_create_buffer(test, &bpages, npages);
276 memset(buffer, 0, bufsize);
280 size = iter.count;
282 copied = copy_to_iter(scratch, size, &iter);
284 KUNIT_EXPECT_EQ(test, copied, size);
288 /* Build the expected image in the scratch buffer. */
292 for (pr = bvec_test_ranges; pr->from >= 0; pr++, b++) {
293 u8 *p = scratch + pr->page * PAGE_SIZE;
295 for (i = pr->from; i < pr->to; i++)
301 KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
302 if (buffer[i] != scratch[i])
310 * Test copying from a ITER_BVEC-type iterator.
318 u8 *scratch, *buffer;
319 size_t bufsize, npages, size, copied;
325 buffer = iov_kunit_create_buffer(test, &bpages, npages);
327 buffer[i] = pattern(i);
334 size = iter.count;
336 copied = copy_from_iter(scratch, size, &iter);
338 KUNIT_EXPECT_EQ(test, copied, size);
342 /* Build the expected image in the main buffer. */
344 memset(buffer, 0, bufsize);
345 for (pr = bvec_test_ranges; pr->from >= 0; pr++) {
346 size_t patt = pr->page * PAGE_SIZE;
348 for (j = pr->from; j < pr->to; j++) {
349 buffer[i++] = pattern(patt + j);
358 KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
359 if (scratch[i] != buffer[i])
371 next = folioq->next;
385 size_t size = 0;
390 p->next = kzalloc(sizeof(struct folio_queue), GFP_KERNEL);
391 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p->next);
392 folioq_init(p->next, 0);
393 p->next->prev = p;
394 p = p->next;
397 size += PAGE_SIZE;
399 iov_iter_folio_queue(iter, dir, folioq, 0, 0, size);
414 * Test copying to a ITER_FOLIOQ-type iterator.
422 u8 *scratch, *buffer;
423 size_t bufsize, npages, size, copied;
435 buffer = iov_kunit_create_buffer(test, &bpages, npages);
436 memset(buffer, 0, bufsize);
441 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
442 size = pr->to - pr->from;
443 KUNIT_ASSERT_LE(test, pr->to, bufsize);
445 iov_iter_folio_queue(&iter, READ, folioq, 0, 0, pr->to);
446 iov_iter_advance(&iter, pr->from);
447 copied = copy_to_iter(scratch + i, size, &iter);
449 KUNIT_EXPECT_EQ(test, copied, size);
451 KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to % PAGE_SIZE);
452 i += size;
453 if (test->status == KUNIT_FAILURE)
457 /* Build the expected image in the scratch buffer. */
460 for (pr = kvec_test_ranges; pr->from >= 0; pr++)
461 for (i = pr->from; i < pr->to; i++)
466 KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
467 if (buffer[i] != scratch[i])
476 * Test copying from a ITER_FOLIOQ-type iterator.
484 u8 *scratch, *buffer;
485 size_t bufsize, npages, size, copied;
493 buffer = iov_kunit_create_buffer(test, &bpages, npages);
495 buffer[i] = pattern(i);
503 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
504 size = pr->to - pr->from;
505 KUNIT_ASSERT_LE(test, pr->to, bufsize);
507 iov_iter_folio_queue(&iter, WRITE, folioq, 0, 0, pr->to);
508 iov_iter_advance(&iter, pr->from);
509 copied = copy_from_iter(scratch + i, size, &iter);
511 KUNIT_EXPECT_EQ(test, copied, size);
513 KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to % PAGE_SIZE);
514 i += size;
517 /* Build the expected image in the main buffer. */
519 memset(buffer, 0, bufsize);
520 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
521 for (j = pr->from; j < pr->to; j++) {
522 buffer[i++] = pattern(j);
531 KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
532 if (scratch[i] != buffer[i])
552 size_t size = 0;
559 size += PAGE_SIZE;
561 iov_iter_xarray(iter, dir, xarray, 0, size);
576 * Test copying to a ITER_XARRAY-type iterator.
584 u8 *scratch, *buffer;
585 size_t bufsize, npages, size, copied;
597 buffer = iov_kunit_create_buffer(test, &bpages, npages);
598 memset(buffer, 0, bufsize);
603 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
604 size = pr->to - pr->from;
605 KUNIT_ASSERT_LE(test, pr->to, bufsize);
607 iov_iter_xarray(&iter, READ, xarray, pr->from, size);
608 copied = copy_to_iter(scratch + i, size, &iter);
610 KUNIT_EXPECT_EQ(test, copied, size);
612 KUNIT_EXPECT_EQ(test, iter.iov_offset, size);
613 i += size;
616 /* Build the expected image in the scratch buffer. */
619 for (pr = kvec_test_ranges; pr->from >= 0; pr++)
620 for (i = pr->from; i < pr->to; i++)
625 KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
626 if (buffer[i] != scratch[i])
634 * Test copying from a ITER_XARRAY-type iterator.
642 u8 *scratch, *buffer;
643 size_t bufsize, npages, size, copied;
651 buffer = iov_kunit_create_buffer(test, &bpages, npages);
653 buffer[i] = pattern(i);
661 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
662 size = pr->to - pr->from;
663 KUNIT_ASSERT_LE(test, pr->to, bufsize);
665 iov_iter_xarray(&iter, WRITE, xarray, pr->from, size);
666 copied = copy_from_iter(scratch + i, size, &iter);
668 KUNIT_EXPECT_EQ(test, copied, size);
670 KUNIT_EXPECT_EQ(test, iter.iov_offset, size);
671 i += size;
674 /* Build the expected image in the main buffer. */
676 memset(buffer, 0, bufsize);
677 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
678 for (j = pr->from; j < pr->to; j++) {
679 buffer[i++] = pattern(j);
688 KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
689 if (scratch[i] != buffer[i])
697 * Test the extraction of ITER_KVEC-type iterators.
705 u8 *buffer;
707 size_t bufsize, size = 0, npages;
713 buffer = iov_kunit_create_buffer(test, &bpages, npages);
716 buffer, bufsize, kvec_test_ranges);
717 size = iter.count;
720 from = pr->from;
734 KUNIT_EXPECT_LE(test, len, size);
735 KUNIT_EXPECT_EQ(test, iter.count, size - len);
736 size -= len;
743 ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
747 while (from == pr->to) {
749 from = pr->from;
759 len -= part;
766 if (test->status == KUNIT_FAILURE)
771 KUNIT_EXPECT_EQ(test, size, 0);
777 * Test the extraction of ITER_BVEC-type iterators.
786 size_t bufsize, size = 0, npages;
795 size = iter.count;
798 from = pr->from;
812 KUNIT_EXPECT_LE(test, len, size);
813 KUNIT_EXPECT_EQ(test, iter.count, size - len);
814 size -= len;
821 ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
825 while (from == pr->to) {
827 from = pr->from;
831 ix = pr->page + from / PAGE_SIZE;
837 len -= part;
844 if (test->status == KUNIT_FAILURE)
849 KUNIT_EXPECT_EQ(test, size, 0);
855 * Test the extraction of ITER_FOLIOQ-type iterators.
864 size_t bufsize, size = 0, npages;
875 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
876 from = pr->from;
877 size = pr->to - from;
878 KUNIT_ASSERT_LE(test, pr->to, bufsize);
880 iov_iter_folio_queue(&iter, WRITE, folioq, 0, 0, pr->to);
894 KUNIT_EXPECT_LE(test, len, size);
895 KUNIT_EXPECT_EQ(test, iter.count, size - len);
898 size -= len;
904 ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
914 len -= part;
921 if (test->status == KUNIT_FAILURE)
925 KUNIT_EXPECT_EQ(test, size, 0);
934 * Test the extraction of ITER_XARRAY-type iterators.
943 size_t bufsize, size = 0, npages;
954 for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
955 from = pr->from;
956 size = pr->to - from;
957 KUNIT_ASSERT_LE(test, pr->to, bufsize);
959 iov_iter_xarray(&iter, WRITE, xarray, from, size);
972 KUNIT_EXPECT_LE(test, len, size);
973 KUNIT_EXPECT_EQ(test, iter.count, size - len);
976 size -= len;
982 ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
992 len -= part;
999 if (test->status == KUNIT_FAILURE)
1003 KUNIT_EXPECT_EQ(test, size, 0);
1005 KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to - pr->from);