1// SPDX-License-Identifier: GPL-2.0 2/* 3 * KUnit test for the Kernel Linked-list structures. 4 * 5 * Copyright (C) 2019, Google LLC. 6 * Author: David Gow <davidgow@google.com> 7 */ 8#include <kunit/test.h> 9 10#include <linux/list.h> 11#include <linux/klist.h> 12 13struct list_test_struct { 14 int data; 15 struct list_head list; 16}; 17 18static void list_test_list_init(struct kunit *test) 19{ 20 /* Test the different ways of initialising a list. */ 21 struct list_head list1 = LIST_HEAD_INIT(list1); 22 struct list_head list2; 23 LIST_HEAD(list3); 24 struct list_head *list4; 25 struct list_head *list5; 26 27 INIT_LIST_HEAD(&list2); 28 29 list4 = kzalloc(sizeof(*list4), GFP_KERNEL | __GFP_NOFAIL); 30 INIT_LIST_HEAD(list4); 31 32 list5 = kmalloc(sizeof(*list5), GFP_KERNEL | __GFP_NOFAIL); 33 memset(list5, 0xFF, sizeof(*list5)); 34 INIT_LIST_HEAD(list5); 35 36 /* list_empty_careful() checks both next and prev. */ 37 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list1)); 38 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 39 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list3)); 40 KUNIT_EXPECT_TRUE(test, list_empty_careful(list4)); 41 KUNIT_EXPECT_TRUE(test, list_empty_careful(list5)); 42 43 kfree(list4); 44 kfree(list5); 45} 46 47static void list_test_list_add(struct kunit *test) 48{ 49 struct list_head a, b; 50 LIST_HEAD(list); 51 52 list_add(&a, &list); 53 list_add(&b, &list); 54 55 /* should be [list] -> b -> a */ 56 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 57 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 58 KUNIT_EXPECT_PTR_EQ(test, b.next, &a); 59} 60 61static void list_test_list_add_tail(struct kunit *test) 62{ 63 struct list_head a, b; 64 LIST_HEAD(list); 65 66 list_add_tail(&a, &list); 67 list_add_tail(&b, &list); 68 69 /* should be [list] -> a -> b */ 70 KUNIT_EXPECT_PTR_EQ(test, list.next, &a); 71 KUNIT_EXPECT_PTR_EQ(test, a.prev, &list); 72 KUNIT_EXPECT_PTR_EQ(test, a.next, &b); 73} 74 75static void list_test_list_del(struct kunit *test) 76{ 77 struct list_head a, b; 78 LIST_HEAD(list); 79 80 list_add_tail(&a, &list); 81 list_add_tail(&b, &list); 82 83 /* before: [list] -> a -> b */ 84 list_del(&a); 85 86 /* now: [list] -> b */ 87 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 88 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 89} 90 91static void list_test_list_replace(struct kunit *test) 92{ 93 struct list_head a_old, a_new, b; 94 LIST_HEAD(list); 95 96 list_add_tail(&a_old, &list); 97 list_add_tail(&b, &list); 98 99 /* before: [list] -> a_old -> b */ 100 list_replace(&a_old, &a_new); 101 102 /* now: [list] -> a_new -> b */ 103 KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new); 104 KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new); 105} 106 107static void list_test_list_replace_init(struct kunit *test) 108{ 109 struct list_head a_old, a_new, b; 110 LIST_HEAD(list); 111 112 list_add_tail(&a_old, &list); 113 list_add_tail(&b, &list); 114 115 /* before: [list] -> a_old -> b */ 116 list_replace_init(&a_old, &a_new); 117 118 /* now: [list] -> a_new -> b */ 119 KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new); 120 KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new); 121 122 /* check a_old is empty (initialized) */ 123 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a_old)); 124} 125 126static void list_test_list_swap(struct kunit *test) 127{ 128 struct list_head a, b; 129 LIST_HEAD(list); 130 131 list_add_tail(&a, &list); 132 list_add_tail(&b, &list); 133 134 /* before: [list] -> a -> b */ 135 list_swap(&a, &b); 136 137 /* after: [list] -> b -> a */ 138 KUNIT_EXPECT_PTR_EQ(test, &b, list.next); 139 KUNIT_EXPECT_PTR_EQ(test, &a, list.prev); 140 141 KUNIT_EXPECT_PTR_EQ(test, &a, b.next); 142 KUNIT_EXPECT_PTR_EQ(test, &list, b.prev); 143 144 KUNIT_EXPECT_PTR_EQ(test, &list, a.next); 145 KUNIT_EXPECT_PTR_EQ(test, &b, a.prev); 146} 147 148static void list_test_list_del_init(struct kunit *test) 149{ 150 struct list_head a, b; 151 LIST_HEAD(list); 152 153 list_add_tail(&a, &list); 154 list_add_tail(&b, &list); 155 156 /* before: [list] -> a -> b */ 157 list_del_init(&a); 158 /* after: [list] -> b, a initialised */ 159 160 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 161 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 162 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a)); 163} 164 165static void list_test_list_del_init_careful(struct kunit *test) 166{ 167 /* NOTE: This test only checks the behaviour of this function in 168 * isolation. It does not verify memory model guarantees. 169 */ 170 struct list_head a, b; 171 LIST_HEAD(list); 172 173 list_add_tail(&a, &list); 174 list_add_tail(&b, &list); 175 176 /* before: [list] -> a -> b */ 177 list_del_init_careful(&a); 178 /* after: [list] -> b, a initialised */ 179 180 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 181 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 182 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a)); 183} 184 185static void list_test_list_move(struct kunit *test) 186{ 187 struct list_head a, b; 188 LIST_HEAD(list1); 189 LIST_HEAD(list2); 190 191 list_add_tail(&a, &list1); 192 list_add_tail(&b, &list2); 193 194 /* before: [list1] -> a, [list2] -> b */ 195 list_move(&a, &list2); 196 /* after: [list1] empty, [list2] -> a -> b */ 197 198 KUNIT_EXPECT_TRUE(test, list_empty(&list1)); 199 200 KUNIT_EXPECT_PTR_EQ(test, &a, list2.next); 201 KUNIT_EXPECT_PTR_EQ(test, &b, a.next); 202} 203 204static void list_test_list_move_tail(struct kunit *test) 205{ 206 struct list_head a, b; 207 LIST_HEAD(list1); 208 LIST_HEAD(list2); 209 210 list_add_tail(&a, &list1); 211 list_add_tail(&b, &list2); 212 213 /* before: [list1] -> a, [list2] -> b */ 214 list_move_tail(&a, &list2); 215 /* after: [list1] empty, [list2] -> b -> a */ 216 217 KUNIT_EXPECT_TRUE(test, list_empty(&list1)); 218 219 KUNIT_EXPECT_PTR_EQ(test, &b, list2.next); 220 KUNIT_EXPECT_PTR_EQ(test, &a, b.next); 221} 222 223static void list_test_list_bulk_move_tail(struct kunit *test) 224{ 225 struct list_head a, b, c, d, x, y; 226 struct list_head *list1_values[] = { &x, &b, &c, &y }; 227 struct list_head *list2_values[] = { &a, &d }; 228 struct list_head *ptr; 229 LIST_HEAD(list1); 230 LIST_HEAD(list2); 231 int i = 0; 232 233 list_add_tail(&x, &list1); 234 list_add_tail(&y, &list1); 235 236 list_add_tail(&a, &list2); 237 list_add_tail(&b, &list2); 238 list_add_tail(&c, &list2); 239 list_add_tail(&d, &list2); 240 241 /* before: [list1] -> x -> y, [list2] -> a -> b -> c -> d */ 242 list_bulk_move_tail(&y, &b, &c); 243 /* after: [list1] -> x -> b -> c -> y, [list2] -> a -> d */ 244 245 list_for_each(ptr, &list1) { 246 KUNIT_EXPECT_PTR_EQ(test, ptr, list1_values[i]); 247 i++; 248 } 249 KUNIT_EXPECT_EQ(test, i, 4); 250 i = 0; 251 list_for_each(ptr, &list2) { 252 KUNIT_EXPECT_PTR_EQ(test, ptr, list2_values[i]); 253 i++; 254 } 255 KUNIT_EXPECT_EQ(test, i, 2); 256} 257 258static void list_test_list_is_head(struct kunit *test) 259{ 260 struct list_head a, b, c; 261 262 /* Two lists: [a] -> b, [c] */ 263 INIT_LIST_HEAD(&a); 264 INIT_LIST_HEAD(&c); 265 list_add_tail(&b, &a); 266 267 KUNIT_EXPECT_TRUE_MSG(test, list_is_head(&a, &a), 268 "Head element of same list"); 269 KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &b), 270 "Non-head element of same list"); 271 KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &c), 272 "Head element of different list"); 273} 274 275 276static void list_test_list_is_first(struct kunit *test) 277{ 278 struct list_head a, b; 279 LIST_HEAD(list); 280 281 list_add_tail(&a, &list); 282 list_add_tail(&b, &list); 283 284 KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list)); 285 KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list)); 286} 287 288static void list_test_list_is_last(struct kunit *test) 289{ 290 struct list_head a, b; 291 LIST_HEAD(list); 292 293 list_add_tail(&a, &list); 294 list_add_tail(&b, &list); 295 296 KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list)); 297 KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list)); 298} 299 300static void list_test_list_empty(struct kunit *test) 301{ 302 struct list_head a; 303 LIST_HEAD(list1); 304 LIST_HEAD(list2); 305 306 list_add_tail(&a, &list1); 307 308 KUNIT_EXPECT_FALSE(test, list_empty(&list1)); 309 KUNIT_EXPECT_TRUE(test, list_empty(&list2)); 310} 311 312static void list_test_list_empty_careful(struct kunit *test) 313{ 314 /* This test doesn't check correctness under concurrent access */ 315 struct list_head a; 316 LIST_HEAD(list1); 317 LIST_HEAD(list2); 318 319 list_add_tail(&a, &list1); 320 321 KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1)); 322 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 323} 324 325static void list_test_list_rotate_left(struct kunit *test) 326{ 327 struct list_head a, b; 328 LIST_HEAD(list); 329 330 list_add_tail(&a, &list); 331 list_add_tail(&b, &list); 332 333 /* before: [list] -> a -> b */ 334 list_rotate_left(&list); 335 /* after: [list] -> b -> a */ 336 337 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 338 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 339 KUNIT_EXPECT_PTR_EQ(test, b.next, &a); 340} 341 342static void list_test_list_rotate_to_front(struct kunit *test) 343{ 344 struct list_head a, b, c, d; 345 struct list_head *list_values[] = { &c, &d, &a, &b }; 346 struct list_head *ptr; 347 LIST_HEAD(list); 348 int i = 0; 349 350 list_add_tail(&a, &list); 351 list_add_tail(&b, &list); 352 list_add_tail(&c, &list); 353 list_add_tail(&d, &list); 354 355 /* before: [list] -> a -> b -> c -> d */ 356 list_rotate_to_front(&c, &list); 357 /* after: [list] -> c -> d -> a -> b */ 358 359 list_for_each(ptr, &list) { 360 KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]); 361 i++; 362 } 363 KUNIT_EXPECT_EQ(test, i, 4); 364} 365 366static void list_test_list_is_singular(struct kunit *test) 367{ 368 struct list_head a, b; 369 LIST_HEAD(list); 370 371 /* [list] empty */ 372 KUNIT_EXPECT_FALSE(test, list_is_singular(&list)); 373 374 list_add_tail(&a, &list); 375 376 /* [list] -> a */ 377 KUNIT_EXPECT_TRUE(test, list_is_singular(&list)); 378 379 list_add_tail(&b, &list); 380 381 /* [list] -> a -> b */ 382 KUNIT_EXPECT_FALSE(test, list_is_singular(&list)); 383} 384 385static void list_test_list_cut_position(struct kunit *test) 386{ 387 struct list_head entries[3], *cur; 388 LIST_HEAD(list1); 389 LIST_HEAD(list2); 390 int i = 0; 391 392 list_add_tail(&entries[0], &list1); 393 list_add_tail(&entries[1], &list1); 394 list_add_tail(&entries[2], &list1); 395 396 /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */ 397 list_cut_position(&list2, &list1, &entries[1]); 398 /* after: [list2] -> entries[0] -> entries[1], [list1] -> entries[2] */ 399 400 list_for_each(cur, &list2) { 401 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 402 i++; 403 } 404 405 KUNIT_EXPECT_EQ(test, i, 2); 406 407 list_for_each(cur, &list1) { 408 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 409 i++; 410 } 411} 412 413static void list_test_list_cut_before(struct kunit *test) 414{ 415 struct list_head entries[3], *cur; 416 LIST_HEAD(list1); 417 LIST_HEAD(list2); 418 int i = 0; 419 420 list_add_tail(&entries[0], &list1); 421 list_add_tail(&entries[1], &list1); 422 list_add_tail(&entries[2], &list1); 423 424 /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */ 425 list_cut_before(&list2, &list1, &entries[1]); 426 /* after: [list2] -> entries[0], [list1] -> entries[1] -> entries[2] */ 427 428 list_for_each(cur, &list2) { 429 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 430 i++; 431 } 432 433 KUNIT_EXPECT_EQ(test, i, 1); 434 435 list_for_each(cur, &list1) { 436 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 437 i++; 438 } 439} 440 441static void list_test_list_splice(struct kunit *test) 442{ 443 struct list_head entries[5], *cur; 444 LIST_HEAD(list1); 445 LIST_HEAD(list2); 446 int i = 0; 447 448 list_add_tail(&entries[0], &list1); 449 list_add_tail(&entries[1], &list1); 450 list_add_tail(&entries[2], &list2); 451 list_add_tail(&entries[3], &list2); 452 list_add_tail(&entries[4], &list1); 453 454 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 455 list_splice(&list2, &entries[1]); 456 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */ 457 458 list_for_each(cur, &list1) { 459 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 460 i++; 461 } 462 463 KUNIT_EXPECT_EQ(test, i, 5); 464} 465 466static void list_test_list_splice_tail(struct kunit *test) 467{ 468 struct list_head entries[5], *cur; 469 LIST_HEAD(list1); 470 LIST_HEAD(list2); 471 int i = 0; 472 473 list_add_tail(&entries[0], &list1); 474 list_add_tail(&entries[1], &list1); 475 list_add_tail(&entries[2], &list2); 476 list_add_tail(&entries[3], &list2); 477 list_add_tail(&entries[4], &list1); 478 479 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 480 list_splice_tail(&list2, &entries[4]); 481 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */ 482 483 list_for_each(cur, &list1) { 484 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 485 i++; 486 } 487 488 KUNIT_EXPECT_EQ(test, i, 5); 489} 490 491static void list_test_list_splice_init(struct kunit *test) 492{ 493 struct list_head entries[5], *cur; 494 LIST_HEAD(list1); 495 LIST_HEAD(list2); 496 int i = 0; 497 498 list_add_tail(&entries[0], &list1); 499 list_add_tail(&entries[1], &list1); 500 list_add_tail(&entries[2], &list2); 501 list_add_tail(&entries[3], &list2); 502 list_add_tail(&entries[4], &list1); 503 504 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 505 list_splice_init(&list2, &entries[1]); 506 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */ 507 508 list_for_each(cur, &list1) { 509 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 510 i++; 511 } 512 513 KUNIT_EXPECT_EQ(test, i, 5); 514 515 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 516} 517 518static void list_test_list_splice_tail_init(struct kunit *test) 519{ 520 struct list_head entries[5], *cur; 521 LIST_HEAD(list1); 522 LIST_HEAD(list2); 523 int i = 0; 524 525 list_add_tail(&entries[0], &list1); 526 list_add_tail(&entries[1], &list1); 527 list_add_tail(&entries[2], &list2); 528 list_add_tail(&entries[3], &list2); 529 list_add_tail(&entries[4], &list1); 530 531 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 532 list_splice_tail_init(&list2, &entries[4]); 533 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */ 534 535 list_for_each(cur, &list1) { 536 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 537 i++; 538 } 539 540 KUNIT_EXPECT_EQ(test, i, 5); 541 542 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 543} 544 545static void list_test_list_entry(struct kunit *test) 546{ 547 struct list_test_struct test_struct; 548 549 KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list), 550 struct list_test_struct, list)); 551} 552 553static void list_test_list_entry_is_head(struct kunit *test) 554{ 555 struct list_test_struct test_struct1, test_struct2, test_struct3; 556 557 INIT_LIST_HEAD(&test_struct1.list); 558 INIT_LIST_HEAD(&test_struct3.list); 559 560 list_add_tail(&test_struct2.list, &test_struct1.list); 561 562 KUNIT_EXPECT_TRUE_MSG(test, 563 list_entry_is_head((&test_struct1), &test_struct1.list, list), 564 "Head element of same list"); 565 KUNIT_EXPECT_FALSE_MSG(test, 566 list_entry_is_head((&test_struct2), &test_struct1.list, list), 567 "Non-head element of same list"); 568 KUNIT_EXPECT_FALSE_MSG(test, 569 list_entry_is_head((&test_struct3), &test_struct1.list, list), 570 "Head element of different list"); 571} 572 573static void list_test_list_first_entry(struct kunit *test) 574{ 575 struct list_test_struct test_struct1, test_struct2; 576 LIST_HEAD(list); 577 578 list_add_tail(&test_struct1.list, &list); 579 list_add_tail(&test_struct2.list, &list); 580 581 582 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list, 583 struct list_test_struct, list)); 584} 585 586static void list_test_list_last_entry(struct kunit *test) 587{ 588 struct list_test_struct test_struct1, test_struct2; 589 LIST_HEAD(list); 590 591 list_add_tail(&test_struct1.list, &list); 592 list_add_tail(&test_struct2.list, &list); 593 594 595 KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list, 596 struct list_test_struct, list)); 597} 598 599static void list_test_list_first_entry_or_null(struct kunit *test) 600{ 601 struct list_test_struct test_struct1, test_struct2; 602 LIST_HEAD(list); 603 604 KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list, 605 struct list_test_struct, list)); 606 607 list_add_tail(&test_struct1.list, &list); 608 list_add_tail(&test_struct2.list, &list); 609 610 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, 611 list_first_entry_or_null(&list, 612 struct list_test_struct, list)); 613} 614 615static void list_test_list_next_entry(struct kunit *test) 616{ 617 struct list_test_struct test_struct1, test_struct2; 618 LIST_HEAD(list); 619 620 list_add_tail(&test_struct1.list, &list); 621 list_add_tail(&test_struct2.list, &list); 622 623 624 KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1, 625 list)); 626} 627 628static void list_test_list_prev_entry(struct kunit *test) 629{ 630 struct list_test_struct test_struct1, test_struct2; 631 LIST_HEAD(list); 632 633 list_add_tail(&test_struct1.list, &list); 634 list_add_tail(&test_struct2.list, &list); 635 636 637 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2, 638 list)); 639} 640 641static void list_test_list_for_each(struct kunit *test) 642{ 643 struct list_head entries[3], *cur; 644 LIST_HEAD(list); 645 int i = 0; 646 647 list_add_tail(&entries[0], &list); 648 list_add_tail(&entries[1], &list); 649 list_add_tail(&entries[2], &list); 650 651 list_for_each(cur, &list) { 652 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 653 i++; 654 } 655 656 KUNIT_EXPECT_EQ(test, i, 3); 657} 658 659static void list_test_list_for_each_prev(struct kunit *test) 660{ 661 struct list_head entries[3], *cur; 662 LIST_HEAD(list); 663 int i = 2; 664 665 list_add_tail(&entries[0], &list); 666 list_add_tail(&entries[1], &list); 667 list_add_tail(&entries[2], &list); 668 669 list_for_each_prev(cur, &list) { 670 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 671 i--; 672 } 673 674 KUNIT_EXPECT_EQ(test, i, -1); 675} 676 677static void list_test_list_for_each_safe(struct kunit *test) 678{ 679 struct list_head entries[3], *cur, *n; 680 LIST_HEAD(list); 681 int i = 0; 682 683 684 list_add_tail(&entries[0], &list); 685 list_add_tail(&entries[1], &list); 686 list_add_tail(&entries[2], &list); 687 688 list_for_each_safe(cur, n, &list) { 689 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 690 list_del(&entries[i]); 691 i++; 692 } 693 694 KUNIT_EXPECT_EQ(test, i, 3); 695 KUNIT_EXPECT_TRUE(test, list_empty(&list)); 696} 697 698static void list_test_list_for_each_prev_safe(struct kunit *test) 699{ 700 struct list_head entries[3], *cur, *n; 701 LIST_HEAD(list); 702 int i = 2; 703 704 list_add_tail(&entries[0], &list); 705 list_add_tail(&entries[1], &list); 706 list_add_tail(&entries[2], &list); 707 708 list_for_each_prev_safe(cur, n, &list) { 709 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 710 list_del(&entries[i]); 711 i--; 712 } 713 714 KUNIT_EXPECT_EQ(test, i, -1); 715 KUNIT_EXPECT_TRUE(test, list_empty(&list)); 716} 717 718static void list_test_list_for_each_entry(struct kunit *test) 719{ 720 struct list_test_struct entries[5], *cur; 721 LIST_HEAD(list); 722 int i = 0; 723 724 for (i = 0; i < 5; ++i) { 725 entries[i].data = i; 726 list_add_tail(&entries[i].list, &list); 727 } 728 729 i = 0; 730 731 list_for_each_entry(cur, &list, list) { 732 KUNIT_EXPECT_EQ(test, cur->data, i); 733 i++; 734 } 735 736 KUNIT_EXPECT_EQ(test, i, 5); 737} 738 739static void list_test_list_for_each_entry_reverse(struct kunit *test) 740{ 741 struct list_test_struct entries[5], *cur; 742 LIST_HEAD(list); 743 int i = 0; 744 745 for (i = 0; i < 5; ++i) { 746 entries[i].data = i; 747 list_add_tail(&entries[i].list, &list); 748 } 749 750 i = 4; 751 752 list_for_each_entry_reverse(cur, &list, list) { 753 KUNIT_EXPECT_EQ(test, cur->data, i); 754 i--; 755 } 756 757 KUNIT_EXPECT_EQ(test, i, -1); 758} 759 760static struct kunit_case list_test_cases[] = { 761 KUNIT_CASE(list_test_list_init), 762 KUNIT_CASE(list_test_list_add), 763 KUNIT_CASE(list_test_list_add_tail), 764 KUNIT_CASE(list_test_list_del), 765 KUNIT_CASE(list_test_list_replace), 766 KUNIT_CASE(list_test_list_replace_init), 767 KUNIT_CASE(list_test_list_swap), 768 KUNIT_CASE(list_test_list_del_init), 769 KUNIT_CASE(list_test_list_del_init_careful), 770 KUNIT_CASE(list_test_list_move), 771 KUNIT_CASE(list_test_list_move_tail), 772 KUNIT_CASE(list_test_list_bulk_move_tail), 773 KUNIT_CASE(list_test_list_is_head), 774 KUNIT_CASE(list_test_list_is_first), 775 KUNIT_CASE(list_test_list_is_last), 776 KUNIT_CASE(list_test_list_empty), 777 KUNIT_CASE(list_test_list_empty_careful), 778 KUNIT_CASE(list_test_list_rotate_left), 779 KUNIT_CASE(list_test_list_rotate_to_front), 780 KUNIT_CASE(list_test_list_is_singular), 781 KUNIT_CASE(list_test_list_cut_position), 782 KUNIT_CASE(list_test_list_cut_before), 783 KUNIT_CASE(list_test_list_splice), 784 KUNIT_CASE(list_test_list_splice_tail), 785 KUNIT_CASE(list_test_list_splice_init), 786 KUNIT_CASE(list_test_list_splice_tail_init), 787 KUNIT_CASE(list_test_list_entry), 788 KUNIT_CASE(list_test_list_entry_is_head), 789 KUNIT_CASE(list_test_list_first_entry), 790 KUNIT_CASE(list_test_list_last_entry), 791 KUNIT_CASE(list_test_list_first_entry_or_null), 792 KUNIT_CASE(list_test_list_next_entry), 793 KUNIT_CASE(list_test_list_prev_entry), 794 KUNIT_CASE(list_test_list_for_each), 795 KUNIT_CASE(list_test_list_for_each_prev), 796 KUNIT_CASE(list_test_list_for_each_safe), 797 KUNIT_CASE(list_test_list_for_each_prev_safe), 798 KUNIT_CASE(list_test_list_for_each_entry), 799 KUNIT_CASE(list_test_list_for_each_entry_reverse), 800 {}, 801}; 802 803static struct kunit_suite list_test_module = { 804 .name = "list-kunit-test", 805 .test_cases = list_test_cases, 806}; 807 808struct hlist_test_struct { 809 int data; 810 struct hlist_node list; 811}; 812 813static void hlist_test_init(struct kunit *test) 814{ 815 /* Test the different ways of initialising a list. */ 816 struct hlist_head list1 = HLIST_HEAD_INIT; 817 struct hlist_head list2; 818 HLIST_HEAD(list3); 819 struct hlist_head *list4; 820 struct hlist_head *list5; 821 822 INIT_HLIST_HEAD(&list2); 823 824 list4 = kzalloc(sizeof(*list4), GFP_KERNEL | __GFP_NOFAIL); 825 INIT_HLIST_HEAD(list4); 826 827 list5 = kmalloc(sizeof(*list5), GFP_KERNEL | __GFP_NOFAIL); 828 memset(list5, 0xFF, sizeof(*list5)); 829 INIT_HLIST_HEAD(list5); 830 831 KUNIT_EXPECT_TRUE(test, hlist_empty(&list1)); 832 KUNIT_EXPECT_TRUE(test, hlist_empty(&list2)); 833 KUNIT_EXPECT_TRUE(test, hlist_empty(&list3)); 834 KUNIT_EXPECT_TRUE(test, hlist_empty(list4)); 835 KUNIT_EXPECT_TRUE(test, hlist_empty(list5)); 836 837 kfree(list4); 838 kfree(list5); 839} 840 841static void hlist_test_unhashed(struct kunit *test) 842{ 843 struct hlist_node a; 844 HLIST_HEAD(list); 845 846 INIT_HLIST_NODE(&a); 847 848 /* is unhashed by default */ 849 KUNIT_EXPECT_TRUE(test, hlist_unhashed(&a)); 850 851 hlist_add_head(&a, &list); 852 853 /* is hashed once added to list */ 854 KUNIT_EXPECT_FALSE(test, hlist_unhashed(&a)); 855 856 hlist_del_init(&a); 857 858 /* is again unhashed after del_init */ 859 KUNIT_EXPECT_TRUE(test, hlist_unhashed(&a)); 860} 861 862/* Doesn't test concurrency guarantees */ 863static void hlist_test_unhashed_lockless(struct kunit *test) 864{ 865 struct hlist_node a; 866 HLIST_HEAD(list); 867 868 INIT_HLIST_NODE(&a); 869 870 /* is unhashed by default */ 871 KUNIT_EXPECT_TRUE(test, hlist_unhashed_lockless(&a)); 872 873 hlist_add_head(&a, &list); 874 875 /* is hashed once added to list */ 876 KUNIT_EXPECT_FALSE(test, hlist_unhashed_lockless(&a)); 877 878 hlist_del_init(&a); 879 880 /* is again unhashed after del_init */ 881 KUNIT_EXPECT_TRUE(test, hlist_unhashed_lockless(&a)); 882} 883 884static void hlist_test_del(struct kunit *test) 885{ 886 struct hlist_node a, b; 887 HLIST_HEAD(list); 888 889 hlist_add_head(&a, &list); 890 hlist_add_behind(&b, &a); 891 892 /* before: [list] -> a -> b */ 893 hlist_del(&a); 894 895 /* now: [list] -> b */ 896 KUNIT_EXPECT_PTR_EQ(test, list.first, &b); 897 KUNIT_EXPECT_PTR_EQ(test, b.pprev, &list.first); 898} 899 900static void hlist_test_del_init(struct kunit *test) 901{ 902 struct hlist_node a, b; 903 HLIST_HEAD(list); 904 905 hlist_add_head(&a, &list); 906 hlist_add_behind(&b, &a); 907 908 /* before: [list] -> a -> b */ 909 hlist_del_init(&a); 910 911 /* now: [list] -> b */ 912 KUNIT_EXPECT_PTR_EQ(test, list.first, &b); 913 KUNIT_EXPECT_PTR_EQ(test, b.pprev, &list.first); 914 915 /* a is now initialised */ 916 KUNIT_EXPECT_PTR_EQ(test, a.next, NULL); 917 KUNIT_EXPECT_PTR_EQ(test, a.pprev, NULL); 918} 919 920/* Tests all three hlist_add_* functions */ 921static void hlist_test_add(struct kunit *test) 922{ 923 struct hlist_node a, b, c, d; 924 HLIST_HEAD(list); 925 926 hlist_add_head(&a, &list); 927 hlist_add_head(&b, &list); 928 hlist_add_before(&c, &a); 929 hlist_add_behind(&d, &a); 930 931 /* should be [list] -> b -> c -> a -> d */ 932 KUNIT_EXPECT_PTR_EQ(test, list.first, &b); 933 934 KUNIT_EXPECT_PTR_EQ(test, c.pprev, &(b.next)); 935 KUNIT_EXPECT_PTR_EQ(test, b.next, &c); 936 937 KUNIT_EXPECT_PTR_EQ(test, a.pprev, &(c.next)); 938 KUNIT_EXPECT_PTR_EQ(test, c.next, &a); 939 940 KUNIT_EXPECT_PTR_EQ(test, d.pprev, &(a.next)); 941 KUNIT_EXPECT_PTR_EQ(test, a.next, &d); 942} 943 944/* Tests both hlist_fake() and hlist_add_fake() */ 945static void hlist_test_fake(struct kunit *test) 946{ 947 struct hlist_node a; 948 949 INIT_HLIST_NODE(&a); 950 951 /* not fake after init */ 952 KUNIT_EXPECT_FALSE(test, hlist_fake(&a)); 953 954 hlist_add_fake(&a); 955 956 /* is now fake */ 957 KUNIT_EXPECT_TRUE(test, hlist_fake(&a)); 958} 959 960static void hlist_test_is_singular_node(struct kunit *test) 961{ 962 struct hlist_node a, b; 963 HLIST_HEAD(list); 964 965 INIT_HLIST_NODE(&a); 966 KUNIT_EXPECT_FALSE(test, hlist_is_singular_node(&a, &list)); 967 968 hlist_add_head(&a, &list); 969 KUNIT_EXPECT_TRUE(test, hlist_is_singular_node(&a, &list)); 970 971 hlist_add_head(&b, &list); 972 KUNIT_EXPECT_FALSE(test, hlist_is_singular_node(&a, &list)); 973 KUNIT_EXPECT_FALSE(test, hlist_is_singular_node(&b, &list)); 974} 975 976static void hlist_test_empty(struct kunit *test) 977{ 978 struct hlist_node a; 979 HLIST_HEAD(list); 980 981 /* list starts off empty */ 982 KUNIT_EXPECT_TRUE(test, hlist_empty(&list)); 983 984 hlist_add_head(&a, &list); 985 986 /* list is no longer empty */ 987 KUNIT_EXPECT_FALSE(test, hlist_empty(&list)); 988} 989 990static void hlist_test_move_list(struct kunit *test) 991{ 992 struct hlist_node a; 993 HLIST_HEAD(list1); 994 HLIST_HEAD(list2); 995 996 hlist_add_head(&a, &list1); 997 998 KUNIT_EXPECT_FALSE(test, hlist_empty(&list1)); 999 KUNIT_EXPECT_TRUE(test, hlist_empty(&list2)); 1000 hlist_move_list(&list1, &list2); 1001 KUNIT_EXPECT_TRUE(test, hlist_empty(&list1)); 1002 KUNIT_EXPECT_FALSE(test, hlist_empty(&list2)); 1003 1004} 1005 1006static void hlist_test_entry(struct kunit *test) 1007{ 1008 struct hlist_test_struct test_struct; 1009 1010 KUNIT_EXPECT_PTR_EQ(test, &test_struct, 1011 hlist_entry(&(test_struct.list), 1012 struct hlist_test_struct, list)); 1013} 1014 1015static void hlist_test_entry_safe(struct kunit *test) 1016{ 1017 struct hlist_test_struct test_struct; 1018 1019 KUNIT_EXPECT_PTR_EQ(test, &test_struct, 1020 hlist_entry_safe(&(test_struct.list), 1021 struct hlist_test_struct, list)); 1022 1023 KUNIT_EXPECT_PTR_EQ(test, NULL, 1024 hlist_entry_safe((struct hlist_node *)NULL, 1025 struct hlist_test_struct, list)); 1026} 1027 1028static void hlist_test_for_each(struct kunit *test) 1029{ 1030 struct hlist_node entries[3], *cur; 1031 HLIST_HEAD(list); 1032 int i = 0; 1033 1034 hlist_add_head(&entries[0], &list); 1035 hlist_add_behind(&entries[1], &entries[0]); 1036 hlist_add_behind(&entries[2], &entries[1]); 1037 1038 hlist_for_each(cur, &list) { 1039 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 1040 i++; 1041 } 1042 1043 KUNIT_EXPECT_EQ(test, i, 3); 1044} 1045 1046 1047static void hlist_test_for_each_safe(struct kunit *test) 1048{ 1049 struct hlist_node entries[3], *cur, *n; 1050 HLIST_HEAD(list); 1051 int i = 0; 1052 1053 hlist_add_head(&entries[0], &list); 1054 hlist_add_behind(&entries[1], &entries[0]); 1055 hlist_add_behind(&entries[2], &entries[1]); 1056 1057 hlist_for_each_safe(cur, n, &list) { 1058 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 1059 hlist_del(&entries[i]); 1060 i++; 1061 } 1062 1063 KUNIT_EXPECT_EQ(test, i, 3); 1064 KUNIT_EXPECT_TRUE(test, hlist_empty(&list)); 1065} 1066 1067static void hlist_test_for_each_entry(struct kunit *test) 1068{ 1069 struct hlist_test_struct entries[5], *cur; 1070 HLIST_HEAD(list); 1071 int i = 0; 1072 1073 entries[0].data = 0; 1074 hlist_add_head(&entries[0].list, &list); 1075 for (i = 1; i < 5; ++i) { 1076 entries[i].data = i; 1077 hlist_add_behind(&entries[i].list, &entries[i-1].list); 1078 } 1079 1080 i = 0; 1081 1082 hlist_for_each_entry(cur, &list, list) { 1083 KUNIT_EXPECT_EQ(test, cur->data, i); 1084 i++; 1085 } 1086 1087 KUNIT_EXPECT_EQ(test, i, 5); 1088} 1089 1090static void hlist_test_for_each_entry_continue(struct kunit *test) 1091{ 1092 struct hlist_test_struct entries[5], *cur; 1093 HLIST_HEAD(list); 1094 int i = 0; 1095 1096 entries[0].data = 0; 1097 hlist_add_head(&entries[0].list, &list); 1098 for (i = 1; i < 5; ++i) { 1099 entries[i].data = i; 1100 hlist_add_behind(&entries[i].list, &entries[i-1].list); 1101 } 1102 1103 /* We skip the first (zero-th) entry. */ 1104 i = 1; 1105 1106 cur = &entries[0]; 1107 hlist_for_each_entry_continue(cur, list) { 1108 KUNIT_EXPECT_EQ(test, cur->data, i); 1109 /* Stamp over the entry. */ 1110 cur->data = 42; 1111 i++; 1112 } 1113 1114 KUNIT_EXPECT_EQ(test, i, 5); 1115 /* The first entry was not visited. */ 1116 KUNIT_EXPECT_EQ(test, entries[0].data, 0); 1117 /* The second (and presumably others), were. */ 1118 KUNIT_EXPECT_EQ(test, entries[1].data, 42); 1119} 1120 1121static void hlist_test_for_each_entry_from(struct kunit *test) 1122{ 1123 struct hlist_test_struct entries[5], *cur; 1124 HLIST_HEAD(list); 1125 int i = 0; 1126 1127 entries[0].data = 0; 1128 hlist_add_head(&entries[0].list, &list); 1129 for (i = 1; i < 5; ++i) { 1130 entries[i].data = i; 1131 hlist_add_behind(&entries[i].list, &entries[i-1].list); 1132 } 1133 1134 i = 0; 1135 1136 cur = &entries[0]; 1137 hlist_for_each_entry_from(cur, list) { 1138 KUNIT_EXPECT_EQ(test, cur->data, i); 1139 /* Stamp over the entry. */ 1140 cur->data = 42; 1141 i++; 1142 } 1143 1144 KUNIT_EXPECT_EQ(test, i, 5); 1145 /* The first entry was visited. */ 1146 KUNIT_EXPECT_EQ(test, entries[0].data, 42); 1147} 1148 1149static void hlist_test_for_each_entry_safe(struct kunit *test) 1150{ 1151 struct hlist_test_struct entries[5], *cur; 1152 struct hlist_node *tmp_node; 1153 HLIST_HEAD(list); 1154 int i = 0; 1155 1156 entries[0].data = 0; 1157 hlist_add_head(&entries[0].list, &list); 1158 for (i = 1; i < 5; ++i) { 1159 entries[i].data = i; 1160 hlist_add_behind(&entries[i].list, &entries[i-1].list); 1161 } 1162 1163 i = 0; 1164 1165 hlist_for_each_entry_safe(cur, tmp_node, &list, list) { 1166 KUNIT_EXPECT_EQ(test, cur->data, i); 1167 hlist_del(&cur->list); 1168 i++; 1169 } 1170 1171 KUNIT_EXPECT_EQ(test, i, 5); 1172 KUNIT_EXPECT_TRUE(test, hlist_empty(&list)); 1173} 1174 1175 1176static struct kunit_case hlist_test_cases[] = { 1177 KUNIT_CASE(hlist_test_init), 1178 KUNIT_CASE(hlist_test_unhashed), 1179 KUNIT_CASE(hlist_test_unhashed_lockless), 1180 KUNIT_CASE(hlist_test_del), 1181 KUNIT_CASE(hlist_test_del_init), 1182 KUNIT_CASE(hlist_test_add), 1183 KUNIT_CASE(hlist_test_fake), 1184 KUNIT_CASE(hlist_test_is_singular_node), 1185 KUNIT_CASE(hlist_test_empty), 1186 KUNIT_CASE(hlist_test_move_list), 1187 KUNIT_CASE(hlist_test_entry), 1188 KUNIT_CASE(hlist_test_entry_safe), 1189 KUNIT_CASE(hlist_test_for_each), 1190 KUNIT_CASE(hlist_test_for_each_safe), 1191 KUNIT_CASE(hlist_test_for_each_entry), 1192 KUNIT_CASE(hlist_test_for_each_entry_continue), 1193 KUNIT_CASE(hlist_test_for_each_entry_from), 1194 KUNIT_CASE(hlist_test_for_each_entry_safe), 1195 {}, 1196}; 1197 1198static struct kunit_suite hlist_test_module = { 1199 .name = "hlist", 1200 .test_cases = hlist_test_cases, 1201}; 1202 1203 1204struct klist_test_struct { 1205 int data; 1206 struct klist klist; 1207 struct klist_node klist_node; 1208}; 1209 1210static int node_count; 1211static struct klist_node *last_node; 1212 1213static void check_node(struct klist_node *node_ptr) 1214{ 1215 node_count++; 1216 last_node = node_ptr; 1217} 1218 1219static void check_delete_node(struct klist_node *node_ptr) 1220{ 1221 node_count--; 1222 last_node = node_ptr; 1223} 1224 1225static void klist_test_add_tail(struct kunit *test) 1226{ 1227 struct klist_node a, b; 1228 struct klist mylist; 1229 struct klist_iter i; 1230 1231 node_count = 0; 1232 klist_init(&mylist, &check_node, NULL); 1233 1234 klist_add_tail(&a, &mylist); 1235 KUNIT_EXPECT_EQ(test, node_count, 1); 1236 KUNIT_EXPECT_PTR_EQ(test, last_node, &a); 1237 1238 klist_add_tail(&b, &mylist); 1239 KUNIT_EXPECT_EQ(test, node_count, 2); 1240 KUNIT_EXPECT_PTR_EQ(test, last_node, &b); 1241 1242 /* should be [list] -> a -> b */ 1243 klist_iter_init(&mylist, &i); 1244 1245 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a); 1246 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b); 1247 KUNIT_EXPECT_NULL(test, klist_next(&i)); 1248 1249 klist_iter_exit(&i); 1250 1251} 1252 1253static void klist_test_add_head(struct kunit *test) 1254{ 1255 struct klist_node a, b; 1256 struct klist mylist; 1257 struct klist_iter i; 1258 1259 node_count = 0; 1260 klist_init(&mylist, &check_node, NULL); 1261 1262 klist_add_head(&a, &mylist); 1263 KUNIT_EXPECT_EQ(test, node_count, 1); 1264 KUNIT_EXPECT_PTR_EQ(test, last_node, &a); 1265 1266 klist_add_head(&b, &mylist); 1267 KUNIT_EXPECT_EQ(test, node_count, 2); 1268 KUNIT_EXPECT_PTR_EQ(test, last_node, &b); 1269 1270 /* should be [list] -> b -> a */ 1271 klist_iter_init(&mylist, &i); 1272 1273 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b); 1274 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a); 1275 KUNIT_EXPECT_NULL(test, klist_next(&i)); 1276 1277 klist_iter_exit(&i); 1278 1279} 1280 1281static void klist_test_add_behind(struct kunit *test) 1282{ 1283 struct klist_node a, b, c, d; 1284 struct klist mylist; 1285 struct klist_iter i; 1286 1287 node_count = 0; 1288 klist_init(&mylist, &check_node, NULL); 1289 1290 klist_add_head(&a, &mylist); 1291 klist_add_head(&b, &mylist); 1292 1293 klist_add_behind(&c, &a); 1294 KUNIT_EXPECT_EQ(test, node_count, 3); 1295 KUNIT_EXPECT_PTR_EQ(test, last_node, &c); 1296 1297 klist_add_behind(&d, &b); 1298 KUNIT_EXPECT_EQ(test, node_count, 4); 1299 KUNIT_EXPECT_PTR_EQ(test, last_node, &d); 1300 1301 klist_iter_init(&mylist, &i); 1302 1303 /* should be [list] -> b -> d -> a -> c*/ 1304 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b); 1305 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &d); 1306 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a); 1307 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &c); 1308 KUNIT_EXPECT_NULL(test, klist_next(&i)); 1309 1310 klist_iter_exit(&i); 1311 1312} 1313 1314static void klist_test_add_before(struct kunit *test) 1315{ 1316 struct klist_node a, b, c, d; 1317 struct klist mylist; 1318 struct klist_iter i; 1319 1320 node_count = 0; 1321 klist_init(&mylist, &check_node, NULL); 1322 1323 klist_add_head(&a, &mylist); 1324 klist_add_head(&b, &mylist); 1325 klist_add_before(&c, &a); 1326 KUNIT_EXPECT_EQ(test, node_count, 3); 1327 KUNIT_EXPECT_PTR_EQ(test, last_node, &c); 1328 1329 klist_add_before(&d, &b); 1330 KUNIT_EXPECT_EQ(test, node_count, 4); 1331 KUNIT_EXPECT_PTR_EQ(test, last_node, &d); 1332 1333 klist_iter_init(&mylist, &i); 1334 1335 /* should be [list] -> b -> d -> a -> c*/ 1336 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &d); 1337 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b); 1338 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &c); 1339 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a); 1340 KUNIT_EXPECT_NULL(test, klist_next(&i)); 1341 1342 klist_iter_exit(&i); 1343 1344} 1345 1346/* 1347 * Verify that klist_del() delays the deletion of a node until there 1348 * are no other references to it 1349 */ 1350static void klist_test_del_refcount_greater_than_zero(struct kunit *test) 1351{ 1352 struct klist_node a, b, c, d; 1353 struct klist mylist; 1354 struct klist_iter i; 1355 1356 node_count = 0; 1357 klist_init(&mylist, &check_node, &check_delete_node); 1358 1359 /* Add nodes a,b,c,d to the list*/ 1360 klist_add_tail(&a, &mylist); 1361 klist_add_tail(&b, &mylist); 1362 klist_add_tail(&c, &mylist); 1363 klist_add_tail(&d, &mylist); 1364 1365 klist_iter_init(&mylist, &i); 1366 1367 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a); 1368 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b); 1369 /* Advance the iterator to point to node c*/ 1370 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &c); 1371 1372 /* Try to delete node c while there is a reference to it*/ 1373 klist_del(&c); 1374 1375 /* 1376 * Verify that node c is still attached to the list even after being 1377 * deleted. Since the iterator still points to c, the reference count is not 1378 * decreased to 0 1379 */ 1380 KUNIT_EXPECT_TRUE(test, klist_node_attached(&c)); 1381 1382 /* Check that node c has not been removed yet*/ 1383 KUNIT_EXPECT_EQ(test, node_count, 4); 1384 KUNIT_EXPECT_PTR_EQ(test, last_node, &d); 1385 1386 klist_iter_exit(&i); 1387 1388 /* 1389 * Since the iterator is no longer pointing to node c, node c is removed 1390 * from the list 1391 */ 1392 KUNIT_EXPECT_EQ(test, node_count, 3); 1393 KUNIT_EXPECT_PTR_EQ(test, last_node, &c); 1394 1395} 1396 1397/* 1398 * Verify that klist_del() deletes a node immediately when there are no 1399 * other references to it. 1400 */ 1401static void klist_test_del_refcount_zero(struct kunit *test) 1402{ 1403 struct klist_node a, b, c, d; 1404 struct klist mylist; 1405 struct klist_iter i; 1406 1407 node_count = 0; 1408 klist_init(&mylist, &check_node, &check_delete_node); 1409 1410 /* Add nodes a,b,c,d to the list*/ 1411 klist_add_tail(&a, &mylist); 1412 klist_add_tail(&b, &mylist); 1413 klist_add_tail(&c, &mylist); 1414 klist_add_tail(&d, &mylist); 1415 /* Delete node c*/ 1416 klist_del(&c); 1417 1418 /* Check that node c is deleted from the list*/ 1419 KUNIT_EXPECT_EQ(test, node_count, 3); 1420 KUNIT_EXPECT_PTR_EQ(test, last_node, &c); 1421 1422 /* Should be [list] -> a -> b -> d*/ 1423 klist_iter_init(&mylist, &i); 1424 1425 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a); 1426 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b); 1427 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &d); 1428 KUNIT_EXPECT_NULL(test, klist_next(&i)); 1429 1430 klist_iter_exit(&i); 1431 1432} 1433 1434static void klist_test_remove(struct kunit *test) 1435{ 1436 /* This test doesn't check correctness under concurrent access */ 1437 struct klist_node a, b, c, d; 1438 struct klist mylist; 1439 struct klist_iter i; 1440 1441 node_count = 0; 1442 klist_init(&mylist, &check_node, &check_delete_node); 1443 1444 /* Add nodes a,b,c,d to the list*/ 1445 klist_add_tail(&a, &mylist); 1446 klist_add_tail(&b, &mylist); 1447 klist_add_tail(&c, &mylist); 1448 klist_add_tail(&d, &mylist); 1449 /* Delete node c*/ 1450 klist_remove(&c); 1451 1452 /* Check the nodes in the list*/ 1453 KUNIT_EXPECT_EQ(test, node_count, 3); 1454 KUNIT_EXPECT_PTR_EQ(test, last_node, &c); 1455 1456 /* should be [list] -> a -> b -> d*/ 1457 klist_iter_init(&mylist, &i); 1458 1459 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a); 1460 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b); 1461 KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &d); 1462 KUNIT_EXPECT_NULL(test, klist_next(&i)); 1463 1464 klist_iter_exit(&i); 1465 1466} 1467 1468static void klist_test_node_attached(struct kunit *test) 1469{ 1470 struct klist_node a = {}; 1471 struct klist mylist; 1472 1473 klist_init(&mylist, NULL, NULL); 1474 1475 KUNIT_EXPECT_FALSE(test, klist_node_attached(&a)); 1476 klist_add_head(&a, &mylist); 1477 KUNIT_EXPECT_TRUE(test, klist_node_attached(&a)); 1478 klist_del(&a); 1479 KUNIT_EXPECT_FALSE(test, klist_node_attached(&a)); 1480 1481} 1482 1483static struct kunit_case klist_test_cases[] = { 1484 KUNIT_CASE(klist_test_add_tail), 1485 KUNIT_CASE(klist_test_add_head), 1486 KUNIT_CASE(klist_test_add_behind), 1487 KUNIT_CASE(klist_test_add_before), 1488 KUNIT_CASE(klist_test_del_refcount_greater_than_zero), 1489 KUNIT_CASE(klist_test_del_refcount_zero), 1490 KUNIT_CASE(klist_test_remove), 1491 KUNIT_CASE(klist_test_node_attached), 1492 {}, 1493}; 1494 1495static struct kunit_suite klist_test_module = { 1496 .name = "klist", 1497 .test_cases = klist_test_cases, 1498}; 1499 1500kunit_test_suites(&list_test_module, &hlist_test_module, &klist_test_module); 1501 1502MODULE_LICENSE("GPL v2"); 1503