LXR linux/net/ceph/crush/crush.c

   1// SPDX-License-Identifier: GPL-2.0
   2#ifdef __KERNEL__
   3# include <linux/slab.h>
   4# include <linux/crush/crush.h>
   5void clear_choose_args(struct crush_map *c);
   6#else
   7# include "crush_compat.h"
   8# include "crush.h"
   9#endif
  10
  11const 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 */
  28int 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
  48void crush_destroy_bucket_uniform(struct crush_bucket_uniform *b)
  49{
  50        kfree(b->h.items);
  51        kfree(b);
  52}
  53
  54void 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
  62void 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
  69void 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
  77void 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
  84void 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 */
 109void 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
 138void crush_destroy_rule(struct crush_rule *rule)
 139{
 140        kfree(rule);
 141}
 142