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