This source file includes following definitions.
- key_id_index
- world_obj_get
- world_obj_put
- delta_check
- delta_create
- delta_destroy
- root_create
- root_destroy
- test_nodelta_obj_get
- test_nodelta_obj_put
- check_stats_zero
- check_stats_nodelta
- delta_check_dummy
- delta_create_dummy
- delta_destroy_dummy
- test_nodelta
- check_expect
- obj_to_key_id
- check_expect_stats_nums
- check_expect_stats_key_id
- check_expect_stats_neigh
- __check_expect_stats
- check_expect_stats
- test_delta_action_item
- test_delta
- __pr_debug_stats
- pr_debug_stats
- pr_debug_hints_stats
- check_expect_hints_stats
- test_hints_case
- test_hints
- test_objagg_init
- test_objagg_exit
1
2
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
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
327
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 },
436 {
437 7, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC,
438 EXPECT_STATS(2, ROOT(1, 1, 1), ROOT(7, 1, 1)),
439 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
550 {
551 6, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_SAME,
552 EXPECT_STATS(2, ROOT(5, 0, 1),
553 DELTA(8, 1)),
554 },
555 {
556 8, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_DEC,
557 EXPECT_STATS(0, ),
558 },
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
730
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
801
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");