crush.c

  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}