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

   1
   2#ifdef __KERNEL__
   3# include <linux/slab.h>
   4#else
   5# include <stdlib.h>
   6# include <assert.h>
   7# define kfree(x) do { if (x) free(x); } while (0)
   8# define BUG_ON(x) assert(!(x))
   9#endif
  10
  11#include <linux/crush/crush.h>
  12
  13const char *crush_bucket_alg_name(int alg)
  14{
  15        switch (alg) {
  16        case CRUSH_BUCKET_UNIFORM: return "uniform";
  17        case CRUSH_BUCKET_LIST: return "list";
  18        case CRUSH_BUCKET_TREE: return "tree";
  19        case CRUSH_BUCKET_STRAW: return "straw";
  20        default: return "unknown";
  21        }
  22}
  23
  24/**
  25 * crush_get_bucket_item_weight - Get weight of an item in given bucket
  26 * @b: bucket pointer
  27 * @p: item index in bucket
  28 */
  29int crush_get_bucket_item_weight(const struct crush_bucket *b, int p)
  30{
  31        if ((__u32)p >= b->size)
  32                return 0;
  33
  34        switch (b->alg) {
  35        case CRUSH_BUCKET_UNIFORM:
  36                return ((struct crush_bucket_uniform *)b)->item_weight;
  37        case CRUSH_BUCKET_LIST:
  38                return ((struct crush_bucket_list *)b)->item_weights[p];
  39        case CRUSH_BUCKET_TREE:
  40                return ((struct crush_bucket_tree *)b)->node_weights[crush_calc_tree_node(p)];
  41        case CRUSH_BUCKET_STRAW:
  42                return ((struct crush_bucket_straw *)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.perm);
  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.perm);
  59        kfree(b->h.items);
  60        kfree(b);
  61}
  62
  63void crush_destroy_bucket_tree(struct crush_bucket_tree *b)
  64{
  65        kfree(b->h.perm);
  66        kfree(b->h.items);
  67        kfree(b->node_weights);
  68        kfree(b);
  69}
  70
  71void crush_destroy_bucket_straw(struct crush_bucket_straw *b)
  72{
  73        kfree(b->straws);
  74        kfree(b->item_weights);
  75        kfree(b->h.perm);
  76        kfree(b->h.items);
  77        kfree(b);
  78}
  79
  80void crush_destroy_bucket(struct crush_bucket *b)
  81{
  82        switch (b->alg) {
  83        case CRUSH_BUCKET_UNIFORM:
  84                crush_destroy_bucket_uniform((struct crush_bucket_uniform *)b);
  85                break;
  86        case CRUSH_BUCKET_LIST:
  87                crush_destroy_bucket_list((struct crush_bucket_list *)b);
  88                break;
  89        case CRUSH_BUCKET_TREE:
  90                crush_destroy_bucket_tree((struct crush_bucket_tree *)b);
  91                break;
  92        case CRUSH_BUCKET_STRAW:
  93                crush_destroy_bucket_straw((struct crush_bucket_straw *)b);
  94                break;
  95        }
  96}
  97
  98/**
  99 * crush_destroy - Destroy a crush_map
 100 * @map: crush_map pointer
 101 */
 102void crush_destroy(struct crush_map *map)
 103{
 104        /* buckets */
 105        if (map->buckets) {
 106                __s32 b;
 107                for (b = 0; b < map->max_buckets; b++) {
 108                        if (map->buckets[b] == NULL)
 109                                continue;
 110                        crush_destroy_bucket(map->buckets[b]);
 111                }
 112                kfree(map->buckets);
 113        }
 114
 115        /* rules */
 116        if (map->rules) {
 117                __u32 b;
 118                for (b = 0; b < map->max_rules; b++)
 119                        kfree(map->rules[b]);
 120                kfree(map->rules);
 121        }
 122
 123        kfree(map);
 124}
 125
 126
 127