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