projects/linux·blob v5.0 · refs

836 lines · 20.1 KiB

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
12struct tokey {
13 unsigned int id;
14};
15
16#define NUM_KEYS 32
17
18static 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
29struct 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
37struct root {
38 struct tokey key;
39 char buf[BUF_LEN];
40};
41
42struct delta {
43 unsigned int key_id_diff;
44};
45
46static 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
71err_key_id_check:
72 objagg_obj_put(objagg, objagg_obj);
73 return ERR_PTR(err);
74}
75
76static 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
90static void *delta_create(void *priv, void *parent_obj, void *obj)
91{
92 struct tokey *parent_key = parent_obj;
93 struct world *world = priv;
94 struct tokey *key = obj;
95 int diff = key->id - parent_key->id;
96 struct delta *delta;
97
98 if (diff < 0 || diff > MAX_KEY_ID_DIFF)
99 return ERR_PTR(-EINVAL);
100
101 delta = kzalloc(sizeof(*delta), GFP_KERNEL);
102 if (!delta)
103 return ERR_PTR(-ENOMEM);
104 delta->key_id_diff = diff;
105 world->delta_count++;
106 return delta;
107}
108
109static void delta_destroy(void *priv, void *delta_priv)
110{
111 struct delta *delta = delta_priv;
112 struct world *world = priv;
113
114 world->delta_count--;
115 kfree(delta);
116}
117
118static void *root_create(void *priv, void *obj)
119{
120 struct world *world = priv;
121 struct tokey *key = obj;
122 struct root *root;
123
124 root = kzalloc(sizeof(*root), GFP_KERNEL);
125 if (!root)
126 return ERR_PTR(-ENOMEM);
127 memcpy(&root->key, key, sizeof(root->key));
128 memcpy(root->buf, world->next_root_buf, sizeof(root->buf));
129 world->root_count++;
130 return root;
131}
132
133static void root_destroy(void *priv, void *root_priv)
134{
135 struct root *root = root_priv;
136 struct world *world = priv;
137
138 world->root_count--;
139 kfree(root);
140}
141
142static int test_nodelta_obj_get(struct world *world, struct objagg *objagg,
143 unsigned int key_id, bool should_create_root)
144{
145 unsigned int orig_root_count = world->root_count;
146 struct objagg_obj *objagg_obj;
147 const struct root *root;
148 int err;
149
150 if (should_create_root)
151 prandom_bytes(world->next_root_buf,
152 sizeof(world->next_root_buf));
153
154 objagg_obj = world_obj_get(world, objagg, key_id);
155 if (IS_ERR(objagg_obj)) {
156 pr_err("Key %u: Failed to get object.\n", key_id);
157 return PTR_ERR(objagg_obj);
158 }
159 if (should_create_root) {
160 if (world->root_count != orig_root_count + 1) {
161 pr_err("Key %u: Root was not created\n", key_id);
162 err = -EINVAL;
163 goto err_check_root_count;
164 }
165 } else {
166 if (world->root_count != orig_root_count) {
167 pr_err("Key %u: Root was incorrectly created\n",
168 key_id);
169 err = -EINVAL;
170 goto err_check_root_count;
171 }
172 }
173 root = objagg_obj_root_priv(objagg_obj);
174 if (root->key.id != key_id) {
175 pr_err("Key %u: Root has unexpected key id\n", key_id);
176 err = -EINVAL;
177 goto err_check_key_id;
178 }
179 if (should_create_root &&
180 memcmp(world->next_root_buf, root->buf, sizeof(root->buf))) {
181 pr_err("Key %u: Buffer does not match the expected content\n",
182 key_id);
183 err = -EINVAL;
184 goto err_check_buf;
185 }
186 return 0;
187
188err_check_buf:
189err_check_key_id:
190err_check_root_count:
191 objagg_obj_put(objagg, objagg_obj);
192 return err;
193}
194
195static int test_nodelta_obj_put(struct world *world, struct objagg *objagg,
196 unsigned int key_id, bool should_destroy_root)
197{
198 unsigned int orig_root_count = world->root_count;
199
200 world_obj_put(world, objagg, key_id);
201
202 if (should_destroy_root) {
203 if (world->root_count != orig_root_count - 1) {
204 pr_err("Key %u: Root was not destroyed\n", key_id);
205 return -EINVAL;
206 }
207 } else {
208 if (world->root_count != orig_root_count) {
209 pr_err("Key %u: Root was incorrectly destroyed\n",
210 key_id);
211 return -EINVAL;
212 }
213 }
214 return 0;
215}
216
217static int check_stats_zero(struct objagg *objagg)
218{
219 const struct objagg_stats *stats;
220 int err = 0;
221
222 stats = objagg_stats_get(objagg);
223 if (IS_ERR(stats))
224 return PTR_ERR(stats);
225
226 if (stats->stats_info_count != 0) {
227 pr_err("Stats: Object count is not zero while it should be\n");
228 err = -EINVAL;
229 }
230
231 objagg_stats_put(stats);
232 return err;
233}
234
235static int check_stats_nodelta(struct objagg *objagg)
236{
237 const struct objagg_stats *stats;
238 int i;
239 int err;
240
241 stats = objagg_stats_get(objagg);
242 if (IS_ERR(stats))
243 return PTR_ERR(stats);
244
245 if (stats->stats_info_count != NUM_KEYS) {
246 pr_err("Stats: Unexpected object count (%u expected, %u returned)\n",
247 NUM_KEYS, stats->stats_info_count);
248 err = -EINVAL;
249 goto stats_put;
250 }
251
252 for (i = 0; i < stats->stats_info_count; i++) {
253 if (stats->stats_info[i].stats.user_count != 2) {
254 pr_err("Stats: incorrect user count\n");
255 err = -EINVAL;
256 goto stats_put;
257 }
258 if (stats->stats_info[i].stats.delta_user_count != 2) {
259 pr_err("Stats: incorrect delta user count\n");
260 err = -EINVAL;
261 goto stats_put;
262 }
263 }
264 err = 0;
265
266stats_put:
267 objagg_stats_put(stats);
268 return err;
269}
270
271static void *delta_create_dummy(void *priv, void *parent_obj, void *obj)
272{
273 return ERR_PTR(-EOPNOTSUPP);
274}
275
276static void delta_destroy_dummy(void *priv, void *delta_priv)
277{
278}
279
280static const struct objagg_ops nodelta_ops = {
281 .obj_size = sizeof(struct tokey),
282 .delta_create = delta_create_dummy,
283 .delta_destroy = delta_destroy_dummy,
284 .root_create = root_create,
285 .root_destroy = root_destroy,
286};
287
288static int test_nodelta(void)
289{
290 struct world world = {};
291 struct objagg *objagg;
292 int i;
293 int err;
294
295 objagg = objagg_create(&nodelta_ops, &world);
296 if (IS_ERR(objagg))
297 return PTR_ERR(objagg);
298
299 err = check_stats_zero(objagg);
300 if (err)
301 goto err_stats_first_zero;
302
303 /* First round of gets, the root objects should be created */
304 for (i = 0; i < NUM_KEYS; i++) {
305 err = test_nodelta_obj_get(&world, objagg, i, true);
306 if (err)
307 goto err_obj_first_get;
308 }
309
310 /* Do the second round of gets, all roots are already created,
311 * make sure that no new root is created
312 */
313 for (i = 0; i < NUM_KEYS; i++) {
314 err = test_nodelta_obj_get(&world, objagg, i, false);
315 if (err)
316 goto err_obj_second_get;
317 }
318
319 err = check_stats_nodelta(objagg);
320 if (err)
321 goto err_stats_nodelta;
322
323 for (i = NUM_KEYS - 1; i >= 0; i--) {
324 err = test_nodelta_obj_put(&world, objagg, i, false);
325 if (err)
326 goto err_obj_first_put;
327 }
328 for (i = NUM_KEYS - 1; i >= 0; i--) {
329 err = test_nodelta_obj_put(&world, objagg, i, true);
330 if (err)
331 goto err_obj_second_put;
332 }
333
334 err = check_stats_zero(objagg);
335 if (err)
336 goto err_stats_second_zero;
337
338 objagg_destroy(objagg);
339 return 0;
340
341err_stats_nodelta:
342err_obj_first_put:
343err_obj_second_get:
344 for (i--; i >= 0; i--)
345 world_obj_put(&world, objagg, i);
346
347 i = NUM_KEYS;
348err_obj_first_get:
349err_obj_second_put:
350 for (i--; i >= 0; i--)
351 world_obj_put(&world, objagg, i);
352err_stats_first_zero:
353err_stats_second_zero:
354 objagg_destroy(objagg);
355 return err;
356}
357
358static const struct objagg_ops delta_ops = {
359 .obj_size = sizeof(struct tokey),
360 .delta_create = delta_create,
361 .delta_destroy = delta_destroy,
362 .root_create = root_create,
363 .root_destroy = root_destroy,
364};
365
366enum action {
367 ACTION_GET,
368 ACTION_PUT,
369};
370
371enum expect_delta {
372 EXPECT_DELTA_SAME,
373 EXPECT_DELTA_INC,
374 EXPECT_DELTA_DEC,
375};
376
377enum expect_root {
378 EXPECT_ROOT_SAME,
379 EXPECT_ROOT_INC,
380 EXPECT_ROOT_DEC,
381};
382
383struct expect_stats_info {
384 struct objagg_obj_stats stats;
385 bool is_root;
386 unsigned int key_id;
387};
388
389struct expect_stats {
390 unsigned int info_count;
391 struct expect_stats_info info[NUM_KEYS];
392};
393
394struct action_item {
395 unsigned int key_id;
396 enum action action;
397 enum expect_delta expect_delta;
398 enum expect_root expect_root;
399 struct expect_stats expect_stats;
400};
401
402#define EXPECT_STATS(count, ...) \
403{ \
404 .info_count = count, \
405 .info = { __VA_ARGS__ } \
406}
407
408#define ROOT(key_id, user_count, delta_user_count) \
409 {{user_count, delta_user_count}, true, key_id}
410
411#define DELTA(key_id, user_count) \
412 {{user_count, user_count}, false, key_id}
413
414static const struct action_item action_items[] = {
415 {
416 1, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC,
417 EXPECT_STATS(1, ROOT(1, 1, 1)),
418 }, /* r: 1 d: */
419 {
420 7, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC,
421 EXPECT_STATS(2, ROOT(1, 1, 1), ROOT(7, 1, 1)),
422 }, /* r: 1, 7 d: */
423 {
424 3, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME,
425 EXPECT_STATS(3, ROOT(1, 1, 2), ROOT(7, 1, 1),
426 DELTA(3, 1)),
427 }, /* r: 1, 7 d: 3^1 */
428 {
429 5, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME,
430 EXPECT_STATS(4, ROOT(1, 1, 3), ROOT(7, 1, 1),
431 DELTA(3, 1), DELTA(5, 1)),
432 }, /* r: 1, 7 d: 3^1, 5^1 */
433 {
434 3, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
435 EXPECT_STATS(4, ROOT(1, 1, 4), ROOT(7, 1, 1),
436 DELTA(3, 2), DELTA(5, 1)),
437 }, /* r: 1, 7 d: 3^1, 3^1, 5^1 */
438 {
439 1, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
440 EXPECT_STATS(4, ROOT(1, 2, 5), ROOT(7, 1, 1),
441 DELTA(3, 2), DELTA(5, 1)),
442 }, /* r: 1, 1, 7 d: 3^1, 3^1, 5^1 */
443 {
444 30, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC,
445 EXPECT_STATS(5, ROOT(1, 2, 5), ROOT(7, 1, 1), ROOT(30, 1, 1),
446 DELTA(3, 2), DELTA(5, 1)),
447 }, /* r: 1, 1, 7, 30 d: 3^1, 3^1, 5^1 */
448 {
449 8, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME,
450 EXPECT_STATS(6, ROOT(1, 2, 5), ROOT(7, 1, 2), ROOT(30, 1, 1),
451 DELTA(3, 2), DELTA(5, 1), DELTA(8, 1)),
452 }, /* r: 1, 1, 7, 30 d: 3^1, 3^1, 5^1, 8^7 */
453 {
454 8, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
455 EXPECT_STATS(6, ROOT(1, 2, 5), ROOT(7, 1, 3), ROOT(30, 1, 1),
456 DELTA(3, 2), DELTA(8, 2), DELTA(5, 1)),
457 }, /* r: 1, 1, 7, 30 d: 3^1, 3^1, 5^1, 8^7, 8^7 */
458 {
459 3, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
460 EXPECT_STATS(6, ROOT(1, 2, 4), ROOT(7, 1, 3), ROOT(30, 1, 1),
461 DELTA(8, 2), DELTA(3, 1), DELTA(5, 1)),
462 }, /* r: 1, 1, 7, 30 d: 3^1, 5^1, 8^7, 8^7 */
463 {
464 3, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_SAME,
465 EXPECT_STATS(5, ROOT(1, 2, 3), ROOT(7, 1, 3), ROOT(30, 1, 1),
466 DELTA(8, 2), DELTA(5, 1)),
467 }, /* r: 1, 1, 7, 30 d: 5^1, 8^7, 8^7 */
468 {
469 1, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
470 EXPECT_STATS(5, ROOT(7, 1, 3), ROOT(1, 1, 2), ROOT(30, 1, 1),
471 DELTA(8, 2), DELTA(5, 1)),
472 }, /* r: 1, 7, 30 d: 5^1, 8^7, 8^7 */
473 {
474 1, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
475 EXPECT_STATS(5, ROOT(7, 1, 3), ROOT(30, 1, 1), ROOT(1, 0, 1),
476 DELTA(8, 2), DELTA(5, 1)),
477 }, /* r: 7, 30 d: 5^1, 8^7, 8^7 */
478 {
479 5, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_DEC,
480 EXPECT_STATS(3, ROOT(7, 1, 3), ROOT(30, 1, 1),
481 DELTA(8, 2)),
482 }, /* r: 7, 30 d: 8^7, 8^7 */
483 {
484 5, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_INC,
485 EXPECT_STATS(4, ROOT(7, 1, 3), ROOT(30, 1, 1), ROOT(5, 1, 1),
486 DELTA(8, 2)),
487 }, /* r: 7, 30, 5 d: 8^7, 8^7 */
488 {
489 6, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME,
490 EXPECT_STATS(5, ROOT(7, 1, 3), ROOT(5, 1, 2), ROOT(30, 1, 1),
491 DELTA(8, 2), DELTA(6, 1)),
492 }, /* r: 7, 30, 5 d: 8^7, 8^7, 6^5 */
493 {
494 8, ACTION_GET, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
495 EXPECT_STATS(5, ROOT(7, 1, 4), ROOT(5, 1, 2), ROOT(30, 1, 1),
496 DELTA(8, 3), DELTA(6, 1)),
497 }, /* r: 7, 30, 5 d: 8^7, 8^7, 8^7, 6^5 */
498 {
499 8, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
500 EXPECT_STATS(5, ROOT(7, 1, 3), ROOT(5, 1, 2), ROOT(30, 1, 1),
501 DELTA(8, 2), DELTA(6, 1)),
502 }, /* r: 7, 30, 5 d: 8^7, 8^7, 6^5 */
503 {
504 8, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
505 EXPECT_STATS(5, ROOT(7, 1, 2), ROOT(5, 1, 2), ROOT(30, 1, 1),
506 DELTA(8, 1), DELTA(6, 1)),
507 }, /* r: 7, 30, 5 d: 8^7, 6^5 */
508 {
509 8, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_SAME,
510 EXPECT_STATS(4, ROOT(5, 1, 2), ROOT(7, 1, 1), ROOT(30, 1, 1),
511 DELTA(6, 1)),
512 }, /* r: 7, 30, 5 d: 6^5 */
513 {
514 8, ACTION_GET, EXPECT_DELTA_INC, EXPECT_ROOT_SAME,
515 EXPECT_STATS(5, ROOT(5, 1, 3), ROOT(7, 1, 1), ROOT(30, 1, 1),
516 DELTA(6, 1), DELTA(8, 1)),
517 }, /* r: 7, 30, 5 d: 6^5, 8^5 */
518 {
519 7, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_DEC,
520 EXPECT_STATS(4, ROOT(5, 1, 3), ROOT(30, 1, 1),
521 DELTA(6, 1), DELTA(8, 1)),
522 }, /* r: 30, 5 d: 6^5, 8^5 */
523 {
524 30, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_DEC,
525 EXPECT_STATS(3, ROOT(5, 1, 3),
526 DELTA(6, 1), DELTA(8, 1)),
527 }, /* r: 5 d: 6^5, 8^5 */
528 {
529 5, ACTION_PUT, EXPECT_DELTA_SAME, EXPECT_ROOT_SAME,
530 EXPECT_STATS(3, ROOT(5, 0, 2),
531 DELTA(6, 1), DELTA(8, 1)),
532 }, /* r: d: 6^5, 8^5 */
533 {
534 6, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_SAME,
535 EXPECT_STATS(2, ROOT(5, 0, 1),
536 DELTA(8, 1)),
537 }, /* r: d: 6^5 */
538 {
539 8, ACTION_PUT, EXPECT_DELTA_DEC, EXPECT_ROOT_DEC,
540 EXPECT_STATS(0, ),
541 }, /* r: d: */
542};
543
544static int check_expect(struct world *world,
545 const struct action_item *action_item,
546 unsigned int orig_delta_count,
547 unsigned int orig_root_count)
548{
549 unsigned int key_id = action_item->key_id;
550
551 switch (action_item->expect_delta) {
552 case EXPECT_DELTA_SAME:
553 if (orig_delta_count != world->delta_count) {
554 pr_err("Key %u: Delta count changed while expected to remain the same.\n",
555 key_id);
556 return -EINVAL;
557 }
558 break;
559 case EXPECT_DELTA_INC:
560 if (WARN_ON(action_item->action == ACTION_PUT))
561 return -EINVAL;
562 if (orig_delta_count + 1 != world->delta_count) {
563 pr_err("Key %u: Delta count was not incremented.\n",
564 key_id);
565 return -EINVAL;
566 }
567 break;
568 case EXPECT_DELTA_DEC:
569 if (WARN_ON(action_item->action == ACTION_GET))
570 return -EINVAL;
571 if (orig_delta_count - 1 != world->delta_count) {
572 pr_err("Key %u: Delta count was not decremented.\n",
573 key_id);
574 return -EINVAL;
575 }
576 break;
577 }
578
579 switch (action_item->expect_root) {
580 case EXPECT_ROOT_SAME:
581 if (orig_root_count != world->root_count) {
582 pr_err("Key %u: Root count changed while expected to remain the same.\n",
583 key_id);
584 return -EINVAL;
585 }
586 break;
587 case EXPECT_ROOT_INC:
588 if (WARN_ON(action_item->action == ACTION_PUT))
589 return -EINVAL;
590 if (orig_root_count + 1 != world->root_count) {
591 pr_err("Key %u: Root count was not incremented.\n",
592 key_id);
593 return -EINVAL;
594 }
595 break;
596 case EXPECT_ROOT_DEC:
597 if (WARN_ON(action_item->action == ACTION_GET))
598 return -EINVAL;
599 if (orig_root_count - 1 != world->root_count) {
600 pr_err("Key %u: Root count was not decremented.\n",
601 key_id);
602 return -EINVAL;
603 }
604 }
605
606 return 0;
607}
608
609static unsigned int obj_to_key_id(struct objagg_obj *objagg_obj)
610{
611 const struct tokey *root_key;
612 const struct delta *delta;
613 unsigned int key_id;
614
615 root_key = objagg_obj_root_priv(objagg_obj);
616 key_id = root_key->id;
617 delta = objagg_obj_delta_priv(objagg_obj);
618 if (delta)
619 key_id += delta->key_id_diff;
620 return key_id;
621}
622
623static int
624check_expect_stats_nums(const struct objagg_obj_stats_info *stats_info,
625 const struct expect_stats_info *expect_stats_info,
626 const char **errmsg)
627{
628 if (stats_info->is_root != expect_stats_info->is_root) {
629 if (errmsg)
630 *errmsg = "Incorrect root/delta indication";
631 return -EINVAL;
632 }
633 if (stats_info->stats.user_count !=
634 expect_stats_info->stats.user_count) {
635 if (errmsg)
636 *errmsg = "Incorrect user count";
637 return -EINVAL;
638 }
639 if (stats_info->stats.delta_user_count !=
640 expect_stats_info->stats.delta_user_count) {
641 if (errmsg)
642 *errmsg = "Incorrect delta user count";
643 return -EINVAL;
644 }
645 return 0;
646}
647
648static int
649check_expect_stats_key_id(const struct objagg_obj_stats_info *stats_info,
650 const struct expect_stats_info *expect_stats_info,
651 const char **errmsg)
652{
653 if (obj_to_key_id(stats_info->objagg_obj) !=
654 expect_stats_info->key_id) {
655 if (errmsg)
656 *errmsg = "incorrect key id";
657 return -EINVAL;
658 }
659 return 0;
660}
661
662static int check_expect_stats_neigh(const struct objagg_stats *stats,
663 const struct expect_stats *expect_stats,
664 int pos)
665{
666 int i;
667 int err;
668
669 for (i = pos - 1; i >= 0; i--) {
670 err = check_expect_stats_nums(&stats->stats_info[i],
671 &expect_stats->info[pos], NULL);
672 if (err)
673 break;
674 err = check_expect_stats_key_id(&stats->stats_info[i],
675 &expect_stats->info[pos], NULL);
676 if (!err)
677 return 0;
678 }
679 for (i = pos + 1; i < stats->stats_info_count; i++) {
680 err = check_expect_stats_nums(&stats->stats_info[i],
681 &expect_stats->info[pos], NULL);
682 if (err)
683 break;
684 err = check_expect_stats_key_id(&stats->stats_info[i],
685 &expect_stats->info[pos], NULL);
686 if (!err)
687 return 0;
688 }
689 return -EINVAL;
690}
691
692static int __check_expect_stats(const struct objagg_stats *stats,
693 const struct expect_stats *expect_stats,
694 const char **errmsg)
695{
696 int i;
697 int err;
698
699 if (stats->stats_info_count != expect_stats->info_count) {
700 *errmsg = "Unexpected object count";
701 return -EINVAL;
702 }
703
704 for (i = 0; i < stats->stats_info_count; i++) {
705 err = check_expect_stats_nums(&stats->stats_info[i],
706 &expect_stats->info[i], errmsg);
707 if (err)
708 return err;
709 err = check_expect_stats_key_id(&stats->stats_info[i],
710 &expect_stats->info[i], errmsg);
711 if (err) {
712 /* It is possible that one of the neighbor stats with
713 * same numbers have the correct key id, so check it
714 */
715 err = check_expect_stats_neigh(stats, expect_stats, i);
716 if (err)
717 return err;
718 }
719 }
720 return 0;
721}
722
723static int check_expect_stats(struct objagg *objagg,
724 const struct expect_stats *expect_stats,
725 const char **errmsg)
726{
727 const struct objagg_stats *stats;
728 int err;
729
730 stats = objagg_stats_get(objagg);
731 if (IS_ERR(stats))
732 return PTR_ERR(stats);
733 err = __check_expect_stats(stats, expect_stats, errmsg);
734 objagg_stats_put(stats);
735 return err;
736}
737
738static int test_delta_action_item(struct world *world,
739 struct objagg *objagg,
740 const struct action_item *action_item,
741 bool inverse)
742{
743 unsigned int orig_delta_count = world->delta_count;
744 unsigned int orig_root_count = world->root_count;
745 unsigned int key_id = action_item->key_id;
746 enum action action = action_item->action;
747 struct objagg_obj *objagg_obj;
748 const char *errmsg;
749 int err;
750
751 if (inverse)
752 action = action == ACTION_GET ? ACTION_PUT : ACTION_GET;
753
754 switch (action) {
755 case ACTION_GET:
756 objagg_obj = world_obj_get(world, objagg, key_id);
757 if (IS_ERR(objagg_obj))
758 return PTR_ERR(objagg_obj);
759 break;
760 case ACTION_PUT:
761 world_obj_put(world, objagg, key_id);
762 break;
763 }
764
765 if (inverse)
766 return 0;
767 err = check_expect(world, action_item,
768 orig_delta_count, orig_root_count);
769 if (err)
770 goto errout;
771
772 errmsg = NULL;
773 err = check_expect_stats(objagg, &action_item->expect_stats, &errmsg);
774 if (err) {
775 pr_err("Key %u: Stats: %s\n", action_item->key_id, errmsg);
776 goto errout;
777 }
778
779 return 0;
780
781errout:
782 /* This can only happen when action is not inversed.
783 * So in case of an error, cleanup by doing inverse action.
784 */
785 test_delta_action_item(world, objagg, action_item, true);
786 return err;
787}
788
789static int test_delta(void)
790{
791 struct world world = {};
792 struct objagg *objagg;
793 int i;
794 int err;
795
796 objagg = objagg_create(&delta_ops, &world);
797 if (IS_ERR(objagg))
798 return PTR_ERR(objagg);
799
800 for (i = 0; i < ARRAY_SIZE(action_items); i++) {
801 err = test_delta_action_item(&world, objagg,
802 &action_items[i], false);
803 if (err)
804 goto err_do_action_item;
805 }
806
807 objagg_destroy(objagg);
808 return 0;
809
810err_do_action_item:
811 for (i--; i >= 0; i--)
812 test_delta_action_item(&world, objagg, &action_items[i], true);
813
814 objagg_destroy(objagg);
815 return err;
816}
817
818static int __init test_objagg_init(void)
819{
820 int err;
821
822 err = test_nodelta();
823 if (err)
824 return err;
825 return test_delta();
826}
827
828static void __exit test_objagg_exit(void)
829{
830}
831
832module_init(test_objagg_init);
833module_exit(test_objagg_exit);
834MODULE_LICENSE("Dual BSD/GPL");
835MODULE_AUTHOR("Jiri Pirko <[email protected]>");
836MODULE_DESCRIPTION("Test module for objagg");