osdmap.c 39.1 KB
Newer Older
Sage Weil's avatar
Sage Weil committed
1

2
#include <linux/ceph/ceph_debug.h>
3

4
#include <linux/module.h>
5
#include <linux/slab.h>
Sage Weil's avatar
Sage Weil committed
6 7
#include <asm/div64.h>

8 9 10 11 12
#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>
Sage Weil's avatar
Sage Weil committed
13 14 15 16

char *ceph_osdmap_state_str(char *str, int len, int state)
{
	if (!len)
17
		return str;
Sage Weil's avatar
Sage Weil committed
18

19 20 21 22 23 24 25
	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
Sage Weil's avatar
Sage Weil committed
26
		snprintf(str, len, "doesn't exist");
27

Sage Weil's avatar
Sage Weil committed
28 29 30 31 32
	return str;
}

/* maps */

33
static int calc_bits_of(unsigned int t)
Sage Weil's avatar
Sage Weil committed
34 35 36 37 38 39 40 41 42 43 44 45 46 47
{
	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)
{
48 49
	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;
Sage Weil's avatar
Sage Weil committed
50 51 52 53 54 55 56 57 58 59
}

/*
 * 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);
60
	b->item_weight = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
	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++) {
79 80
		b->item_weights[j] = ceph_decode_32(p);
		b->sum_weights[j] = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
81 82 83 84 85 86 87 88 89 90 91
	}
	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);
92
	ceph_decode_8_safe(p, end, b->num_nodes, bad);
Sage Weil's avatar
Sage Weil committed
93 94 95 96 97
	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++)
98
		b->node_weights[j] = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
	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++) {
117 118
		b->item_weights[j] = ceph_decode_32(p);
		b->straws[j] = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
119 120 121 122 123 124
	}
	return 0;
bad:
	return -EINVAL;
}

125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
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;
}

Sage Weil's avatar
Sage Weil committed
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
static int skip_name_map(void **p, void *end)
{
        int len;
        ceph_decode_32_safe(p, end, len ,bad);
        while (len--) {
                int strlen;
                *p += sizeof(u32);
                ceph_decode_32_safe(p, end, strlen, bad);
                *p += strlen;
}
        return 0;
bad:
        return -EINVAL;
}

Sage Weil's avatar
Sage Weil committed
156 157 158 159 160 161 162 163
static struct crush_map *crush_decode(void *pbyval, void *end)
{
	struct crush_map *c;
	int err = -EINVAL;
	int i, j;
	void **p = &pbyval;
	void *start = pbyval;
	u32 magic;
Sage Weil's avatar
Sage Weil committed
164
	u32 num_name_maps;
Sage Weil's avatar
Sage Weil committed
165 166 167 168 169 170 171

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

	c = kzalloc(sizeof(*c), GFP_NOFS);
	if (c == NULL)
		return ERR_PTR(-ENOMEM);

Sage Weil's avatar
Sage Weil committed
172 173 174 175
        /* set tunables to default values */
        c->choose_local_tries = 2;
        c->choose_local_fallback_tries = 5;
        c->choose_total_tries = 19;
176
	c->chooseleaf_descend_once = 0;
Sage Weil's avatar
Sage Weil committed
177

Sage Weil's avatar
Sage Weil committed
178
	ceph_decode_need(p, end, 4*sizeof(u32), bad);
179
	magic = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
180 181
	if (magic != CRUSH_MAGIC) {
		pr_err("crush_decode magic %x != current %x\n",
182
		       (unsigned int)magic, (unsigned int)CRUSH_MAGIC);
Sage Weil's avatar
Sage Weil committed
183 184
		goto bad;
	}
185 186 187
	c->max_buckets = ceph_decode_32(p);
	c->max_rules = ceph_decode_32(p);
	c->max_devices = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222

	c->buckets = kcalloc(c->max_buckets, sizeof(*c->buckets), GFP_NOFS);
	if (c->buckets == NULL)
		goto badmem;
	c->rules = kcalloc(c->max_rules, sizeof(*c->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;
223 224 225
		case CRUSH_BUCKET_STRAW2:
			size = sizeof(struct crush_bucket_straw2);
			break;
Sage Weil's avatar
Sage Weil committed
226
		default:
227
			err = -EINVAL;
Sage Weil's avatar
Sage Weil committed
228 229 230 231 232 233 234 235
			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);
236 237
		b->id = ceph_decode_32(p);
		b->type = ceph_decode_16(p);
238 239
		b->alg = ceph_decode_8(p);
		b->hash = ceph_decode_8(p);
240 241
		b->weight = ceph_decode_32(p);
		b->size = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
242 243 244 245 246 247 248 249 250 251 252 253 254 255

		dout("crush_decode bucket size %d off %x %p to %p\n",
		     b->size, (int)(*p-start), *p, end);

		b->items = kcalloc(b->size, sizeof(__s32), GFP_NOFS);
		if (b->items == NULL)
			goto badmem;
		b->perm = kcalloc(b->size, sizeof(u32), GFP_NOFS);
		if (b->perm == NULL)
			goto badmem;
		b->perm_n = 0;

		ceph_decode_need(p, end, b->size*sizeof(u32), bad);
		for (j = 0; j < b->size; j++)
256
			b->items[j] = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282

		switch (b->alg) {
		case CRUSH_BUCKET_UNIFORM:
			err = crush_decode_uniform_bucket(p, end,
				  (struct crush_bucket_uniform *)b);
			if (err < 0)
				goto bad;
			break;
		case CRUSH_BUCKET_LIST:
			err = crush_decode_list_bucket(p, end,
			       (struct crush_bucket_list *)b);
			if (err < 0)
				goto bad;
			break;
		case CRUSH_BUCKET_TREE:
			err = crush_decode_tree_bucket(p, end,
				(struct crush_bucket_tree *)b);
			if (err < 0)
				goto bad;
			break;
		case CRUSH_BUCKET_STRAW:
			err = crush_decode_straw_bucket(p, end,
				(struct crush_bucket_straw *)b);
			if (err < 0)
				goto bad;
			break;
283 284 285 286 287 288
		case CRUSH_BUCKET_STRAW2:
			err = crush_decode_straw2_bucket(p, end,
				(struct crush_bucket_straw2 *)b);
			if (err < 0)
				goto bad;
			break;
Sage Weil's avatar
Sage Weil committed
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
		}
	}

	/* 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
312
		err = -EINVAL;
313 314
		if (yes > (ULONG_MAX - sizeof(*r))
			  / sizeof(struct crush_rule_step))
Sage Weil's avatar
Sage Weil committed
315 316 317 318 319 320 321 322 323 324 325 326
			goto bad;
#endif
		r = c->rules[i] = kmalloc(sizeof(*r) +
					  yes*sizeof(struct crush_rule_step),
					  GFP_NOFS);
		if (r == NULL)
			goto badmem;
		dout(" rule %d is at %p\n", 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++) {
327 328 329
			r->steps[j].op = ceph_decode_32(p);
			r->steps[j].arg1 = ceph_decode_32(p);
			r->steps[j].arg2 = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
330 331 332 333
		}
	}

	/* ignore trailing name maps. */
