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>
   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}
 143