// SPDX-License-Identifier: GPL-2.0

#include <linux/ceph/ceph_debug.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/ceph/libceph.h>

#include <linux/ceph/osdmap.h>

#include <linux/ceph/decode.h>

#include <linux/crush/hash.h>

#include <linux/crush/mapper.h>

static __printf(2, 3)

void osdmap_info(const struct ceph_osdmap *map, const char *fmt, ...)

{

struct va_format vaf;

va_list args;

va_start(args, fmt);

vaf.fmt = fmt;

vaf.va = &args;

printk(KERN_INFO "%s (%pU e%u): %pV", KBUILD_MODNAME, &map->fsid,

map->epoch, &vaf);

va_end(args);

}

char *ceph_osdmap_state_str(char *str, int len, u32 state)

{

if (!len)

return str;

if ((state & CEPH_OSD_EXISTS) && (state & CEPH_OSD_UP))

snprintf(str, len, "exists, up");

else if (state & CEPH_OSD_EXISTS)

snprintf(str, len, "exists");

else if (state & CEPH_OSD_UP)

snprintf(str, len, "up");

else

snprintf(str, len, "doesn't exist");

return str;

}

/* maps */

static int calc_bits_of(unsigned int t)

{

int b = 0;

while (t) {

t = t >> 1;

b++;

}

return b;

}

/*

* the foo_mask is the smallest value 2^n-1 that is >= foo.

*/

static void calc_pg_masks(struct ceph_pg_pool_info *pi)

{

pi->pg_num_mask = (1 << calc_bits_of(pi->pg_num-1)) - 1;

pi->pgp_num_mask = (1 << calc_bits_of(pi->pgp_num-1)) - 1;

}

/*

* decode crush map

*/

static int crush_decode_uniform_bucket(void **p, void *end,

struct crush_bucket_uniform *b)

{

dout("crush_decode_uniform_bucket %p to %p\n", *p, end);

ceph_decode_need(p, end, (1+b->h.size) * sizeof(u32), bad);

b->item_weight = ceph_decode_32(p);

return 0;

bad:

return -EINVAL;

}

static int crush_decode_list_bucket(void **p, void *end,

struct crush_bucket_list *b)

{

int j;

dout("crush_decode_list_bucket %p to %p\n", *p, end);

b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);

if (b->item_weights == NULL)

return -ENOMEM;

b->sum_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);

if (b->sum_weights == NULL)

return -ENOMEM;

ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad);

for (j = 0; j < b->h.size; j++) {

b->item_weights[j] = ceph_decode_32(p);

b->sum_weights[j] = ceph_decode_32(p);

}

return 0;

bad:

return -EINVAL;

}

static int crush_decode_tree_bucket(void **p, void *end,

struct crush_bucket_tree *b)

{

int j;

dout("crush_decode_tree_bucket %p to %p\n", *p, end);

ceph_decode_8_safe(p, end, b->num_nodes, bad);

b->node_weights = kcalloc(b->num_nodes, sizeof(u32), GFP_NOFS);

if (b->node_weights == NULL)

return -ENOMEM;

ceph_decode_need(p, end, b->num_nodes * sizeof(u32), bad);

for (j = 0; j < b->num_nodes; j++)

b->node_weights[j] = ceph_decode_32(p);

return 0;

bad:

return -EINVAL;

}

static int crush_decode_straw_bucket(void **p, void *end,

struct crush_bucket_straw *b)

{

int j;

dout("crush_decode_straw_bucket %p to %p\n", *p, end);

b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);

if (b->item_weights == NULL)

return -ENOMEM;

b->straws = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);

if (b->straws == NULL)

return -ENOMEM;

ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad);

for (j = 0; j < b->h.size; j++) {

b->item_weights[j] = ceph_decode_32(p);

b->straws[j] = ceph_decode_32(p);

}

return 0;

bad:

return -EINVAL;

}

static int crush_decode_straw2_bucket(void **p, void *end,

struct crush_bucket_straw2 *b)

{

int j;

dout("crush_decode_straw2_bucket %p to %p\n", *p, end);

b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);

if (b->item_weights == NULL)

return -ENOMEM;