Sage Weil's avatar
Sage Weil committed
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
        for (num_name_maps = 0; num_name_maps < 3; num_name_maps++) {
                err = skip_name_map(p, end);
                if (err < 0)
                        goto done;
        }

        /* 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",
             c->choose_local_tries);
        dout("crush decode tunable choose_local_fallback_tries = %d",
             c->choose_local_fallback_tries);
        dout("crush decode tunable choose_total_tries = %d",
             c->choose_total_tries);
Sage Weil's avatar
Sage Weil committed
351

352 353 354 355 356
	ceph_decode_need(p, end, sizeof(u32), done);
	c->chooseleaf_descend_once = ceph_decode_32(p);
	dout("crush decode tunable chooseleaf_descend_once = %d",
	     c->chooseleaf_descend_once);

357 358 359 360 361
	ceph_decode_need(p, end, sizeof(u8), done);
	c->chooseleaf_vary_r = ceph_decode_8(p);
	dout("crush decode tunable chooseleaf_vary_r = %d",
	     c->chooseleaf_vary_r);

Sage Weil's avatar
Sage Weil committed
362
done:
Sage Weil's avatar
Sage Weil committed
363 364 365 366 367 368 369 370 371 372 373 374
	dout("crush_decode success\n");
	return c;

badmem:
	err = -ENOMEM;
bad:
	dout("crush_decode fail %d\n", err);
	crush_destroy(c);
	return ERR_PTR(err);
}

/*
375
 * rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid
376
 * to a set of osds) and primary_temp (explicit primary setting)
Sage Weil's avatar
Sage Weil committed
377
 */
378
static int pgid_cmp(struct ceph_pg l, struct ceph_pg r)
379
{
380 381 382 383 384
	if (l.pool < r.pool)
		return -1;
	if (l.pool > r.pool)
		return 1;
	if (l.seed < r.seed)
385
		return -1;
386
	if (l.seed > r.seed)
387 388 389 390
		return 1;
	return 0;
}

391 392
static int __insert_pg_mapping(struct ceph_pg_mapping *new,
			       struct rb_root *root)
Sage Weil's avatar
Sage Weil committed
393 394 395 396
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct ceph_pg_mapping *pg = NULL;
397
	int c;
Sage Weil's avatar
Sage Weil committed
398

399
	dout("__insert_pg_mapping %llx %p\n", *(u64 *)&new->pgid, new);
Sage Weil's avatar
Sage Weil committed
400 401 402
	while (*p) {
		parent = *p;
		pg = rb_entry(parent, struct ceph_pg_mapping, node);
403 404
		c = pgid_cmp(new->pgid, pg->pgid);
		if (c < 0)
Sage Weil's avatar
Sage Weil committed
405
			p = &(*p)->rb_left;
406
		else if (c > 0)
Sage Weil's avatar
Sage Weil committed
407 408
			p = &(*p)->rb_right;
		else
409
			return -EEXIST;
Sage Weil's avatar
Sage Weil committed
410 411 412 413
	}

	rb_link_node(&new->node, parent, p);
	rb_insert_color(&new->node, root);
414
	return 0;
Sage Weil's avatar
Sage Weil committed
415 416
}

417
static struct ceph_pg_mapping *__lookup_pg_mapping(struct rb_root *root,
418
						   struct ceph_pg pgid)
419 420 421 422 423 424 425 426
{
	struct rb_node *n = root->rb_node;
	struct ceph_pg_mapping *pg;
	int c;

	while (n) {
		pg = rb_entry(n, struct ceph_pg_mapping, node);
		c = pgid_cmp(pgid, pg->pgid);
427
		if (c < 0) {
428
			n = n->rb_left;
429
		} else if (c > 0) {
430
			n = n->rb_right;
431
		} else {
432 433
			dout("__lookup_pg_mapping %lld.%x got %p\n",
			     pgid.pool, pgid.seed, pg);
434
			return pg;
435
		}
436 437 438 439
	}
	return NULL;
}

440
static int __remove_pg_mapping(struct rb_root *root, struct ceph_pg pgid)
441 442 443 444
{
	struct ceph_pg_mapping *pg = __lookup_pg_mapping(root, pgid);

	if (pg) {
445 446
		dout("__remove_pg_mapping %lld.%x %p\n", pgid.pool, pgid.seed,
		     pg);
447 448 449 450
		rb_erase(&pg->node, root);
		kfree(pg);
		return 0;
	}
451
	dout("__remove_pg_mapping %lld.%x dne\n", pgid.pool, pgid.seed);
452 453 454
	return -ENOENT;
}

455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
/*
 * rbtree of pg pool info
 */
static int __insert_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *new)
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct ceph_pg_pool_info *pi = NULL;

	while (*p) {
		parent = *p;
		pi = rb_entry(parent, struct ceph_pg_pool_info, node);
		if (new->id < pi->id)
			p = &(*p)->rb_left;
		else if (new->id > pi->id)
			p = &(*p)->rb_right;
		else
			return -EEXIST;
	}

	rb_link_node(&new->node, parent, p);
	rb_insert_color(&new->node, root);
	return 0;
}

480
static struct ceph_pg_pool_info *__lookup_pg_pool(struct rb_root *root, u64 id)
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
{
	struct ceph_pg_pool_info *pi;
	struct rb_node *n = root->rb_node;

	while (n) {
		pi = rb_entry(n, struct ceph_pg_pool_info, node);
		if (id < pi->id)
			n = n->rb_left;
		else if (id > pi->id)
			n = n->rb_right;
		else
			return pi;
	}
	return NULL;
}

497 498 499 500 501
struct ceph_pg_pool_info *ceph_pg_pool_by_id(struct ceph_osdmap *map, u64 id)
{
	return __lookup_pg_pool(&map->pg_pools, id);
}

502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
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, (int) id);

	return pi ? pi->name : NULL;
}
EXPORT_SYMBOL(ceph_pg_pool_name_by_id);

518 519 520 521 522 523 524 525 526 527 528 529
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;
}
530
EXPORT_SYMBOL(ceph_pg_poolid_by_name);
531

532 533 534 535 536 537 538
static void __remove_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *pi)
{
	rb_erase(&pi->node, root);
	kfree(pi->name);
	kfree(pi);
}

539
static int decode_pool(void **p, void *end, struct ceph_pg_pool_info *pi)
540
{
541 542 543 544 545 546 547 548
	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) {
549
		pr_warn("got v %d < 5 cv %d of ceph_pg_pool\n", ev, cv);
550 551
		return -EINVAL;
	}
552
	if (cv > 9) {
553
		pr_warn("got v %d cv %d > 9 of ceph_pg_pool\n", ev, cv);
554 555 556 557 558
		return -EINVAL;
	}
	len = ceph_decode_32(p);
	ceph_decode_need(p, end, len, bad);
	pool_end = *p + len;
559

560 561 562 563
	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);
564

