crush.c 3.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142
  1. // SPDX-License-Identifier: GPL-2.0
  2. #ifdef __KERNEL__
  3. # include <linux/slab.h>
  4. # include <linux/crush/crush.h>
  5. #else
  6. # include "crush_compat.h"
  7. # include "crush.h"
  8. #endif
  9. const char *crush_bucket_alg_name(int alg)
  10. {
  11. switch (alg) {
  12. case CRUSH_BUCKET_UNIFORM: return "uniform";
  13. case CRUSH_BUCKET_LIST: return "list";
  14. case CRUSH_BUCKET_TREE: return "tree";
  15. case CRUSH_BUCKET_STRAW: return "straw";
  16. case CRUSH_BUCKET_STRAW2: return "straw2";
  17. default: return "unknown";
  18. }
  19. }
  20. /**
  21. * crush_get_bucket_item_weight - Get weight of an item in given bucket
  22. * @b: bucket pointer
  23. * @p: item index in bucket
  24. */
  25. int crush_get_bucket_item_weight(const struct crush_bucket *b, int p)
  26. {
  27. if ((__u32)p >= b->size)
  28. return 0;
  29. switch (b->alg) {
  30. case CRUSH_BUCKET_UNIFORM:
  31. return ((struct crush_bucket_uniform *)b)->item_weight;
  32. case CRUSH_BUCKET_LIST:
  33. return ((struct crush_bucket_list *)b)->item_weights[p];
  34. case CRUSH_BUCKET_TREE:
  35. return ((struct crush_bucket_tree *)b)->node_weights[crush_calc_tree_node(p)];
  36. case CRUSH_BUCKET_STRAW:
  37. return ((struct crush_bucket_straw *)b)->item_weights[p];
  38. case CRUSH_BUCKET_STRAW2:
  39. return ((struct crush_bucket_straw2 *)b)->item_weights[p];
  40. }
  41. return 0;
  42. }
  43. void crush_destroy_bucket_uniform(struct crush_bucket_uniform *b)
  44. {
  45. kfree(b->h.items);
  46. kfree(b);
  47. }
  48. void crush_destroy_bucket_list(struct crush_bucket_list *b)
  49. {
  50. kfree(b->item_weights);
  51. kfree(b->sum_weights);
  52. kfree(b->h.items);
  53. kfree(b);
  54. }
  55. void crush_destroy_bucket_tree(struct crush_bucket_tree *b)
  56. {
  57. kfree(b->h.items);
  58. kfree(b->node_weights);
  59. kfree(b);
  60. }
  61. void crush_destroy_bucket_straw(struct crush_bucket_straw *b)
  62. {
  63. kfree(b->straws);
  64. kfree(b->item_weights);
  65. kfree(b->h.items);
  66. kfree(b);
  67. }
  68. void crush_destroy_bucket_straw2(struct crush_bucket_straw2 *b)
  69. {
  70. kfree(b->item_weights);
  71. kfree(b->h.items);
  72. kfree(b);
  73. }
  74. void crush_destroy_bucket(struct crush_bucket *b)
  75. {
  76. switch (b->alg) {
  77. case CRUSH_BUCKET_UNIFORM:
  78. crush_destroy_bucket_uniform((struct crush_bucket_uniform *)b);
  79. break;
  80. case CRUSH_BUCKET_LIST:
  81. crush_destroy_bucket_list((struct crush_bucket_list *)b);
  82. break;
  83. case CRUSH_BUCKET_TREE:
  84. crush_destroy_bucket_tree((struct crush_bucket_tree *)b);
  85. break;
  86. case CRUSH_BUCKET_STRAW:
  87. crush_destroy_bucket_straw((struct crush_bucket_straw *)b);
  88. break;
  89. case CRUSH_BUCKET_STRAW2:
  90. crush_destroy_bucket_straw2((struct crush_bucket_straw2 *)b);
  91. break;
  92. }
  93. }
  94. /**
  95. * crush_destroy - Destroy a crush_map
  96. * @map: crush_map pointer
  97. */
  98. void crush_destroy(struct crush_map *map)
  99. {
  100. /* buckets */
  101. if (map->buckets) {
  102. __s32 b;
  103. for (b = 0; b < map->max_buckets; b++) {
  104. if (map->buckets[b] == NULL)
  105. continue;
  106. crush_destroy_bucket(map->buckets[b]);
  107. }
  108. kfree(map->buckets);
  109. }
  110. /* rules */
  111. if (map->rules) {
  112. __u32 b;
  113. for (b = 0; b < map->max_rules; b++)
  114. crush_destroy_rule(map->rules[b]);
  115. kfree(map->rules);
  116. }
  117. #ifndef __KERNEL__
  118. kfree(map->choose_tries);
  119. #else
  120. clear_crush_names(&map->type_names);
  121. clear_crush_names(&map->names);
  122. clear_choose_args(map);
  123. #endif
  124. kfree(map);
  125. }
  126. void crush_destroy_rule(struct crush_rule *rule)
  127. {
  128. kfree(rule);
  129. }