1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */ 3 4 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 5 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/slab.h> 9 #include <linux/random.h> 10 #include <linux/objagg.h> 11 12 struct tokey { 13 unsigned int id; 14 }; 15 16 #define NUM_KEYS 32 17 18 static int key_id_index(unsigned int key_id) 19 { 20 if (key_id >= NUM_KEYS) { 21 WARN_ON(1); 22 return 0; 23 } 24 return key_id; 25 } 26 27 #define BUF_LEN 128 28 29 struct world { 30 unsigned int root_count; 31 unsigned int delta_count; 32 char next_root_buf[BUF_LEN]; 33 struct objagg_obj *objagg_objs[NUM_KEYS]; 34 unsigned int key_refs[NUM_KEYS]; 35 }; 36 37 struct root { 38 struct tokey key; 39 char buf[BUF_LEN]; 40 }; 41 42 struct delta { 43 unsigned int key_id_diff; 44 }; 45 46 static struct objagg_obj *world_obj_get(struct world *world, 47 struct objagg *objagg, 48 unsigned int key_id) 49 { 50 struct objagg_obj *objagg_obj; 51 struct tokey key; 52 int err; 53 54 key.id = key_id; 55 objagg_obj = objagg_obj_get(objagg, &key); 56 if (IS_ERR(objagg_obj)) { 57 pr_err("Key %u: Failed to get object.\n", key_id); 58 return objagg_obj; 59 } 60 if (!world->key_refs[key_id_index(key_id)]) { 61 world->objagg_objs[key_id_index(key_id)] = objagg_obj; 62 } else if (world->objagg_objs[key_id_index(key_id)] != objagg_obj) { 63 pr_err("Key %u: God another object for the same key.\n", 64 key_id); 65 err = -EINVAL; 66 goto err_key_id_check; 67 } 68 world->key_refs[key_id_index(key_id)]++; 69 return objagg_obj; 70 71 err_key_id_check: 72 objagg_obj_put(objagg, objagg_obj); 73 return ERR_PTR(err); 74 } 75 76 static void world_obj_put(struct world *world, struct objagg *objagg, 77 unsigned int key_id) 78 { 79 struct objagg_obj *objagg_obj; 80 81 if (!world->key_refs[key_id_index(key_id)]) 82 return; 83 objagg_obj = world->objagg_objs[key_id_index(key_id)]; 84 objagg_obj_put(objagg, objagg_obj); 85 world->key_refs[key_id_index(key_id)]--; 86 } 87 88 #define MAX_KEY_ID_DIFF 5 89 90 static bool delta_check(void *priv, const void *parent_obj, const void *obj) 91 { 92 const struct tokey *parent_key = parent_obj; 93 const struct tokey *key = obj; 94 int diff = key->id - parent_key->id; 95 96 return diff >= 0 && diff <= MAX_KEY_ID_DIFF; 97 } 98 99 static void *delta_create(void *priv, void *parent_obj, void *obj) 100 { 101 struct tokey *parent_key = parent_obj; 102 struct world *world = priv; 103 struct tokey *key = obj; 104 int diff = key->id - parent_key->id; 105 struct delta *delta; 106 107 if (!delta_check(priv, parent_obj, obj)) 108 return ERR_PTR(-EINVAL); 109 110 delta = kzalloc(sizeof(*delta), GFP_KERNEL); 111 if (!delta) 112 return ERR_PTR(-ENOMEM); 113 delta->key_id_diff = diff; 114 world->delta_count++; 115 return delta; 116 } 117 118 static void delta_destroy(void *priv, void *delta_priv) 119 { 120 struct delta *delta = delta_priv; 121 struct world *world = priv; 122 123 world->delta_count--; 124 kfree(delta); 125 } 126 127 static void *root_create(void *priv, void *obj, unsigned int id) 128 { 129 struct world *world = priv; 130 struct tokey *key = obj; 131 struct root *root; 132 133 root = kzalloc(sizeof(*root), GFP_KERNEL); 134 if (!root) 135 return ERR_PTR(-ENOMEM); 136 memcpy(&root->key, key, sizeof(root->key)); 137 memcpy(root->buf, world->next_root_buf, sizeof(root->buf)); 138 world->root_count++; 139 return root; 140 } 141 142 static void root_destroy(void *priv, void *root_priv) 143 { 144 struct root *root = root_priv; 145 struct world *world = priv; 146 147 world->root_count--; 148 kfree(root); 149 } 150 151 static int test_nodelta_obj_get(struct world *world, struct objagg *objagg, 152 unsigned int key_id, bool should_create_root) 153 { 154 unsigned int orig_root_count = world->root_count; 155 struct objagg_obj *objagg_obj; 156 const struct root *root; 157 int err; 158 159 if (should_create_root) 160 prandom_bytes(world->next_root_buf, 161 sizeof(world->next_root_buf)); 162 163 objagg_obj = world_obj_get(world, objagg, key_id); 164 if (IS_ERR(objagg_obj)) { 165 pr_err("Key %u: Failed to get object.\n", key_id); 166 return PTR_ERR(objagg_obj); 167 } 168 if (should_create_root) { 169 if (world->root_count != orig_root_count + 1) { 170 pr_err("Key %u: Root was not created\n", key_id); 171 err = -EINVAL; 172 goto err_check_root_count; 173 } 174 } else { 175 if (world->root_count != orig_root_count) { 176 pr_err("Key %u: Root was incorrectly created\n", 177 key_id); 178 err = -EINVAL; 179 goto err_check_root_count; 180 } 181 } 182 root = objagg_obj_root_priv(objagg_obj); 183 if (root->key.id != key_id) { 184 pr_err("Key %u: Root has unexpected key id\n", key_id); 185 err = -EINVAL; 186 goto err_check_key_id; 187 } 188 if (should_create_root && 189 memcmp(world->next_root_buf, root->buf, sizeof(root->buf))) { 190 pr_err("Key %u: Buffer does not match the expected content\n", 191 key_id); 192 err = -EINVAL; 193 goto err_check_buf; 194 } 195 return 0; 196 197 err_check_buf: 198 err_check_key_id: 199 err_check_root_count: 200 objagg_obj_put(objagg, objagg_obj); 201 return err; 202 } 203 204 static int test_nodelta_obj_put(struct world *world, struct objagg *objagg, 205 unsigned int key_id, bool should_destroy_root) 206 { 207 unsigned int orig_root_count = world->root_count; 208 209 world_obj_put(world, objagg, key_id); 210 211 if (should_destroy_root) { 212 if (world->root_count != orig_root_count - 1) { 213 pr_err("Key %u: Root was not destroyed\n", key_id); 214 return -EINVAL; 215 } 216 } else { 217 if (world->root_count != orig_root_count) { 218 pr_err("Key %u: Root was incorrectly destroyed\n", 219 key_id); 220 return -EINVAL; 221 } 222 } 223 return 0; 224 } 225 226 static int check_stats_zero(struct objagg *objagg) 227 { 228 const struct objagg_stats *stats; 229 int err = 0; 230 231 stats = objagg_stats_get(objagg); 232 if (IS_ERR(stats)) 233 return PTR_ERR(stats); 234 235 if (stats->stats_info_count != 0) { 236 pr_err("Stats: Object count is not zero while it should be\n"); 237 err = -EINVAL; 238 } 239 240 objagg_stats_put(stats); 241 return err; 242 } 243 244 static int check_stats_nodelta(struct objagg *objagg) 245 { 246 const struct objagg_stats *stats; 247 int i; 248 int err; 249 250 stats = objagg_stats_get(objagg); 251 if (IS_ERR(stats)) 252 return PTR_ERR(stats); 253 254 if (stats->stats_info_count != NUM_KEYS) { 255 pr_err("Stats: Unexpected object count (%u expected, %u returned)\n", 256 NUM_KEYS, stats->stats_info_count); 257 err = -EINVAL; 258 goto stats_put; 259 } 260 261 for (i = 0; i < stats->stats_info_count; i++) { 262 if (stats->stats_info[i].stats.user_count != 2) { 263 pr_err("Stats: incorrect user count\n"); 264 err = -EINVAL; 265 goto stats_put; 266 } 267 if (stats->stats_info[i].stats.delta_user_count != 2) { 268 pr_err("Stats: incorrect delta user count\n"); 269 err = -EINVAL; 270 goto stats_put; 271 } 272 } 273 err = 0; 274 275 stats_put: 276 objagg_stats_put(stats); 277 return err; 278 } 279 280 static bool delta_check_dummy(void *priv, const void *parent_obj, 281 const void *obj) 282 { 283 return false; 284 } 285 286 static void *delta_create_dummy(void *priv, void *parent_obj, void *obj) 287 { 288 return ERR_PTR(-EOPNOTSUPP); 289 } 290 291 static void delta_destroy_dummy(void *priv, void *delta_priv) 292 { 293 } 294 295 static const struct objagg_ops nodelta_ops = { 296 .obj_size = sizeof(struct tokey), 297 .delta_check = delta_check_dummy, 298 .delta_create = delta_create_dummy, 299 .delta_destroy = delta_destroy_dummy, 300 .root_create = root_create, 301 .root_destroy = root_destroy, 302 }; 303 304 static int test_nodelta(void) 305 { 306 struct world world = {}; 307 struct objagg *objagg; 308 int i; 309 int err; 310 311 objagg = objagg_create(&nodelta_ops, NULL, &world); 312 if (IS_ERR(objagg)) 313 return PTR_ERR(objagg); 314 315 err = check_stats_zero(objagg); 316 if (err) 317 goto err_stats_first_zero; 318 319 /* First round of gets, the root objects should be created */ 320 for (i = 0; i < NUM_KEYS; i++) { 321 err = test_nodelta_obj_get(&world, objagg, i, true); 322 if (err) 323 goto err_obj_first_get; 324 } 325 326 /* Do the second round of gets, all roots are already created, 327 * make sure that no new root is created 328 */ 329 for (i = 0; i < NUM_KEYS; i++) { 330 err = test_nodelta_obj_get(&world, objagg, i, false); 331 if (err) 332 goto err_obj_second_get; 333 } 334 335 err = check_stats_nodelta(objagg); 336 if (err) 337 goto err_stats_nodelta; 338 339 for (i = NUM_KEYS - 1; i >= 0; i--) { 340 err = test_nodelta_obj_put(&world, objagg, i, false); 341 if (err) 342 goto err_obj_first_put; 343 } 344 for (i = NUM_KEYS - 1; i >= 0; i--) { 345 err = test_nodelta_obj_put(&world, objagg, i, true); 346 if (err) 347 goto err_obj_second_put; 348 } 349 350 err = check_stats_zero(objagg); 351 if (err) 352 goto err_stats_second_zero; 353 354 objagg_destroy(objagg); 355 return 0; 356 357 err_stats_nodelta: 358 err_obj_first_put: 359 err_obj_second_get: 360 for (i--; i >= 0; i--) 361 world_obj_put(&world, objagg, i); 362 363 i = NUM_KEYS; 364 err_obj_first_get: 365 err_obj_second_put: 366 for (i--; i >= 0; i--) 367 world_obj_put(&world, objagg, i); 368 err_stats_first_zero: 369 err_stats_second_zero: 370 objagg_destroy(objagg); 371 return err; 372 } 373 374 static const struct objagg_ops delta_ops = { 375 .obj_size = sizeof(struct tokey), 376 .delta_check = delta_check, 377 .delta_create = delta_create, 378 .delta_destroy = delta_destroy, 379 .root_create = root_create, 380 .root_destroy = root_destroy, 381 }; 382 383 enum action { 384 ACTION_GET, 385 ACTION_PUT, 386 }; 387 388 enum expect_delta { 389 EXPECT_DELTA_SAME, 390 EXPECT_DELTA_INC, 391 EXPECT_DELTA_DEC, 392 }; 393 394 enum expect_root { 395 EXPECT_ROOT_SAME, 396 EXPECT_ROOT_INC, 397 EXPECT_ROOT_DEC, 398 }; 399 400 struct expect_stats_info { 401 struct objagg_obj_stats stats; 402 bool is_root; 403 unsigned int key_id; 404 }; 405 406 struct expect_stats { 407 unsigned int info_count; 408 struct expect_stats_info info[NUM_KEYS]; 409 }; 410 411 struct action_item { 412 unsigned int key_id; 413 enum action action; 414 enum expect_delta expect_delta; 415 enum expect_root expect_root; 416 struct expect_stats expect_stats; 417 }; 418 419 #define EXPECT_STATS(count, ...) \ 420 { \ 421 .info_count = count, \ 422 .info = { __VA_ARGS__ } \ 423 } 424 425 #define ROOT(key_id, user_count, delta_user_count) \ 426 {{user_count, delta_user_count}, true, key_id} 427 428 #define DELTA(key_id, user_count) \ 429 {{user_count, user_count}, false, key_id} 430 431 static const struct action_item action_items[] = { 432 { 433 1, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC, 434 EXPECT_STATS(1, ROOT(1, 1, 1)), 435 }, /* r: 1 d: */ 436 { 437 7, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC, 438 EXPECT_STATS(2, ROOT(1, 1, 1), ROOT(7, 1, 1)), 439 }, /* r: 1, 7 d: */ 440 { 441 3, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME, 442 EXPECT_STATS(3, ROOT(1, 1, 2), ROOT(7, 1, 1), 443 DELTA(3, 1)), 444 }, /* r: 1, 7 d: 3^1 */ 445 { 446 5, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME, 447 EXPECT_STATS(4, ROOT(1, 1, 3), ROOT(7, 1, 1), 448 DELTA(3, 1), DELTA(5, 1)), 449 }, /* r: 1, 7 d: 3^1, 5^1 */ 450 { 451 3, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 452 EXPECT_STATS(4, ROOT(1, 1, 4), ROOT(7, 1, 1), 453 DELTA(3, 2), DELTA(5, 1)), 454 }, /* r: 1, 7 d: 3^1, 3^1, 5^1 */ 455 { 456 1, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 457 EXPECT_STATS(4, ROOT(1, 2, 5), ROOT(7, 1, 1), 458 DELTA(3, 2), DELTA(5, 1)), 459 }, /* r: 1, 1, 7 d: 3^1, 3^1, 5^1 */ 460 { 461 30, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC, 462 EXPECT_STATS(5, ROOT(1, 2, 5), ROOT(7, 1, 1), ROOT(30, 1, 1), 463 DELTA(3, 2), DELTA(5, 1)), 464 }, /* r: 1, 1, 7, 30 d: 3^1, 3^1, 5^1 */ 465 { 466 8, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME, 467 EXPECT_STATS(6, ROOT(1, 2, 5), ROOT(7, 1, 2), ROOT(30, 1, 1), 468 DELTA(3, 2), DELTA(5, 1), DELTA(8, 1)), 469 }, /* r: 1, 1, 7, 30 d: 3^1, 3^1, 5^1, 8^7 */ 470 { 471 8, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 472 EXPECT_STATS(6, ROOT(1, 2, 5), ROOT(7, 1, 3), ROOT(30, 1, 1), 473 DELTA(3, 2), DELTA(8, 2), DELTA(5, 1)), 474 }, /* r: 1, 1, 7, 30 d: 3^1, 3^1, 5^1, 8^7, 8^7 */ 475 { 476 3, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 477 EXPECT_STATS(6, ROOT(1, 2, 4), ROOT(7, 1, 3), ROOT(30, 1, 1), 478 DELTA(8, 2), DELTA(3, 1), DELTA(5, 1)), 479 }, /* r: 1, 1, 7, 30 d: 3^1, 5^1, 8^7, 8^7 */ 480 { 481 3, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_SAME, 482 EXPECT_STATS(5, ROOT(1, 2, 3), ROOT(7, 1, 3), ROOT(30, 1, 1), 483 DELTA(8, 2), DELTA(5, 1)), 484 }, /* r: 1, 1, 7, 30 d: 5^1, 8^7, 8^7 */ 485 { 486 1, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 487 EXPECT_STATS(5, ROOT(7, 1, 3), ROOT(1, 1, 2), ROOT(30, 1, 1), 488 DELTA(8, 2), DELTA(5, 1)), 489 }, /* r: 1, 7, 30 d: 5^1, 8^7, 8^7 */ 490 { 491 1, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 492 EXPECT_STATS(5, ROOT(7, 1, 3), ROOT(30, 1, 1), ROOT(1, 0, 1), 493 DELTA(8, 2), DELTA(5, 1)), 494 }, /* r: 7, 30 d: 5^1, 8^7, 8^7 */ 495 { 496 5, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_DEC, 497 EXPECT_STATS(3, ROOT(7, 1, 3), ROOT(30, 1, 1), 498 DELTA(8, 2)), 499 }, /* r: 7, 30 d: 8^7, 8^7 */ 500 { 501 5, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC, 502 EXPECT_STATS(4, ROOT(7, 1, 3), ROOT(30, 1, 1), ROOT(5, 1, 1), 503 DELTA(8, 2)), 504 }, /* r: 7, 30, 5 d: 8^7, 8^7 */ 505 { 506 6, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME, 507 EXPECT_STATS(5, ROOT(7, 1, 3), ROOT(5, 1, 2), ROOT(30, 1, 1), 508 DELTA(8, 2), DELTA(6, 1)), 509 }, /* r: 7, 30, 5 d: 8^7, 8^7, 6^5 */ 510 { 511 8, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 512 EXPECT_STATS(5, ROOT(7, 1, 4), ROOT(5, 1, 2), ROOT(30, 1, 1), 513 DELTA(8, 3), DELTA(6, 1)), 514 }, /* r: 7, 30, 5 d: 8^7, 8^7, 8^7, 6^5 */ 515 { 516 8, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 517 EXPECT_STATS(5, ROOT(7, 1, 3), ROOT(5, 1, 2), ROOT(30, 1, 1), 518 DELTA(8, 2), DELTA(6, 1)), 519 }, /* r: 7, 30, 5 d: 8^7, 8^7, 6^5 */ 520 { 521 8, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 522 EXPECT_STATS(5, ROOT(7, 1, 2), ROOT(5, 1, 2), ROOT(30, 1, 1), 523 DELTA(8, 1), DELTA(6, 1)), 524 }, /* r: 7, 30, 5 d: 8^7, 6^5 */ 525 { 526 8, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_SAME, 527 EXPECT_STATS(4, ROOT(5, 1, 2), ROOT(7, 1, 1), ROOT(30, 1, 1), 528 DELTA(6, 1)), 529 }, /* r: 7, 30, 5 d: 6^5 */ 530 { 531 8, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME, 532 EXPECT_STATS(5, ROOT(5, 1, 3), ROOT(7, 1, 1), ROOT(30, 1, 1), 533 DELTA(6, 1), DELTA(8, 1)), 534 }, /* r: 7, 30, 5 d: 6^5, 8^5 */ 535 { 536 7, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_DEC, 537 EXPECT_STATS(4, ROOT(5, 1, 3), ROOT(30, 1, 1), 538 DELTA(6, 1), DELTA(8, 1)), 539 }, /* r: 30, 5 d: 6^5, 8^5 */ 540 { 541 30, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_DEC, 542 EXPECT_STATS(3, ROOT(5, 1, 3), 543 DELTA(6, 1), DELTA(8, 1)), 544 }, /* r: 5 d: 6^5, 8^5 */ 545 { 546 5, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME, 547 EXPECT_STATS(3, ROOT(5, 0, 2), 548 DELTA(6, 1), DELTA(8, 1)), 549 }, /* r: d: 6^5, 8^5 */ 550 { 551 6, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_SAME, 552 EXPECT_STATS(2, ROOT(5, 0, 1), 553 DELTA(8, 1)), 554 }, /* r: d: 6^5 */ 555 { 556 8, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_DEC, 557 EXPECT_STATS(0, ), 558 }, /* r: d: */ 559 }; 560 561 static int check_expect(struct world *world, 562 const struct action_item *action_item, 563 unsigned int orig_delta_count, 564 unsigned int orig_root_count) 565 { 566 unsigned int key_id = action_item->key_id; 567 568 switch (action_item->expect_delta) { 569 case EXPECT_DELTA_SAME: 570 if (orig_delta_count != world->delta_count) { 571 pr_err("Key %u: Delta count changed while expected to remain the same.\n", 572 key_id); 573 return -EINVAL; 574 } 575 break; 576 case EXPECT_DELTA_INC: 577 if (WARN_ON(action_item->action == ACTION_PUT)) 578 return -EINVAL; 579 if (orig_delta_count + 1 != world->delta_count) { 580 pr_err("Key %u: Delta count was not incremented.\n", 581 key_id); 582 return -EINVAL; 583 } 584 break; 585 case EXPECT_DELTA_DEC: 586 if (WARN_ON(action_item->action == ACTION_GET)) 587 return -EINVAL; 588 if (orig_delta_count - 1 != world->delta_count) { 589 pr_err("Key %u: Delta count was not decremented.\n", 590 key_id); 591 return -EINVAL; 592 } 593 break; 594 } 595 596 switch (action_item->expect_root) { 597 case EXPECT_ROOT_SAME: 598 if (orig_root_count != world->root_count) { 599 pr_err("Key %u: Root count changed while expected to remain the same.\n", 600 key_id); 601 return -EINVAL; 602 } 603 break; 604 case EXPECT_ROOT_INC: 605 if (WARN_ON(action_item->action == ACTION_PUT)) 606 return -EINVAL; 607 if (orig_root_count + 1 != world->root_count) { 608 pr_err("Key %u: Root count was not incremented.\n", 609 key_id); 610 return -EINVAL; 611 } 612 break; 613 case EXPECT_ROOT_DEC: 614 if (WARN_ON(action_item->action == ACTION_GET)) 615 return -EINVAL; 616 if (orig_root_count - 1 != world->root_count) { 617 pr_err("Key %u: Root count was not decremented.\n", 618 key_id); 619 return -EINVAL; 620 } 621 } 622 623 return 0; 624 } 625 626 static unsigned int obj_to_key_id(struct objagg_obj *objagg_obj) 627 { 628 const struct tokey *root_key; 629 const struct delta *delta; 630 unsigned int key_id; 631 632 root_key = objagg_obj_root_priv(objagg_obj); 633 key_id = root_key->id; 634 delta = objagg_obj_delta_priv(objagg_obj); 635 if (delta) 636 key_id += delta->key_id_diff; 637 return key_id; 638 } 639 640 static int 641 check_expect_stats_nums(const struct objagg_obj_stats_info *stats_info, 642 const struct expect_stats_info *expect_stats_info, 643 const char **errmsg) 644 { 645 if (stats_info->is_root != expect_stats_info->is_root) { 646 if (errmsg) 647 *errmsg = "Incorrect root/delta indication"; 648 return -EINVAL; 649 } 650 if (stats_info->stats.user_count != 651 expect_stats_info->stats.user_count) { 652 if (errmsg) 653 *errmsg = "Incorrect user count"; 654 return -EINVAL; 655 } 656 if (stats_info->stats.delta_user_count != 657 expect_stats_info->stats.delta_user_count) { 658 if (errmsg) 659 *errmsg = "Incorrect delta user count"; 660 return -EINVAL; 661 } 662 return 0; 663 } 664 665 static int 666 check_expect_stats_key_id(const struct objagg_obj_stats_info *stats_info, 667 const struct expect_stats_info *expect_stats_info, 668 const char **errmsg) 669 { 670 if (obj_to_key_id(stats_info->objagg_obj) != 671 expect_stats_info->key_id) { 672 if (errmsg) 673 *errmsg = "incorrect key id"; 674 return -EINVAL; 675 } 676 return 0; 677 } 678 679 static int check_expect_stats_neigh(const struct objagg_stats *stats, 680 const struct expect_stats *expect_stats, 681 int pos) 682 { 683 int i; 684 int err; 685 686 for (i = pos - 1; i >= 0; i--) { 687 err = check_expect_stats_nums(&stats->stats_info[i], 688 &expect_stats->info[pos], NULL); 689 if (err) 690 break; 691 err = check_expect_stats_key_id(&stats->stats_info[i], 692 &expect_stats->info[pos], NULL); 693 if (!err) 694 return 0; 695 } 696 for (i = pos + 1; i < stats->stats_info_count; i++) { 697 err = check_expect_stats_nums(&stats->stats_info[i], 698 &expect_stats->info[pos], NULL); 699 if (err) 700 break; 701 err = check_expect_stats_key_id(&stats->stats_info[i], 702 &expect_stats->info[pos], NULL); 703 if (!err) 704 return 0; 705 } 706 return -EINVAL; 707 } 708 709 static int __check_expect_stats(const struct objagg_stats *stats, 710 const struct expect_stats *expect_stats, 711 const char **errmsg) 712 { 713 int i; 714 int err; 715 716 if (stats->stats_info_count != expect_stats->info_count) { 717 *errmsg = "Unexpected object count"; 718 return -EINVAL; 719 } 720 721 for (i = 0; i < stats->stats_info_count; i++) { 722 err = check_expect_stats_nums(&stats->stats_info[i], 723 &expect_stats->info[i], errmsg); 724 if (err) 725 return err; 726 err = check_expect_stats_key_id(&stats->stats_info[i], 727 &expect_stats->info[i], errmsg); 728 if (err) { 729 /* It is possible that one of the neighbor stats with 730 * same numbers have the correct key id, so check it 731 */ 732 err = check_expect_stats_neigh(stats, expect_stats, i); 733 if (err) 734 return err; 735 } 736 } 737 return 0; 738 } 739 740 static int check_expect_stats(struct objagg *objagg, 741 const struct expect_stats *expect_stats, 742 const char **errmsg) 743 { 744 const struct objagg_stats *stats; 745 int err; 746 747 stats = objagg_stats_get(objagg); 748 if (IS_ERR(stats)) { 749 *errmsg = "objagg_stats_get() failed."; 750 return PTR_ERR(stats); 751 } 752 err = __check_expect_stats(stats, expect_stats, errmsg); 753 objagg_stats_put(stats); 754 return err; 755 } 756 757 static int test_delta_action_item(struct world *world, 758 struct objagg *objagg, 759 const struct action_item *action_item, 760 bool inverse) 761 { 762 unsigned int orig_delta_count = world->delta_count; 763 unsigned int orig_root_count = world->root_count; 764 unsigned int key_id = action_item->key_id; 765 enum action action = action_item->action; 766 struct objagg_obj *objagg_obj; 767 const char *errmsg; 768 int err; 769 770 if (inverse) 771 action = action == ACTION_GET ? ACTION_PUT : ACTION_GET; 772 773 switch (action) { 774 case ACTION_GET: 775 objagg_obj = world_obj_get(world, objagg, key_id); 776 if (IS_ERR(objagg_obj)) 777 return PTR_ERR(objagg_obj); 778 break; 779 case ACTION_PUT: 780 world_obj_put(world, objagg, key_id); 781 break; 782 } 783 784 if (inverse) 785 return 0; 786 err = check_expect(world, action_item, 787 orig_delta_count, orig_root_count); 788 if (err) 789 goto errout; 790 791 err = check_expect_stats(objagg, &action_item->expect_stats, &errmsg); 792 if (err) { 793 pr_err("Key %u: Stats: %s\n", action_item->key_id, errmsg); 794 goto errout; 795 } 796 797 return 0; 798 799 errout: 800 /* This can only happen when action is not inversed. 801 * So in case of an error, cleanup by doing inverse action. 802 */ 803 test_delta_action_item(world, objagg, action_item, true); 804 return err; 805 } 806 807 static int test_delta(void) 808 { 809 struct world world = {}; 810 struct objagg *objagg; 811 int i; 812 int err; 813 814 objagg = objagg_create(&delta_ops, NULL, &world); 815 if (IS_ERR(objagg)) 816 return PTR_ERR(objagg); 817 818 for (i = 0; i < ARRAY_SIZE(action_items); i++) { 819 err = test_delta_action_item(&world, objagg, 820 &action_items[i], false); 821 if (err) 822 goto err_do_action_item; 823 } 824 825 objagg_destroy(objagg); 826 return 0; 827 828 err_do_action_item: 829 for (i--; i >= 0; i--) 830 test_delta_action_item(&world, objagg, &action_items[i], true); 831 832 objagg_destroy(objagg); 833 return err; 834 } 835 836 struct hints_case { 837 const unsigned int *key_ids; 838 size_t key_ids_count; 839 struct expect_stats expect_stats; 840 struct expect_stats expect_stats_hints; 841 }; 842 843 static const unsigned int hints_case_key_ids[] = { 844 1, 7, 3, 5, 3, 1, 30, 8, 8, 5, 6, 8, 845 }; 846 847 static const struct hints_case hints_case = { 848 .key_ids = hints_case_key_ids, 849 .key_ids_count = ARRAY_SIZE(hints_case_key_ids), 850 .expect_stats = 851 EXPECT_STATS(7, ROOT(1, 2, 7), ROOT(7, 1, 4), ROOT(30, 1, 1), 852 DELTA(8, 3), DELTA(3, 2), 853 DELTA(5, 2), DELTA(6, 1)), 854 .expect_stats_hints = 855 EXPECT_STATS(7, ROOT(3, 2, 9), ROOT(1, 2, 2), ROOT(30, 1, 1), 856 DELTA(8, 3), DELTA(5, 2), 857 DELTA(6, 1), DELTA(7, 1)), 858 }; 859 860 static void __pr_debug_stats(const struct objagg_stats *stats) 861 { 862 int i; 863 864 for (i = 0; i < stats->stats_info_count; i++) 865 pr_debug("Stat index %d key %u: u %d, d %d, %s\n", i, 866 obj_to_key_id(stats->stats_info[i].objagg_obj), 867 stats->stats_info[i].stats.user_count, 868 stats->stats_info[i].stats.delta_user_count, 869 stats->stats_info[i].is_root ? "root" : "noroot"); 870 } 871 872 static void pr_debug_stats(struct objagg *objagg) 873 { 874 const struct objagg_stats *stats; 875 876 stats = objagg_stats_get(objagg); 877 if (IS_ERR(stats)) 878 return; 879 __pr_debug_stats(stats); 880 objagg_stats_put(stats); 881 } 882 883 static void pr_debug_hints_stats(struct objagg_hints *objagg_hints) 884 { 885 const struct objagg_stats *stats; 886 887 stats = objagg_hints_stats_get(objagg_hints); 888 if (IS_ERR(stats)) 889 return; 890 __pr_debug_stats(stats); 891 objagg_stats_put(stats); 892 } 893 894 static int check_expect_hints_stats(struct objagg_hints *objagg_hints, 895 const struct expect_stats *expect_stats, 896 const char **errmsg) 897 { 898 const struct objagg_stats *stats; 899 int err; 900 901 stats = objagg_hints_stats_get(objagg_hints); 902 if (IS_ERR(stats)) 903 return PTR_ERR(stats); 904 err = __check_expect_stats(stats, expect_stats, errmsg); 905 objagg_stats_put(stats); 906 return err; 907 } 908 909 static int test_hints_case(const struct hints_case *hints_case) 910 { 911 struct objagg_obj *objagg_obj; 912 struct objagg_hints *hints; 913 struct world world2 = {}; 914 struct world world = {}; 915 struct objagg *objagg2; 916 struct objagg *objagg; 917 const char *errmsg; 918 int i; 919 int err; 920 921 objagg = objagg_create(&delta_ops, NULL, &world); 922 if (IS_ERR(objagg)) 923 return PTR_ERR(objagg); 924 925 for (i = 0; i < hints_case->key_ids_count; i++) { 926 objagg_obj = world_obj_get(&world, objagg, 927 hints_case->key_ids[i]); 928 if (IS_ERR(objagg_obj)) { 929 err = PTR_ERR(objagg_obj); 930 goto err_world_obj_get; 931 } 932 } 933 934 pr_debug_stats(objagg); 935 err = check_expect_stats(objagg, &hints_case->expect_stats, &errmsg); 936 if (err) { 937 pr_err("Stats: %s\n", errmsg); 938 goto err_check_expect_stats; 939 } 940 941 hints = objagg_hints_get(objagg, OBJAGG_OPT_ALGO_SIMPLE_GREEDY); 942 if (IS_ERR(hints)) { 943 err = PTR_ERR(hints); 944 goto err_hints_get; 945 } 946 947 pr_debug_hints_stats(hints); 948 err = check_expect_hints_stats(hints, &hints_case->expect_stats_hints, 949 &errmsg); 950 if (err) { 951 pr_err("Hints stats: %s\n", errmsg); 952 goto err_check_expect_hints_stats; 953 } 954 955 objagg2 = objagg_create(&delta_ops, hints, &world2); 956 if (IS_ERR(objagg2)) 957 return PTR_ERR(objagg2); 958 959 for (i = 0; i < hints_case->key_ids_count; i++) { 960 objagg_obj = world_obj_get(&world2, objagg2, 961 hints_case->key_ids[i]); 962 if (IS_ERR(objagg_obj)) { 963 err = PTR_ERR(objagg_obj); 964 goto err_world2_obj_get; 965 } 966 } 967 968 pr_debug_stats(objagg2); 969 err = check_expect_stats(objagg2, &hints_case->expect_stats_hints, 970 &errmsg); 971 if (err) { 972 pr_err("Stats2: %s\n", errmsg); 973 goto err_check_expect_stats2; 974 } 975 976 err = 0; 977 978 err_check_expect_stats2: 979 err_world2_obj_get: 980 for (i--; i >= 0; i--) 981 world_obj_put(&world2, objagg, hints_case->key_ids[i]); 982 objagg_hints_put(hints); 983 objagg_destroy(objagg2); 984 i = hints_case->key_ids_count; 985 err_check_expect_hints_stats: 986 err_hints_get: 987 err_check_expect_stats: 988 err_world_obj_get: 989 for (i--; i >= 0; i--) 990 world_obj_put(&world, objagg, hints_case->key_ids[i]); 991 992 objagg_destroy(objagg); 993 return err; 994 } 995 static int test_hints(void) 996 { 997 return test_hints_case(&hints_case); 998 } 999 1000 static int __init test_objagg_init(void) 1001 { 1002 int err; 1003 1004 err = test_nodelta(); 1005 if (err) 1006 return err; 1007 err = test_delta(); 1008 if (err) 1009 return err; 1010 return test_hints(); 1011 } 1012 1013 static void __exit test_objagg_exit(void) 1014 { 1015 } 1016 1017 module_init(test_objagg_init); 1018 module_exit(test_objagg_exit); 1019 MODULE_LICENSE("Dual BSD/GPL"); 1020 MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>"); 1021 MODULE_DESCRIPTION("Test module for objagg"); 1022