565 566 567 568 569 570 571 572 573 574 575 576 577 578
	pi->pg_num = ceph_decode_32(p);
	pi->pgp_num = ceph_decode_32(p);

	*p += 4 + 4;  /* skip lpg* */
	*p += 4;      /* skip last_change */
	*p += 8 + 4;  /* skip snap_seq, snap_epoch */

	/* skip snaps */
	num = ceph_decode_32(p);
	while (num--) {
		*p += 8;  /* snapid key */
		*p += 1 + 1; /* versions */
		len = ceph_decode_32(p);
		*p += len;
579 580
	}

581
	/* skip removed_snaps */
582 583 584 585 586
	num = ceph_decode_32(p);
	*p += num * (8 + 8);

	*p += 8;  /* skip auid */
	pi->flags = ceph_decode_64(p);
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
	*p += 4;  /* skip crash_replay_interval */

	if (ev >= 7)
		*p += 1;  /* skip min_size */

	if (ev >= 8)
		*p += 8 + 8;  /* skip quota_max_* */

	if (ev >= 9) {
		/* skip tiers */
		num = ceph_decode_32(p);
		*p += num * 8;

		*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;
	}
609 610 611 612 613

	/* ignore the rest */

	*p = pool_end;
	calc_pg_masks(pi);
614 615 616 617
	return 0;

bad:
	return -EINVAL;
618 619
}

620
static int decode_pool_names(void **p, void *end, struct ceph_osdmap *map)
621 622
{
	struct ceph_pg_pool_info *pi;
623 624
	u32 num, len;
	u64 pool;
625 626 627 628

	ceph_decode_32_safe(p, end, num, bad);
	dout(" %d pool names\n", num);
	while (num--) {
629
		ceph_decode_64_safe(p, end, pool, bad);
630
		ceph_decode_32_safe(p, end, len, bad);
631
		dout("  pool %llu len %d\n", pool, len);
632
		ceph_decode_need(p, end, len, bad);
633 634
		pi = __lookup_pg_pool(&map->pg_pools, pool);
		if (pi) {
635 636 637 638
			char *name = kstrndup(*p, len, GFP_NOFS);

			if (!name)
				return -ENOMEM;
639
			kfree(pi->name);
640 641
			pi->name = name;
			dout("  name is %s\n", pi->name);
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
		}
		*p += len;
	}
	return 0;

bad:
	return -EINVAL;
}

/*
 * osd map
 */
void ceph_osdmap_destroy(struct ceph_osdmap *map)
{
	dout("osdmap_destroy %p\n", map);
	if (map->crush)
		crush_destroy(map->crush);
	while (!RB_EMPTY_ROOT(&map->pg_temp)) {
		struct ceph_pg_mapping *pg =
			rb_entry(rb_first(&map->pg_temp),
				 struct ceph_pg_mapping, node);
		rb_erase(&pg->node, &map->pg_temp);
		kfree(pg);
	}
666 667 668 669 670 671 672
	while (!RB_EMPTY_ROOT(&map->primary_temp)) {
		struct ceph_pg_mapping *pg =
			rb_entry(rb_first(&map->primary_temp),
				 struct ceph_pg_mapping, node);
		rb_erase(&pg->node, &map->primary_temp);
		kfree(pg);
	}
673 674 675 676 677 678 679 680 681
	while (!RB_EMPTY_ROOT(&map->pg_pools)) {
		struct ceph_pg_pool_info *pi =
			rb_entry(rb_first(&map->pg_pools),
				 struct ceph_pg_pool_info, node);
		__remove_pg_pool(&map->pg_pools, pi);
	}
	kfree(map->osd_state);
	kfree(map->osd_weight);
	kfree(map->osd_addr);
682
	kfree(map->osd_primary_affinity);
683 684 685 686
	kfree(map);
}

/*
687 688 689
 * Adjust max_osd value, (re)allocate arrays.
 *
 * The new elements are properly initialized.
690 691 692 693 694
 */
static int osdmap_set_max_osd(struct ceph_osdmap *map, int max)
{
	u8 *state;
	u32 *weight;
695 696
	struct ceph_entity_addr *addr;
	int i;
697

698
	state = krealloc(map->osd_state, max*sizeof(*state), GFP_NOFS);
699 700 701 702
	if (!state)
		return -ENOMEM;
	map->osd_state = state;

703
	weight = krealloc(map->osd_weight, max*sizeof(*weight), GFP_NOFS);
704 705 706
	if (!weight)
		return -ENOMEM;
	map->osd_weight = weight;
707

708 709
	addr = krealloc(map->osd_addr, max*sizeof(*addr), GFP_NOFS);
	if (!addr)
710
		return -ENOMEM;
711
	map->osd_addr = addr;
712

713
	for (i = map->max_osd; i < max; i++) {
714 715 716
		map->osd_state[i] = 0;
		map->osd_weight[i] = CEPH_OSD_OUT;
		memset(map->osd_addr + i, 0, sizeof(*map->osd_addr));
717 718
	}

719 720 721 722 723 724 725
	if (map->osd_primary_affinity) {
		u32 *affinity;

		affinity = krealloc(map->osd_primary_affinity,
				    max*sizeof(*affinity), GFP_NOFS);
		if (!affinity)
			return -ENOMEM;
726
		map->osd_primary_affinity = affinity;
727 728

		for (i = map->max_osd; i < max; i++)
729 730
			map->osd_primary_affinity[i] =
			    CEPH_OSD_DEFAULT_PRIMARY_AFFINITY;
731 732
	}

733
	map->max_osd = max;
734

735 736 737
	return 0;
}

738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
#define OSDMAP_WRAPPER_COMPAT_VER	7
#define OSDMAP_CLIENT_DATA_COMPAT_VER	1

/*
 * Return 0 or error.  On success, *v is set to 0 for old (v6) osdmaps,
 * to struct_v of the client_data section for new (v7 and above)
 * osdmaps.
 */
static int get_osdmap_client_data_v(void **p, void *end,
				    const char *prefix, u8 *v)
{
	u8 struct_v;

	ceph_decode_8_safe(p, end, struct_v, e_inval);
	if (struct_v >= 7) {
		u8 struct_compat;

		ceph_decode_8_safe(p, end, struct_compat, e_inval);
		if (struct_compat > OSDMAP_WRAPPER_COMPAT_VER) {
757 758 759
			pr_warn("got v %d cv %d > %d of %s ceph_osdmap\n",
				struct_v, struct_compat,
				OSDMAP_WRAPPER_COMPAT_VER, prefix);
760 761 762 763 764 765 766
			return -EINVAL;
		}
		*p += 4; /* ignore wrapper struct_len */

		ceph_decode_8_safe(p, end, struct_v, e_inval);
		ceph_decode_8_safe(p, end, struct_compat, e_inval);
		if (struct_compat > OSDMAP_CLIENT_DATA_COMPAT_VER) {
767 768 769
			pr_warn("got v %d cv %d > %d of %s ceph_osdmap client data\n",
				struct_v, struct_compat,
				OSDMAP_CLIENT_DATA_COMPAT_VER, prefix);
770 771 772 773 774 775 776 777 778
			return -EINVAL;
		}
		*p += 4; /* ignore client data struct_len */
	} else {
		u16 version;

		*p -= 1;
		ceph_decode_16_safe(p, end, version, e_inval);
		if (version < 6) {
779 780
			pr_warn("got v %d < 6 of %s ceph_osdmap\n",
				version, prefix);
781 782 783 784 785 786 787 788 789 790 791 792 793 794
			return -EINVAL;
		}

		/* old osdmap enconding */
		struct_v = 0;
	}

	*v = struct_v;
	return 0;

e_inval:
	return -EINVAL;
}

