1 // SPDX-License-Identifier: GPL-2.0 2 #ifdef CONFIG_BCACHEFS_TESTS 3 4 #include "bcachefs.h" 5 #include "btree_update.h" 6 #include "journal_reclaim.h" 7 #include "snapshot.h" 8 #include "tests.h" 9 10 #include "linux/kthread.h" 11 #include "linux/random.h" 12 13 static void delete_test_keys(struct bch_fs *c) 14 { 15 int ret; 16 17 ret = bch2_btree_delete_range(c, BTREE_ID_extents, 18 SPOS(0, 0, U32_MAX), 19 POS(0, U64_MAX), 20 0, NULL); 21 BUG_ON(ret); 22 23 ret = bch2_btree_delete_range(c, BTREE_ID_xattrs, 24 SPOS(0, 0, U32_MAX), 25 POS(0, U64_MAX), 26 0, NULL); 27 BUG_ON(ret); 28 } 29 30 /* unit tests */ 31 32 static int test_delete(struct bch_fs *c, u64 nr) 33 { 34 struct btree_trans *trans = bch2_trans_get(c); 35 struct btree_iter iter; 36 struct bkey_i_cookie k; 37 int ret; 38 39 bkey_cookie_init(&k.k_i); 40 k.k.p.snapshot = U32_MAX; 41 42 bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs, k.k.p, 43 BTREE_ITER_intent); 44 45 ret = commit_do(trans, NULL, NULL, 0, 46 bch2_btree_iter_traverse(trans, &iter) ?: 47 bch2_trans_update(trans, &iter, &k.k_i, 0)); 48 bch_err_msg(c, ret, "update error"); 49 if (ret) 50 goto err; 51 52 pr_info("deleting once"); 53 ret = commit_do(trans, NULL, NULL, 0, 54 bch2_btree_iter_traverse(trans, &iter) ?: 55 bch2_btree_delete_at(trans, &iter, 0)); 56 bch_err_msg(c, ret, "delete error (first)"); 57 if (ret) 58 goto err; 59 60 pr_info("deleting twice"); 61 ret = commit_do(trans, NULL, NULL, 0, 62 bch2_btree_iter_traverse(trans, &iter) ?: 63 bch2_btree_delete_at(trans, &iter, 0)); 64 bch_err_msg(c, ret, "delete error (second)"); 65 if (ret) 66 goto err; 67 err: 68 bch2_trans_iter_exit(trans, &iter); 69 bch2_trans_put(trans); 70 return ret; 71 } 72 73 static int test_delete_written(struct bch_fs *c, u64 nr) 74 { 75 struct btree_trans *trans = bch2_trans_get(c); 76 struct btree_iter iter; 77 struct bkey_i_cookie k; 78 int ret; 79 80 bkey_cookie_init(&k.k_i); 81 k.k.p.snapshot = U32_MAX; 82 83 bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs, k.k.p, 84 BTREE_ITER_intent); 85 86 ret = commit_do(trans, NULL, NULL, 0, 87 bch2_btree_iter_traverse(trans, &iter) ?: 88 bch2_trans_update(trans, &iter, &k.k_i, 0)); 89 bch_err_msg(c, ret, "update error"); 90 if (ret) 91 goto err; 92 93 bch2_trans_unlock(trans); 94 bch2_journal_flush_all_pins(&c->journal); 95 96 ret = commit_do(trans, NULL, NULL, 0, 97 bch2_btree_iter_traverse(trans, &iter) ?: 98 bch2_btree_delete_at(trans, &iter, 0)); 99 bch_err_msg(c, ret, "delete error"); 100 if (ret) 101 goto err; 102 err: 103 bch2_trans_iter_exit(trans, &iter); 104 bch2_trans_put(trans); 105 return ret; 106 } 107 108 static int test_iterate(struct bch_fs *c, u64 nr) 109 { 110 u64 i; 111 int ret = 0; 112 113 delete_test_keys(c); 114 115 pr_info("inserting test keys"); 116 117 for (i = 0; i < nr; i++) { 118 struct bkey_i_cookie ck; 119 120 bkey_cookie_init(&ck.k_i); 121 ck.k.p.offset = i; 122 ck.k.p.snapshot = U32_MAX; 123 124 ret = bch2_btree_insert(c, BTREE_ID_xattrs, &ck.k_i, NULL, 0, 0); 125 bch_err_msg(c, ret, "insert error"); 126 if (ret) 127 return ret; 128 } 129 130 pr_info("iterating forwards"); 131 i = 0; 132 133 ret = bch2_trans_run(c, 134 for_each_btree_key_max(trans, iter, BTREE_ID_xattrs, 135 SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 136 0, k, ({ 137 BUG_ON(k.k->p.offset != i++); 138 0; 139 }))); 140 bch_err_msg(c, ret, "error iterating forwards"); 141 if (ret) 142 return ret; 143 144 BUG_ON(i != nr); 145 146 pr_info("iterating backwards"); 147 148 ret = bch2_trans_run(c, 149 for_each_btree_key_reverse(trans, iter, BTREE_ID_xattrs, 150 SPOS(0, U64_MAX, U32_MAX), 0, k, ({ 151 BUG_ON(k.k->p.offset != --i); 152 0; 153 }))); 154 bch_err_msg(c, ret, "error iterating backwards"); 155 if (ret) 156 return ret; 157 158 BUG_ON(i); 159 return 0; 160 } 161 162 static int test_iterate_extents(struct bch_fs *c, u64 nr) 163 { 164 u64 i; 165 int ret = 0; 166 167 delete_test_keys(c); 168 169 pr_info("inserting test extents"); 170 171 for (i = 0; i < nr; i += 8) { 172 struct bkey_i_cookie ck; 173 174 bkey_cookie_init(&ck.k_i); 175 ck.k.p.offset = i + 8; 176 ck.k.p.snapshot = U32_MAX; 177 ck.k.size = 8; 178 179 ret = bch2_btree_insert(c, BTREE_ID_extents, &ck.k_i, NULL, 0, 0); 180 bch_err_msg(c, ret, "insert error"); 181 if (ret) 182 return ret; 183 } 184 185 pr_info("iterating forwards"); 186 i = 0; 187 188 ret = bch2_trans_run(c, 189 for_each_btree_key_max(trans, iter, BTREE_ID_extents, 190 SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 191 0, k, ({ 192 BUG_ON(bkey_start_offset(k.k) != i); 193 i = k.k->p.offset; 194 0; 195 }))); 196 bch_err_msg(c, ret, "error iterating forwards"); 197 if (ret) 198 return ret; 199 200 BUG_ON(i != nr); 201 202 pr_info("iterating backwards"); 203 204 ret = bch2_trans_run(c, 205 for_each_btree_key_reverse(trans, iter, BTREE_ID_extents, 206 SPOS(0, U64_MAX, U32_MAX), 0, k, ({ 207 BUG_ON(k.k->p.offset != i); 208 i = bkey_start_offset(k.k); 209 0; 210 }))); 211 bch_err_msg(c, ret, "error iterating backwards"); 212 if (ret) 213 return ret; 214 215 BUG_ON(i); 216 return 0; 217 } 218 219 static int test_iterate_slots(struct bch_fs *c, u64 nr) 220 { 221 u64 i; 222 int ret = 0; 223 224 delete_test_keys(c); 225 226 pr_info("inserting test keys"); 227 228 for (i = 0; i < nr; i++) { 229 struct bkey_i_cookie ck; 230 231 bkey_cookie_init(&ck.k_i); 232 ck.k.p.offset = i * 2; 233 ck.k.p.snapshot = U32_MAX; 234 235 ret = bch2_btree_insert(c, BTREE_ID_xattrs, &ck.k_i, NULL, 0, 0); 236 bch_err_msg(c, ret, "insert error"); 237 if (ret) 238 return ret; 239 } 240 241 pr_info("iterating forwards"); 242 i = 0; 243 244 ret = bch2_trans_run(c, 245 for_each_btree_key_max(trans, iter, BTREE_ID_xattrs, 246 SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 247 0, k, ({ 248 BUG_ON(k.k->p.offset != i); 249 i += 2; 250 0; 251 }))); 252 bch_err_msg(c, ret, "error iterating forwards"); 253 if (ret) 254 return ret; 255 256 BUG_ON(i != nr * 2); 257 258 pr_info("iterating forwards by slots"); 259 i = 0; 260 261 ret = bch2_trans_run(c, 262 for_each_btree_key_max(trans, iter, BTREE_ID_xattrs, 263 SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 264 BTREE_ITER_slots, k, ({ 265 if (i >= nr * 2) 266 break; 267 268 BUG_ON(k.k->p.offset != i); 269 BUG_ON(bkey_deleted(k.k) != (i & 1)); 270 271 i++; 272 0; 273 }))); 274 bch_err_msg(c, ret, "error iterating forwards by slots"); 275 return ret; 276 } 277 278 static int test_iterate_slots_extents(struct bch_fs *c, u64 nr) 279 { 280 u64 i; 281 int ret = 0; 282 283 delete_test_keys(c); 284 285 pr_info("inserting test keys"); 286 287 for (i = 0; i < nr; i += 16) { 288 struct bkey_i_cookie ck; 289 290 bkey_cookie_init(&ck.k_i); 291 ck.k.p.offset = i + 16; 292 ck.k.p.snapshot = U32_MAX; 293 ck.k.size = 8; 294 295 ret = bch2_btree_insert(c, BTREE_ID_extents, &ck.k_i, NULL, 0, 0); 296 bch_err_msg(c, ret, "insert error"); 297 if (ret) 298 return ret; 299 } 300 301 pr_info("iterating forwards"); 302 i = 0; 303 304 ret = bch2_trans_run(c, 305 for_each_btree_key_max(trans, iter, BTREE_ID_extents, 306 SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 307 0, k, ({ 308 BUG_ON(bkey_start_offset(k.k) != i + 8); 309 BUG_ON(k.k->size != 8); 310 i += 16; 311 0; 312 }))); 313 bch_err_msg(c, ret, "error iterating forwards"); 314 if (ret) 315 return ret; 316 317 BUG_ON(i != nr); 318 319 pr_info("iterating forwards by slots"); 320 i = 0; 321 322 ret = bch2_trans_run(c, 323 for_each_btree_key_max(trans, iter, BTREE_ID_extents, 324 SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 325 BTREE_ITER_slots, k, ({ 326 if (i == nr) 327 break; 328 BUG_ON(bkey_deleted(k.k) != !(i % 16)); 329 330 BUG_ON(bkey_start_offset(k.k) != i); 331 BUG_ON(k.k->size != 8); 332 i = k.k->p.offset; 333 0; 334 }))); 335 bch_err_msg(c, ret, "error iterating forwards by slots"); 336 return ret; 337 } 338 339 /* 340 * XXX: we really want to make sure we've got a btree with depth > 0 for these 341 * tests 342 */ 343 static int test_peek_end(struct bch_fs *c, u64 nr) 344 { 345 delete_test_keys(c); 346 347 struct btree_trans *trans = bch2_trans_get(c); 348 struct btree_iter iter; 349 struct bkey_s_c k; 350 351 bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs, 352 SPOS(0, 0, U32_MAX), 0); 353 354 lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(trans, &iter, POS(0, U64_MAX)))); 355 BUG_ON(k.k); 356 357 lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(trans, &iter, POS(0, U64_MAX)))); 358 BUG_ON(k.k); 359 360 bch2_trans_iter_exit(trans, &iter); 361 bch2_trans_put(trans); 362 return 0; 363 } 364 365 static int test_peek_end_extents(struct bch_fs *c, u64 nr) 366 { 367 delete_test_keys(c); 368 369 struct btree_trans *trans = bch2_trans_get(c); 370 struct btree_iter iter; 371 struct bkey_s_c k; 372 373 bch2_trans_iter_init(trans, &iter, BTREE_ID_extents, 374 SPOS(0, 0, U32_MAX), 0); 375 376 lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(trans, &iter, POS(0, U64_MAX)))); 377 BUG_ON(k.k); 378 379 lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(trans, &iter, POS(0, U64_MAX)))); 380 BUG_ON(k.k); 381 382 bch2_trans_iter_exit(trans, &iter); 383 bch2_trans_put(trans); 384 return 0; 385 } 386 387 /* extent unit tests */ 388 389 static u64 test_version; 390 391 static int insert_test_extent(struct bch_fs *c, 392 u64 start, u64 end) 393 { 394 struct bkey_i_cookie k; 395 int ret; 396 397 bkey_cookie_init(&k.k_i); 398 k.k_i.k.p.offset = end; 399 k.k_i.k.p.snapshot = U32_MAX; 400 k.k_i.k.size = end - start; 401 k.k_i.k.bversion.lo = test_version++; 402 403 ret = bch2_btree_insert(c, BTREE_ID_extents, &k.k_i, NULL, 0, 0); 404 bch_err_fn(c, ret); 405 return ret; 406 } 407 408 static int __test_extent_overwrite(struct bch_fs *c, 409 u64 e1_start, u64 e1_end, 410 u64 e2_start, u64 e2_end) 411 { 412 int ret; 413 414 ret = insert_test_extent(c, e1_start, e1_end) ?: 415 insert_test_extent(c, e2_start, e2_end); 416 417 delete_test_keys(c); 418 return ret; 419 } 420 421 static int test_extent_overwrite_front(struct bch_fs *c, u64 nr) 422 { 423 return __test_extent_overwrite(c, 0, 64, 0, 32) ?: 424 __test_extent_overwrite(c, 8, 64, 0, 32); 425 } 426 427 static int test_extent_overwrite_back(struct bch_fs *c, u64 nr) 428 { 429 return __test_extent_overwrite(c, 0, 64, 32, 64) ?: 430 __test_extent_overwrite(c, 0, 64, 32, 72); 431 } 432 433 static int test_extent_overwrite_middle(struct bch_fs *c, u64 nr) 434 { 435 return __test_extent_overwrite(c, 0, 64, 32, 40); 436 } 437 438 static int test_extent_overwrite_all(struct bch_fs *c, u64 nr) 439 { 440 return __test_extent_overwrite(c, 32, 64, 0, 64) ?: 441 __test_extent_overwrite(c, 32, 64, 0, 128) ?: 442 __test_extent_overwrite(c, 32, 64, 32, 64) ?: 443 __test_extent_overwrite(c, 32, 64, 32, 128); 444 } 445 446 static int insert_test_overlapping_extent(struct bch_fs *c, u64 inum, u64 start, u32 len, u32 snapid) 447 { 448 struct bkey_i_cookie k; 449 int ret; 450 451 bkey_cookie_init(&k.k_i); 452 k.k_i.k.p.inode = inum; 453 k.k_i.k.p.offset = start + len; 454 k.k_i.k.p.snapshot = snapid; 455 k.k_i.k.size = len; 456 457 ret = bch2_trans_commit_do(c, NULL, NULL, 0, 458 bch2_btree_insert_nonextent(trans, BTREE_ID_extents, &k.k_i, 459 BTREE_UPDATE_internal_snapshot_node)); 460 bch_err_fn(c, ret); 461 return ret; 462 } 463 464 static int test_extent_create_overlapping(struct bch_fs *c, u64 inum) 465 { 466 return insert_test_overlapping_extent(c, inum, 0, 16, U32_MAX - 2) ?: /* overwrite entire */ 467 insert_test_overlapping_extent(c, inum, 2, 8, U32_MAX - 2) ?: 468 insert_test_overlapping_extent(c, inum, 4, 4, U32_MAX) ?: 469 insert_test_overlapping_extent(c, inum, 32, 8, U32_MAX - 2) ?: /* overwrite front/back */ 470 insert_test_overlapping_extent(c, inum, 36, 8, U32_MAX) ?: 471 insert_test_overlapping_extent(c, inum, 60, 8, U32_MAX - 2) ?: 472 insert_test_overlapping_extent(c, inum, 64, 8, U32_MAX); 473 } 474 475 /* snapshot unit tests */ 476 477 /* Test skipping over keys in unrelated snapshots: */ 478 static int test_snapshot_filter(struct bch_fs *c, u32 snapid_lo, u32 snapid_hi) 479 { 480 struct btree_trans *trans; 481 struct btree_iter iter; 482 struct bkey_s_c k; 483 struct bkey_i_cookie cookie; 484 int ret; 485 486 bkey_cookie_init(&cookie.k_i); 487 cookie.k.p.snapshot = snapid_hi; 488 ret = bch2_btree_insert(c, BTREE_ID_xattrs, &cookie.k_i, NULL, 0, 0); 489 if (ret) 490 return ret; 491 492 trans = bch2_trans_get(c); 493 bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs, 494 SPOS(0, 0, snapid_lo), 0); 495 lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(trans, &iter, POS(0, U64_MAX)))); 496 497 BUG_ON(k.k->p.snapshot != U32_MAX); 498 499 bch2_trans_iter_exit(trans, &iter); 500 bch2_trans_put(trans); 501 return ret; 502 } 503 504 static int test_snapshots(struct bch_fs *c, u64 nr) 505 { 506 struct bkey_i_cookie cookie; 507 u32 snapids[2]; 508 u32 snapid_subvols[2] = { 1, 1 }; 509 int ret; 510 511 bkey_cookie_init(&cookie.k_i); 512 cookie.k.p.snapshot = U32_MAX; 513 ret = bch2_btree_insert(c, BTREE_ID_xattrs, &cookie.k_i, NULL, 0, 0); 514 if (ret) 515 return ret; 516 517 ret = bch2_trans_commit_do(c, NULL, NULL, 0, 518 bch2_snapshot_node_create(trans, U32_MAX, 519 snapids, 520 snapid_subvols, 521 2)); 522 if (ret) 523 return ret; 524 525 if (snapids[0] > snapids[1]) 526 swap(snapids[0], snapids[1]); 527 528 ret = test_snapshot_filter(c, snapids[0], snapids[1]); 529 bch_err_msg(c, ret, "from test_snapshot_filter"); 530 return ret; 531 } 532 533 /* perf tests */ 534 535 static u64 test_rand(void) 536 { 537 u64 v; 538 539 get_random_bytes(&v, sizeof(v)); 540 return v; 541 } 542 543 static int rand_insert(struct bch_fs *c, u64 nr) 544 { 545 struct btree_trans *trans = bch2_trans_get(c); 546 struct bkey_i_cookie k; 547 int ret = 0; 548 u64 i; 549 550 for (i = 0; i < nr; i++) { 551 bkey_cookie_init(&k.k_i); 552 k.k.p.offset = test_rand(); 553 k.k.p.snapshot = U32_MAX; 554 555 ret = commit_do(trans, NULL, NULL, 0, 556 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k.k_i, 0)); 557 if (ret) 558 break; 559 } 560 561 bch2_trans_put(trans); 562 return ret; 563 } 564 565 static int rand_insert_multi(struct bch_fs *c, u64 nr) 566 { 567 struct btree_trans *trans = bch2_trans_get(c); 568 struct bkey_i_cookie k[8]; 569 int ret = 0; 570 unsigned j; 571 u64 i; 572 573 for (i = 0; i < nr; i += ARRAY_SIZE(k)) { 574 for (j = 0; j < ARRAY_SIZE(k); j++) { 575 bkey_cookie_init(&k[j].k_i); 576 k[j].k.p.offset = test_rand(); 577 k[j].k.p.snapshot = U32_MAX; 578 } 579 580 ret = commit_do(trans, NULL, NULL, 0, 581 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k[0].k_i, 0) ?: 582 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k[1].k_i, 0) ?: 583 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k[2].k_i, 0) ?: 584 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k[3].k_i, 0) ?: 585 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k[4].k_i, 0) ?: 586 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k[5].k_i, 0) ?: 587 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k[6].k_i, 0) ?: 588 bch2_btree_insert_trans(trans, BTREE_ID_xattrs, &k[7].k_i, 0)); 589 if (ret) 590 break; 591 } 592 593 bch2_trans_put(trans); 594 return ret; 595 } 596 597 static int rand_lookup(struct bch_fs *c, u64 nr) 598 { 599 struct btree_trans *trans = bch2_trans_get(c); 600 struct btree_iter iter; 601 struct bkey_s_c k; 602 int ret = 0; 603 u64 i; 604 605 bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs, 606 SPOS(0, 0, U32_MAX), 0); 607 608 for (i = 0; i < nr; i++) { 609 bch2_btree_iter_set_pos(trans, &iter, SPOS(0, test_rand(), U32_MAX)); 610 611 lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek(trans, &iter))); 612 ret = bkey_err(k); 613 if (ret) 614 break; 615 } 616 617 bch2_trans_iter_exit(trans, &iter); 618 bch2_trans_put(trans); 619 return ret; 620 } 621 622 static int rand_mixed_trans(struct btree_trans *trans, 623 struct btree_iter *iter, 624 struct bkey_i_cookie *cookie, 625 u64 i, u64 pos) 626 { 627 struct bkey_s_c k; 628 int ret; 629 630 bch2_btree_iter_set_pos(trans, iter, SPOS(0, pos, U32_MAX)); 631 632 k = bch2_btree_iter_peek(trans, iter); 633 ret = bkey_err(k); 634 bch_err_msg(trans->c, ret, "lookup error"); 635 if (ret) 636 return ret; 637 638 if (!(i & 3) && k.k) { 639 bkey_cookie_init(&cookie->k_i); 640 cookie->k.p = iter->pos; 641 ret = bch2_trans_update(trans, iter, &cookie->k_i, 0); 642 } 643 644 return ret; 645 } 646 647 static int rand_mixed(struct bch_fs *c, u64 nr) 648 { 649 struct btree_trans *trans = bch2_trans_get(c); 650 struct btree_iter iter; 651 struct bkey_i_cookie cookie; 652 int ret = 0; 653 u64 i, rand; 654 655 bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs, 656 SPOS(0, 0, U32_MAX), 0); 657 658 for (i = 0; i < nr; i++) { 659 rand = test_rand(); 660 ret = commit_do(trans, NULL, NULL, 0, 661 rand_mixed_trans(trans, &iter, &cookie, i, rand)); 662 if (ret) 663 break; 664 } 665 666 bch2_trans_iter_exit(trans, &iter); 667 bch2_trans_put(trans); 668 return ret; 669 } 670 671 static int __do_delete(struct btree_trans *trans, struct bpos pos) 672 { 673 struct btree_iter iter; 674 struct bkey_s_c k; 675 int ret = 0; 676 677 bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs, pos, 678 BTREE_ITER_intent); 679 k = bch2_btree_iter_peek_max(trans, &iter, POS(0, U64_MAX)); 680 ret = bkey_err(k); 681 if (ret) 682 goto err; 683 684 if (!k.k) 685 goto err; 686 687 ret = bch2_btree_delete_at(trans, &iter, 0); 688 err: 689 bch2_trans_iter_exit(trans, &iter); 690 return ret; 691 } 692 693 static int rand_delete(struct bch_fs *c, u64 nr) 694 { 695 struct btree_trans *trans = bch2_trans_get(c); 696 int ret = 0; 697 u64 i; 698 699 for (i = 0; i < nr; i++) { 700 struct bpos pos = SPOS(0, test_rand(), U32_MAX); 701 702 ret = commit_do(trans, NULL, NULL, 0, 703 __do_delete(trans, pos)); 704 if (ret) 705 break; 706 } 707 708 bch2_trans_put(trans); 709 return ret; 710 } 711 712 static int seq_insert(struct bch_fs *c, u64 nr) 713 { 714 struct bkey_i_cookie insert; 715 716 bkey_cookie_init(&insert.k_i); 717 718 return bch2_trans_run(c, 719 for_each_btree_key_commit(trans, iter, BTREE_ID_xattrs, 720 SPOS(0, 0, U32_MAX), 721 BTREE_ITER_slots|BTREE_ITER_intent, k, 722 NULL, NULL, 0, ({ 723 if (iter.pos.offset >= nr) 724 break; 725 insert.k.p = iter.pos; 726 bch2_trans_update(trans, &iter, &insert.k_i, 0); 727 }))); 728 } 729 730 static int seq_lookup(struct bch_fs *c, u64 nr) 731 { 732 return bch2_trans_run(c, 733 for_each_btree_key_max(trans, iter, BTREE_ID_xattrs, 734 SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 735 0, k, 736 0)); 737 } 738 739 static int seq_overwrite(struct bch_fs *c, u64 nr) 740 { 741 return bch2_trans_run(c, 742 for_each_btree_key_commit(trans, iter, BTREE_ID_xattrs, 743 SPOS(0, 0, U32_MAX), 744 BTREE_ITER_intent, k, 745 NULL, NULL, 0, ({ 746 struct bkey_i_cookie u; 747 748 bkey_reassemble(&u.k_i, k); 749 bch2_trans_update(trans, &iter, &u.k_i, 0); 750 }))); 751 } 752 753 static int seq_delete(struct bch_fs *c, u64 nr) 754 { 755 return bch2_btree_delete_range(c, BTREE_ID_xattrs, 756 SPOS(0, 0, U32_MAX), 757 POS(0, U64_MAX), 758 0, NULL); 759 } 760 761 typedef int (*perf_test_fn)(struct bch_fs *, u64); 762 763 struct test_job { 764 struct bch_fs *c; 765 u64 nr; 766 unsigned nr_threads; 767 perf_test_fn fn; 768 769 atomic_t ready; 770 wait_queue_head_t ready_wait; 771 772 atomic_t done; 773 struct completion done_completion; 774 775 u64 start; 776 u64 finish; 777 int ret; 778 }; 779 780 static int btree_perf_test_thread(void *data) 781 { 782 struct test_job *j = data; 783 int ret; 784 785 if (atomic_dec_and_test(&j->ready)) { 786 wake_up(&j->ready_wait); 787 j->start = sched_clock(); 788 } else { 789 wait_event(j->ready_wait, !atomic_read(&j->ready)); 790 } 791 792 ret = j->fn(j->c, div64_u64(j->nr, j->nr_threads)); 793 if (ret) { 794 bch_err(j->c, "%ps: error %s", j->fn, bch2_err_str(ret)); 795 j->ret = ret; 796 } 797 798 if (atomic_dec_and_test(&j->done)) { 799 j->finish = sched_clock(); 800 complete(&j->done_completion); 801 } 802 803 return 0; 804 } 805 806 int bch2_btree_perf_test(struct bch_fs *c, const char *testname, 807 u64 nr, unsigned nr_threads) 808 { 809 struct test_job j = { .c = c, .nr = nr, .nr_threads = nr_threads }; 810 char name_buf[20]; 811 struct printbuf nr_buf = PRINTBUF; 812 struct printbuf per_sec_buf = PRINTBUF; 813 unsigned i; 814 u64 time; 815 816 if (nr == 0 || nr_threads == 0) { 817 pr_err("nr of iterations or threads is not allowed to be 0"); 818 return -EINVAL; 819 } 820 821 atomic_set(&j.ready, nr_threads); 822 init_waitqueue_head(&j.ready_wait); 823 824 atomic_set(&j.done, nr_threads); 825 init_completion(&j.done_completion); 826 827 #define perf_test(_test) \ 828 if (!strcmp(testname, #_test)) j.fn = _test 829 830 perf_test(rand_insert); 831 perf_test(rand_insert_multi); 832 perf_test(rand_lookup); 833 perf_test(rand_mixed); 834 perf_test(rand_delete); 835 836 perf_test(seq_insert); 837 perf_test(seq_lookup); 838 perf_test(seq_overwrite); 839 perf_test(seq_delete); 840 841 /* a unit test, not a perf test: */ 842 perf_test(test_delete); 843 perf_test(test_delete_written); 844 perf_test(test_iterate); 845 perf_test(test_iterate_extents); 846 perf_test(test_iterate_slots); 847 perf_test(test_iterate_slots_extents); 848 perf_test(test_peek_end); 849 perf_test(test_peek_end_extents); 850 851 perf_test(test_extent_overwrite_front); 852 perf_test(test_extent_overwrite_back); 853 perf_test(test_extent_overwrite_middle); 854 perf_test(test_extent_overwrite_all); 855 perf_test(test_extent_create_overlapping); 856 857 perf_test(test_snapshots); 858 859 if (!j.fn) { 860 pr_err("unknown test %s", testname); 861 return -EINVAL; 862 } 863 864 //pr_info("running test %s:", testname); 865 866 if (nr_threads == 1) 867 btree_perf_test_thread(&j); 868 else 869 for (i = 0; i < nr_threads; i++) 870 kthread_run(btree_perf_test_thread, &j, 871 "bcachefs perf test[%u]", i); 872 873 while (wait_for_completion_interruptible(&j.done_completion)) 874 ; 875 876 time = j.finish - j.start; 877 878 scnprintf(name_buf, sizeof(name_buf), "%s:", testname); 879 prt_human_readable_u64(&nr_buf, nr); 880 prt_human_readable_u64(&per_sec_buf, div64_u64(nr * NSEC_PER_SEC, time)); 881 printk(KERN_INFO "%-12s %s with %u threads in %5llu sec, %5llu nsec per iter, %5s per sec\n", 882 name_buf, nr_buf.buf, nr_threads, 883 div_u64(time, NSEC_PER_SEC), 884 div_u64(time * nr_threads, nr), 885 per_sec_buf.buf); 886 printbuf_exit(&per_sec_buf); 887 printbuf_exit(&nr_buf); 888 return j.ret; 889 } 890 891 #endif /* CONFIG_BCACHEFS_TESTS */ 892