ceph_decode_need(p, end, b->h.size * sizeof(u32), bad);

for (j = 0; j < b->h.size; j++)

b->item_weights[j] = ceph_decode_32(p);

return 0;

bad:

return -EINVAL;

}

struct crush_name_node {

struct rb_node cn_node;

int cn_id;

char cn_name[];

};

static struct crush_name_node *alloc_crush_name(size_t name_len)

{

struct crush_name_node *cn;

cn = kmalloc(sizeof(*cn) + name_len + 1, GFP_NOIO);

if (!cn)

return NULL;

RB_CLEAR_NODE(&cn->cn_node);

return cn;

}

static void free_crush_name(struct crush_name_node *cn)

{

WARN_ON(!RB_EMPTY_NODE(&cn->cn_node));

kfree(cn);

}

DEFINE_RB_FUNCS(crush_name, struct crush_name_node, cn_id, cn_node)

static int decode_crush_names(void **p, void *end, struct rb_root *root)

{

u32 n;

ceph_decode_32_safe(p, end, n, e_inval);

while (n--) {

struct crush_name_node *cn;

int id;

u32 name_len;

ceph_decode_32_safe(p, end, id, e_inval);

ceph_decode_32_safe(p, end, name_len, e_inval);

ceph_decode_need(p, end, name_len, e_inval);

cn = alloc_crush_name(name_len);

if (!cn)

return -ENOMEM;

cn->cn_id = id;

memcpy(cn->cn_name, *p, name_len);

cn->cn_name[name_len] = '\0';

*p += name_len;

if (!__insert_crush_name(root, cn)) {

free_crush_name(cn);

return -EEXIST;

}

}

return 0;

e_inval:

return -EINVAL;

}

void clear_crush_names(struct rb_root *root)

{

while (!RB_EMPTY_ROOT(root)) {

struct crush_name_node *cn =

rb_entry(rb_first(root), struct crush_name_node, cn_node);

erase_crush_name(root, cn);

free_crush_name(cn);

}

}

static struct crush_choose_arg_map *alloc_choose_arg_map(void)

{

struct crush_choose_arg_map *arg_map;

arg_map = kzalloc_obj(*arg_map, GFP_NOIO);

if (!arg_map)

return NULL;

RB_CLEAR_NODE(&arg_map->node);

return arg_map;

}

static void free_choose_arg_map(struct crush_choose_arg_map *arg_map)

{

int i, j;

if (!arg_map)

return;

WARN_ON(!RB_EMPTY_NODE(&arg_map->node));

if (arg_map->args) {

for (i = 0; i < arg_map->size; i++) {

struct crush_choose_arg *arg = &arg_map->args[i];

if (arg->weight_set) {

for (j = 0; j < arg->weight_set_size; j++)

kfree(arg->weight_set[j].weights);

kfree(arg->weight_set);

}

kfree(arg->ids);

}

kfree(arg_map->args);

}

kfree(arg_map);

}

DEFINE_RB_FUNCS(choose_arg_map, struct crush_choose_arg_map, choose_args_index,

node);

void clear_choose_args(struct crush_map *c)

{

while (!RB_EMPTY_ROOT(&c->choose_args)) {

struct crush_choose_arg_map *arg_map =

rb_entry(rb_first(&c->choose_args),

struct crush_choose_arg_map, node);

erase_choose_arg_map(&c->choose_args, arg_map);

free_choose_arg_map(arg_map);

}

}

static u32 *decode_array_32_alloc(void **p, void *end, u32 *plen)

{

u32 *a = NULL;

u32 len;

int ret;

ceph_decode_32_safe(p, end, len, e_inval);

if (len) {

u32 i;

a = kmalloc_array(len, sizeof(u32), GFP_NOIO);

if (!a) {

ret = -ENOMEM;

goto fail;

}

ceph_decode_need(p, end, len * sizeof(u32), e_inval);

for (i = 0; i < len; i++)

a[i] = ceph_decode_32(p);

}

*plen = len;

return a;

e_inval:

ret = -EINVAL;

fail:

kfree(a);

return ERR_PTR(ret);

}

/*

* Assumes @arg is zero-initialized.

*/