795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
static int __decode_pools(void **p, void *end, struct ceph_osdmap *map,
			  bool incremental)
{
	u32 n;

	ceph_decode_32_safe(p, end, n, e_inval);
	while (n--) {
		struct ceph_pg_pool_info *pi;
		u64 pool;
		int ret;

		ceph_decode_64_safe(p, end, pool, e_inval);

		pi = __lookup_pg_pool(&map->pg_pools, pool);
		if (!incremental || !pi) {
			pi = kzalloc(sizeof(*pi), GFP_NOFS);
			if (!pi)
				return -ENOMEM;

			pi->id = pool;

			ret = __insert_pg_pool(&map->pg_pools, pi);
			if (ret) {
				kfree(pi);
				return ret;
			}
		}

		ret = decode_pool(p, end, pi);
		if (ret)
			return ret;
	}

	return 0;

e_inval:
	return -EINVAL;
}

static int decode_pools(void **p, void *end, struct ceph_osdmap *map)
{
	return __decode_pools(p, end, map, false);
}

static int decode_new_pools(void **p, void *end, struct ceph_osdmap *map)
{
	return __decode_pools(p, end, map, true);
}

844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
static int __decode_pg_temp(void **p, void *end, struct ceph_osdmap *map,
			    bool incremental)
{
	u32 n;

	ceph_decode_32_safe(p, end, n, e_inval);
	while (n--) {
		struct ceph_pg pgid;
		u32 len, i;
		int ret;

		ret = ceph_decode_pgid(p, end, &pgid);
		if (ret)
			return ret;

		ceph_decode_32_safe(p, end, len, e_inval);

		ret = __remove_pg_mapping(&map->pg_temp, pgid);
		BUG_ON(!incremental && ret != -ENOENT);

		if (!incremental || len > 0) {
			struct ceph_pg_mapping *pg;

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

			if (len > (UINT_MAX - sizeof(*pg)) / sizeof(u32))
				return -EINVAL;

			pg = kzalloc(sizeof(*pg) + len*sizeof(u32), GFP_NOFS);
			if (!pg)
				return -ENOMEM;

			pg->pgid = pgid;
877
			pg->pg_temp.len = len;
878
			for (i = 0; i < len; i++)
879
				pg->pg_temp.osds[i] = ceph_decode_32(p);
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904

			ret = __insert_pg_mapping(pg, &map->pg_temp);
			if (ret) {
				kfree(pg);
				return ret;
			}
		}
	}

	return 0;

e_inval:
	return -EINVAL;
}

static int decode_pg_temp(void **p, void *end, struct ceph_osdmap *map)
{
	return __decode_pg_temp(p, end, map, false);
}

static int decode_new_pg_temp(void **p, void *end, struct ceph_osdmap *map)
{
	return __decode_pg_temp(p, end, map, true);
}

905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
static int __decode_primary_temp(void **p, void *end, struct ceph_osdmap *map,
				 bool incremental)
{
	u32 n;

	ceph_decode_32_safe(p, end, n, e_inval);
	while (n--) {
		struct ceph_pg pgid;
		u32 osd;
		int ret;

		ret = ceph_decode_pgid(p, end, &pgid);
		if (ret)
			return ret;

		ceph_decode_32_safe(p, end, osd, e_inval);

		ret = __remove_pg_mapping(&map->primary_temp, pgid);
		BUG_ON(!incremental && ret != -ENOENT);

		if (!incremental || osd != (u32)-1) {
			struct ceph_pg_mapping *pg;

			pg = kzalloc(sizeof(*pg), GFP_NOFS);
			if (!pg)
				return -ENOMEM;

			pg->pgid = pgid;
			pg->primary_temp.osd = osd;

			ret = __insert_pg_mapping(pg, &map->primary_temp);
			if (ret) {
				kfree(pg);
				return ret;
			}
		}
	}

	return 0;

e_inval:
	return -EINVAL;
}

static int decode_primary_temp(void **p, void *end, struct ceph_osdmap *map)
{
	return __decode_primary_temp(p, end, map, false);
}

static int decode_new_primary_temp(void **p, void *end,
				   struct ceph_osdmap *map)
{
	return __decode_primary_temp(p, end, map, true);
}

960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
u32 ceph_get_primary_affinity(struct ceph_osdmap *map, int osd)
{
	BUG_ON(osd >= map->max_osd);

	if (!map->osd_primary_affinity)
		return CEPH_OSD_DEFAULT_PRIMARY_AFFINITY;

	return map->osd_primary_affinity[osd];
}

static int set_primary_affinity(struct ceph_osdmap *map, int osd, u32 aff)
{
	BUG_ON(osd >= map->max_osd);

	if (!map->osd_primary_affinity) {
		int i;

		map->osd_primary_affinity = kmalloc(map->max_osd*sizeof(u32),
						    GFP_NOFS);
		if (!map->osd_primary_affinity)
			return -ENOMEM;

		for (i = 0; i < map->max_osd; i++)
			map->osd_primary_affinity[i] =
			    CEPH_OSD_DEFAULT_PRIMARY_AFFINITY;
	}

	map->osd_primary_affinity[osd] = aff;

	return 0;
}

992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
static int decode_primary_affinity(void **p, void *end,
				   struct ceph_osdmap *map)
{
	u32 len, i;

	ceph_decode_32_safe(p, end, len, e_inval);
	if (len == 0) {
		kfree(map->osd_primary_affinity);
		map->osd_primary_affinity = NULL;
		return 0;
	}
	if (len != map->max_osd)
		goto e_inval;

	ceph_decode_need(p, end, map->max_osd*sizeof(u32), e_inval);

	for (i = 0; i < map->max_osd; i++) {
		int ret;

		ret = set_primary_affinity(map, i, ceph_decode_32(p));
		if (ret)
			return ret;
	}

	return 0;

e_inval:
	return -EINVAL;
}

static int decode_new_primary_affinity(void **p, void *end,
				       struct ceph_osdmap *map)
{
	u32 n;

	ceph_decode_32_safe(p, end, n, e_inval);
	while (n--) {
		u32 osd, aff;
		int ret;

		ceph_decode_32_safe(p, end, osd, e_inval);
		ceph_decode_32_safe(p, end, aff, e_inval);

		ret = set_primary_affinity(map, osd, aff);
		if (ret)
			return ret;
1038 1039

		pr_info("osd%d primary-affinity 0x%x\n", osd, aff);
1040 1041 1042 1043 1044 1045 1046 1047
	}

	return 0;

e_inval:
	return -EINVAL;
}

Sage Weil's avatar
Sage Weil committed
1048 1049 1050
/*
 * decode a full map.
 */
