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
10const 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 */
27int 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(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
47void crush_destroy_bucket_uniform(struct crush_bucket_uniform *b)
48{
49	kfree(b->h.items);
50	kfree(b);
51}
52
53void crush_destroy_bucket_list(struct crush_bucket_list *b)
54{
55	kfree(b->item_weights);
56	kfree(b->sum_weights);
57	kfree(b->h.items);
58	kfree(b);
59}
60
61void crush_destroy_bucket_tree(struct crush_bucket_tree *b)
62{
63	kfree(b->h.items);
64	kfree(b->node_weights);
65	kfree(b);
66}
67
68void crush_destroy_bucket_straw(struct crush_bucket_straw *b)
69{
70	kfree(b->straws);
71	kfree(b->item_weights);
72	kfree(b->h.items);
73	kfree(b);
74}
75
76void crush_destroy_bucket_straw2(struct crush_bucket_straw2 *b)
77{
78	kfree(b->item_weights);
79	kfree(b->h.items);
80	kfree(b);
81}
82
83void crush_destroy_bucket(struct crush_bucket *b)
84{
85	switch (b->alg) {
86	case CRUSH_BUCKET_UNIFORM:
87		crush_destroy_bucket_uniform((struct crush_bucket_uniform *)b);
88		break;
89	case CRUSH_BUCKET_LIST:
90		crush_destroy_bucket_list((struct crush_bucket_list *)b);
91		break;
92	case CRUSH_BUCKET_TREE:
93		crush_destroy_bucket_tree((struct crush_bucket_tree *)b);
94		break;
95	case CRUSH_BUCKET_STRAW:
96		crush_destroy_bucket_straw((struct crush_bucket_straw *)b);
97		break;
98	case CRUSH_BUCKET_STRAW2:
99		crush_destroy_bucket_straw2((struct crush_bucket_straw2 *)b);
100		break;
101	}
102}
103
104/**
105 * crush_destroy - Destroy a crush_map
106 * @map: crush_map pointer
107 */
108void 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(map->buckets[b]);
117		}
118		kfree(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(map->rules[b]);
126		kfree(map->rules);
127	}
128
129#ifndef __KERNEL__
130	kfree(map->choose_tries);
131#else
132	clear_crush_names(&map->type_names);
133	clear_crush_names(&map->names);
134	clear_choose_args(map);
135#endif
136	kfree(map);
137}
138
139void crush_destroy_rule(struct crush_rule *rule)
140{
141	kfree(rule);
142}
143