static int decode_choose_arg(void **p, void *end, struct crush_choose_arg *arg)

{

int ret;

ceph_decode_32_safe(p, end, arg->weight_set_size, e_inval);

if (arg->weight_set_size) {

u32 i;

arg->weight_set = kmalloc_objs(*arg->weight_set,

arg->weight_set_size, GFP_NOIO);

if (!arg->weight_set)

return -ENOMEM;

for (i = 0; i < arg->weight_set_size; i++) {

struct crush_weight_set *w = &arg->weight_set[i];

w->weights = decode_array_32_alloc(p, end, &w->size);

if (IS_ERR(w->weights)) {

ret = PTR_ERR(w->weights);

w->weights = NULL;

return ret;

}

}

}

arg->ids = decode_array_32_alloc(p, end, &arg->ids_size);

if (IS_ERR(arg->ids)) {

ret = PTR_ERR(arg->ids);

arg->ids = NULL;

return ret;

}

return 0;

e_inval:

return -EINVAL;

}

static int decode_choose_args(void **p, void *end, struct crush_map *c)

{

struct crush_choose_arg_map *arg_map = NULL;

u32 num_choose_arg_maps, num_buckets;

int ret;

ceph_decode_32_safe(p, end, num_choose_arg_maps, e_inval);

while (num_choose_arg_maps--) {

arg_map = alloc_choose_arg_map();

if (!arg_map) {

ret = -ENOMEM;

goto fail;

}

ceph_decode_64_safe(p, end, arg_map->choose_args_index,

e_inval);

arg_map->size = c->max_buckets;

arg_map->args = kzalloc_objs(*arg_map->args, arg_map->size,

GFP_NOIO);

if (!arg_map->args) {

ret = -ENOMEM;

goto fail;

}

ceph_decode_32_safe(p, end, num_buckets, e_inval);

while (num_buckets--) {

struct crush_choose_arg *arg;

u32 bucket_index;

ceph_decode_32_safe(p, end, bucket_index, e_inval);

if (bucket_index >= arg_map->size)

goto e_inval;

arg = &arg_map->args[bucket_index];

ret = decode_choose_arg(p, end, arg);

if (ret)

goto fail;

if (arg->ids_size &&

arg->ids_size != c->buckets[bucket_index]->size)

goto e_inval;

}

insert_choose_arg_map(&c->choose_args, arg_map);

}

return 0;

e_inval:

ret = -EINVAL;

fail:

free_choose_arg_map(arg_map);

return ret;

}

static void crush_finalize(struct crush_map *c)

{

__s32 b;

/* Space for the array of pointers to per-bucket workspace */

c->working_size = sizeof(struct crush_work) +

c->max_buckets * sizeof(struct crush_work_bucket *);

for (b = 0; b < c->max_buckets; b++) {

if (!c->buckets[b])

continue;

switch (c->buckets[b]->alg) {

default:

/*

* The base case, permutation variables and

* the pointer to the permutation array.

*/

c->working_size += sizeof(struct crush_work_bucket);

break;

}

/* Every bucket has a permutation array. */

c->working_size += c->buckets[b]->size * sizeof(__u32);

}

}

static struct crush_map *crush_decode(void *pbyval, void *end)