1051
static int osdmap_decode(void **p, void *end, struct ceph_osdmap *map)
Sage Weil's avatar
Sage Weil committed
1052
{
1053
	u8 struct_v;
1054
	u32 epoch = 0;
Sage Weil's avatar
Sage Weil committed
1055
	void *start = *p;
1056 1057
	u32 max;
	u32 len, i;
1058
	int err;
Sage Weil's avatar
Sage Weil committed
1059

1060
	dout("%s %p to %p len %d\n", __func__, *p, end, (int)(end - *p));
Sage Weil's avatar
Sage Weil committed
1061

1062 1063 1064
	err = get_osdmap_client_data_v(p, end, "full", &struct_v);
	if (err)
		goto bad;
Sage Weil's avatar
Sage Weil committed
1065

1066 1067 1068
	/* fsid, epoch, created, modified */
	ceph_decode_need(p, end, sizeof(map->fsid) + sizeof(u32) +
			 sizeof(map->created) + sizeof(map->modified), e_inval);
Sage Weil's avatar
Sage Weil committed
1069
	ceph_decode_copy(p, &map->fsid, sizeof(map->fsid));
1070
	epoch = map->epoch = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
1071 1072 1073
	ceph_decode_copy(p, &map->created, sizeof(map->created));
	ceph_decode_copy(p, &map->modified, sizeof(map->modified));

1074 1075 1076 1077
	/* pools */
	err = decode_pools(p, end, map);
	if (err)
		goto bad;
1078

1079 1080
	/* pool_name */
	err = decode_pool_names(p, end, map);
1081
	if (err)
1082
		goto bad;
1083

1084
	ceph_decode_32_safe(p, end, map->pool_max, e_inval);
Sage Weil's avatar
Sage Weil committed
1085

1086
	ceph_decode_32_safe(p, end, map->flags, e_inval);
Sage Weil's avatar
Sage Weil committed
1087

1088 1089
	/* max_osd */
	ceph_decode_32_safe(p, end, max, e_inval);
Sage Weil's avatar
Sage Weil committed
1090 1091 1092

	/* (re)alloc osd arrays */
	err = osdmap_set_max_osd(map, max);
1093
	if (err)
Sage Weil's avatar
Sage Weil committed
1094 1095
		goto bad;

1096
	/* osd_state, osd_weight, osd_addrs->client_addr */
Sage Weil's avatar
Sage Weil committed
1097 1098
	ceph_decode_need(p, end, 3*sizeof(u32) +
			 map->max_osd*(1 + sizeof(*map->osd_weight) +
1099 1100
				       sizeof(*map->osd_addr)), e_inval);

1101 1102 1103
	if (ceph_decode_32(p) != map->max_osd)
		goto e_inval;

Sage Weil's avatar
Sage Weil committed
1104 1105
	ceph_decode_copy(p, map->osd_state, map->max_osd);

1106 1107 1108
	if (ceph_decode_32(p) != map->max_osd)
		goto e_inval;

Sage Weil's avatar
Sage Weil committed
1109
	for (i = 0; i < map->max_osd; i++)
1110
		map->osd_weight[i] = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
1111

1112 1113 1114
	if (ceph_decode_32(p) != map->max_osd)
		goto e_inval;

Sage Weil's avatar
Sage Weil committed
1115
	ceph_decode_copy(p, map->osd_addr, map->max_osd*sizeof(*map->osd_addr));
1116 1117
	for (i = 0; i < map->max_osd; i++)
		ceph_decode_addr(&map->osd_addr[i]);
Sage Weil's avatar
Sage Weil committed
1118 1119

	/* pg_temp */
1120 1121 1122
	err = decode_pg_temp(p, end, map);
	if (err)
		goto bad;
Sage Weil's avatar
Sage Weil committed
1123

1124 1125 1126 1127 1128 1129 1130
	/* primary_temp */
	if (struct_v >= 1) {
		err = decode_primary_temp(p, end, map);
		if (err)
			goto bad;
	}

1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
	/* primary_affinity */
	if (struct_v >= 2) {
		err = decode_primary_affinity(p, end, map);
		if (err)
			goto bad;
	} else {
		/* XXX can this happen? */
		kfree(map->osd_primary_affinity);
		map->osd_primary_affinity = NULL;
	}

Sage Weil's avatar
Sage Weil committed
1142
	/* crush */
1143
	ceph_decode_32_safe(p, end, len, e_inval);
1144
	map->crush = crush_decode(*p, min(*p + len, end));
Sage Weil's avatar
Sage Weil committed
1145 1146 1147 1148 1149
	if (IS_ERR(map->crush)) {
		err = PTR_ERR(map->crush);
		map->crush = NULL;
		goto bad;
	}
1150
	*p += len;
Sage Weil's avatar
Sage Weil committed
1151

1152
	/* ignore the rest */
Sage Weil's avatar
Sage Weil committed
1153 1154
	*p = end;

1155
	dout("full osdmap epoch %d max_osd %d\n", map->epoch, map->max_osd);
1156
	return 0;
Sage Weil's avatar
Sage Weil committed
1157

1158 1159
e_inval:
	err = -EINVAL;
Sage Weil's avatar
Sage Weil committed
1160
bad:
1161 1162 1163 1164 1165
	pr_err("corrupt full osdmap (%d) epoch %d off %d (%p of %p-%p)\n",
	       err, epoch, (int)(*p - start), *p, start, end);
	print_hex_dump(KERN_DEBUG, "osdmap: ",
		       DUMP_PREFIX_OFFSET, 16, 1,
		       start, end - start, true);
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
	return err;
}

/*
 * Allocate and decode a full map.
 */
struct ceph_osdmap *ceph_osdmap_decode(void **p, void *end)
{
	struct ceph_osdmap *map;
	int ret;

	map = kzalloc(sizeof(*map), GFP_NOFS);
	if (!map)
		return ERR_PTR(-ENOMEM);

	map->pg_temp = RB_ROOT;
1182
	map->primary_temp = RB_ROOT;
1183 1184 1185 1186 1187 1188 1189 1190 1191
	mutex_init(&map->crush_scratch_mutex);

	ret = osdmap_decode(p, end, map);
	if (ret) {
		ceph_osdmap_destroy(map);
		return ERR_PTR(ret);
	}

	return map;
Sage Weil's avatar
Sage Weil committed
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
}

/*
 * decode and apply an incremental map update.
 */
