lib/kunit_iov_iter.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* I/O iterator tests.  This can only test kernel-backed iterator types.
   3  *
   4  * Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/module.h>
  11 #include <linux/vmalloc.h>
  12 #include <linux/mm.h>
  13 #include <linux/uio.h>
  14 #include <linux/bvec.h>
  15 #include <kunit/test.h>
  16
  17 MODULE_DESCRIPTION("iov_iter testing");
  18 MODULE_AUTHOR("David Howells <dhowells@redhat.com>");
  19 MODULE_LICENSE("GPL");
  20
  21 struct kvec_test_range {
  22         int     from, to;
  23 };
  24
  25 static const struct kvec_test_range kvec_test_ranges[] = {
  26         { 0x00002, 0x00002 },
  27         { 0x00027, 0x03000 },
  28         { 0x05193, 0x18794 },
  29         { 0x20000, 0x20000 },
  30         { 0x20000, 0x24000 },
  31         { 0x24000, 0x27001 },
  32         { 0x29000, 0xffffb },
  33         { 0xffffd, 0xffffe },
  34         { -1 }
  35 };
  36
  37 static inline u8 pattern(unsigned long x)
  38 {
  39         return x & 0xff;
  40 }
  41
  42 static void iov_kunit_unmap(void *data)
  43 {
  44         vunmap(data);
  45 }
  46
  47 static void *__init iov_kunit_create_buffer(struct kunit *test,
  48                                             struct page ***ppages,
  49                                             size_t npages)
  50 {
  51         struct page **pages;
  52         unsigned long got;
  53         void *buffer;
  54
  55         pages = kunit_kcalloc(test, npages, sizeof(struct page *), GFP_KERNEL);
  56         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pages);
  57         *ppages = pages;
  58
  59         got = alloc_pages_bulk_array(GFP_KERNEL, npages, pages);
  60         if (got != npages) {
  61                 release_pages(pages, got);
  62                 KUNIT_ASSERT_EQ(test, got, npages);
  63         }
  64
  65         buffer = vmap(pages, npages, VM_MAP | VM_MAP_PUT_PAGES, PAGE_KERNEL);
  66         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buffer);
  67
  68         kunit_add_action_or_reset(test, iov_kunit_unmap, buffer);
  69         return buffer;
  70 }
  71
  72 static void __init iov_kunit_load_kvec(struct kunit *test,
  73                                        struct iov_iter *iter, int dir,
  74                                        struct kvec *kvec, unsigned int kvmax,
  75                                        void *buffer, size_t bufsize,
  76                                        const struct kvec_test_range *pr)
  77 {
  78         size_t size = 0;
  79         int i;
  80
  81         for (i = 0; i < kvmax; i++, pr++) {
  82                 if (pr->from < 0)
  83                         break;
  84                 KUNIT_ASSERT_GE(test, pr->to, pr->from);
  85                 KUNIT_ASSERT_LE(test, pr->to, bufsize);
  86                 kvec[i].iov_base = buffer + pr->from;
  87                 kvec[i].iov_len = pr->to - pr->from;
  88                 size += pr->to - pr->from;
  89         }
  90         KUNIT_ASSERT_LE(test, size, bufsize);
  91
  92         iov_iter_kvec(iter, dir, kvec, i, size);
  93 }
  94
  95 /*
  96  * Test copying to a ITER_KVEC-type iterator.
  97  */
  98 static void __init iov_kunit_copy_to_kvec(struct kunit *test)
  99 {
 100         const struct kvec_test_range *pr;
 101         struct iov_iter iter;
 102         struct page **spages, **bpages;
 103         struct kvec kvec[8];
 104         u8 *scratch, *buffer;
 105         size_t bufsize, npages, size, copied;
 106         int i, patt;
 107
 108         bufsize = 0x100000;
 109         npages = bufsize / PAGE_SIZE;
 110
 111         scratch = iov_kunit_create_buffer(test, &spages, npages);
 112         for (i = 0; i < bufsize; i++)
 113                 scratch[i] = pattern(i);
 114
 115         buffer = iov_kunit_create_buffer(test, &bpages, npages);
 116         memset(buffer, 0, bufsize);
 117
 118         iov_kunit_load_kvec(test, &iter, READ, kvec, ARRAY_SIZE(kvec),
 119                             buffer, bufsize, kvec_test_ranges);
 120         size = iter.count;
 121
 122         copied = copy_to_iter(scratch, size, &iter);
 123
 124         KUNIT_EXPECT_EQ(test, copied, size);
 125         KUNIT_EXPECT_EQ(test, iter.count, 0);
 126         KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);
 127
 128         /* Build the expected image in the scratch buffer. */
 129         patt = 0;
 130         memset(scratch, 0, bufsize);
 131         for (pr = kvec_test_ranges; pr->from >= 0; pr++)
 132                 for (i = pr->from; i < pr->to; i++)
 133                         scratch[i] = pattern(patt++);
 134
 135         /* Compare the images */
 136         for (i = 0; i < bufsize; i++) {
 137                 KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
 138                 if (buffer[i] != scratch[i])
 139                         return;
 140         }
 141
 142         KUNIT_SUCCEED();
 143 }
 144
 145 /*
 146  * Test copying from a ITER_KVEC-type iterator.
 147  */
 148 static void __init iov_kunit_copy_from_kvec(struct kunit *test)
 149 {
 150         const struct kvec_test_range *pr;
 151         struct iov_iter iter;
 152         struct page **spages, **bpages;
 153         struct kvec kvec[8];
 154         u8 *scratch, *buffer;
 155         size_t bufsize, npages, size, copied;
 156         int i, j;
 157
 158         bufsize = 0x100000;
 159         npages = bufsize / PAGE_SIZE;
 160
 161         buffer = iov_kunit_create_buffer(test, &bpages, npages);
 162         for (i = 0; i < bufsize; i++)
 163                 buffer[i] = pattern(i);
 164
 165         scratch = iov_kunit_create_buffer(test, &spages, npages);
 166         memset(scratch, 0, bufsize);
 167
 168         iov_kunit_load_kvec(test, &iter, WRITE, kvec, ARRAY_SIZE(kvec),
 169                             buffer, bufsize, kvec_test_ranges);
 170         size = min(iter.count, bufsize);
 171
 172         copied = copy_from_iter(scratch, size, &iter);
 173
 174         KUNIT_EXPECT_EQ(test, copied, size);
 175         KUNIT_EXPECT_EQ(test, iter.count, 0);
 176         KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);
 177
 178         /* Build the expected image in the main buffer. */
 179         i = 0;
 180         memset(buffer, 0, bufsize);
 181         for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
 182                 for (j = pr->from; j < pr->to; j++) {
 183                         buffer[i++] = pattern(j);
 184                         if (i >= bufsize)
 185                                 goto stop;
 186                 }
 187         }
 188 stop:
 189
 190         /* Compare the images */
 191         for (i = 0; i < bufsize; i++) {
 192                 KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
 193                 if (scratch[i] != buffer[i])
 194                         return;
 195         }
 196
 197         KUNIT_SUCCEED();
 198 }
 199
 200 struct bvec_test_range {
 201         int     page, from, to;
 202 };
 203
 204 static const struct bvec_test_range bvec_test_ranges[] = {
 205         { 0, 0x0002, 0x0002 },
 206         { 1, 0x0027, 0x0893 },
 207         { 2, 0x0193, 0x0794 },
 208         { 3, 0x0000, 0x1000 },
 209         { 4, 0x0000, 0x1000 },
 210         { 5, 0x0000, 0x1000 },
 211         { 6, 0x0000, 0x0ffb },
 212         { 6, 0x0ffd, 0x0ffe },
 213         { -1, -1, -1 }
 214 };
 215
 216 static void __init iov_kunit_load_bvec(struct kunit *test,
 217                                        struct iov_iter *iter, int dir,
 218                                        struct bio_vec *bvec, unsigned int bvmax,
 219                                        struct page **pages, size_t npages,
 220                                        size_t bufsize,
 221                                        const struct bvec_test_range *pr)
 222 {
 223         struct page *can_merge = NULL, *page;
 224         size_t size = 0;
 225         int i;
 226
 227         for (i = 0; i < bvmax; i++, pr++) {
 228                 if (pr->from < 0)
 229                         break;
 230                 KUNIT_ASSERT_LT(test, pr->page, npages);
 231                 KUNIT_ASSERT_LT(test, pr->page * PAGE_SIZE, bufsize);
 232                 KUNIT_ASSERT_GE(test, pr->from, 0);
 233                 KUNIT_ASSERT_GE(test, pr->to, pr->from);
 234                 KUNIT_ASSERT_LE(test, pr->to, PAGE_SIZE);
 235
 236                 page = pages[pr->page];
 237                 if (pr->from == 0 && pr->from != pr->to && page == can_merge) {
 238                         i--;
 239                         bvec[i].bv_len += pr->to;
 240                 } else {
 241                         bvec_set_page(&bvec[i], page, pr->to - pr->from, pr->from);
 242                 }
 243
 244                 size += pr->to - pr->from;
 245                 if ((pr->to & ~PAGE_MASK) == 0)
 246                         can_merge = page + pr->to / PAGE_SIZE;
 247                 else
 248                         can_merge = NULL;
 249         }
 250
 251         iov_iter_bvec(iter, dir, bvec, i, size);
 252 }
 253
 254 /*
 255  * Test copying to a ITER_BVEC-type iterator.
 256  */
 257 static void __init iov_kunit_copy_to_bvec(struct kunit *test)
 258 {
 259         const struct bvec_test_range *pr;
 260         struct iov_iter iter;
 261         struct bio_vec bvec[8];
 262         struct page **spages, **bpages;
 263         u8 *scratch, *buffer;
 264         size_t bufsize, npages, size, copied;
 265         int i, b, patt;
 266
 267         bufsize = 0x100000;
 268         npages = bufsize / PAGE_SIZE;
 269
 270         scratch = iov_kunit_create_buffer(test, &spages, npages);
 271         for (i = 0; i < bufsize; i++)
 272                 scratch[i] = pattern(i);
 273
 274         buffer = iov_kunit_create_buffer(test, &bpages, npages);
 275         memset(buffer, 0, bufsize);
 276
 277         iov_kunit_load_bvec(test, &iter, READ, bvec, ARRAY_SIZE(bvec),
 278                             bpages, npages, bufsize, bvec_test_ranges);
 279         size = iter.count;
 280
 281         copied = copy_to_iter(scratch, size, &iter);
 282
 283         KUNIT_EXPECT_EQ(test, copied, size);
 284         KUNIT_EXPECT_EQ(test, iter.count, 0);
 285         KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);
 286
 287         /* Build the expected image in the scratch buffer. */
 288         b = 0;
 289         patt = 0;
 290         memset(scratch, 0, bufsize);
 291         for (pr = bvec_test_ranges; pr->from >= 0; pr++, b++) {
 292                 u8 *p = scratch + pr->page * PAGE_SIZE;
 293
 294                 for (i = pr->from; i < pr->to; i++)
 295                         p[i] = pattern(patt++);
 296         }
 297
 298         /* Compare the images */
 299         for (i = 0; i < bufsize; i++) {
 300                 KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
 301                 if (buffer[i] != scratch[i])
 302                         return;
 303         }
 304
 305         KUNIT_SUCCEED();
 306 }
 307
 308 /*
 309  * Test copying from a ITER_BVEC-type iterator.
 310  */
 311 static void __init iov_kunit_copy_from_bvec(struct kunit *test)
 312 {
 313         const struct bvec_test_range *pr;
 314         struct iov_iter iter;
 315         struct bio_vec bvec[8];
 316         struct page **spages, **bpages;
 317         u8 *scratch, *buffer;
 318         size_t bufsize, npages, size, copied;
 319         int i, j;
 320
 321         bufsize = 0x100000;
 322         npages = bufsize / PAGE_SIZE;
 323
 324         buffer = iov_kunit_create_buffer(test, &bpages, npages);
 325         for (i = 0; i < bufsize; i++)
 326                 buffer[i] = pattern(i);
 327
 328         scratch = iov_kunit_create_buffer(test, &spages, npages);
 329         memset(scratch, 0, bufsize);
 330
 331         iov_kunit_load_bvec(test, &iter, WRITE, bvec, ARRAY_SIZE(bvec),
 332                             bpages, npages, bufsize, bvec_test_ranges);
 333         size = iter.count;
 334
 335         copied = copy_from_iter(scratch, size, &iter);
 336
 337         KUNIT_EXPECT_EQ(test, copied, size);
 338         KUNIT_EXPECT_EQ(test, iter.count, 0);
 339         KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);
 340
 341         /* Build the expected image in the main buffer. */
 342         i = 0;
 343         memset(buffer, 0, bufsize);
 344         for (pr = bvec_test_ranges; pr->from >= 0; pr++) {
 345                 size_t patt = pr->page * PAGE_SIZE;
 346
 347                 for (j = pr->from; j < pr->to; j++) {
 348                         buffer[i++] = pattern(patt + j);
 349                         if (i >= bufsize)
 350                                 goto stop;
 351                 }
 352         }
 353 stop:
 354
 355         /* Compare the images */
 356         for (i = 0; i < bufsize; i++) {
 357                 KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
 358                 if (scratch[i] != buffer[i])
 359                         return;
 360         }
 361
 362         KUNIT_SUCCEED();
 363 }
 364
 365 static void iov_kunit_destroy_xarray(void *data)
 366 {
 367         struct xarray *xarray = data;
 368
 369         xa_destroy(xarray);
 370         kfree(xarray);
 371 }
 372
 373 static void __init iov_kunit_load_xarray(struct kunit *test,
 374                                          struct iov_iter *iter, int dir,
 375                                          struct xarray *xarray,
 376                                          struct page **pages, size_t npages)
 377 {
 378         size_t size = 0;
 379         int i;
 380
 381         for (i = 0; i < npages; i++) {
 382                 void *x = xa_store(xarray, i, pages[i], GFP_KERNEL);
 383
 384                 KUNIT_ASSERT_FALSE(test, xa_is_err(x));
 385                 size += PAGE_SIZE;
 386         }
 387         iov_iter_xarray(iter, dir, xarray, 0, size);
 388 }
 389
 390 static struct xarray *iov_kunit_create_xarray(struct kunit *test)
 391 {
 392         struct xarray *xarray;
 393
 394         xarray = kzalloc(sizeof(struct xarray), GFP_KERNEL);
 395         xa_init(xarray);
 396         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xarray);
 397         kunit_add_action_or_reset(test, iov_kunit_destroy_xarray, xarray);
 398         return xarray;
 399 }
 400
 401 /*
 402  * Test copying to a ITER_XARRAY-type iterator.
 403  */
 404 static void __init iov_kunit_copy_to_xarray(struct kunit *test)
 405 {
 406         const struct kvec_test_range *pr;
 407         struct iov_iter iter;
 408         struct xarray *xarray;
 409         struct page **spages, **bpages;
 410         u8 *scratch, *buffer;
 411         size_t bufsize, npages, size, copied;
 412         int i, patt;
 413
 414         bufsize = 0x100000;
 415         npages = bufsize / PAGE_SIZE;
 416
 417         xarray = iov_kunit_create_xarray(test);
 418
 419         scratch = iov_kunit_create_buffer(test, &spages, npages);
 420         for (i = 0; i < bufsize; i++)
 421                 scratch[i] = pattern(i);
 422
 423         buffer = iov_kunit_create_buffer(test, &bpages, npages);
 424         memset(buffer, 0, bufsize);
 425
 426         iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);
 427
 428         i = 0;
 429         for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
 430                 size = pr->to - pr->from;
 431                 KUNIT_ASSERT_LE(test, pr->to, bufsize);
 432
 433                 iov_iter_xarray(&iter, READ, xarray, pr->from, size);
 434                 copied = copy_to_iter(scratch + i, size, &iter);
 435
 436                 KUNIT_EXPECT_EQ(test, copied, size);
 437                 KUNIT_EXPECT_EQ(test, iter.count, 0);
 438                 KUNIT_EXPECT_EQ(test, iter.iov_offset, size);
 439                 i += size;
 440         }
 441
 442         /* Build the expected image in the scratch buffer. */
 443         patt = 0;
 444         memset(scratch, 0, bufsize);
 445         for (pr = kvec_test_ranges; pr->from >= 0; pr++)
 446                 for (i = pr->from; i < pr->to; i++)
 447                         scratch[i] = pattern(patt++);
 448
 449         /* Compare the images */
 450         for (i = 0; i < bufsize; i++) {
 451                 KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
 452                 if (buffer[i] != scratch[i])
 453                         return;
 454         }
 455
 456         KUNIT_SUCCEED();
 457 }
 458
 459 /*
 460  * Test copying from a ITER_XARRAY-type iterator.
 461  */
 462 static void __init iov_kunit_copy_from_xarray(struct kunit *test)
 463 {
 464         const struct kvec_test_range *pr;
 465         struct iov_iter iter;
 466         struct xarray *xarray;
 467         struct page **spages, **bpages;
 468         u8 *scratch, *buffer;
 469         size_t bufsize, npages, size, copied;
 470         int i, j;
 471
 472         bufsize = 0x100000;
 473         npages = bufsize / PAGE_SIZE;
 474
 475         xarray = iov_kunit_create_xarray(test);
 476
 477         buffer = iov_kunit_create_buffer(test, &bpages, npages);
 478         for (i = 0; i < bufsize; i++)
 479                 buffer[i] = pattern(i);
 480
 481         scratch = iov_kunit_create_buffer(test, &spages, npages);
 482         memset(scratch, 0, bufsize);
 483
 484         iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);
 485
 486         i = 0;
 487         for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
 488                 size = pr->to - pr->from;
 489                 KUNIT_ASSERT_LE(test, pr->to, bufsize);
 490
 491                 iov_iter_xarray(&iter, WRITE, xarray, pr->from, size);
 492                 copied = copy_from_iter(scratch + i, size, &iter);
 493
 494                 KUNIT_EXPECT_EQ(test, copied, size);
 495                 KUNIT_EXPECT_EQ(test, iter.count, 0);
 496                 KUNIT_EXPECT_EQ(test, iter.iov_offset, size);
 497                 i += size;
 498         }
 499
 500         /* Build the expected image in the main buffer. */
 501         i = 0;
 502         memset(buffer, 0, bufsize);
 503         for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
 504                 for (j = pr->from; j < pr->to; j++) {
 505                         buffer[i++] = pattern(j);
 506                         if (i >= bufsize)
 507                                 goto stop;
 508                 }
 509         }
 510 stop:
 511
 512         /* Compare the images */
 513         for (i = 0; i < bufsize; i++) {
 514                 KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
 515                 if (scratch[i] != buffer[i])
 516                         return;
 517         }
 518
 519         KUNIT_SUCCEED();
 520 }
 521
 522 /*
 523  * Test the extraction of ITER_KVEC-type iterators.
 524  */
 525 static void __init iov_kunit_extract_pages_kvec(struct kunit *test)
 526 {
 527         const struct kvec_test_range *pr;
 528         struct iov_iter iter;
 529         struct page **bpages, *pagelist[8], **pages = pagelist;
 530         struct kvec kvec[8];
 531         u8 *buffer;
 532         ssize_t len;
 533         size_t bufsize, size = 0, npages;
 534         int i, from;
 535
 536         bufsize = 0x100000;
 537         npages = bufsize / PAGE_SIZE;
 538
 539         buffer = iov_kunit_create_buffer(test, &bpages, npages);
 540
 541         iov_kunit_load_kvec(test, &iter, READ, kvec, ARRAY_SIZE(kvec),
 542                             buffer, bufsize, kvec_test_ranges);
 543         size = iter.count;
 544
 545         pr = kvec_test_ranges;
 546         from = pr->from;
 547         do {
 548                 size_t offset0 = LONG_MAX;
 549
 550                 for (i = 0; i < ARRAY_SIZE(pagelist); i++)
 551                         pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;
 552
 553                 len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
 554                                              ARRAY_SIZE(pagelist), 0, &offset0);
 555                 KUNIT_EXPECT_GE(test, len, 0);
 556                 if (len < 0)
 557                         break;
 558                 KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
 559                 KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);
 560                 KUNIT_EXPECT_LE(test, len, size);
 561                 KUNIT_EXPECT_EQ(test, iter.count, size - len);
 562                 size -= len;
 563
 564                 if (len == 0)
 565                         break;
 566
 567                 for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
 568                         struct page *p;
 569                         ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
 570                         int ix;
 571
 572                         KUNIT_ASSERT_GE(test, part, 0);
 573                         while (from == pr->to) {
 574                                 pr++;
 575                                 from = pr->from;
 576                                 if (from < 0)
 577                                         goto stop;
 578                         }
 579                         ix = from / PAGE_SIZE;
 580                         KUNIT_ASSERT_LT(test, ix, npages);
 581                         p = bpages[ix];
 582                         KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
 583                         KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
 584                         from += part;
 585                         len -= part;
 586                         KUNIT_ASSERT_GE(test, len, 0);
 587                         if (len == 0)
 588                                 break;
 589                         offset0 = 0;
 590                 }
 591
 592                 if (test->status == KUNIT_FAILURE)
 593                         break;
 594         } while (iov_iter_count(&iter) > 0);
 595
 596 stop:
 597         KUNIT_EXPECT_EQ(test, size, 0);
 598         KUNIT_EXPECT_EQ(test, iter.count, 0);
 599         KUNIT_SUCCEED();
 600 }
 601
 602 /*
 603  * Test the extraction of ITER_BVEC-type iterators.
 604  */
 605 static void __init iov_kunit_extract_pages_bvec(struct kunit *test)
 606 {
 607         const struct bvec_test_range *pr;
 608         struct iov_iter iter;
 609         struct page **bpages, *pagelist[8], **pages = pagelist;
 610         struct bio_vec bvec[8];
 611         ssize_t len;
 612         size_t bufsize, size = 0, npages;
 613         int i, from;
 614
 615         bufsize = 0x100000;
 616         npages = bufsize / PAGE_SIZE;
 617
 618         iov_kunit_create_buffer(test, &bpages, npages);
 619         iov_kunit_load_bvec(test, &iter, READ, bvec, ARRAY_SIZE(bvec),
 620                             bpages, npages, bufsize, bvec_test_ranges);
 621         size = iter.count;
 622
 623         pr = bvec_test_ranges;
 624         from = pr->from;
 625         do {
 626                 size_t offset0 = LONG_MAX;
 627
 628                 for (i = 0; i < ARRAY_SIZE(pagelist); i++)
 629                         pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;
 630
 631                 len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
 632                                              ARRAY_SIZE(pagelist), 0, &offset0);
 633                 KUNIT_EXPECT_GE(test, len, 0);
 634                 if (len < 0)
 635                         break;
 636                 KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
 637                 KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);
 638                 KUNIT_EXPECT_LE(test, len, size);
 639                 KUNIT_EXPECT_EQ(test, iter.count, size - len);
 640                 size -= len;
 641
 642                 if (len == 0)
 643                         break;
 644
 645                 for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
 646                         struct page *p;
 647                         ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
 648                         int ix;
 649
 650                         KUNIT_ASSERT_GE(test, part, 0);
 651                         while (from == pr->to) {
 652                                 pr++;
 653                                 from = pr->from;
 654                                 if (from < 0)
 655                                         goto stop;
 656                         }
 657                         ix = pr->page + from / PAGE_SIZE;
 658                         KUNIT_ASSERT_LT(test, ix, npages);
 659                         p = bpages[ix];
 660                         KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
 661                         KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
 662                         from += part;
 663                         len -= part;
 664                         KUNIT_ASSERT_GE(test, len, 0);
 665                         if (len == 0)
 666                                 break;
 667                         offset0 = 0;
 668                 }
 669
 670                 if (test->status == KUNIT_FAILURE)
 671                         break;
 672         } while (iov_iter_count(&iter) > 0);
 673
 674 stop:
 675         KUNIT_EXPECT_EQ(test, size, 0);
 676         KUNIT_EXPECT_EQ(test, iter.count, 0);
 677         KUNIT_SUCCEED();
 678 }
 679
 680 /*
 681  * Test the extraction of ITER_XARRAY-type iterators.
 682  */
 683 static void __init iov_kunit_extract_pages_xarray(struct kunit *test)
 684 {
 685         const struct kvec_test_range *pr;
 686         struct iov_iter iter;
 687         struct xarray *xarray;
 688         struct page **bpages, *pagelist[8], **pages = pagelist;
 689         ssize_t len;
 690         size_t bufsize, size = 0, npages;
 691         int i, from;
 692
 693         bufsize = 0x100000;
 694         npages = bufsize / PAGE_SIZE;
 695
 696         xarray = iov_kunit_create_xarray(test);
 697
 698         iov_kunit_create_buffer(test, &bpages, npages);
 699         iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);
 700
 701         for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
 702                 from = pr->from;
 703                 size = pr->to - from;
 704                 KUNIT_ASSERT_LE(test, pr->to, bufsize);
 705
 706                 iov_iter_xarray(&iter, WRITE, xarray, from, size);
 707
 708                 do {
 709                         size_t offset0 = LONG_MAX;
 710
 711                         for (i = 0; i < ARRAY_SIZE(pagelist); i++)
 712                                 pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;
 713
 714                         len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
 715                                                      ARRAY_SIZE(pagelist), 0, &offset0);
 716                         KUNIT_EXPECT_GE(test, len, 0);
 717                         if (len < 0)
 718                                 break;
 719                         KUNIT_EXPECT_LE(test, len, size);
 720                         KUNIT_EXPECT_EQ(test, iter.count, size - len);
 721                         if (len == 0)
 722                                 break;
 723                         size -= len;
 724                         KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
 725                         KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);
 726
 727                         for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
 728                                 struct page *p;
 729                                 ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
 730                                 int ix;
 731
 732                                 KUNIT_ASSERT_GE(test, part, 0);
 733                                 ix = from / PAGE_SIZE;
 734                                 KUNIT_ASSERT_LT(test, ix, npages);
 735                                 p = bpages[ix];
 736                                 KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
 737                                 KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
 738                                 from += part;
 739                                 len -= part;
 740                                 KUNIT_ASSERT_GE(test, len, 0);
 741                                 if (len == 0)
 742                                         break;
 743                                 offset0 = 0;
 744                         }
 745
 746                         if (test->status == KUNIT_FAILURE)
 747                                 goto stop;
 748                 } while (iov_iter_count(&iter) > 0);
 749
 750                 KUNIT_EXPECT_EQ(test, size, 0);
 751                 KUNIT_EXPECT_EQ(test, iter.count, 0);
 752                 KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to - pr->from);
 753         }
 754
 755 stop:
 756         KUNIT_SUCCEED();
 757 }
 758
 759 static struct kunit_case __refdata iov_kunit_cases[] = {
 760         KUNIT_CASE(iov_kunit_copy_to_kvec),
 761         KUNIT_CASE(iov_kunit_copy_from_kvec),
 762         KUNIT_CASE(iov_kunit_copy_to_bvec),
 763         KUNIT_CASE(iov_kunit_copy_from_bvec),
 764         KUNIT_CASE(iov_kunit_copy_to_xarray),
 765         KUNIT_CASE(iov_kunit_copy_from_xarray),
 766         KUNIT_CASE(iov_kunit_extract_pages_kvec),
 767         KUNIT_CASE(iov_kunit_extract_pages_bvec),
 768         KUNIT_CASE(iov_kunit_extract_pages_xarray),
 769         {}
 770 };
 771
 772 static struct kunit_suite iov_kunit_suite = {
 773         .name = "iov_iter",
 774         .test_cases = iov_kunit_cases,
 775 };
 776
 777 kunit_test_suites(&iov_kunit_suite);