{

struct crush_map *c;

int err;

int i, j;

void **p = &pbyval;

void *start = pbyval;

u32 magic;

dout("crush_decode %p to %p len %d\n", *p, end, (int)(end - *p));

c = kzalloc_obj(*c, GFP_NOFS);

if (c == NULL)

return ERR_PTR(-ENOMEM);

c->type_names = RB_ROOT;

c->names = RB_ROOT;

c->choose_args = RB_ROOT;

/* set tunables to default values */

c->choose_local_tries = 2;

c->choose_local_fallback_tries = 5;

c->choose_total_tries = 19;

c->chooseleaf_descend_once = 0;

ceph_decode_need(p, end, 4*sizeof(u32), bad);

magic = ceph_decode_32(p);

if (magic != CRUSH_MAGIC) {

pr_err("crush_decode magic %x != current %x\n",

(unsigned int)magic, (unsigned int)CRUSH_MAGIC);

goto bad;

}

c->max_buckets = ceph_decode_32(p);

c->max_rules = ceph_decode_32(p);

c->max_devices = ceph_decode_32(p);

c->buckets = kzalloc_objs(*c->buckets, c->max_buckets, GFP_NOFS);

if (c->buckets == NULL)

goto badmem;

c->rules = kzalloc_objs(*c->rules, c->max_rules, GFP_NOFS);

if (c->rules == NULL)

goto badmem;

/* buckets */

for (i = 0; i < c->max_buckets; i++) {

int size = 0;

u32 alg;

struct crush_bucket *b;

ceph_decode_32_safe(p, end, alg, bad);

if (alg == 0) {

c->buckets[i] = NULL;

continue;

}

dout("crush_decode bucket %d off %x %p to %p\n",

i, (int)(*p-start), *p, end);

switch (alg) {

case CRUSH_BUCKET_UNIFORM:

size = sizeof(struct crush_bucket_uniform);

break;

case CRUSH_BUCKET_LIST:

size = sizeof(struct crush_bucket_list);

break;

case CRUSH_BUCKET_TREE:

size = sizeof(struct crush_bucket_tree);

break;

case CRUSH_BUCKET_STRAW:

size = sizeof(struct crush_bucket_straw);

break;

case CRUSH_BUCKET_STRAW2:

size = sizeof(struct crush_bucket_straw2);

break;

default:

goto bad;

}

BUG_ON(size == 0);

b = c->buckets[i] = kzalloc(size, GFP_NOFS);

if (b == NULL)

goto badmem;

ceph_decode_need(p, end, 4*sizeof(u32), bad);

b->id = ceph_decode_32(p);

b->type = ceph_decode_16(p);

b->alg = ceph_decode_8(p);

b->hash = ceph_decode_8(p);

b->weight = ceph_decode_32(p);

b->size = ceph_decode_32(p);

dout("crush_decode bucket size %d off %x %p to %p\n",

b->size, (int)(*p-start), *p, end);

b->items = kzalloc_objs(__s32, b->size, GFP_NOFS);

if (b->items == NULL)

goto badmem;

ceph_decode_need(p, end, b->size*sizeof(u32), bad);

for (j = 0; j < b->size; j++)

b->items[j] = ceph_decode_32(p);

switch (b->alg) {

case CRUSH_BUCKET_UNIFORM:

err = crush_decode_uniform_bucket(p, end,

(struct crush_bucket_uniform *)b);

if (err < 0)

goto fail;

break;

case CRUSH_BUCKET_LIST:

err = crush_decode_list_bucket(p, end,

(struct crush_bucket_list *)b);

if (err < 0)

goto fail;

break;

case CRUSH_BUCKET_TREE:

err = crush_decode_tree_bucket(p, end,

(struct crush_bucket_tree *)b);

if (err < 0)

goto fail;

break;

case CRUSH_BUCKET_STRAW:

err = crush_decode_straw_bucket(p, end,

(struct crush_bucket_straw *)b);

if (err < 0)

goto fail;

break;

case CRUSH_BUCKET_STRAW2:

err = crush_decode_straw2_bucket(p, end,

(struct crush_bucket_straw2 *)b);

if (err < 0)

goto fail;

break;

}

}

/* rules */

dout("rule vec is %p\n", c->rules);

for (i = 0; i < c->max_rules; i++) {

u32 yes;

struct crush_rule *r;

ceph_decode_32_safe(p, end, yes, bad);

if (!yes) {

dout("crush_decode NO rule %d off %x %p to %p\n",

i, (int)(*p-start), *p, end);

c->rules[i] = NULL;

continue;

}

dout("crush_decode rule %d off %x %p to %p\n",

i, (int)(*p-start), *p, end);

/* len */

ceph_decode_32_safe(p, end, yes, bad);

#if BITS_PER_LONG == 32

if (yes > (ULONG_MAX - sizeof(*r))

/ sizeof(struct crush_rule_step))

goto bad;

#endif

r = kmalloc_flex(*r, steps, yes, GFP_NOFS);

if (r == NULL)

goto badmem;

dout(" rule %d is at %p\n", i, r);

c->rules[i] = r;

r->len = yes;

ceph_decode_copy_safe(p, end, &r->mask, 4, bad); /* 4 u8's */

ceph_decode_need(p, end, r->len*3*sizeof(u32), bad);

for (j = 0; j < r->len; j++) {

r->steps[j].op = ceph_decode_32(p);

r->steps[j].arg1 = ceph_decode_32(p);

r->steps[j].arg2 = ceph_decode_32(p);

}

}

err = decode_crush_names(p, end, &c->type_names);

if (err)

goto fail;

err = decode_crush_names(p, end, &c->names);

if (err)

goto fail;

ceph_decode_skip_map(p, end, 32, string, bad); /* rule_name_map */

/* tunables */

ceph_decode_need(p, end, 3*sizeof(u32), done);

c->choose_local_tries = ceph_decode_32(p);

c->choose_local_fallback_tries = ceph_decode_32(p);

c->choose_total_tries = ceph_decode_32(p);

dout("crush decode tunable choose_local_tries = %d\n",

c->choose_local_tries);

dout("crush decode tunable choose_local_fallback_tries = %d\n",

c->choose_local_fallback_tries);

dout("crush decode tunable choose_total_tries = %d\n",

c->choose_total_tries);

ceph_decode_need(p, end, sizeof(u32), done);

c->chooseleaf_descend_once = ceph_decode_32(p);

dout("crush decode tunable chooseleaf_descend_once = %d\n",

c->chooseleaf_descend_once);

ceph_decode_need(p, end, sizeof(u8), done);

c->chooseleaf_vary_r = ceph_decode_8(p);

dout("crush decode tunable chooseleaf_vary_r = %d\n",

c->chooseleaf_vary_r);

/* skip straw_calc_version, allowed_bucket_algs */

ceph_decode_need(p, end, sizeof(u8) + sizeof(u32), done);

*p += sizeof(u8) + sizeof(u32);

ceph_decode_need(p, end, sizeof(u8), done);

c->chooseleaf_stable = ceph_decode_8(p);

dout("crush decode tunable chooseleaf_stable = %d\n",

c->chooseleaf_stable);

if (*p != end) {

/* class_map */

ceph_decode_skip_map(p, end, 32, 32, bad);

/* class_name */

ceph_decode_skip_map(p, end, 32, string, bad);

/* class_bucket */

ceph_decode_skip_map_of_map(p, end, 32, 32, 32, bad);

}

if (*p != end) {

err = decode_choose_args(p, end, c);

if (err)

goto fail;

}

done:

crush_finalize(c);

dout("crush_decode success\n");

return c;

badmem:

err = -ENOMEM;

fail:

dout("crush_decode fail %d\n", err);

crush_destroy(c);

return ERR_PTR(err);

bad:

err = -EINVAL;

goto fail;

}