struct ceph_osdmap *osdmap_apply_incremental(void **p, void *end,
					     struct ceph_osdmap *map,
					     struct ceph_messenger *msgr)
{
	struct crush_map *newcrush = NULL;
	struct ceph_fsid fsid;
	u32 epoch = 0;
	struct ceph_timespec modified;
1205 1206 1207 1208
	s32 len;
	u64 pool;
	__s64 new_pool_max;
	__s32 new_flags, max;
Sage Weil's avatar
Sage Weil committed
1209
	void *start = *p;
1210
	int err;
1211
	u8 struct_v;
Sage Weil's avatar
Sage Weil committed
1212

1213 1214
	dout("%s %p to %p len %d\n", __func__, *p, end, (int)(end - *p));

1215 1216 1217
	err = get_osdmap_client_data_v(p, end, "inc", &struct_v);
	if (err)
		goto bad;
Sage Weil's avatar
Sage Weil committed
1218

1219 1220 1221
	/* fsid, epoch, modified, new_pool_max, new_flags */
	ceph_decode_need(p, end, sizeof(fsid) + sizeof(u32) + sizeof(modified) +
			 sizeof(u64) + sizeof(u32), e_inval);
Sage Weil's avatar
Sage Weil committed
1222
	ceph_decode_copy(p, &fsid, sizeof(fsid));
1223
	epoch = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
1224 1225
	BUG_ON(epoch != map->epoch+1);
	ceph_decode_copy(p, &modified, sizeof(modified));
1226
	new_pool_max = ceph_decode_64(p);
1227
	new_flags = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
1228 1229

	/* full map? */
1230
	ceph_decode_32_safe(p, end, len, e_inval);
Sage Weil's avatar
Sage Weil committed
1231 1232 1233
	if (len > 0) {
		dout("apply_incremental full map len %d, %p to %p\n",
		     len, *p, end);
1234
		return ceph_osdmap_decode(p, min(*p+len, end));
Sage Weil's avatar
Sage Weil committed
1235 1236 1237
	}

	/* new crush? */
1238
	ceph_decode_32_safe(p, end, len, e_inval);
Sage Weil's avatar
Sage Weil committed
1239 1240
	if (len > 0) {
		newcrush = crush_decode(*p, min(*p+len, end));
1241 1242 1243 1244 1245
		if (IS_ERR(newcrush)) {
			err = PTR_ERR(newcrush);
			newcrush = NULL;
			goto bad;
		}
1246
		*p += len;
Sage Weil's avatar
Sage Weil committed
1247 1248 1249 1250 1251
	}

	/* new flags? */
	if (new_flags >= 0)
		map->flags = new_flags;
1252 1253
	if (new_pool_max >= 0)
		map->pool_max = new_pool_max;
Sage Weil's avatar
Sage Weil committed
1254 1255

	/* new max? */
1256
	ceph_decode_32_safe(p, end, max, e_inval);
Sage Weil's avatar
Sage Weil committed
1257 1258
	if (max >= 0) {
		err = osdmap_set_max_osd(map, max);
1259
		if (err)
Sage Weil's avatar
Sage Weil committed
1260 1261 1262 1263
			goto bad;
	}

	map->epoch++;
1264
	map->modified = modified;
Sage Weil's avatar
Sage Weil committed
1265 1266 1267 1268 1269 1270 1271
	if (newcrush) {
		if (map->crush)
			crush_destroy(map->crush);
		map->crush = newcrush;
		newcrush = NULL;
	}

1272 1273 1274 1275
	/* new_pools */
	err = decode_new_pools(p, end, map);
	if (err)
		goto bad;
1276

1277 1278
	/* new_pool_names */
	err = decode_pool_names(p, end, map);
1279 1280
	if (err)
		goto bad;
Sage Weil's avatar
Sage Weil committed
1281

1282
	/* old_pool */
1283
	ceph_decode_32_safe(p, end, len, e_inval);
1284 1285 1286
	while (len--) {
		struct ceph_pg_pool_info *pi;

1287
		ceph_decode_64_safe(p, end, pool, e_inval);
1288
		pi = __lookup_pg_pool(&map->pg_pools, pool);
1289 1290
		if (pi)
			__remove_pg_pool(&map->pg_pools, pi);
1291
	}
Sage Weil's avatar
Sage Weil committed
1292 1293

	/* new_up */
1294
	ceph_decode_32_safe(p, end, len, e_inval);
Sage Weil's avatar
Sage Weil committed
1295 1296 1297
	while (len--) {
		u32 osd;
		struct ceph_entity_addr addr;
1298 1299
		ceph_decode_32_safe(p, end, osd, e_inval);
		ceph_decode_copy_safe(p, end, &addr, sizeof(addr), e_inval);
1300
		ceph_decode_addr(&addr);
Sage Weil's avatar
Sage Weil committed
1301 1302 1303 1304 1305 1306
		pr_info("osd%d up\n", osd);
		BUG_ON(osd >= map->max_osd);
		map->osd_state[osd] |= CEPH_OSD_UP;
		map->osd_addr[osd] = addr;
	}

1307
	/* new_state */
1308
	ceph_decode_32_safe(p, end, len, e_inval);
Sage Weil's avatar
Sage Weil committed
1309 1310
	while (len--) {
		u32 osd;
1311
		u8 xorstate;
1312
		ceph_decode_32_safe(p, end, osd, e_inval);
1313
		xorstate = **(u8 **)p;
Sage Weil's avatar
Sage Weil committed
1314
		(*p)++;  /* clean flag */
1315 1316 1317 1318
		if (xorstate == 0)
			xorstate = CEPH_OSD_UP;
		if (xorstate & CEPH_OSD_UP)
			pr_info("osd%d down\n", osd);
Sage Weil's avatar
Sage Weil committed
1319
		if (osd < map->max_osd)
1320
			map->osd_state[osd] ^= xorstate;
Sage Weil's avatar
Sage Weil committed
1321 1322 1323
	}

	/* new_weight */
1324
	ceph_decode_32_safe(p, end, len, e_inval);
Sage Weil's avatar
Sage Weil committed
1325 1326
	while (len--) {
		u32 osd, off;
1327
		ceph_decode_need(p, end, sizeof(u32)*2, e_inval);
1328 1329
		osd = ceph_decode_32(p);
		off = ceph_decode_32(p);
Sage Weil's avatar
Sage Weil committed
1330 1331 1332 1333 1334 1335 1336 1337
		pr_info("osd%d weight 0x%x %s\n", osd, off,
		     off == CEPH_OSD_IN ? "(in)" :
		     (off == CEPH_OSD_OUT ? "(out)" : ""));
		if (osd < map->max_osd)
			map->osd_weight[osd] = off;
	}

	/* new_pg_temp */
1338 1339 1340
	err = decode_new_pg_temp(p, end, map);
	if (err)
		goto bad;
Sage Weil's avatar
Sage Weil committed
1341

1342 1343 1344 1345 1346 1347 1348
	/* new_primary_temp */
	if (struct_v >= 1) {
		err = decode_new_primary_temp(p, end, map);
		if (err)
			goto bad;
	}

1349 1350 1351 1352 1353 1354 1355
	/* new_primary_affinity */
	if (struct_v >= 2) {
		err = decode_new_primary_affinity(p, end, map);
		if (err)
			goto bad;
	}

Sage Weil's avatar
Sage Weil committed
1356 1357
	/* ignore the rest */
	*p = end;
1358 1359

	dout("inc osdmap epoch %d max_osd %d\n", map->epoch, map->max_osd);
Sage Weil's avatar
Sage Weil committed
1360 1361
	return map;

1362 1363
e_inval:
	err = -EINVAL;
Sage Weil's avatar
Sage Weil committed
1364
bad:
1365 1366
	pr_err("corrupt inc osdmap (%d) epoch %d off %d (%p of %p-%p)\n",
	       err, epoch, (int)(*p - start), *p, start, end);
1367 1368 1369
	print_hex_dump(KERN_DEBUG, "osdmap: ",
		       DUMP_PREFIX_OFFSET, 16, 1,
		       start, end - start, true);
Sage Weil's avatar
Sage Weil committed
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
	if (newcrush)
		crush_destroy(newcrush);
	return ERR_PTR(err);
}




