cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

crush.c (3116B)

      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}