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