/*
 * calculate file layout from given offset, length.
 * fill in correct oid, logical length, and object extent
 * offset, length.
 *
 * for now, we write only a single su, until we can
 * pass a stride back to the caller.
 */
1386
int ceph_calc_file_object_mapping(struct ceph_file_layout *layout,
1387
				   u64 off, u64 len,
1388
				   u64 *ono,
Sage Weil's avatar
Sage Weil committed
1389 1390 1391 1392 1393 1394 1395
				   u64 *oxoff, u64 *oxlen)
{
	u32 osize = le32_to_cpu(layout->fl_object_size);
	u32 su = le32_to_cpu(layout->fl_stripe_unit);
	u32 sc = le32_to_cpu(layout->fl_stripe_count);
	u32 bl, stripeno, stripepos, objsetno;
	u32 su_per_object;
1396
	u64 t, su_offset;
Sage Weil's avatar
Sage Weil committed
1397

1398
	dout("mapping %llu~%llu  osize %u fl_su %u\n", off, len,
Sage Weil's avatar
Sage Weil committed
1399
	     osize, su);
1400 1401
	if (su == 0 || sc == 0)
		goto invalid;
1402
	su_per_object = osize / su;
1403 1404
	if (su_per_object == 0)
		goto invalid;
Sage Weil's avatar
Sage Weil committed
1405 1406 1407
	dout("osize %u / su %u = su_per_object %u\n", osize, su,
	     su_per_object);

1408 1409 1410
	if ((su & ~PAGE_MASK) != 0)
		goto invalid;

Sage Weil's avatar
Sage Weil committed
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
	/* bl = *off / su; */
	t = off;
	do_div(t, su);
	bl = t;
	dout("off %llu / su %u = bl %u\n", off, su, bl);

	stripeno = bl / sc;
	stripepos = bl % sc;
	objsetno = stripeno / su_per_object;

1421
	*ono = objsetno * sc + stripepos;
1422
	dout("objset %u * sc %u = ono %u\n", objsetno, sc, (unsigned int)*ono);
1423 1424

	/* *oxoff = *off % layout->fl_stripe_unit;  # offset in su */
Sage Weil's avatar
Sage Weil committed
1425
	t = off;
1426 1427 1428 1429 1430
	su_offset = do_div(t, su);
	*oxoff = su_offset + (stripeno % su_per_object) * su;

	/*
	 * Calculate the length of the extent being written to the selected
1431
	 * object. This is the minimum of the full length requested (len) or
1432 1433
	 * the remainder of the current stripe being written to.
	 */
1434
	*oxlen = min_t(u64, len, su - su_offset);
Sage Weil's avatar
Sage Weil committed
1435 1436

	dout(" obj extent %llu~%llu\n", *oxoff, *oxlen);
1437 1438 1439 1440 1441 1442 1443 1444
	return 0;

invalid:
	dout(" invalid layout\n");
	*ono = 0;
	*oxoff = 0;
	*oxlen = 0;
	return -EINVAL;
Sage Weil's avatar
Sage Weil committed
1445
}
1446
EXPORT_SYMBOL(ceph_calc_file_object_mapping);
Sage Weil's avatar
Sage Weil committed
1447 1448

/*
1449 1450 1451
 * Calculate mapping of a (oloc, oid) pair to a PG.  Should only be
 * called with target's (oloc, oid), since tiering isn't taken into
 * account.
Sage Weil's avatar
Sage Weil committed
1452
 */
1453 1454 1455 1456
int ceph_oloc_oid_to_pg(struct ceph_osdmap *osdmap,
			struct ceph_object_locator *oloc,
			struct ceph_object_id *oid,
			struct ceph_pg *pg_out)
Sage Weil's avatar
Sage Weil committed
1457
{
1458
	struct ceph_pg_pool_info *pi;
Sage Weil's avatar
Sage Weil committed
1459

1460 1461
	pi = __lookup_pg_pool(&osdmap->pg_pools, oloc->pool);
	if (!pi)
1462
		return -EIO;
Sage Weil's avatar
Sage Weil committed
1463

1464 1465 1466 1467 1468 1469
	pg_out->pool = oloc->pool;
	pg_out->seed = ceph_str_hash(pi->object_hash, oid->name,
				     oid->name_len);

	dout("%s '%.*s' pgid %llu.%x\n", __func__, oid->name_len, oid->name,
	     pg_out->pool, pg_out->seed);
Sage Weil's avatar
Sage Weil committed
1470 1471
	return 0;
}
1472
EXPORT_SYMBOL(ceph_oloc_oid_to_pg);
Sage Weil's avatar
Sage Weil committed
1473

1474 1475 1476
static int do_crush(struct ceph_osdmap *map, int ruleno, int x,
		    int *result, int result_max,
		    const __u32 *weight, int weight_max)
1477
{
1478 1479 1480 1481 1482 1483 1484 1485
	int r;

	BUG_ON(result_max > CEPH_PG_MAX_SIZE);

	mutex_lock(&map->crush_scratch_mutex);
	r = crush_do_rule(map->crush, ruleno, x, result, result_max,
			  weight, weight_max, map->crush_scratch_ary);
	mutex_unlock(&map->crush_scratch_mutex);
1486

1487
	return r;
1488 1489
}

1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565
/*
 * Calculate raw (crush) set for given pgid.
 *
 * Return raw set length, or error.
 */
static int pg_to_raw_osds(struct ceph_osdmap *osdmap,
			  struct ceph_pg_pool_info *pool,
			  struct ceph_pg pgid, u32 pps, int *osds)
{
	int ruleno;
	int len;

	/* crush */
	ruleno = crush_find_rule(osdmap->crush, pool->crush_ruleset,
				 pool->type, pool->size);
	if (ruleno < 0) {
		pr_err("no crush rule: pool %lld ruleset %d type %d size %d\n",
		       pgid.pool, pool->crush_ruleset, pool->type,
		       pool->size);
		return -ENOENT;
	}

	len = do_crush(osdmap, ruleno, pps, osds,
		       min_t(int, pool->size, CEPH_PG_MAX_SIZE),
		       osdmap->osd_weight, osdmap->max_osd);
	if (len < 0) {
		pr_err("error %d from crush rule %d: pool %lld ruleset %d type %d size %d\n",
		       len, ruleno, pgid.pool, pool->crush_ruleset,
		       pool->type, pool->size);
		return len;
	}

	return len;
}

/*
 * Given raw set, calculate up set and up primary.
 *
 * Return up set length.  *primary is set to up primary osd id, or -1
 * if up set is empty.
 */