int ceph_pg_compare(const struct ceph_pg *lhs, const struct ceph_pg *rhs)

{

if (lhs->pool < rhs->pool)

return -1;

if (lhs->pool > rhs->pool)

return 1;

if (lhs->seed < rhs->seed)

return -1;

if (lhs->seed > rhs->seed)

return 1;

return 0;

}

int ceph_spg_compare(const struct ceph_spg *lhs, const struct ceph_spg *rhs)

{

int ret;

ret = ceph_pg_compare(&lhs->pgid, &rhs->pgid);

if (ret)

return ret;

if (lhs->shard < rhs->shard)

return -1;

if (lhs->shard > rhs->shard)

return 1;

return 0;

}

static struct ceph_pg_mapping *alloc_pg_mapping(size_t payload_len)

{

struct ceph_pg_mapping *pg;

pg = kmalloc(sizeof(*pg) + payload_len, GFP_NOIO);

if (!pg)

return NULL;

RB_CLEAR_NODE(&pg->node);

return pg;

}

static void free_pg_mapping(struct ceph_pg_mapping *pg)

{

WARN_ON(!RB_EMPTY_NODE(&pg->node));

kfree(pg);

}

/*

* rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid

* to a set of osds) and primary_temp (explicit primary setting)

*/

DEFINE_RB_FUNCS2(pg_mapping, struct ceph_pg_mapping, pgid, ceph_pg_compare,

RB_BYPTR, const struct ceph_pg *, node)

