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

   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
   9const 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 */
  26int 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
  46void 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
  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.perm);
  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.perm);
  65        kfree(b->h.items);
  66        kfree(b->node_weights);
  67        kfree(b);
  68}
  69
  70void 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
  79void 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
  87void 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 */
 112void 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
 139void crush_destroy_rule(struct crush_rule *rule)
 140{
 141        kfree(rule);
 142}
 143