1 2 #include <linux/ceph/ceph_debug.h> 3 4 #include <linux/module.h> 5 #include <linux/slab.h> 6 #include <asm/div64.h> 7 8 #include <linux/ceph/libceph.h> 9 #include <linux/ceph/osdmap.h> 10 #include <linux/ceph/decode.h> 11 #include <linux/crush/hash.h> 12 #include <linux/crush/mapper.h> 13 14 char *ceph_osdmap_state_str(char *str, int len, int state) 15 { 16 if (!len) 17 return str; 18 19 if ((state & CEPH_OSD_EXISTS) && (state & CEPH_OSD_UP)) 20 snprintf(str, len, "exists, up"); 21 else if (state & CEPH_OSD_EXISTS) 22 snprintf(str, len, "exists"); 23 else if (state & CEPH_OSD_UP) 24 snprintf(str, len, "up"); 25 else 26 snprintf(str, len, "doesn't exist"); 27 28 return str; 29 } 30 31 /* maps */ 32 33 static int calc_bits_of(unsigned int t) 34 { 35 int b = 0; 36 while (t) { 37 t = t >> 1; 38 b++; 39 } 40 return b; 41 } 42 43 /* 44 * the foo_mask is the smallest value 2^n-1 that is >= foo. 45 */ 46 static void calc_pg_masks(struct ceph_pg_pool_info *pi) 47 { 48 pi->pg_num_mask = (1 << calc_bits_of(pi->pg_num-1)) - 1; 49 pi->pgp_num_mask = (1 << calc_bits_of(pi->pgp_num-1)) - 1; 50 } 51 52 /* 53 * decode crush map 54 */ 55 static int crush_decode_uniform_bucket(void **p, void *end, 56 struct crush_bucket_uniform *b) 57 { 58 dout("crush_decode_uniform_bucket %p to %p\n", *p, end); 59 ceph_decode_need(p, end, (1+b->h.size) * sizeof(u32), bad); 60 b->item_weight = ceph_decode_32(p); 61 return 0; 62 bad: 63 return -EINVAL; 64 } 65 66 static int crush_decode_list_bucket(void **p, void *end, 67 struct crush_bucket_list *b) 68 { 69 int j; 70 dout("crush_decode_list_bucket %p to %p\n", *p, end); 71 b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 72 if (b->item_weights == NULL) 73 return -ENOMEM; 74 b->sum_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 75 if (b->sum_weights == NULL) 76 return -ENOMEM; 77 ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad); 78 for (j = 0; j < b->h.size; j++) { 79 b->item_weights[j] = ceph_decode_32(p); 80 b->sum_weights[j] = ceph_decode_32(p); 81 } 82 return 0; 83 bad: 84 return -EINVAL; 85 } 86 87 static int crush_decode_tree_bucket(void **p, void *end, 88 struct crush_bucket_tree *b) 89 { 90 int j; 91 dout("crush_decode_tree_bucket %p to %p\n", *p, end); 92 ceph_decode_32_safe(p, end, b->num_nodes, bad); 93 b->node_weights = kcalloc(b->num_nodes, sizeof(u32), GFP_NOFS); 94 if (b->node_weights == NULL) 95 return -ENOMEM; 96 ceph_decode_need(p, end, b->num_nodes * sizeof(u32), bad); 97 for (j = 0; j < b->num_nodes; j++) 98 b->node_weights[j] = ceph_decode_32(p); 99 return 0; 100 bad: 101 return -EINVAL; 102 } 103 104 static int crush_decode_straw_bucket(void **p, void *end, 105 struct crush_bucket_straw *b) 106 { 107 int j; 108 dout("crush_decode_straw_bucket %p to %p\n", *p, end); 109 b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 110 if (b->item_weights == NULL) 111 return -ENOMEM; 112 b->straws = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 113 if (b->straws == NULL) 114 return -ENOMEM; 115 ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad); 116 for (j = 0; j < b->h.size; j++) { 117 b->item_weights[j] = ceph_decode_32(p); 118 b->straws[j] = ceph_decode_32(p); 119 } 120 return 0; 121 bad: 122 return -EINVAL; 123 } 124 125 static int skip_name_map(void **p, void *end) 126 { 127 int len; 128 ceph_decode_32_safe(p, end, len ,bad); 129 while (len--) { 130 int strlen; 131 *p += sizeof(u32); 132 ceph_decode_32_safe(p, end, strlen, bad); 133 *p += strlen; 134 } 135 return 0; 136 bad: 137 return -EINVAL; 138 } 139 140 static struct crush_map *crush_decode(void *pbyval, void *end) 141 { 142 struct crush_map *c; 143 int err = -EINVAL; 144 int i, j; 145 void **p = &pbyval; 146 void *start = pbyval; 147 u32 magic; 148 u32 num_name_maps; 149 150 dout("crush_decode %p to %p len %d\n", *p, end, (int)(end - *p)); 151 152 c = kzalloc(sizeof(*c), GFP_NOFS); 153 if (c == NULL) 154 return ERR_PTR(-ENOMEM); 155 156 /* set tunables to default values */ 157 c->choose_local_tries = 2; 158 c->choose_local_fallback_tries = 5; 159 c->choose_total_tries = 19; 160 c->chooseleaf_descend_once = 0; 161 162 ceph_decode_need(p, end, 4*sizeof(u32), bad); 163 magic = ceph_decode_32(p); 164 if (magic != CRUSH_MAGIC) { 165 pr_err("crush_decode magic %x != current %x\n", 166 (unsigned int)magic, (unsigned int)CRUSH_MAGIC); 167 goto bad; 168 } 169 c->max_buckets = ceph_decode_32(p); 170 c->max_rules = ceph_decode_32(p); 171 c->max_devices = ceph_decode_32(p); 172 173 c->buckets = kcalloc(c->max_buckets, sizeof(*c->buckets), GFP_NOFS); 174 if (c->buckets == NULL) 175 goto badmem; 176 c->rules = kcalloc(c->max_rules, sizeof(*c->rules), GFP_NOFS); 177 if (c->rules == NULL) 178 goto badmem; 179 180 /* buckets */ 181 for (i = 0; i < c->max_buckets; i++) { 182 int size = 0; 183 u32 alg; 184 struct crush_bucket *b; 185 186 ceph_decode_32_safe(p, end, alg, bad); 187 if (alg == 0) { 188 c->buckets[i] = NULL; 189 continue; 190 } 191 dout("crush_decode bucket %d off %x %p to %p\n", 192 i, (int)(*p-start), *p, end); 193 194 switch (alg) { 195 case CRUSH_BUCKET_UNIFORM: 196 size = sizeof(struct crush_bucket_uniform); 197 break; 198 case CRUSH_BUCKET_LIST: 199 size = sizeof(struct crush_bucket_list); 200 break; 201 case CRUSH_BUCKET_TREE: 202 size = sizeof(struct crush_bucket_tree); 203 break; 204 case CRUSH_BUCKET_STRAW: 205 size = sizeof(struct crush_bucket_straw); 206 break; 207 default: 208 err = -EINVAL; 209 goto bad; 210 } 211 BUG_ON(size == 0); 212 b = c->buckets[i] = kzalloc(size, GFP_NOFS); 213 if (b == NULL) 214 goto badmem; 215 216 ceph_decode_need(p, end, 4*sizeof(u32), bad); 217 b->id = ceph_decode_32(p); 218 b->type = ceph_decode_16(p); 219 b->alg = ceph_decode_8(p); 220 b->hash = ceph_decode_8(p); 221 b->weight = ceph_decode_32(p); 222 b->size = ceph_decode_32(p); 223 224 dout("crush_decode bucket size %d off %x %p to %p\n", 225 b->size, (int)(*p-start), *p, end); 226 227 b->items = kcalloc(b->size, sizeof(__s32), GFP_NOFS); 228 if (b->items == NULL) 229 goto badmem; 230 b->perm = kcalloc(b->size, sizeof(u32), GFP_NOFS); 231 if (b->perm == NULL) 232 goto badmem; 233 b->perm_n = 0; 234 235 ceph_decode_need(p, end, b->size*sizeof(u32), bad); 236 for (j = 0; j < b->size; j++) 237 b->items[j] = ceph_decode_32(p); 238 239 switch (b->alg) { 240 case CRUSH_BUCKET_UNIFORM: 241 err = crush_decode_uniform_bucket(p, end, 242 (struct crush_bucket_uniform *)b); 243 if (err < 0) 244 goto bad; 245 break; 246 case CRUSH_BUCKET_LIST: 247 err = crush_decode_list_bucket(p, end, 248 (struct crush_bucket_list *)b); 249 if (err < 0) 250 goto bad; 251 break; 252 case CRUSH_BUCKET_TREE: 253 err = crush_decode_tree_bucket(p, end, 254 (struct crush_bucket_tree *)b); 255 if (err < 0) 256 goto bad; 257 break; 258 case CRUSH_BUCKET_STRAW: 259 err = crush_decode_straw_bucket(p, end, 260 (struct crush_bucket_straw *)b); 261 if (err < 0) 262 goto bad; 263 break; 264 } 265 } 266 267 /* rules */ 268 dout("rule vec is %p\n", c->rules); 269 for (i = 0; i < c->max_rules; i++) { 270 u32 yes; 271 struct crush_rule *r; 272 273 ceph_decode_32_safe(p, end, yes, bad); 274 if (!yes) { 275 dout("crush_decode NO rule %d off %x %p to %p\n", 276 i, (int)(*p-start), *p, end); 277 c->rules[i] = NULL; 278 continue; 279 } 280 281 dout("crush_decode rule %d off %x %p to %p\n", 282 i, (int)(*p-start), *p, end); 283 284 /* len */ 285 ceph_decode_32_safe(p, end, yes, bad); 286 #if BITS_PER_LONG == 32 287 err = -EINVAL; 288 if (yes > (ULONG_MAX - sizeof(*r)) 289 / sizeof(struct crush_rule_step)) 290 goto bad; 291 #endif 292 r = c->rules[i] = kmalloc(sizeof(*r) + 293 yes*sizeof(struct crush_rule_step), 294 GFP_NOFS); 295 if (r == NULL) 296 goto badmem; 297 dout(" rule %d is at %p\n", i, r); 298 r->len = yes; 299 ceph_decode_copy_safe(p, end, &r->mask, 4, bad); /* 4 u8's */ 300 ceph_decode_need(p, end, r->len*3*sizeof(u32), bad); 301 for (j = 0; j < r->len; j++) { 302 r->steps[j].op = ceph_decode_32(p); 303 r->steps[j].arg1 = ceph_decode_32(p); 304 r->steps[j].arg2 = ceph_decode_32(p); 305 } 306 } 307 308 /* ignore trailing name maps. */ 309 for (num_name_maps = 0; num_name_maps < 3; num_name_maps++) { 310 err = skip_name_map(p, end); 311 if (err < 0) 312 goto done; 313 } 314 315 /* tunables */ 316 ceph_decode_need(p, end, 3*sizeof(u32), done); 317 c->choose_local_tries = ceph_decode_32(p); 318 c->choose_local_fallback_tries = ceph_decode_32(p); 319 c->choose_total_tries = ceph_decode_32(p); 320 dout("crush decode tunable choose_local_tries = %d", 321 c->choose_local_tries); 322 dout("crush decode tunable choose_local_fallback_tries = %d", 323 c->choose_local_fallback_tries); 324 dout("crush decode tunable choose_total_tries = %d", 325 c->choose_total_tries); 326 327 ceph_decode_need(p, end, sizeof(u32), done); 328 c->chooseleaf_descend_once = ceph_decode_32(p); 329 dout("crush decode tunable chooseleaf_descend_once = %d", 330 c->chooseleaf_descend_once); 331 332 done: 333 dout("crush_decode success\n"); 334 return c; 335 336 badmem: 337 err = -ENOMEM; 338 bad: 339 dout("crush_decode fail %d\n", err); 340 crush_destroy(c); 341 return ERR_PTR(err); 342 } 343 344 /* 345 * rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid 346 * to a set of osds) 347 */ 348 static int pgid_cmp(struct ceph_pg l, struct ceph_pg r) 349 { 350 if (l.pool < r.pool) 351 return -1; 352 if (l.pool > r.pool) 353 return 1; 354 if (l.seed < r.seed) 355 return -1; 356 if (l.seed > r.seed) 357 return 1; 358 return 0; 359 } 360 361 static int __insert_pg_mapping(struct ceph_pg_mapping *new, 362 struct rb_root *root) 363 { 364 struct rb_node **p = &root->rb_node; 365 struct rb_node *parent = NULL; 366 struct ceph_pg_mapping *pg = NULL; 367 int c; 368 369 dout("__insert_pg_mapping %llx %p\n", *(u64 *)&new->pgid, new); 370 while (*p) { 371 parent = *p; 372 pg = rb_entry(parent, struct ceph_pg_mapping, node); 373 c = pgid_cmp(new->pgid, pg->pgid); 374 if (c < 0) 375 p = &(*p)->rb_left; 376 else if (c > 0) 377 p = &(*p)->rb_right; 378 else 379 return -EEXIST; 380 } 381 382 rb_link_node(&new->node, parent, p); 383 rb_insert_color(&new->node, root); 384 return 0; 385 } 386 387 static struct ceph_pg_mapping *__lookup_pg_mapping(struct rb_root *root, 388 struct ceph_pg pgid) 389 { 390 struct rb_node *n = root->rb_node; 391 struct ceph_pg_mapping *pg; 392 int c; 393 394 while (n) { 395 pg = rb_entry(n, struct ceph_pg_mapping, node); 396 c = pgid_cmp(pgid, pg->pgid); 397 if (c < 0) { 398 n = n->rb_left; 399 } else if (c > 0) { 400 n = n->rb_right; 401 } else { 402 dout("__lookup_pg_mapping %lld.%x got %p\n", 403 pgid.pool, pgid.seed, pg); 404 return pg; 405 } 406 } 407 return NULL; 408 } 409 410 static int __remove_pg_mapping(struct rb_root *root, struct ceph_pg pgid) 411 { 412 struct ceph_pg_mapping *pg = __lookup_pg_mapping(root, pgid); 413 414 if (pg) { 415 dout("__remove_pg_mapping %lld.%x %p\n", pgid.pool, pgid.seed, 416 pg); 417 rb_erase(&pg->node, root); 418 kfree(pg); 419 return 0; 420 } 421 dout("__remove_pg_mapping %lld.%x dne\n", pgid.pool, pgid.seed); 422 return -ENOENT; 423 } 424 425 /* 426 * rbtree of pg pool info 427 */ 428 static int __insert_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *new) 429 { 430 struct rb_node **p = &root->rb_node; 431 struct rb_node *parent = NULL; 432 struct ceph_pg_pool_info *pi = NULL; 433 434 while (*p) { 435 parent = *p; 436 pi = rb_entry(parent, struct ceph_pg_pool_info, node); 437 if (new->id < pi->id) 438 p = &(*p)->rb_left; 439 else if (new->id > pi->id) 440 p = &(*p)->rb_right; 441 else 442 return -EEXIST; 443 } 444 445 rb_link_node(&new->node, parent, p); 446 rb_insert_color(&new->node, root); 447 return 0; 448 } 449 450 static struct ceph_pg_pool_info *__lookup_pg_pool(struct rb_root *root, u64 id) 451 { 452 struct ceph_pg_pool_info *pi; 453 struct rb_node *n = root->rb_node; 454 455 while (n) { 456 pi = rb_entry(n, struct ceph_pg_pool_info, node); 457 if (id < pi->id) 458 n = n->rb_left; 459 else if (id > pi->id) 460 n = n->rb_right; 461 else 462 return pi; 463 } 464 return NULL; 465 } 466 467 struct ceph_pg_pool_info *ceph_pg_pool_by_id(struct ceph_osdmap *map, u64 id) 468 { 469 return __lookup_pg_pool(&map->pg_pools, id); 470 } 471 472 const char *ceph_pg_pool_name_by_id(struct ceph_osdmap *map, u64 id) 473 { 474 struct ceph_pg_pool_info *pi; 475 476 if (id == CEPH_NOPOOL) 477 return NULL; 478 479 if (WARN_ON_ONCE(id > (u64) INT_MAX)) 480 return NULL; 481 482 pi = __lookup_pg_pool(&map->pg_pools, (int) id); 483 484 return pi ? pi->name : NULL; 485 } 486 EXPORT_SYMBOL(ceph_pg_pool_name_by_id); 487 488 int ceph_pg_poolid_by_name(struct ceph_osdmap *map, const char *name) 489 { 490 struct rb_node *rbp; 491 492 for (rbp = rb_first(&map->pg_pools); rbp; rbp = rb_next(rbp)) { 493 struct ceph_pg_pool_info *pi = 494 rb_entry(rbp, struct ceph_pg_pool_info, node); 495 if (pi->name && strcmp(pi->name, name) == 0) 496 return pi->id; 497 } 498 return -ENOENT; 499 } 500 EXPORT_SYMBOL(ceph_pg_poolid_by_name); 501 502 static void __remove_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *pi) 503 { 504 rb_erase(&pi->node, root); 505 kfree(pi->name); 506 kfree(pi); 507 } 508 509 static int __decode_pool(void **p, void *end, struct ceph_pg_pool_info *pi) 510 { 511 u8 ev, cv; 512 unsigned len, num; 513 void *pool_end; 514 515 ceph_decode_need(p, end, 2 + 4, bad); 516 ev = ceph_decode_8(p); /* encoding version */ 517 cv = ceph_decode_8(p); /* compat version */ 518 if (ev < 5) { 519 pr_warning("got v %d < 5 cv %d of ceph_pg_pool\n", ev, cv); 520 return -EINVAL; 521 } 522 if (cv > 7) { 523 pr_warning("got v %d cv %d > 7 of ceph_pg_pool\n", ev, cv); 524 return -EINVAL; 525 } 526 len = ceph_decode_32(p); 527 ceph_decode_need(p, end, len, bad); 528 pool_end = *p + len; 529 530 pi->type = ceph_decode_8(p); 531 pi->size = ceph_decode_8(p); 532 pi->crush_ruleset = ceph_decode_8(p); 533 pi->object_hash = ceph_decode_8(p); 534 535 pi->pg_num = ceph_decode_32(p); 536 pi->pgp_num = ceph_decode_32(p); 537 538 *p += 4 + 4; /* skip lpg* */ 539 *p += 4; /* skip last_change */ 540 *p += 8 + 4; /* skip snap_seq, snap_epoch */ 541 542 /* skip snaps */ 543 num = ceph_decode_32(p); 544 while (num--) { 545 *p += 8; /* snapid key */ 546 *p += 1 + 1; /* versions */ 547 len = ceph_decode_32(p); 548 *p += len; 549 } 550 551 /* skip removed snaps */ 552 num = ceph_decode_32(p); 553 *p += num * (8 + 8); 554 555 *p += 8; /* skip auid */ 556 pi->flags = ceph_decode_64(p); 557 558 /* ignore the rest */ 559 560 *p = pool_end; 561 calc_pg_masks(pi); 562 return 0; 563 564 bad: 565 return -EINVAL; 566 } 567 568 static int __decode_pool_names(void **p, void *end, struct ceph_osdmap *map) 569 { 570 struct ceph_pg_pool_info *pi; 571 u32 num, len; 572 u64 pool; 573 574 ceph_decode_32_safe(p, end, num, bad); 575 dout(" %d pool names\n", num); 576 while (num--) { 577 ceph_decode_64_safe(p, end, pool, bad); 578 ceph_decode_32_safe(p, end, len, bad); 579 dout(" pool %llu len %d\n", pool, len); 580 ceph_decode_need(p, end, len, bad); 581 pi = __lookup_pg_pool(&map->pg_pools, pool); 582 if (pi) { 583 char *name = kstrndup(*p, len, GFP_NOFS); 584 585 if (!name) 586 return -ENOMEM; 587 kfree(pi->name); 588 pi->name = name; 589 dout(" name is %s\n", pi->name); 590 } 591 *p += len; 592 } 593 return 0; 594 595 bad: 596 return -EINVAL; 597 } 598 599 /* 600 * osd map 601 */ 602 void ceph_osdmap_destroy(struct ceph_osdmap *map) 603 { 604 dout("osdmap_destroy %p\n", map); 605 if (map->crush) 606 crush_destroy(map->crush); 607 while (!RB_EMPTY_ROOT(&map->pg_temp)) { 608 struct ceph_pg_mapping *pg = 609 rb_entry(rb_first(&map->pg_temp), 610 struct ceph_pg_mapping, node); 611 rb_erase(&pg->node, &map->pg_temp); 612 kfree(pg); 613 } 614 while (!RB_EMPTY_ROOT(&map->pg_pools)) { 615 struct ceph_pg_pool_info *pi = 616 rb_entry(rb_first(&map->pg_pools), 617 struct ceph_pg_pool_info, node); 618 __remove_pg_pool(&map->pg_pools, pi); 619 } 620 kfree(map->osd_state); 621 kfree(map->osd_weight); 622 kfree(map->osd_addr); 623 kfree(map); 624 } 625 626 /* 627 * adjust max osd value. reallocate arrays. 628 */ 629 static int osdmap_set_max_osd(struct ceph_osdmap *map, int max) 630 { 631 u8 *state; 632 struct ceph_entity_addr *addr; 633 u32 *weight; 634 635 state = kcalloc(max, sizeof(*state), GFP_NOFS); 636 addr = kcalloc(max, sizeof(*addr), GFP_NOFS); 637 weight = kcalloc(max, sizeof(*weight), GFP_NOFS); 638 if (state == NULL || addr == NULL || weight == NULL) { 639 kfree(state); 640 kfree(addr); 641 kfree(weight); 642 return -ENOMEM; 643 } 644 645 /* copy old? */ 646 if (map->osd_state) { 647 memcpy(state, map->osd_state, map->max_osd*sizeof(*state)); 648 memcpy(addr, map->osd_addr, map->max_osd*sizeof(*addr)); 649 memcpy(weight, map->osd_weight, map->max_osd*sizeof(*weight)); 650 kfree(map->osd_state); 651 kfree(map->osd_addr); 652 kfree(map->osd_weight); 653 } 654 655 map->osd_state = state; 656 map->osd_weight = weight; 657 map->osd_addr = addr; 658 map->max_osd = max; 659 return 0; 660 } 661 662 /* 663 * decode a full map. 664 */ 665 struct ceph_osdmap *osdmap_decode(void **p, void *end) 666 { 667 struct ceph_osdmap *map; 668 u16 version; 669 u32 len, max, i; 670 int err = -EINVAL; 671 void *start = *p; 672 struct ceph_pg_pool_info *pi; 673 674 dout("osdmap_decode %p to %p len %d\n", *p, end, (int)(end - *p)); 675 676 map = kzalloc(sizeof(*map), GFP_NOFS); 677 if (map == NULL) 678 return ERR_PTR(-ENOMEM); 679 map->pg_temp = RB_ROOT; 680 681 ceph_decode_16_safe(p, end, version, bad); 682 if (version > 6) { 683 pr_warning("got unknown v %d > 6 of osdmap\n", version); 684 goto bad; 685 } 686 if (version < 6) { 687 pr_warning("got old v %d < 6 of osdmap\n", version); 688 goto bad; 689 } 690 691 ceph_decode_need(p, end, 2*sizeof(u64)+6*sizeof(u32), bad); 692 ceph_decode_copy(p, &map->fsid, sizeof(map->fsid)); 693 map->epoch = ceph_decode_32(p); 694 ceph_decode_copy(p, &map->created, sizeof(map->created)); 695 ceph_decode_copy(p, &map->modified, sizeof(map->modified)); 696 697 ceph_decode_32_safe(p, end, max, bad); 698 while (max--) { 699 ceph_decode_need(p, end, 8 + 2, bad); 700 err = -ENOMEM; 701 pi = kzalloc(sizeof(*pi), GFP_NOFS); 702 if (!pi) 703 goto bad; 704 pi->id = ceph_decode_64(p); 705 err = __decode_pool(p, end, pi); 706 if (err < 0) { 707 kfree(pi); 708 goto bad; 709 } 710 __insert_pg_pool(&map->pg_pools, pi); 711 } 712 713 err = __decode_pool_names(p, end, map); 714 if (err < 0) { 715 dout("fail to decode pool names"); 716 goto bad; 717 } 718 719 ceph_decode_32_safe(p, end, map->pool_max, bad); 720 721 ceph_decode_32_safe(p, end, map->flags, bad); 722 723 max = ceph_decode_32(p); 724 725 /* (re)alloc osd arrays */ 726 err = osdmap_set_max_osd(map, max); 727 if (err < 0) 728 goto bad; 729 dout("osdmap_decode max_osd = %d\n", map->max_osd); 730 731 /* osds */ 732 err = -EINVAL; 733 ceph_decode_need(p, end, 3*sizeof(u32) + 734 map->max_osd*(1 + sizeof(*map->osd_weight) + 735 sizeof(*map->osd_addr)), bad); 736 *p += 4; /* skip length field (should match max) */ 737 ceph_decode_copy(p, map->osd_state, map->max_osd); 738 739 *p += 4; /* skip length field (should match max) */ 740 for (i = 0; i < map->max_osd; i++) 741 map->osd_weight[i] = ceph_decode_32(p); 742 743 *p += 4; /* skip length field (should match max) */ 744 ceph_decode_copy(p, map->osd_addr, map->max_osd*sizeof(*map->osd_addr)); 745 for (i = 0; i < map->max_osd; i++) 746 ceph_decode_addr(&map->osd_addr[i]); 747 748 /* pg_temp */ 749 ceph_decode_32_safe(p, end, len, bad); 750 for (i = 0; i < len; i++) { 751 int n, j; 752 struct ceph_pg pgid; 753 struct ceph_pg_mapping *pg; 754 755 err = ceph_decode_pgid(p, end, &pgid); 756 if (err) 757 goto bad; 758 ceph_decode_need(p, end, sizeof(u32), bad); 759 n = ceph_decode_32(p); 760 err = -EINVAL; 761 if (n > (UINT_MAX - sizeof(*pg)) / sizeof(u32)) 762 goto bad; 763 ceph_decode_need(p, end, n * sizeof(u32), bad); 764 err = -ENOMEM; 765 pg = kmalloc(sizeof(*pg) + n*sizeof(u32), GFP_NOFS); 766 if (!pg) 767 goto bad; 768 pg->pgid = pgid; 769 pg->len = n; 770 for (j = 0; j < n; j++) 771 pg->osds[j] = ceph_decode_32(p); 772 773 err = __insert_pg_mapping(pg, &map->pg_temp); 774 if (err) 775 goto bad; 776 dout(" added pg_temp %lld.%x len %d\n", pgid.pool, pgid.seed, 777 len); 778 } 779 780 /* crush */ 781 ceph_decode_32_safe(p, end, len, bad); 782 dout("osdmap_decode crush len %d from off 0x%x\n", len, 783 (int)(*p - start)); 784 ceph_decode_need(p, end, len, bad); 785 map->crush = crush_decode(*p, end); 786 *p += len; 787 if (IS_ERR(map->crush)) { 788 err = PTR_ERR(map->crush); 789 map->crush = NULL; 790 goto bad; 791 } 792 793 /* ignore the rest of the map */ 794 *p = end; 795 796 dout("osdmap_decode done %p %p\n", *p, end); 797 return map; 798 799 bad: 800 dout("osdmap_decode fail err %d\n", err); 801 ceph_osdmap_destroy(map); 802 return ERR_PTR(err); 803 } 804 805 /* 806 * decode and apply an incremental map update. 807 */ 808 struct ceph_osdmap *osdmap_apply_incremental(void **p, void *end, 809 struct ceph_osdmap *map, 810 struct ceph_messenger *msgr) 811 { 812 struct crush_map *newcrush = NULL; 813 struct ceph_fsid fsid; 814 u32 epoch = 0; 815 struct ceph_timespec modified; 816 s32 len; 817 u64 pool; 818 __s64 new_pool_max; 819 __s32 new_flags, max; 820 void *start = *p; 821 int err = -EINVAL; 822 u16 version; 823 824 ceph_decode_16_safe(p, end, version, bad); 825 if (version != 6) { 826 pr_warning("got unknown v %d != 6 of inc osdmap\n", version); 827 goto bad; 828 } 829 830 ceph_decode_need(p, end, sizeof(fsid)+sizeof(modified)+2*sizeof(u32), 831 bad); 832 ceph_decode_copy(p, &fsid, sizeof(fsid)); 833 epoch = ceph_decode_32(p); 834 BUG_ON(epoch != map->epoch+1); 835 ceph_decode_copy(p, &modified, sizeof(modified)); 836 new_pool_max = ceph_decode_64(p); 837 new_flags = ceph_decode_32(p); 838 839 /* full map? */ 840 ceph_decode_32_safe(p, end, len, bad); 841 if (len > 0) { 842 dout("apply_incremental full map len %d, %p to %p\n", 843 len, *p, end); 844 return osdmap_decode(p, min(*p+len, end)); 845 } 846 847 /* new crush? */ 848 ceph_decode_32_safe(p, end, len, bad); 849 if (len > 0) { 850 dout("apply_incremental new crush map len %d, %p to %p\n", 851 len, *p, end); 852 newcrush = crush_decode(*p, min(*p+len, end)); 853 if (IS_ERR(newcrush)) 854 return ERR_CAST(newcrush); 855 *p += len; 856 } 857 858 /* new flags? */ 859 if (new_flags >= 0) 860 map->flags = new_flags; 861 if (new_pool_max >= 0) 862 map->pool_max = new_pool_max; 863 864 ceph_decode_need(p, end, 5*sizeof(u32), bad); 865 866 /* new max? */ 867 max = ceph_decode_32(p); 868 if (max >= 0) { 869 err = osdmap_set_max_osd(map, max); 870 if (err < 0) 871 goto bad; 872 } 873 874 map->epoch++; 875 map->modified = modified; 876 if (newcrush) { 877 if (map->crush) 878 crush_destroy(map->crush); 879 map->crush = newcrush; 880 newcrush = NULL; 881 } 882 883 /* new_pool */ 884 ceph_decode_32_safe(p, end, len, bad); 885 while (len--) { 886 struct ceph_pg_pool_info *pi; 887 888 ceph_decode_64_safe(p, end, pool, bad); 889 pi = __lookup_pg_pool(&map->pg_pools, pool); 890 if (!pi) { 891 pi = kzalloc(sizeof(*pi), GFP_NOFS); 892 if (!pi) { 893 err = -ENOMEM; 894 goto bad; 895 } 896 pi->id = pool; 897 __insert_pg_pool(&map->pg_pools, pi); 898 } 899 err = __decode_pool(p, end, pi); 900 if (err < 0) 901 goto bad; 902 } 903 if (version >= 5) { 904 err = __decode_pool_names(p, end, map); 905 if (err < 0) 906 goto bad; 907 } 908 909 /* old_pool */ 910 ceph_decode_32_safe(p, end, len, bad); 911 while (len--) { 912 struct ceph_pg_pool_info *pi; 913 914 ceph_decode_64_safe(p, end, pool, bad); 915 pi = __lookup_pg_pool(&map->pg_pools, pool); 916 if (pi) 917 __remove_pg_pool(&map->pg_pools, pi); 918 } 919 920 /* new_up */ 921 err = -EINVAL; 922 ceph_decode_32_safe(p, end, len, bad); 923 while (len--) { 924 u32 osd; 925 struct ceph_entity_addr addr; 926 ceph_decode_32_safe(p, end, osd, bad); 927 ceph_decode_copy_safe(p, end, &addr, sizeof(addr), bad); 928 ceph_decode_addr(&addr); 929 pr_info("osd%d up\n", osd); 930 BUG_ON(osd >= map->max_osd); 931 map->osd_state[osd] |= CEPH_OSD_UP; 932 map->osd_addr[osd] = addr; 933 } 934 935 /* new_state */ 936 ceph_decode_32_safe(p, end, len, bad); 937 while (len--) { 938 u32 osd; 939 u8 xorstate; 940 ceph_decode_32_safe(p, end, osd, bad); 941 xorstate = **(u8 **)p; 942 (*p)++; /* clean flag */ 943 if (xorstate == 0) 944 xorstate = CEPH_OSD_UP; 945 if (xorstate & CEPH_OSD_UP) 946 pr_info("osd%d down\n", osd); 947 if (osd < map->max_osd) 948 map->osd_state[osd] ^= xorstate; 949 } 950 951 /* new_weight */ 952 ceph_decode_32_safe(p, end, len, bad); 953 while (len--) { 954 u32 osd, off; 955 ceph_decode_need(p, end, sizeof(u32)*2, bad); 956 osd = ceph_decode_32(p); 957 off = ceph_decode_32(p); 958 pr_info("osd%d weight 0x%x %s\n", osd, off, 959 off == CEPH_OSD_IN ? "(in)" : 960 (off == CEPH_OSD_OUT ? "(out)" : "")); 961 if (osd < map->max_osd) 962 map->osd_weight[osd] = off; 963 } 964 965 /* new_pg_temp */ 966 ceph_decode_32_safe(p, end, len, bad); 967 while (len--) { 968 struct ceph_pg_mapping *pg; 969 int j; 970 struct ceph_pg pgid; 971 u32 pglen; 972 973 err = ceph_decode_pgid(p, end, &pgid); 974 if (err) 975 goto bad; 976 ceph_decode_need(p, end, sizeof(u32), bad); 977 pglen = ceph_decode_32(p); 978 if (pglen) { 979 ceph_decode_need(p, end, pglen*sizeof(u32), bad); 980 981 /* removing existing (if any) */ 982 (void) __remove_pg_mapping(&map->pg_temp, pgid); 983 984 /* insert */ 985 err = -EINVAL; 986 if (pglen > (UINT_MAX - sizeof(*pg)) / sizeof(u32)) 987 goto bad; 988 err = -ENOMEM; 989 pg = kmalloc(sizeof(*pg) + sizeof(u32)*pglen, GFP_NOFS); 990 if (!pg) 991 goto bad; 992 pg->pgid = pgid; 993 pg->len = pglen; 994 for (j = 0; j < pglen; j++) 995 pg->osds[j] = ceph_decode_32(p); 996 err = __insert_pg_mapping(pg, &map->pg_temp); 997 if (err) { 998 kfree(pg); 999 goto bad; 1000 } 1001 dout(" added pg_temp %lld.%x len %d\n", pgid.pool, 1002 pgid.seed, pglen); 1003 } else { 1004 /* remove */ 1005 __remove_pg_mapping(&map->pg_temp, pgid); 1006 } 1007 } 1008 1009 /* ignore the rest */ 1010 *p = end; 1011 return map; 1012 1013 bad: 1014 pr_err("corrupt inc osdmap epoch %d off %d (%p of %p-%p)\n", 1015 epoch, (int)(*p - start), *p, start, end); 1016 print_hex_dump(KERN_DEBUG, "osdmap: ", 1017 DUMP_PREFIX_OFFSET, 16, 1, 1018 start, end - start, true); 1019 if (newcrush) 1020 crush_destroy(newcrush); 1021 return ERR_PTR(err); 1022 } 1023 1024 1025 1026 1027 /* 1028 * calculate file layout from given offset, length. 1029 * fill in correct oid, logical length, and object extent 1030 * offset, length. 1031 * 1032 * for now, we write only a single su, until we can 1033 * pass a stride back to the caller. 1034 */ 1035 int ceph_calc_file_object_mapping(struct ceph_file_layout *layout, 1036 u64 off, u64 len, 1037 u64 *ono, 1038 u64 *oxoff, u64 *oxlen) 1039 { 1040 u32 osize = le32_to_cpu(layout->fl_object_size); 1041 u32 su = le32_to_cpu(layout->fl_stripe_unit); 1042 u32 sc = le32_to_cpu(layout->fl_stripe_count); 1043 u32 bl, stripeno, stripepos, objsetno; 1044 u32 su_per_object; 1045 u64 t, su_offset; 1046 1047 dout("mapping %llu~%llu osize %u fl_su %u\n", off, len, 1048 osize, su); 1049 if (su == 0 || sc == 0) 1050 goto invalid; 1051 su_per_object = osize / su; 1052 if (su_per_object == 0) 1053 goto invalid; 1054 dout("osize %u / su %u = su_per_object %u\n", osize, su, 1055 su_per_object); 1056 1057 if ((su & ~PAGE_MASK) != 0) 1058 goto invalid; 1059 1060 /* bl = *off / su; */ 1061 t = off; 1062 do_div(t, su); 1063 bl = t; 1064 dout("off %llu / su %u = bl %u\n", off, su, bl); 1065 1066 stripeno = bl / sc; 1067 stripepos = bl % sc; 1068 objsetno = stripeno / su_per_object; 1069 1070 *ono = objsetno * sc + stripepos; 1071 dout("objset %u * sc %u = ono %u\n", objsetno, sc, (unsigned int)*ono); 1072 1073 /* *oxoff = *off % layout->fl_stripe_unit; # offset in su */ 1074 t = off; 1075 su_offset = do_div(t, su); 1076 *oxoff = su_offset + (stripeno % su_per_object) * su; 1077 1078 /* 1079 * Calculate the length of the extent being written to the selected 1080 * object. This is the minimum of the full length requested (len) or 1081 * the remainder of the current stripe being written to. 1082 */ 1083 *oxlen = min_t(u64, len, su - su_offset); 1084 1085 dout(" obj extent %llu~%llu\n", *oxoff, *oxlen); 1086 return 0; 1087 1088 invalid: 1089 dout(" invalid layout\n"); 1090 *ono = 0; 1091 *oxoff = 0; 1092 *oxlen = 0; 1093 return -EINVAL; 1094 } 1095 EXPORT_SYMBOL(ceph_calc_file_object_mapping); 1096 1097 /* 1098 * Calculate mapping of a (oloc, oid) pair to a PG. Should only be 1099 * called with target's (oloc, oid), since tiering isn't taken into 1100 * account. 1101 */ 1102 int ceph_oloc_oid_to_pg(struct ceph_osdmap *osdmap, 1103 struct ceph_object_locator *oloc, 1104 struct ceph_object_id *oid, 1105 struct ceph_pg *pg_out) 1106 { 1107 struct ceph_pg_pool_info *pi; 1108 1109 pi = __lookup_pg_pool(&osdmap->pg_pools, oloc->pool); 1110 if (!pi) 1111 return -EIO; 1112 1113 pg_out->pool = oloc->pool; 1114 pg_out->seed = ceph_str_hash(pi->object_hash, oid->name, 1115 oid->name_len); 1116 1117 dout("%s '%.*s' pgid %llu.%x\n", __func__, oid->name_len, oid->name, 1118 pg_out->pool, pg_out->seed); 1119 return 0; 1120 } 1121 EXPORT_SYMBOL(ceph_oloc_oid_to_pg); 1122 1123 static int crush_do_rule_ary(const struct crush_map *map, int ruleno, int x, 1124 int *result, int result_max, 1125 const __u32 *weight, int weight_max) 1126 { 1127 int scratch[result_max * 3]; 1128 1129 return crush_do_rule(map, ruleno, x, result, result_max, 1130 weight, weight_max, scratch); 1131 } 1132 1133 /* 1134 * Calculate raw osd vector for the given pgid. Return pointer to osd 1135 * array, or NULL on failure. 1136 */ 1137 static int *calc_pg_raw(struct ceph_osdmap *osdmap, struct ceph_pg pgid, 1138 int *osds, int *num) 1139 { 1140 struct ceph_pg_mapping *pg; 1141 struct ceph_pg_pool_info *pool; 1142 int ruleno; 1143 int r; 1144 u32 pps; 1145 1146 pool = __lookup_pg_pool(&osdmap->pg_pools, pgid.pool); 1147 if (!pool) 1148 return NULL; 1149 1150 /* pg_temp? */ 1151 pgid.seed = ceph_stable_mod(pgid.seed, pool->pg_num, 1152 pool->pg_num_mask); 1153 pg = __lookup_pg_mapping(&osdmap->pg_temp, pgid); 1154 if (pg) { 1155 *num = pg->len; 1156 return pg->osds; 1157 } 1158 1159 /* crush */ 1160 ruleno = crush_find_rule(osdmap->crush, pool->crush_ruleset, 1161 pool->type, pool->size); 1162 if (ruleno < 0) { 1163 pr_err("no crush rule pool %lld ruleset %d type %d size %d\n", 1164 pgid.pool, pool->crush_ruleset, pool->type, 1165 pool->size); 1166 return NULL; 1167 } 1168 1169 if (pool->flags & CEPH_POOL_FLAG_HASHPSPOOL) { 1170 /* hash pool id and seed sothat pool PGs do not overlap */ 1171 pps = crush_hash32_2(CRUSH_HASH_RJENKINS1, 1172 ceph_stable_mod(pgid.seed, pool->pgp_num, 1173 pool->pgp_num_mask), 1174 pgid.pool); 1175 } else { 1176 /* 1177 * legacy ehavior: add ps and pool together. this is 1178 * not a great approach because the PGs from each pool 1179 * will overlap on top of each other: 0.5 == 1.4 == 1180 * 2.3 == ... 1181 */ 1182 pps = ceph_stable_mod(pgid.seed, pool->pgp_num, 1183 pool->pgp_num_mask) + 1184 (unsigned)pgid.pool; 1185 } 1186 r = crush_do_rule_ary(osdmap->crush, ruleno, pps, 1187 osds, min_t(int, pool->size, *num), 1188 osdmap->osd_weight, osdmap->max_osd); 1189 if (r < 0) { 1190 pr_err("error %d from crush rule: pool %lld ruleset %d type %d" 1191 " size %d\n", r, pgid.pool, pool->crush_ruleset, 1192 pool->type, pool->size); 1193 return NULL; 1194 } 1195 *num = r; 1196 return osds; 1197 } 1198 1199 /* 1200 * Return acting set for given pgid. 1201 */ 1202 int ceph_calc_pg_acting(struct ceph_osdmap *osdmap, struct ceph_pg pgid, 1203 int *acting) 1204 { 1205 int rawosds[CEPH_PG_MAX_SIZE], *osds; 1206 int i, o, num = CEPH_PG_MAX_SIZE; 1207 1208 osds = calc_pg_raw(osdmap, pgid, rawosds, &num); 1209 if (!osds) 1210 return -1; 1211 1212 /* primary is first up osd */ 1213 o = 0; 1214 for (i = 0; i < num; i++) 1215 if (ceph_osd_is_up(osdmap, osds[i])) 1216 acting[o++] = osds[i]; 1217 return o; 1218 } 1219 1220 /* 1221 * Return primary osd for given pgid, or -1 if none. 1222 */ 1223 int ceph_calc_pg_primary(struct ceph_osdmap *osdmap, struct ceph_pg pgid) 1224 { 1225 int rawosds[CEPH_PG_MAX_SIZE], *osds; 1226 int i, num = CEPH_PG_MAX_SIZE; 1227 1228 osds = calc_pg_raw(osdmap, pgid, rawosds, &num); 1229 if (!osds) 1230 return -1; 1231 1232 /* primary is first up osd */ 1233 for (i = 0; i < num; i++) 1234 if (ceph_osd_is_up(osdmap, osds[i])) 1235 return osds[i]; 1236 return -1; 1237 } 1238 EXPORT_SYMBOL(ceph_calc_pg_primary); 1239