/*

* rbtree of pg pool info

*/

DEFINE_RB_FUNCS(pg_pool, struct ceph_pg_pool_info, id, node)

struct ceph_pg_pool_info *ceph_pg_pool_by_id(struct ceph_osdmap *map, u64 id)

{

return lookup_pg_pool(&map->pg_pools, id);

}

const char *ceph_pg_pool_name_by_id(struct ceph_osdmap *map, u64 id)

{

struct ceph_pg_pool_info *pi;

if (id == CEPH_NOPOOL)

return NULL;

if (WARN_ON_ONCE(id > (u64) INT_MAX))

return NULL;

pi = lookup_pg_pool(&map->pg_pools, id);

return pi ? pi->name : NULL;

}

EXPORT_SYMBOL(ceph_pg_pool_name_by_id);

int ceph_pg_poolid_by_name(struct ceph_osdmap *map, const char *name)

{

struct rb_node *rbp;

for (rbp = rb_first(&map->pg_pools); rbp; rbp = rb_next(rbp)) {

struct ceph_pg_pool_info *pi =

rb_entry(rbp, struct ceph_pg_pool_info, node);

if (pi->name && strcmp(pi->name, name) == 0)

return pi->id;

}

return -ENOENT;

}

EXPORT_SYMBOL(ceph_pg_poolid_by_name);

u64 ceph_pg_pool_flags(struct ceph_osdmap *map, u64 id)

{

struct ceph_pg_pool_info *pi;

pi = lookup_pg_pool(&map->pg_pools, id);

return pi ? pi->flags : 0;

}

EXPORT_SYMBOL(ceph_pg_pool_flags);

static void __remove_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *pi)

{

erase_pg_pool(root, pi);

kfree(pi->name);

kfree(pi);

}

static int decode_pool(void **p, void *end, struct ceph_pg_pool_info *pi)

