root/net/ceph/crush/crush.c

DEFINITIONS

1. crush_bucket_alg_name
2. crush_get_bucket_item_weight
3. crush_destroy_bucket_uniform
4. crush_destroy_bucket_list
5. crush_destroy_bucket_tree
6. crush_destroy_bucket_straw
7. crush_destroy_bucket_straw2
8. crush_destroy_bucket
9. crush_destroy
10. crush_destroy_rule

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