static int raw_to_up_osds(struct ceph_osdmap *osdmap,
			  struct ceph_pg_pool_info *pool,
			  int *osds, int len, int *primary)
{
	int up_primary = -1;
	int i;

	if (ceph_can_shift_osds(pool)) {
		int removed = 0;

		for (i = 0; i < len; i++) {
			if (ceph_osd_is_down(osdmap, osds[i])) {
				removed++;
				continue;
			}
			if (removed)
				osds[i - removed] = osds[i];
		}

		len -= removed;
		if (len > 0)
			up_primary = osds[0];
	} else {
		for (i = len - 1; i >= 0; i--) {
			if (ceph_osd_is_down(osdmap, osds[i]))
				osds[i] = CRUSH_ITEM_NONE;
			else
				up_primary = osds[i];
		}
	}

	*primary = up_primary;
	return len;
}

1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
static void apply_primary_affinity(struct ceph_osdmap *osdmap, u32 pps,
				   struct ceph_pg_pool_info *pool,
				   int *osds, int len, int *primary)
{
	int i;
	int pos = -1;

	/*
	 * Do we have any non-default primary_affinity values for these
	 * osds?
	 */
	if (!osdmap->osd_primary_affinity)
		return;

	for (i = 0; i < len; i++) {
1581 1582 1583 1584
		int osd = osds[i];

		if (osd != CRUSH_ITEM_NONE &&
		    osdmap->osd_primary_affinity[osd] !=
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
					CEPH_OSD_DEFAULT_PRIMARY_AFFINITY) {
			break;
		}
	}
	if (i == len)
		return;

	/*
	 * Pick the primary.  Feed both the seed (for the pg) and the
	 * osd into the hash/rng so that a proportional fraction of an
	 * osd's pgs get rejected as primary.
	 */
	for (i = 0; i < len; i++) {
1598
		int osd = osds[i];
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
		u32 aff;

		if (osd == CRUSH_ITEM_NONE)
			continue;

		aff = osdmap->osd_primary_affinity[osd];
		if (aff < CEPH_OSD_MAX_PRIMARY_AFFINITY &&
		    (crush_hash32_2(CRUSH_HASH_RJENKINS1,
				    pps, osd) >> 16) >= aff) {
			/*
			 * We chose not to use this primary.  Note it
			 * anyway as a fallback in case we don't pick
			 * anyone else, but keep looking.
			 */
			if (pos < 0)
				pos = i;
		} else {
			pos = i;
			break;
		}
	}
	if (pos < 0)
		return;

	*primary = osds[pos];

	if (ceph_can_shift_osds(pool) && pos > 0) {
		/* move the new primary to the front */
		for (i = pos; i > 0; i--)
			osds[i] = osds[i - 1];
		osds[0] = *primary;
	}
}

1633
/*
1634
 * Given up set, apply pg_temp and primary_temp mappings.
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
 *
 * Return acting set length.  *primary is set to acting primary osd id,
 * or -1 if acting set is empty.
 */
static int apply_temps(struct ceph_osdmap *osdmap,
		       struct ceph_pg_pool_info *pool, struct ceph_pg pgid,
		       int *osds, int len, int *primary)
{
	struct ceph_pg_mapping *pg;
	int temp_len;
	int temp_primary;
	int i;

	/* raw_pg -> pg */
	pgid.seed = ceph_stable_mod(pgid.seed, pool->pg_num,
				    pool->pg_num_mask);

	/* pg_temp? */
	pg = __lookup_pg_mapping(&osdmap->pg_temp, pgid);
	if (pg) {
		temp_len = 0;
		temp_primary = -1;

		for (i = 0; i < pg->pg_temp.len; i++) {
			if (ceph_osd_is_down(osdmap, pg->pg_temp.osds[i])) {
				if (ceph_can_shift_osds(pool))
					continue;
				else
					osds[temp_len++] = CRUSH_ITEM_NONE;
			} else {
				osds[temp_len++] = pg->pg_temp.osds[i];
			}
		}

		/* apply pg_temp's primary */
		for (i = 0; i < temp_len; i++) {
			if (osds[i] != CRUSH_ITEM_NONE) {
				temp_primary = osds[i];
				break;
			}
		}
	} else {
		temp_len = len;
		temp_primary = *primary;
	}

1681 1682 1683 1684 1685
	/* primary_temp? */
	pg = __lookup_pg_mapping(&osdmap->primary_temp, pgid);
	if (pg)
		temp_primary = pg->primary_temp.osd;

1686 1687 1688 1689
	*primary = temp_primary;
	return temp_len;
}

1690
/*
1691 1692
 * Calculate acting set for given pgid.
 *
1693 1694
 * Return acting set length, or error.  *primary is set to acting
 * primary osd id, or -1 if acting set is empty or on error.
1695
 */
1696
int ceph_calc_pg_acting(struct ceph_osdmap *osdmap, struct ceph_pg pgid,
1697
			int *osds, int *primary)
1698
{
1699 1700 1701
	struct ceph_pg_pool_info *pool;
	u32 pps;
	int len;
1702

1703
	pool = __lookup_pg_pool(&osdmap->pg_pools, pgid.pool);
1704 1705 1706 1707
	if (!pool) {
		*primary = -1;
		return -ENOENT;
	}
1708

1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
	if (pool->flags & CEPH_POOL_FLAG_HASHPSPOOL) {
		/* hash pool id and seed so that pool PGs do not overlap */
		pps = crush_hash32_2(CRUSH_HASH_RJENKINS1,
				     ceph_stable_mod(pgid.seed, pool->pgp_num,
						     pool->pgp_num_mask),
				     pgid.pool);
	} else {
		/*
		 * legacy behavior: add ps and pool together.  this is
		 * not a great approach because the PGs from each pool
		 * will overlap on top of each other: 0.5 == 1.4 ==
		 * 2.3 == ...
		 */
		pps = ceph_stable_mod(pgid.seed, pool->pgp_num,
				      pool->pgp_num_mask) +
			(unsigned)pgid.pool;
	}

	len = pg_to_raw_osds(osdmap, pool, pgid, pps, osds);
1728 1729
	if (len < 0) {
		*primary = -1;
1730
		return len;
1731
	}
1732

1733
	len = raw_to_up_osds(osdmap, pool, osds, len, primary);
1734

1735 1736
	apply_primary_affinity(osdmap, pps, pool, osds, len, primary);

1737
	len = apply_temps(osdmap, pool, pgid, osds, len, primary);
1738 1739

	return len;
1740 1741
}

Sage Weil's avatar
Sage Weil committed
1742 1743 1744
/*
 * Return primary osd for given pgid, or -1 if none.
 */
1745
int ceph_calc_pg_primary(struct ceph_osdmap *osdmap, struct ceph_pg pgid)
Sage Weil's avatar
Sage Weil committed
1746
{
1747 1748
	int osds[CEPH_PG_MAX_SIZE];
	int primary;
Sage Weil's avatar
Sage Weil committed
1749

1750
	ceph_calc_pg_acting(osdmap, pgid, osds, &primary);
Sage Weil's avatar
Sage Weil committed
1751

1752
	return primary;
Sage Weil's avatar
Sage Weil committed
1753
}
1754
EXPORT_SYMBOL(ceph_calc_pg_primary);