{

u8 ev, cv;

unsigned len, num;

void *pool_end;

ceph_decode_need(p, end, 2 + 4, bad);

ev = ceph_decode_8(p); /* encoding version */

cv = ceph_decode_8(p); /* compat version */

if (ev < 5) {

pr_warn("got v %d < 5 cv %d of ceph_pg_pool\n", ev, cv);

return -EINVAL;

}

if (cv > 9) {

pr_warn("got v %d cv %d > 9 of ceph_pg_pool\n", ev, cv);

return -EINVAL;

}

len = ceph_decode_32(p);

ceph_decode_need(p, end, len, bad);

pool_end = *p + len;

ceph_decode_need(p, end, 4 + 4 + 4, bad);

pi->type = ceph_decode_8(p);

pi->size = ceph_decode_8(p);

pi->crush_ruleset = ceph_decode_8(p);

pi->object_hash = ceph_decode_8(p);

pi->pg_num = ceph_decode_32(p);

pi->pgp_num = ceph_decode_32(p);

/* lpg*, last_change, snap_seq, snap_epoch */

ceph_decode_skip_n(p, end, 8 + 4 + 8 + 4, bad);

/* skip snaps */

ceph_decode_32_safe(p, end, num, bad);

while (num--) {

/* snapid key, pool snap (with versions) */

ceph_decode_skip_n(p, end, 8 + 2, bad);

ceph_decode_skip_string(p, end, bad);

}

/* removed_snaps */

ceph_decode_skip_map(p, end, 64, 64, bad);

ceph_decode_need(p, end, 8 + 8 + 4, bad);

*p += 8; /* skip auid */

pi->flags = ceph_decode_64(p);

*p += 4; /* skip crash_replay_interval */

if (ev >= 7)

ceph_decode_8_safe(p, end, pi->min_size, bad);

else

pi->min_size = pi->size - pi->size / 2;

if (ev >= 8)

/* quota_max_* */

ceph_decode_skip_n(p, end, 8 + 8, bad);

if (ev >= 9) {

/* tiers */

ceph_decode_skip_set(p, end, 64, bad);

ceph_decode_need(p, end, 8 + 1 + 8 + 8, bad);

*p += 8; /* skip tier_of */

*p += 1; /* skip cache_mode */

pi->read_tier = ceph_decode_64(p);

pi->write_tier = ceph_decode_64(p);

} else {

pi->read_tier = -1;

pi->write_tier = -1;

}

if (ev >= 10)

/* properties */

ceph_decode_skip_map(p, end, string, string, bad);

if (ev >= 11) {

/* hit_set_params (with versions) */

ceph_decode_skip_n(p, end, 2, bad);

ceph_decode_skip_string(p, end, bad);

/* hit_set_period, hit_set_count */

ceph_decode_skip_n(p, end, 4 + 4, bad);

}

if (ev >= 12)

/* stripe_width */

ceph_decode_skip_32(p, end, bad);

if (ev >= 13)

/* target_max_*, cache_target_*, cache_min_* */

ceph_decode_skip_n(p, end, 16 + 8 + 8, bad);

if (ev >= 14)

/* erasure_code_profile */

ceph_decode_skip_string(p, end, bad);

/*

* last_force_op_resend_preluminous, will be overridden if the

* map was encoded with RESEND_ON_SPLIT

*/

if (ev >= 15)

ceph_decode_32_safe(p, end, pi->last_force_request_resend, bad);

else

pi->last_force_request_resend = 0;

if (ev >= 16)

/* min_read_recency_for_promote */

ceph_decode_skip_32(p, end, bad);

if (ev >= 17)

/* expected_num_objects */

ceph_decode_skip_64(p, end, bad);

if (ev >= 19)

/* cache_target_dirty_high_ratio_micro */

ceph_decode_skip_32(p, end, bad);

if (ev >= 20)

/* min_write_recency_for_promote */

ceph_decode_skip_32(p, end, bad);

if (ev >= 21)

/* use_gmt_hitset */

ceph_decode_skip_8(p, end, bad);

if (ev >= 22)

/* fast_read */

ceph_decode_skip_8(p, end, bad);

if (ev >= 23)

/* hit_set_grade_decay_rate, hit_set_search_last_n */

ceph_decode_skip_n(p, end, 4 + 4, bad);

if (ev >= 24) {

/* opts (with versions) */

ceph_decode_skip_n(p, end, 2, bad);

ceph_decode_skip_string(p, end, bad);

}

if (ev >= 25)

ceph_decode_32_safe(p, end, pi->last_force_request_resend, bad);

/* ignore the rest */

*p = pool_end;

calc_pg_masks(pi);

return 0;

bad:

return -EINVAL;

}

static int decode_pool_names(void **p, void *end, struct ceph_osdmap *map)

{

struct ceph_pg_pool_info *pi;

u32 num, len;

u64 pool;

ceph_decode_32_safe(p, end, num, bad);

dout(" %d pool names\n", num);

while (num--) {

ceph_decode_64_safe(p, end, pool, bad);

ceph_decode_32_safe(p, end, len, bad);

dout(" pool %llu len %d\n", pool, len);

ceph_decode_need(p, end, len, bad);

pi = lookup_pg_pool(&map->pg_pools, pool);

if (pi) {

char *name = kstrndup(*p, len, GFP_NOFS);

if (!name)

return -ENOMEM;

kfree(pi->name);

pi->name = name;

dout(" name is %s\n", pi->name);

}

*p += len;

}

return 0;

bad:

return -EINVAL;

}

/*

* CRUSH workspaces

*

* workspace_manager framework borrowed from fs/btrfs/compression.c.

* Two simplifications: there is only one type of workspace and there

* is always at least one workspace.

*/

static struct crush_work *alloc_workspace(const struct crush_map *c)

{

struct crush_work *work;

size_t work_size;

WARN_ON(!c->working_size);

work_size = crush_work_size(c, CEPH_PG_MAX_SIZE);

dout("%s work_size %zu bytes\n", __func__, work_size);

work = kvmalloc(work_size, GFP_NOIO);

if (!work)

return NULL;

INIT_LIST_HEAD(&work->item);

crush_init_workspace(c, work);

return work;

}

static void free_workspace(struct crush_work *work)

{