13d14c5d2SYehuda Sadeh 23d14c5d2SYehuda Sadeh #include <linux/ceph/ceph_debug.h> 33d14c5d2SYehuda Sadeh 43d14c5d2SYehuda Sadeh #include <linux/module.h> 53d14c5d2SYehuda Sadeh #include <linux/slab.h> 63d14c5d2SYehuda Sadeh #include <asm/div64.h> 73d14c5d2SYehuda Sadeh 83d14c5d2SYehuda Sadeh #include <linux/ceph/libceph.h> 93d14c5d2SYehuda Sadeh #include <linux/ceph/osdmap.h> 103d14c5d2SYehuda Sadeh #include <linux/ceph/decode.h> 113d14c5d2SYehuda Sadeh #include <linux/crush/hash.h> 123d14c5d2SYehuda Sadeh #include <linux/crush/mapper.h> 133d14c5d2SYehuda Sadeh 143d14c5d2SYehuda Sadeh char *ceph_osdmap_state_str(char *str, int len, int state) 153d14c5d2SYehuda Sadeh { 163d14c5d2SYehuda Sadeh if (!len) 171ec3911dSCong Ding return str; 183d14c5d2SYehuda Sadeh 191ec3911dSCong Ding if ((state & CEPH_OSD_EXISTS) && (state & CEPH_OSD_UP)) 201ec3911dSCong Ding snprintf(str, len, "exists, up"); 211ec3911dSCong Ding else if (state & CEPH_OSD_EXISTS) 223d14c5d2SYehuda Sadeh snprintf(str, len, "exists"); 231ec3911dSCong Ding else if (state & CEPH_OSD_UP) 241ec3911dSCong Ding snprintf(str, len, "up"); 251ec3911dSCong Ding else 263d14c5d2SYehuda Sadeh snprintf(str, len, "doesn't exist"); 271ec3911dSCong Ding 283d14c5d2SYehuda Sadeh return str; 293d14c5d2SYehuda Sadeh } 303d14c5d2SYehuda Sadeh 313d14c5d2SYehuda Sadeh /* maps */ 323d14c5d2SYehuda Sadeh 3395c96174SEric Dumazet static int calc_bits_of(unsigned int t) 343d14c5d2SYehuda Sadeh { 353d14c5d2SYehuda Sadeh int b = 0; 363d14c5d2SYehuda Sadeh while (t) { 373d14c5d2SYehuda Sadeh t = t >> 1; 383d14c5d2SYehuda Sadeh b++; 393d14c5d2SYehuda Sadeh } 403d14c5d2SYehuda Sadeh return b; 413d14c5d2SYehuda Sadeh } 423d14c5d2SYehuda Sadeh 433d14c5d2SYehuda Sadeh /* 443d14c5d2SYehuda Sadeh * the foo_mask is the smallest value 2^n-1 that is >= foo. 453d14c5d2SYehuda Sadeh */ 463d14c5d2SYehuda Sadeh static void calc_pg_masks(struct ceph_pg_pool_info *pi) 473d14c5d2SYehuda Sadeh { 484f6a7e5eSSage Weil pi->pg_num_mask = (1 << calc_bits_of(pi->pg_num-1)) - 1; 494f6a7e5eSSage Weil pi->pgp_num_mask = (1 << calc_bits_of(pi->pgp_num-1)) - 1; 503d14c5d2SYehuda Sadeh } 513d14c5d2SYehuda Sadeh 523d14c5d2SYehuda Sadeh /* 533d14c5d2SYehuda Sadeh * decode crush map 543d14c5d2SYehuda Sadeh */ 553d14c5d2SYehuda Sadeh static int crush_decode_uniform_bucket(void **p, void *end, 563d14c5d2SYehuda Sadeh struct crush_bucket_uniform *b) 573d14c5d2SYehuda Sadeh { 583d14c5d2SYehuda Sadeh dout("crush_decode_uniform_bucket %p to %p\n", *p, end); 593d14c5d2SYehuda Sadeh ceph_decode_need(p, end, (1+b->h.size) * sizeof(u32), bad); 603d14c5d2SYehuda Sadeh b->item_weight = ceph_decode_32(p); 613d14c5d2SYehuda Sadeh return 0; 623d14c5d2SYehuda Sadeh bad: 633d14c5d2SYehuda Sadeh return -EINVAL; 643d14c5d2SYehuda Sadeh } 653d14c5d2SYehuda Sadeh 663d14c5d2SYehuda Sadeh static int crush_decode_list_bucket(void **p, void *end, 673d14c5d2SYehuda Sadeh struct crush_bucket_list *b) 683d14c5d2SYehuda Sadeh { 693d14c5d2SYehuda Sadeh int j; 703d14c5d2SYehuda Sadeh dout("crush_decode_list_bucket %p to %p\n", *p, end); 713d14c5d2SYehuda Sadeh b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 723d14c5d2SYehuda Sadeh if (b->item_weights == NULL) 733d14c5d2SYehuda Sadeh return -ENOMEM; 743d14c5d2SYehuda Sadeh b->sum_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 753d14c5d2SYehuda Sadeh if (b->sum_weights == NULL) 763d14c5d2SYehuda Sadeh return -ENOMEM; 773d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad); 783d14c5d2SYehuda Sadeh for (j = 0; j < b->h.size; j++) { 793d14c5d2SYehuda Sadeh b->item_weights[j] = ceph_decode_32(p); 803d14c5d2SYehuda Sadeh b->sum_weights[j] = ceph_decode_32(p); 813d14c5d2SYehuda Sadeh } 823d14c5d2SYehuda Sadeh return 0; 833d14c5d2SYehuda Sadeh bad: 843d14c5d2SYehuda Sadeh return -EINVAL; 853d14c5d2SYehuda Sadeh } 863d14c5d2SYehuda Sadeh 873d14c5d2SYehuda Sadeh static int crush_decode_tree_bucket(void **p, void *end, 883d14c5d2SYehuda Sadeh struct crush_bucket_tree *b) 893d14c5d2SYehuda Sadeh { 903d14c5d2SYehuda Sadeh int j; 913d14c5d2SYehuda Sadeh dout("crush_decode_tree_bucket %p to %p\n", *p, end); 923d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, b->num_nodes, bad); 933d14c5d2SYehuda Sadeh b->node_weights = kcalloc(b->num_nodes, sizeof(u32), GFP_NOFS); 943d14c5d2SYehuda Sadeh if (b->node_weights == NULL) 953d14c5d2SYehuda Sadeh return -ENOMEM; 963d14c5d2SYehuda Sadeh ceph_decode_need(p, end, b->num_nodes * sizeof(u32), bad); 973d14c5d2SYehuda Sadeh for (j = 0; j < b->num_nodes; j++) 983d14c5d2SYehuda Sadeh b->node_weights[j] = ceph_decode_32(p); 993d14c5d2SYehuda Sadeh return 0; 1003d14c5d2SYehuda Sadeh bad: 1013d14c5d2SYehuda Sadeh return -EINVAL; 1023d14c5d2SYehuda Sadeh } 1033d14c5d2SYehuda Sadeh 1043d14c5d2SYehuda Sadeh static int crush_decode_straw_bucket(void **p, void *end, 1053d14c5d2SYehuda Sadeh struct crush_bucket_straw *b) 1063d14c5d2SYehuda Sadeh { 1073d14c5d2SYehuda Sadeh int j; 1083d14c5d2SYehuda Sadeh dout("crush_decode_straw_bucket %p to %p\n", *p, end); 1093d14c5d2SYehuda Sadeh b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 1103d14c5d2SYehuda Sadeh if (b->item_weights == NULL) 1113d14c5d2SYehuda Sadeh return -ENOMEM; 1123d14c5d2SYehuda Sadeh b->straws = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 1133d14c5d2SYehuda Sadeh if (b->straws == NULL) 1143d14c5d2SYehuda Sadeh return -ENOMEM; 1153d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad); 1163d14c5d2SYehuda Sadeh for (j = 0; j < b->h.size; j++) { 1173d14c5d2SYehuda Sadeh b->item_weights[j] = ceph_decode_32(p); 1183d14c5d2SYehuda Sadeh b->straws[j] = ceph_decode_32(p); 1193d14c5d2SYehuda Sadeh } 1203d14c5d2SYehuda Sadeh return 0; 1213d14c5d2SYehuda Sadeh bad: 1223d14c5d2SYehuda Sadeh return -EINVAL; 1233d14c5d2SYehuda Sadeh } 1243d14c5d2SYehuda Sadeh 125546f04efSSage Weil static int skip_name_map(void **p, void *end) 126546f04efSSage Weil { 127546f04efSSage Weil int len; 128546f04efSSage Weil ceph_decode_32_safe(p, end, len ,bad); 129546f04efSSage Weil while (len--) { 130546f04efSSage Weil int strlen; 131546f04efSSage Weil *p += sizeof(u32); 132546f04efSSage Weil ceph_decode_32_safe(p, end, strlen, bad); 133546f04efSSage Weil *p += strlen; 134546f04efSSage Weil } 135546f04efSSage Weil return 0; 136546f04efSSage Weil bad: 137546f04efSSage Weil return -EINVAL; 138546f04efSSage Weil } 139546f04efSSage Weil 1403d14c5d2SYehuda Sadeh static struct crush_map *crush_decode(void *pbyval, void *end) 1413d14c5d2SYehuda Sadeh { 1423d14c5d2SYehuda Sadeh struct crush_map *c; 1433d14c5d2SYehuda Sadeh int err = -EINVAL; 1443d14c5d2SYehuda Sadeh int i, j; 1453d14c5d2SYehuda Sadeh void **p = &pbyval; 1463d14c5d2SYehuda Sadeh void *start = pbyval; 1473d14c5d2SYehuda Sadeh u32 magic; 148546f04efSSage Weil u32 num_name_maps; 1493d14c5d2SYehuda Sadeh 1503d14c5d2SYehuda Sadeh dout("crush_decode %p to %p len %d\n", *p, end, (int)(end - *p)); 1513d14c5d2SYehuda Sadeh 1523d14c5d2SYehuda Sadeh c = kzalloc(sizeof(*c), GFP_NOFS); 1533d14c5d2SYehuda Sadeh if (c == NULL) 1543d14c5d2SYehuda Sadeh return ERR_PTR(-ENOMEM); 1553d14c5d2SYehuda Sadeh 156546f04efSSage Weil /* set tunables to default values */ 157546f04efSSage Weil c->choose_local_tries = 2; 158546f04efSSage Weil c->choose_local_fallback_tries = 5; 159546f04efSSage Weil c->choose_total_tries = 19; 1601604f488SJim Schutt c->chooseleaf_descend_once = 0; 161546f04efSSage Weil 1623d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 4*sizeof(u32), bad); 1633d14c5d2SYehuda Sadeh magic = ceph_decode_32(p); 1643d14c5d2SYehuda Sadeh if (magic != CRUSH_MAGIC) { 1653d14c5d2SYehuda Sadeh pr_err("crush_decode magic %x != current %x\n", 16695c96174SEric Dumazet (unsigned int)magic, (unsigned int)CRUSH_MAGIC); 1673d14c5d2SYehuda Sadeh goto bad; 1683d14c5d2SYehuda Sadeh } 1693d14c5d2SYehuda Sadeh c->max_buckets = ceph_decode_32(p); 1703d14c5d2SYehuda Sadeh c->max_rules = ceph_decode_32(p); 1713d14c5d2SYehuda Sadeh c->max_devices = ceph_decode_32(p); 1723d14c5d2SYehuda Sadeh 1733d14c5d2SYehuda Sadeh c->buckets = kcalloc(c->max_buckets, sizeof(*c->buckets), GFP_NOFS); 1743d14c5d2SYehuda Sadeh if (c->buckets == NULL) 1753d14c5d2SYehuda Sadeh goto badmem; 1763d14c5d2SYehuda Sadeh c->rules = kcalloc(c->max_rules, sizeof(*c->rules), GFP_NOFS); 1773d14c5d2SYehuda Sadeh if (c->rules == NULL) 1783d14c5d2SYehuda Sadeh goto badmem; 1793d14c5d2SYehuda Sadeh 1803d14c5d2SYehuda Sadeh /* buckets */ 1813d14c5d2SYehuda Sadeh for (i = 0; i < c->max_buckets; i++) { 1823d14c5d2SYehuda Sadeh int size = 0; 1833d14c5d2SYehuda Sadeh u32 alg; 1843d14c5d2SYehuda Sadeh struct crush_bucket *b; 1853d14c5d2SYehuda Sadeh 1863d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, alg, bad); 1873d14c5d2SYehuda Sadeh if (alg == 0) { 1883d14c5d2SYehuda Sadeh c->buckets[i] = NULL; 1893d14c5d2SYehuda Sadeh continue; 1903d14c5d2SYehuda Sadeh } 1913d14c5d2SYehuda Sadeh dout("crush_decode bucket %d off %x %p to %p\n", 1923d14c5d2SYehuda Sadeh i, (int)(*p-start), *p, end); 1933d14c5d2SYehuda Sadeh 1943d14c5d2SYehuda Sadeh switch (alg) { 1953d14c5d2SYehuda Sadeh case CRUSH_BUCKET_UNIFORM: 1963d14c5d2SYehuda Sadeh size = sizeof(struct crush_bucket_uniform); 1973d14c5d2SYehuda Sadeh break; 1983d14c5d2SYehuda Sadeh case CRUSH_BUCKET_LIST: 1993d14c5d2SYehuda Sadeh size = sizeof(struct crush_bucket_list); 2003d14c5d2SYehuda Sadeh break; 2013d14c5d2SYehuda Sadeh case CRUSH_BUCKET_TREE: 2023d14c5d2SYehuda Sadeh size = sizeof(struct crush_bucket_tree); 2033d14c5d2SYehuda Sadeh break; 2043d14c5d2SYehuda Sadeh case CRUSH_BUCKET_STRAW: 2053d14c5d2SYehuda Sadeh size = sizeof(struct crush_bucket_straw); 2063d14c5d2SYehuda Sadeh break; 2073d14c5d2SYehuda Sadeh default: 2083d14c5d2SYehuda Sadeh err = -EINVAL; 2093d14c5d2SYehuda Sadeh goto bad; 2103d14c5d2SYehuda Sadeh } 2113d14c5d2SYehuda Sadeh BUG_ON(size == 0); 2123d14c5d2SYehuda Sadeh b = c->buckets[i] = kzalloc(size, GFP_NOFS); 2133d14c5d2SYehuda Sadeh if (b == NULL) 2143d14c5d2SYehuda Sadeh goto badmem; 2153d14c5d2SYehuda Sadeh 2163d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 4*sizeof(u32), bad); 2173d14c5d2SYehuda Sadeh b->id = ceph_decode_32(p); 2183d14c5d2SYehuda Sadeh b->type = ceph_decode_16(p); 2193d14c5d2SYehuda Sadeh b->alg = ceph_decode_8(p); 2203d14c5d2SYehuda Sadeh b->hash = ceph_decode_8(p); 2213d14c5d2SYehuda Sadeh b->weight = ceph_decode_32(p); 2223d14c5d2SYehuda Sadeh b->size = ceph_decode_32(p); 2233d14c5d2SYehuda Sadeh 2243d14c5d2SYehuda Sadeh dout("crush_decode bucket size %d off %x %p to %p\n", 2253d14c5d2SYehuda Sadeh b->size, (int)(*p-start), *p, end); 2263d14c5d2SYehuda Sadeh 2273d14c5d2SYehuda Sadeh b->items = kcalloc(b->size, sizeof(__s32), GFP_NOFS); 2283d14c5d2SYehuda Sadeh if (b->items == NULL) 2293d14c5d2SYehuda Sadeh goto badmem; 2303d14c5d2SYehuda Sadeh b->perm = kcalloc(b->size, sizeof(u32), GFP_NOFS); 2313d14c5d2SYehuda Sadeh if (b->perm == NULL) 2323d14c5d2SYehuda Sadeh goto badmem; 2333d14c5d2SYehuda Sadeh b->perm_n = 0; 2343d14c5d2SYehuda Sadeh 2353d14c5d2SYehuda Sadeh ceph_decode_need(p, end, b->size*sizeof(u32), bad); 2363d14c5d2SYehuda Sadeh for (j = 0; j < b->size; j++) 2373d14c5d2SYehuda Sadeh b->items[j] = ceph_decode_32(p); 2383d14c5d2SYehuda Sadeh 2393d14c5d2SYehuda Sadeh switch (b->alg) { 2403d14c5d2SYehuda Sadeh case CRUSH_BUCKET_UNIFORM: 2413d14c5d2SYehuda Sadeh err = crush_decode_uniform_bucket(p, end, 2423d14c5d2SYehuda Sadeh (struct crush_bucket_uniform *)b); 2433d14c5d2SYehuda Sadeh if (err < 0) 2443d14c5d2SYehuda Sadeh goto bad; 2453d14c5d2SYehuda Sadeh break; 2463d14c5d2SYehuda Sadeh case CRUSH_BUCKET_LIST: 2473d14c5d2SYehuda Sadeh err = crush_decode_list_bucket(p, end, 2483d14c5d2SYehuda Sadeh (struct crush_bucket_list *)b); 2493d14c5d2SYehuda Sadeh if (err < 0) 2503d14c5d2SYehuda Sadeh goto bad; 2513d14c5d2SYehuda Sadeh break; 2523d14c5d2SYehuda Sadeh case CRUSH_BUCKET_TREE: 2533d14c5d2SYehuda Sadeh err = crush_decode_tree_bucket(p, end, 2543d14c5d2SYehuda Sadeh (struct crush_bucket_tree *)b); 2553d14c5d2SYehuda Sadeh if (err < 0) 2563d14c5d2SYehuda Sadeh goto bad; 2573d14c5d2SYehuda Sadeh break; 2583d14c5d2SYehuda Sadeh case CRUSH_BUCKET_STRAW: 2593d14c5d2SYehuda Sadeh err = crush_decode_straw_bucket(p, end, 2603d14c5d2SYehuda Sadeh (struct crush_bucket_straw *)b); 2613d14c5d2SYehuda Sadeh if (err < 0) 2623d14c5d2SYehuda Sadeh goto bad; 2633d14c5d2SYehuda Sadeh break; 2643d14c5d2SYehuda Sadeh } 2653d14c5d2SYehuda Sadeh } 2663d14c5d2SYehuda Sadeh 2673d14c5d2SYehuda Sadeh /* rules */ 2683d14c5d2SYehuda Sadeh dout("rule vec is %p\n", c->rules); 2693d14c5d2SYehuda Sadeh for (i = 0; i < c->max_rules; i++) { 2703d14c5d2SYehuda Sadeh u32 yes; 2713d14c5d2SYehuda Sadeh struct crush_rule *r; 2723d14c5d2SYehuda Sadeh 2733d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, yes, bad); 2743d14c5d2SYehuda Sadeh if (!yes) { 2753d14c5d2SYehuda Sadeh dout("crush_decode NO rule %d off %x %p to %p\n", 2763d14c5d2SYehuda Sadeh i, (int)(*p-start), *p, end); 2773d14c5d2SYehuda Sadeh c->rules[i] = NULL; 2783d14c5d2SYehuda Sadeh continue; 2793d14c5d2SYehuda Sadeh } 2803d14c5d2SYehuda Sadeh 2813d14c5d2SYehuda Sadeh dout("crush_decode rule %d off %x %p to %p\n", 2823d14c5d2SYehuda Sadeh i, (int)(*p-start), *p, end); 2833d14c5d2SYehuda Sadeh 2843d14c5d2SYehuda Sadeh /* len */ 2853d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, yes, bad); 2863d14c5d2SYehuda Sadeh #if BITS_PER_LONG == 32 2873d14c5d2SYehuda Sadeh err = -EINVAL; 28864486697SXi Wang if (yes > (ULONG_MAX - sizeof(*r)) 28964486697SXi Wang / sizeof(struct crush_rule_step)) 2903d14c5d2SYehuda Sadeh goto bad; 2913d14c5d2SYehuda Sadeh #endif 2923d14c5d2SYehuda Sadeh r = c->rules[i] = kmalloc(sizeof(*r) + 2933d14c5d2SYehuda Sadeh yes*sizeof(struct crush_rule_step), 2943d14c5d2SYehuda Sadeh GFP_NOFS); 2953d14c5d2SYehuda Sadeh if (r == NULL) 2963d14c5d2SYehuda Sadeh goto badmem; 2973d14c5d2SYehuda Sadeh dout(" rule %d is at %p\n", i, r); 2983d14c5d2SYehuda Sadeh r->len = yes; 2993d14c5d2SYehuda Sadeh ceph_decode_copy_safe(p, end, &r->mask, 4, bad); /* 4 u8's */ 3003d14c5d2SYehuda Sadeh ceph_decode_need(p, end, r->len*3*sizeof(u32), bad); 3013d14c5d2SYehuda Sadeh for (j = 0; j < r->len; j++) { 3023d14c5d2SYehuda Sadeh r->steps[j].op = ceph_decode_32(p); 3033d14c5d2SYehuda Sadeh r->steps[j].arg1 = ceph_decode_32(p); 3043d14c5d2SYehuda Sadeh r->steps[j].arg2 = ceph_decode_32(p); 3053d14c5d2SYehuda Sadeh } 3063d14c5d2SYehuda Sadeh } 3073d14c5d2SYehuda Sadeh 3083d14c5d2SYehuda Sadeh /* ignore trailing name maps. */ 309546f04efSSage Weil for (num_name_maps = 0; num_name_maps < 3; num_name_maps++) { 310546f04efSSage Weil err = skip_name_map(p, end); 311546f04efSSage Weil if (err < 0) 312546f04efSSage Weil goto done; 313546f04efSSage Weil } 3143d14c5d2SYehuda Sadeh 315546f04efSSage Weil /* tunables */ 316546f04efSSage Weil ceph_decode_need(p, end, 3*sizeof(u32), done); 317546f04efSSage Weil c->choose_local_tries = ceph_decode_32(p); 318546f04efSSage Weil c->choose_local_fallback_tries = ceph_decode_32(p); 319546f04efSSage Weil c->choose_total_tries = ceph_decode_32(p); 320546f04efSSage Weil dout("crush decode tunable choose_local_tries = %d", 321546f04efSSage Weil c->choose_local_tries); 322546f04efSSage Weil dout("crush decode tunable choose_local_fallback_tries = %d", 323546f04efSSage Weil c->choose_local_fallback_tries); 324546f04efSSage Weil dout("crush decode tunable choose_total_tries = %d", 325546f04efSSage Weil c->choose_total_tries); 326546f04efSSage Weil 3271604f488SJim Schutt ceph_decode_need(p, end, sizeof(u32), done); 3281604f488SJim Schutt c->chooseleaf_descend_once = ceph_decode_32(p); 3291604f488SJim Schutt dout("crush decode tunable chooseleaf_descend_once = %d", 3301604f488SJim Schutt c->chooseleaf_descend_once); 3311604f488SJim Schutt 332546f04efSSage Weil done: 3333d14c5d2SYehuda Sadeh dout("crush_decode success\n"); 3343d14c5d2SYehuda Sadeh return c; 3353d14c5d2SYehuda Sadeh 3363d14c5d2SYehuda Sadeh badmem: 3373d14c5d2SYehuda Sadeh err = -ENOMEM; 3383d14c5d2SYehuda Sadeh bad: 3393d14c5d2SYehuda Sadeh dout("crush_decode fail %d\n", err); 3403d14c5d2SYehuda Sadeh crush_destroy(c); 3413d14c5d2SYehuda Sadeh return ERR_PTR(err); 3423d14c5d2SYehuda Sadeh } 3433d14c5d2SYehuda Sadeh 3443d14c5d2SYehuda Sadeh /* 3453d14c5d2SYehuda Sadeh * rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid 3463d14c5d2SYehuda Sadeh * to a set of osds) 3473d14c5d2SYehuda Sadeh */ 3485b191d99SSage Weil static int pgid_cmp(struct ceph_pg l, struct ceph_pg r) 3493d14c5d2SYehuda Sadeh { 3505b191d99SSage Weil if (l.pool < r.pool) 3513d14c5d2SYehuda Sadeh return -1; 3525b191d99SSage Weil if (l.pool > r.pool) 3535b191d99SSage Weil return 1; 3545b191d99SSage Weil if (l.seed < r.seed) 3555b191d99SSage Weil return -1; 3565b191d99SSage Weil if (l.seed > r.seed) 3573d14c5d2SYehuda Sadeh return 1; 3583d14c5d2SYehuda Sadeh return 0; 3593d14c5d2SYehuda Sadeh } 3603d14c5d2SYehuda Sadeh 3613d14c5d2SYehuda Sadeh static int __insert_pg_mapping(struct ceph_pg_mapping *new, 3623d14c5d2SYehuda Sadeh struct rb_root *root) 3633d14c5d2SYehuda Sadeh { 3643d14c5d2SYehuda Sadeh struct rb_node **p = &root->rb_node; 3653d14c5d2SYehuda Sadeh struct rb_node *parent = NULL; 3663d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg = NULL; 3673d14c5d2SYehuda Sadeh int c; 3683d14c5d2SYehuda Sadeh 3698adc8b3dSSage Weil dout("__insert_pg_mapping %llx %p\n", *(u64 *)&new->pgid, new); 3703d14c5d2SYehuda Sadeh while (*p) { 3713d14c5d2SYehuda Sadeh parent = *p; 3723d14c5d2SYehuda Sadeh pg = rb_entry(parent, struct ceph_pg_mapping, node); 3733d14c5d2SYehuda Sadeh c = pgid_cmp(new->pgid, pg->pgid); 3743d14c5d2SYehuda Sadeh if (c < 0) 3753d14c5d2SYehuda Sadeh p = &(*p)->rb_left; 3763d14c5d2SYehuda Sadeh else if (c > 0) 3773d14c5d2SYehuda Sadeh p = &(*p)->rb_right; 3783d14c5d2SYehuda Sadeh else 3793d14c5d2SYehuda Sadeh return -EEXIST; 3803d14c5d2SYehuda Sadeh } 3813d14c5d2SYehuda Sadeh 3823d14c5d2SYehuda Sadeh rb_link_node(&new->node, parent, p); 3833d14c5d2SYehuda Sadeh rb_insert_color(&new->node, root); 3843d14c5d2SYehuda Sadeh return 0; 3853d14c5d2SYehuda Sadeh } 3863d14c5d2SYehuda Sadeh 3873d14c5d2SYehuda Sadeh static struct ceph_pg_mapping *__lookup_pg_mapping(struct rb_root *root, 3885b191d99SSage Weil struct ceph_pg pgid) 3893d14c5d2SYehuda Sadeh { 3903d14c5d2SYehuda Sadeh struct rb_node *n = root->rb_node; 3913d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg; 3923d14c5d2SYehuda Sadeh int c; 3933d14c5d2SYehuda Sadeh 3943d14c5d2SYehuda Sadeh while (n) { 3953d14c5d2SYehuda Sadeh pg = rb_entry(n, struct ceph_pg_mapping, node); 3963d14c5d2SYehuda Sadeh c = pgid_cmp(pgid, pg->pgid); 3978adc8b3dSSage Weil if (c < 0) { 3983d14c5d2SYehuda Sadeh n = n->rb_left; 3998adc8b3dSSage Weil } else if (c > 0) { 4003d14c5d2SYehuda Sadeh n = n->rb_right; 4018adc8b3dSSage Weil } else { 4025b191d99SSage Weil dout("__lookup_pg_mapping %lld.%x got %p\n", 4035b191d99SSage Weil pgid.pool, pgid.seed, pg); 4043d14c5d2SYehuda Sadeh return pg; 4053d14c5d2SYehuda Sadeh } 4068adc8b3dSSage Weil } 4073d14c5d2SYehuda Sadeh return NULL; 4083d14c5d2SYehuda Sadeh } 4093d14c5d2SYehuda Sadeh 4105b191d99SSage Weil static int __remove_pg_mapping(struct rb_root *root, struct ceph_pg pgid) 4118adc8b3dSSage Weil { 4128adc8b3dSSage Weil struct ceph_pg_mapping *pg = __lookup_pg_mapping(root, pgid); 4138adc8b3dSSage Weil 4148adc8b3dSSage Weil if (pg) { 4155b191d99SSage Weil dout("__remove_pg_mapping %lld.%x %p\n", pgid.pool, pgid.seed, 4165b191d99SSage Weil pg); 4178adc8b3dSSage Weil rb_erase(&pg->node, root); 4188adc8b3dSSage Weil kfree(pg); 4198adc8b3dSSage Weil return 0; 4208adc8b3dSSage Weil } 4215b191d99SSage Weil dout("__remove_pg_mapping %lld.%x dne\n", pgid.pool, pgid.seed); 4228adc8b3dSSage Weil return -ENOENT; 4238adc8b3dSSage Weil } 4248adc8b3dSSage Weil 4253d14c5d2SYehuda Sadeh /* 4263d14c5d2SYehuda Sadeh * rbtree of pg pool info 4273d14c5d2SYehuda Sadeh */ 4283d14c5d2SYehuda Sadeh static int __insert_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *new) 4293d14c5d2SYehuda Sadeh { 4303d14c5d2SYehuda Sadeh struct rb_node **p = &root->rb_node; 4313d14c5d2SYehuda Sadeh struct rb_node *parent = NULL; 4323d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi = NULL; 4333d14c5d2SYehuda Sadeh 4343d14c5d2SYehuda Sadeh while (*p) { 4353d14c5d2SYehuda Sadeh parent = *p; 4363d14c5d2SYehuda Sadeh pi = rb_entry(parent, struct ceph_pg_pool_info, node); 4373d14c5d2SYehuda Sadeh if (new->id < pi->id) 4383d14c5d2SYehuda Sadeh p = &(*p)->rb_left; 4393d14c5d2SYehuda Sadeh else if (new->id > pi->id) 4403d14c5d2SYehuda Sadeh p = &(*p)->rb_right; 4413d14c5d2SYehuda Sadeh else 4423d14c5d2SYehuda Sadeh return -EEXIST; 4433d14c5d2SYehuda Sadeh } 4443d14c5d2SYehuda Sadeh 4453d14c5d2SYehuda Sadeh rb_link_node(&new->node, parent, p); 4463d14c5d2SYehuda Sadeh rb_insert_color(&new->node, root); 4473d14c5d2SYehuda Sadeh return 0; 4483d14c5d2SYehuda Sadeh } 4493d14c5d2SYehuda Sadeh 4504f6a7e5eSSage Weil static struct ceph_pg_pool_info *__lookup_pg_pool(struct rb_root *root, u64 id) 4513d14c5d2SYehuda Sadeh { 4523d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi; 4533d14c5d2SYehuda Sadeh struct rb_node *n = root->rb_node; 4543d14c5d2SYehuda Sadeh 4553d14c5d2SYehuda Sadeh while (n) { 4563d14c5d2SYehuda Sadeh pi = rb_entry(n, struct ceph_pg_pool_info, node); 4573d14c5d2SYehuda Sadeh if (id < pi->id) 4583d14c5d2SYehuda Sadeh n = n->rb_left; 4593d14c5d2SYehuda Sadeh else if (id > pi->id) 4603d14c5d2SYehuda Sadeh n = n->rb_right; 4613d14c5d2SYehuda Sadeh else 4623d14c5d2SYehuda Sadeh return pi; 4633d14c5d2SYehuda Sadeh } 4643d14c5d2SYehuda Sadeh return NULL; 4653d14c5d2SYehuda Sadeh } 4663d14c5d2SYehuda Sadeh 467ce7f6a27SIlya Dryomov struct ceph_pg_pool_info *ceph_pg_pool_by_id(struct ceph_osdmap *map, u64 id) 468ce7f6a27SIlya Dryomov { 469ce7f6a27SIlya Dryomov return __lookup_pg_pool(&map->pg_pools, id); 470ce7f6a27SIlya Dryomov } 471ce7f6a27SIlya Dryomov 47272afc71fSAlex Elder const char *ceph_pg_pool_name_by_id(struct ceph_osdmap *map, u64 id) 47372afc71fSAlex Elder { 47472afc71fSAlex Elder struct ceph_pg_pool_info *pi; 47572afc71fSAlex Elder 47672afc71fSAlex Elder if (id == CEPH_NOPOOL) 47772afc71fSAlex Elder return NULL; 47872afc71fSAlex Elder 47972afc71fSAlex Elder if (WARN_ON_ONCE(id > (u64) INT_MAX)) 48072afc71fSAlex Elder return NULL; 48172afc71fSAlex Elder 48272afc71fSAlex Elder pi = __lookup_pg_pool(&map->pg_pools, (int) id); 48372afc71fSAlex Elder 48472afc71fSAlex Elder return pi ? pi->name : NULL; 48572afc71fSAlex Elder } 48672afc71fSAlex Elder EXPORT_SYMBOL(ceph_pg_pool_name_by_id); 48772afc71fSAlex Elder 4883d14c5d2SYehuda Sadeh int ceph_pg_poolid_by_name(struct ceph_osdmap *map, const char *name) 4893d14c5d2SYehuda Sadeh { 4903d14c5d2SYehuda Sadeh struct rb_node *rbp; 4913d14c5d2SYehuda Sadeh 4923d14c5d2SYehuda Sadeh for (rbp = rb_first(&map->pg_pools); rbp; rbp = rb_next(rbp)) { 4933d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi = 4943d14c5d2SYehuda Sadeh rb_entry(rbp, struct ceph_pg_pool_info, node); 4953d14c5d2SYehuda Sadeh if (pi->name && strcmp(pi->name, name) == 0) 4963d14c5d2SYehuda Sadeh return pi->id; 4973d14c5d2SYehuda Sadeh } 4983d14c5d2SYehuda Sadeh return -ENOENT; 4993d14c5d2SYehuda Sadeh } 5003d14c5d2SYehuda Sadeh EXPORT_SYMBOL(ceph_pg_poolid_by_name); 5013d14c5d2SYehuda Sadeh 5023d14c5d2SYehuda Sadeh static void __remove_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *pi) 5033d14c5d2SYehuda Sadeh { 5043d14c5d2SYehuda Sadeh rb_erase(&pi->node, root); 5053d14c5d2SYehuda Sadeh kfree(pi->name); 5063d14c5d2SYehuda Sadeh kfree(pi); 5073d14c5d2SYehuda Sadeh } 5083d14c5d2SYehuda Sadeh 5090f70c7eeSIlya Dryomov static int decode_pool(void **p, void *end, struct ceph_pg_pool_info *pi) 5103d14c5d2SYehuda Sadeh { 5114f6a7e5eSSage Weil u8 ev, cv; 5124f6a7e5eSSage Weil unsigned len, num; 5134f6a7e5eSSage Weil void *pool_end; 5143d14c5d2SYehuda Sadeh 5154f6a7e5eSSage Weil ceph_decode_need(p, end, 2 + 4, bad); 5164f6a7e5eSSage Weil ev = ceph_decode_8(p); /* encoding version */ 5174f6a7e5eSSage Weil cv = ceph_decode_8(p); /* compat version */ 5184f6a7e5eSSage Weil if (ev < 5) { 5194f6a7e5eSSage Weil pr_warning("got v %d < 5 cv %d of ceph_pg_pool\n", ev, cv); 5204f6a7e5eSSage Weil return -EINVAL; 5214f6a7e5eSSage Weil } 52217a13e40SIlya Dryomov if (cv > 9) { 52317a13e40SIlya Dryomov pr_warning("got v %d cv %d > 9 of ceph_pg_pool\n", ev, cv); 5244f6a7e5eSSage Weil return -EINVAL; 5254f6a7e5eSSage Weil } 5264f6a7e5eSSage Weil len = ceph_decode_32(p); 5274f6a7e5eSSage Weil ceph_decode_need(p, end, len, bad); 5284f6a7e5eSSage Weil pool_end = *p + len; 5293d14c5d2SYehuda Sadeh 5304f6a7e5eSSage Weil pi->type = ceph_decode_8(p); 5314f6a7e5eSSage Weil pi->size = ceph_decode_8(p); 5324f6a7e5eSSage Weil pi->crush_ruleset = ceph_decode_8(p); 5334f6a7e5eSSage Weil pi->object_hash = ceph_decode_8(p); 5344f6a7e5eSSage Weil 5354f6a7e5eSSage Weil pi->pg_num = ceph_decode_32(p); 5364f6a7e5eSSage Weil pi->pgp_num = ceph_decode_32(p); 5374f6a7e5eSSage Weil 5384f6a7e5eSSage Weil *p += 4 + 4; /* skip lpg* */ 5394f6a7e5eSSage Weil *p += 4; /* skip last_change */ 5404f6a7e5eSSage Weil *p += 8 + 4; /* skip snap_seq, snap_epoch */ 5414f6a7e5eSSage Weil 5424f6a7e5eSSage Weil /* skip snaps */ 5434f6a7e5eSSage Weil num = ceph_decode_32(p); 5444f6a7e5eSSage Weil while (num--) { 5454f6a7e5eSSage Weil *p += 8; /* snapid key */ 5464f6a7e5eSSage Weil *p += 1 + 1; /* versions */ 5474f6a7e5eSSage Weil len = ceph_decode_32(p); 5484f6a7e5eSSage Weil *p += len; 5493d14c5d2SYehuda Sadeh } 5503d14c5d2SYehuda Sadeh 55117a13e40SIlya Dryomov /* skip removed_snaps */ 5524f6a7e5eSSage Weil num = ceph_decode_32(p); 5534f6a7e5eSSage Weil *p += num * (8 + 8); 5544f6a7e5eSSage Weil 5554f6a7e5eSSage Weil *p += 8; /* skip auid */ 5564f6a7e5eSSage Weil pi->flags = ceph_decode_64(p); 55717a13e40SIlya Dryomov *p += 4; /* skip crash_replay_interval */ 55817a13e40SIlya Dryomov 55917a13e40SIlya Dryomov if (ev >= 7) 56017a13e40SIlya Dryomov *p += 1; /* skip min_size */ 56117a13e40SIlya Dryomov 56217a13e40SIlya Dryomov if (ev >= 8) 56317a13e40SIlya Dryomov *p += 8 + 8; /* skip quota_max_* */ 56417a13e40SIlya Dryomov 56517a13e40SIlya Dryomov if (ev >= 9) { 56617a13e40SIlya Dryomov /* skip tiers */ 56717a13e40SIlya Dryomov num = ceph_decode_32(p); 56817a13e40SIlya Dryomov *p += num * 8; 56917a13e40SIlya Dryomov 57017a13e40SIlya Dryomov *p += 8; /* skip tier_of */ 57117a13e40SIlya Dryomov *p += 1; /* skip cache_mode */ 57217a13e40SIlya Dryomov 57317a13e40SIlya Dryomov pi->read_tier = ceph_decode_64(p); 57417a13e40SIlya Dryomov pi->write_tier = ceph_decode_64(p); 57517a13e40SIlya Dryomov } else { 57617a13e40SIlya Dryomov pi->read_tier = -1; 57717a13e40SIlya Dryomov pi->write_tier = -1; 57817a13e40SIlya Dryomov } 5794f6a7e5eSSage Weil 5804f6a7e5eSSage Weil /* ignore the rest */ 5814f6a7e5eSSage Weil 5824f6a7e5eSSage Weil *p = pool_end; 5834f6a7e5eSSage Weil calc_pg_masks(pi); 5843d14c5d2SYehuda Sadeh return 0; 5853d14c5d2SYehuda Sadeh 5863d14c5d2SYehuda Sadeh bad: 5873d14c5d2SYehuda Sadeh return -EINVAL; 5883d14c5d2SYehuda Sadeh } 5893d14c5d2SYehuda Sadeh 5900f70c7eeSIlya Dryomov static int decode_pool_names(void **p, void *end, struct ceph_osdmap *map) 5913d14c5d2SYehuda Sadeh { 5923d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi; 5934f6a7e5eSSage Weil u32 num, len; 5944f6a7e5eSSage Weil u64 pool; 5953d14c5d2SYehuda Sadeh 5963d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, num, bad); 5973d14c5d2SYehuda Sadeh dout(" %d pool names\n", num); 5983d14c5d2SYehuda Sadeh while (num--) { 5994f6a7e5eSSage Weil ceph_decode_64_safe(p, end, pool, bad); 6003d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 6014f6a7e5eSSage Weil dout(" pool %llu len %d\n", pool, len); 602ad3b904cSXi Wang ceph_decode_need(p, end, len, bad); 6033d14c5d2SYehuda Sadeh pi = __lookup_pg_pool(&map->pg_pools, pool); 6043d14c5d2SYehuda Sadeh if (pi) { 605ad3b904cSXi Wang char *name = kstrndup(*p, len, GFP_NOFS); 606ad3b904cSXi Wang 607ad3b904cSXi Wang if (!name) 608ad3b904cSXi Wang return -ENOMEM; 6093d14c5d2SYehuda Sadeh kfree(pi->name); 610ad3b904cSXi Wang pi->name = name; 6113d14c5d2SYehuda Sadeh dout(" name is %s\n", pi->name); 6123d14c5d2SYehuda Sadeh } 6133d14c5d2SYehuda Sadeh *p += len; 6143d14c5d2SYehuda Sadeh } 6153d14c5d2SYehuda Sadeh return 0; 6163d14c5d2SYehuda Sadeh 6173d14c5d2SYehuda Sadeh bad: 6183d14c5d2SYehuda Sadeh return -EINVAL; 6193d14c5d2SYehuda Sadeh } 6203d14c5d2SYehuda Sadeh 6213d14c5d2SYehuda Sadeh /* 6223d14c5d2SYehuda Sadeh * osd map 6233d14c5d2SYehuda Sadeh */ 6243d14c5d2SYehuda Sadeh void ceph_osdmap_destroy(struct ceph_osdmap *map) 6253d14c5d2SYehuda Sadeh { 6263d14c5d2SYehuda Sadeh dout("osdmap_destroy %p\n", map); 6273d14c5d2SYehuda Sadeh if (map->crush) 6283d14c5d2SYehuda Sadeh crush_destroy(map->crush); 6293d14c5d2SYehuda Sadeh while (!RB_EMPTY_ROOT(&map->pg_temp)) { 6303d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg = 6313d14c5d2SYehuda Sadeh rb_entry(rb_first(&map->pg_temp), 6323d14c5d2SYehuda Sadeh struct ceph_pg_mapping, node); 6333d14c5d2SYehuda Sadeh rb_erase(&pg->node, &map->pg_temp); 6343d14c5d2SYehuda Sadeh kfree(pg); 6353d14c5d2SYehuda Sadeh } 6363d14c5d2SYehuda Sadeh while (!RB_EMPTY_ROOT(&map->pg_pools)) { 6373d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi = 6383d14c5d2SYehuda Sadeh rb_entry(rb_first(&map->pg_pools), 6393d14c5d2SYehuda Sadeh struct ceph_pg_pool_info, node); 6403d14c5d2SYehuda Sadeh __remove_pg_pool(&map->pg_pools, pi); 6413d14c5d2SYehuda Sadeh } 6423d14c5d2SYehuda Sadeh kfree(map->osd_state); 6433d14c5d2SYehuda Sadeh kfree(map->osd_weight); 6443d14c5d2SYehuda Sadeh kfree(map->osd_addr); 6453d14c5d2SYehuda Sadeh kfree(map); 6463d14c5d2SYehuda Sadeh } 6473d14c5d2SYehuda Sadeh 6483d14c5d2SYehuda Sadeh /* 6493d14c5d2SYehuda Sadeh * adjust max osd value. reallocate arrays. 6503d14c5d2SYehuda Sadeh */ 6513d14c5d2SYehuda Sadeh static int osdmap_set_max_osd(struct ceph_osdmap *map, int max) 6523d14c5d2SYehuda Sadeh { 6533d14c5d2SYehuda Sadeh u8 *state; 6543d14c5d2SYehuda Sadeh struct ceph_entity_addr *addr; 6553d14c5d2SYehuda Sadeh u32 *weight; 6563d14c5d2SYehuda Sadeh 6573d14c5d2SYehuda Sadeh state = kcalloc(max, sizeof(*state), GFP_NOFS); 6583d14c5d2SYehuda Sadeh addr = kcalloc(max, sizeof(*addr), GFP_NOFS); 6593d14c5d2SYehuda Sadeh weight = kcalloc(max, sizeof(*weight), GFP_NOFS); 6603d14c5d2SYehuda Sadeh if (state == NULL || addr == NULL || weight == NULL) { 6613d14c5d2SYehuda Sadeh kfree(state); 6623d14c5d2SYehuda Sadeh kfree(addr); 6633d14c5d2SYehuda Sadeh kfree(weight); 6643d14c5d2SYehuda Sadeh return -ENOMEM; 6653d14c5d2SYehuda Sadeh } 6663d14c5d2SYehuda Sadeh 6673d14c5d2SYehuda Sadeh /* copy old? */ 6683d14c5d2SYehuda Sadeh if (map->osd_state) { 6693d14c5d2SYehuda Sadeh memcpy(state, map->osd_state, map->max_osd*sizeof(*state)); 6703d14c5d2SYehuda Sadeh memcpy(addr, map->osd_addr, map->max_osd*sizeof(*addr)); 6713d14c5d2SYehuda Sadeh memcpy(weight, map->osd_weight, map->max_osd*sizeof(*weight)); 6723d14c5d2SYehuda Sadeh kfree(map->osd_state); 6733d14c5d2SYehuda Sadeh kfree(map->osd_addr); 6743d14c5d2SYehuda Sadeh kfree(map->osd_weight); 6753d14c5d2SYehuda Sadeh } 6763d14c5d2SYehuda Sadeh 6773d14c5d2SYehuda Sadeh map->osd_state = state; 6783d14c5d2SYehuda Sadeh map->osd_weight = weight; 6793d14c5d2SYehuda Sadeh map->osd_addr = addr; 6803d14c5d2SYehuda Sadeh map->max_osd = max; 6813d14c5d2SYehuda Sadeh return 0; 6823d14c5d2SYehuda Sadeh } 6833d14c5d2SYehuda Sadeh 684433fbdd3SIlya Dryomov static int __decode_pools(void **p, void *end, struct ceph_osdmap *map, 685433fbdd3SIlya Dryomov bool incremental) 686433fbdd3SIlya Dryomov { 687433fbdd3SIlya Dryomov u32 n; 688433fbdd3SIlya Dryomov 689433fbdd3SIlya Dryomov ceph_decode_32_safe(p, end, n, e_inval); 690433fbdd3SIlya Dryomov while (n--) { 691433fbdd3SIlya Dryomov struct ceph_pg_pool_info *pi; 692433fbdd3SIlya Dryomov u64 pool; 693433fbdd3SIlya Dryomov int ret; 694433fbdd3SIlya Dryomov 695433fbdd3SIlya Dryomov ceph_decode_64_safe(p, end, pool, e_inval); 696433fbdd3SIlya Dryomov 697433fbdd3SIlya Dryomov pi = __lookup_pg_pool(&map->pg_pools, pool); 698433fbdd3SIlya Dryomov if (!incremental || !pi) { 699433fbdd3SIlya Dryomov pi = kzalloc(sizeof(*pi), GFP_NOFS); 700433fbdd3SIlya Dryomov if (!pi) 701433fbdd3SIlya Dryomov return -ENOMEM; 702433fbdd3SIlya Dryomov 703433fbdd3SIlya Dryomov pi->id = pool; 704433fbdd3SIlya Dryomov 705433fbdd3SIlya Dryomov ret = __insert_pg_pool(&map->pg_pools, pi); 706433fbdd3SIlya Dryomov if (ret) { 707433fbdd3SIlya Dryomov kfree(pi); 708433fbdd3SIlya Dryomov return ret; 709433fbdd3SIlya Dryomov } 710433fbdd3SIlya Dryomov } 711433fbdd3SIlya Dryomov 712433fbdd3SIlya Dryomov ret = decode_pool(p, end, pi); 713433fbdd3SIlya Dryomov if (ret) 714433fbdd3SIlya Dryomov return ret; 715433fbdd3SIlya Dryomov } 716433fbdd3SIlya Dryomov 717433fbdd3SIlya Dryomov return 0; 718433fbdd3SIlya Dryomov 719433fbdd3SIlya Dryomov e_inval: 720433fbdd3SIlya Dryomov return -EINVAL; 721433fbdd3SIlya Dryomov } 722433fbdd3SIlya Dryomov 723433fbdd3SIlya Dryomov static int decode_pools(void **p, void *end, struct ceph_osdmap *map) 724433fbdd3SIlya Dryomov { 725433fbdd3SIlya Dryomov return __decode_pools(p, end, map, false); 726433fbdd3SIlya Dryomov } 727433fbdd3SIlya Dryomov 728433fbdd3SIlya Dryomov static int decode_new_pools(void **p, void *end, struct ceph_osdmap *map) 729433fbdd3SIlya Dryomov { 730433fbdd3SIlya Dryomov return __decode_pools(p, end, map, true); 731433fbdd3SIlya Dryomov } 732433fbdd3SIlya Dryomov 7333d14c5d2SYehuda Sadeh /* 7343d14c5d2SYehuda Sadeh * decode a full map. 7353d14c5d2SYehuda Sadeh */ 736a2505d63SIlya Dryomov static int osdmap_decode(void **p, void *end, struct ceph_osdmap *map) 7373d14c5d2SYehuda Sadeh { 7383d14c5d2SYehuda Sadeh u16 version; 73938a8d560SIlya Dryomov u32 epoch = 0; 7403d14c5d2SYehuda Sadeh void *start = *p; 7413977058cSIlya Dryomov u32 max; 7423977058cSIlya Dryomov u32 len, i; 743597b52f6SIlya Dryomov int err; 7443d14c5d2SYehuda Sadeh 745a2505d63SIlya Dryomov dout("%s %p to %p len %d\n", __func__, *p, end, (int)(end - *p)); 7463d14c5d2SYehuda Sadeh 747597b52f6SIlya Dryomov ceph_decode_16_safe(p, end, version, e_inval); 7484f6a7e5eSSage Weil if (version > 6) { 7494f6a7e5eSSage Weil pr_warning("got unknown v %d > 6 of osdmap\n", version); 750597b52f6SIlya Dryomov goto e_inval; 7514f6a7e5eSSage Weil } 7524f6a7e5eSSage Weil if (version < 6) { 7534f6a7e5eSSage Weil pr_warning("got old v %d < 6 of osdmap\n", version); 754597b52f6SIlya Dryomov goto e_inval; 7553d14c5d2SYehuda Sadeh } 7563d14c5d2SYehuda Sadeh 75753bbaba9SIlya Dryomov /* fsid, epoch, created, modified */ 75853bbaba9SIlya Dryomov ceph_decode_need(p, end, sizeof(map->fsid) + sizeof(u32) + 75953bbaba9SIlya Dryomov sizeof(map->created) + sizeof(map->modified), e_inval); 7603d14c5d2SYehuda Sadeh ceph_decode_copy(p, &map->fsid, sizeof(map->fsid)); 76138a8d560SIlya Dryomov epoch = map->epoch = ceph_decode_32(p); 7623d14c5d2SYehuda Sadeh ceph_decode_copy(p, &map->created, sizeof(map->created)); 7633d14c5d2SYehuda Sadeh ceph_decode_copy(p, &map->modified, sizeof(map->modified)); 7643d14c5d2SYehuda Sadeh 765433fbdd3SIlya Dryomov /* pools */ 766433fbdd3SIlya Dryomov err = decode_pools(p, end, map); 767433fbdd3SIlya Dryomov if (err) 7683d14c5d2SYehuda Sadeh goto bad; 7693d14c5d2SYehuda Sadeh 7700f70c7eeSIlya Dryomov /* pool_name */ 7710f70c7eeSIlya Dryomov err = decode_pool_names(p, end, map); 772597b52f6SIlya Dryomov if (err) 7733d14c5d2SYehuda Sadeh goto bad; 7743d14c5d2SYehuda Sadeh 775597b52f6SIlya Dryomov ceph_decode_32_safe(p, end, map->pool_max, e_inval); 7763d14c5d2SYehuda Sadeh 777597b52f6SIlya Dryomov ceph_decode_32_safe(p, end, map->flags, e_inval); 7783d14c5d2SYehuda Sadeh 7793977058cSIlya Dryomov /* max_osd */ 7803977058cSIlya Dryomov ceph_decode_32_safe(p, end, max, e_inval); 7813d14c5d2SYehuda Sadeh 7823d14c5d2SYehuda Sadeh /* (re)alloc osd arrays */ 7833d14c5d2SYehuda Sadeh err = osdmap_set_max_osd(map, max); 784597b52f6SIlya Dryomov if (err) 7853d14c5d2SYehuda Sadeh goto bad; 7863d14c5d2SYehuda Sadeh 7872d88b2e0SIlya Dryomov /* osd_state, osd_weight, osd_addrs->client_addr */ 7883d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 3*sizeof(u32) + 7893d14c5d2SYehuda Sadeh map->max_osd*(1 + sizeof(*map->osd_weight) + 790597b52f6SIlya Dryomov sizeof(*map->osd_addr)), e_inval); 791597b52f6SIlya Dryomov 7922d88b2e0SIlya Dryomov if (ceph_decode_32(p) != map->max_osd) 7932d88b2e0SIlya Dryomov goto e_inval; 7942d88b2e0SIlya Dryomov 7953d14c5d2SYehuda Sadeh ceph_decode_copy(p, map->osd_state, map->max_osd); 7963d14c5d2SYehuda Sadeh 7972d88b2e0SIlya Dryomov if (ceph_decode_32(p) != map->max_osd) 7982d88b2e0SIlya Dryomov goto e_inval; 7992d88b2e0SIlya Dryomov 8003d14c5d2SYehuda Sadeh for (i = 0; i < map->max_osd; i++) 8013d14c5d2SYehuda Sadeh map->osd_weight[i] = ceph_decode_32(p); 8023d14c5d2SYehuda Sadeh 8032d88b2e0SIlya Dryomov if (ceph_decode_32(p) != map->max_osd) 8042d88b2e0SIlya Dryomov goto e_inval; 8052d88b2e0SIlya Dryomov 8063d14c5d2SYehuda Sadeh ceph_decode_copy(p, map->osd_addr, map->max_osd*sizeof(*map->osd_addr)); 8073d14c5d2SYehuda Sadeh for (i = 0; i < map->max_osd; i++) 8083d14c5d2SYehuda Sadeh ceph_decode_addr(&map->osd_addr[i]); 8093d14c5d2SYehuda Sadeh 8103d14c5d2SYehuda Sadeh /* pg_temp */ 811597b52f6SIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 8123d14c5d2SYehuda Sadeh for (i = 0; i < len; i++) { 8133d14c5d2SYehuda Sadeh int n, j; 8145b191d99SSage Weil struct ceph_pg pgid; 8153d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg; 8163d14c5d2SYehuda Sadeh 817ef4859d6SAlex Elder err = ceph_decode_pgid(p, end, &pgid); 818d6c0dd6bSSage Weil if (err) 819d6c0dd6bSSage Weil goto bad; 820597b52f6SIlya Dryomov ceph_decode_need(p, end, sizeof(u32), e_inval); 8213d14c5d2SYehuda Sadeh n = ceph_decode_32(p); 822e91a9b63SXi Wang if (n > (UINT_MAX - sizeof(*pg)) / sizeof(u32)) 823597b52f6SIlya Dryomov goto e_inval; 824597b52f6SIlya Dryomov ceph_decode_need(p, end, n * sizeof(u32), e_inval); 8253d14c5d2SYehuda Sadeh pg = kmalloc(sizeof(*pg) + n*sizeof(u32), GFP_NOFS); 826597b52f6SIlya Dryomov if (!pg) { 827597b52f6SIlya Dryomov err = -ENOMEM; 8283d14c5d2SYehuda Sadeh goto bad; 829597b52f6SIlya Dryomov } 8303d14c5d2SYehuda Sadeh pg->pgid = pgid; 8313d14c5d2SYehuda Sadeh pg->len = n; 8323d14c5d2SYehuda Sadeh for (j = 0; j < n; j++) 8333d14c5d2SYehuda Sadeh pg->osds[j] = ceph_decode_32(p); 8343d14c5d2SYehuda Sadeh 8353d14c5d2SYehuda Sadeh err = __insert_pg_mapping(pg, &map->pg_temp); 8363d14c5d2SYehuda Sadeh if (err) 8373d14c5d2SYehuda Sadeh goto bad; 8385b191d99SSage Weil dout(" added pg_temp %lld.%x len %d\n", pgid.pool, pgid.seed, 8395b191d99SSage Weil len); 8403d14c5d2SYehuda Sadeh } 8413d14c5d2SYehuda Sadeh 8423d14c5d2SYehuda Sadeh /* crush */ 843597b52f6SIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 8449902e682SIlya Dryomov map->crush = crush_decode(*p, min(*p + len, end)); 8453d14c5d2SYehuda Sadeh if (IS_ERR(map->crush)) { 8463d14c5d2SYehuda Sadeh err = PTR_ERR(map->crush); 8473d14c5d2SYehuda Sadeh map->crush = NULL; 8483d14c5d2SYehuda Sadeh goto bad; 8493d14c5d2SYehuda Sadeh } 8509902e682SIlya Dryomov *p += len; 8513d14c5d2SYehuda Sadeh 85238a8d560SIlya Dryomov /* ignore the rest */ 8533d14c5d2SYehuda Sadeh *p = end; 8543d14c5d2SYehuda Sadeh 85538a8d560SIlya Dryomov dout("full osdmap epoch %d max_osd %d\n", map->epoch, map->max_osd); 856a2505d63SIlya Dryomov return 0; 8573d14c5d2SYehuda Sadeh 858597b52f6SIlya Dryomov e_inval: 859597b52f6SIlya Dryomov err = -EINVAL; 8603d14c5d2SYehuda Sadeh bad: 86138a8d560SIlya Dryomov pr_err("corrupt full osdmap (%d) epoch %d off %d (%p of %p-%p)\n", 86238a8d560SIlya Dryomov err, epoch, (int)(*p - start), *p, start, end); 86338a8d560SIlya Dryomov print_hex_dump(KERN_DEBUG, "osdmap: ", 86438a8d560SIlya Dryomov DUMP_PREFIX_OFFSET, 16, 1, 86538a8d560SIlya Dryomov start, end - start, true); 866a2505d63SIlya Dryomov return err; 867a2505d63SIlya Dryomov } 868a2505d63SIlya Dryomov 869a2505d63SIlya Dryomov /* 870a2505d63SIlya Dryomov * Allocate and decode a full map. 871a2505d63SIlya Dryomov */ 872a2505d63SIlya Dryomov struct ceph_osdmap *ceph_osdmap_decode(void **p, void *end) 873a2505d63SIlya Dryomov { 874a2505d63SIlya Dryomov struct ceph_osdmap *map; 875a2505d63SIlya Dryomov int ret; 876a2505d63SIlya Dryomov 877a2505d63SIlya Dryomov map = kzalloc(sizeof(*map), GFP_NOFS); 878a2505d63SIlya Dryomov if (!map) 879a2505d63SIlya Dryomov return ERR_PTR(-ENOMEM); 880a2505d63SIlya Dryomov 881a2505d63SIlya Dryomov map->pg_temp = RB_ROOT; 882a2505d63SIlya Dryomov mutex_init(&map->crush_scratch_mutex); 883a2505d63SIlya Dryomov 884a2505d63SIlya Dryomov ret = osdmap_decode(p, end, map); 885a2505d63SIlya Dryomov if (ret) { 8863d14c5d2SYehuda Sadeh ceph_osdmap_destroy(map); 887a2505d63SIlya Dryomov return ERR_PTR(ret); 888a2505d63SIlya Dryomov } 889a2505d63SIlya Dryomov 890a2505d63SIlya Dryomov return map; 8913d14c5d2SYehuda Sadeh } 8923d14c5d2SYehuda Sadeh 8933d14c5d2SYehuda Sadeh /* 8943d14c5d2SYehuda Sadeh * decode and apply an incremental map update. 8953d14c5d2SYehuda Sadeh */ 8963d14c5d2SYehuda Sadeh struct ceph_osdmap *osdmap_apply_incremental(void **p, void *end, 8973d14c5d2SYehuda Sadeh struct ceph_osdmap *map, 8983d14c5d2SYehuda Sadeh struct ceph_messenger *msgr) 8993d14c5d2SYehuda Sadeh { 9003d14c5d2SYehuda Sadeh struct crush_map *newcrush = NULL; 9013d14c5d2SYehuda Sadeh struct ceph_fsid fsid; 9023d14c5d2SYehuda Sadeh u32 epoch = 0; 9033d14c5d2SYehuda Sadeh struct ceph_timespec modified; 9044f6a7e5eSSage Weil s32 len; 9054f6a7e5eSSage Weil u64 pool; 9064f6a7e5eSSage Weil __s64 new_pool_max; 9074f6a7e5eSSage Weil __s32 new_flags, max; 9083d14c5d2SYehuda Sadeh void *start = *p; 90986f1742bSIlya Dryomov int err; 9103d14c5d2SYehuda Sadeh u16 version; 9113d14c5d2SYehuda Sadeh 91238a8d560SIlya Dryomov dout("%s %p to %p len %d\n", __func__, *p, end, (int)(end - *p)); 91338a8d560SIlya Dryomov 91486f1742bSIlya Dryomov ceph_decode_16_safe(p, end, version, e_inval); 915d6c0dd6bSSage Weil if (version != 6) { 916d6c0dd6bSSage Weil pr_warning("got unknown v %d != 6 of inc osdmap\n", version); 91786f1742bSIlya Dryomov goto e_inval; 9183d14c5d2SYehuda Sadeh } 9193d14c5d2SYehuda Sadeh 92053bbaba9SIlya Dryomov /* fsid, epoch, modified, new_pool_max, new_flags */ 92153bbaba9SIlya Dryomov ceph_decode_need(p, end, sizeof(fsid) + sizeof(u32) + sizeof(modified) + 92253bbaba9SIlya Dryomov sizeof(u64) + sizeof(u32), e_inval); 9233d14c5d2SYehuda Sadeh ceph_decode_copy(p, &fsid, sizeof(fsid)); 9243d14c5d2SYehuda Sadeh epoch = ceph_decode_32(p); 9253d14c5d2SYehuda Sadeh BUG_ON(epoch != map->epoch+1); 9263d14c5d2SYehuda Sadeh ceph_decode_copy(p, &modified, sizeof(modified)); 9274f6a7e5eSSage Weil new_pool_max = ceph_decode_64(p); 9283d14c5d2SYehuda Sadeh new_flags = ceph_decode_32(p); 9293d14c5d2SYehuda Sadeh 9303d14c5d2SYehuda Sadeh /* full map? */ 93186f1742bSIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 9323d14c5d2SYehuda Sadeh if (len > 0) { 9333d14c5d2SYehuda Sadeh dout("apply_incremental full map len %d, %p to %p\n", 9343d14c5d2SYehuda Sadeh len, *p, end); 935a2505d63SIlya Dryomov return ceph_osdmap_decode(p, min(*p+len, end)); 9363d14c5d2SYehuda Sadeh } 9373d14c5d2SYehuda Sadeh 9383d14c5d2SYehuda Sadeh /* new crush? */ 93986f1742bSIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 9403d14c5d2SYehuda Sadeh if (len > 0) { 9413d14c5d2SYehuda Sadeh newcrush = crush_decode(*p, min(*p+len, end)); 94286f1742bSIlya Dryomov if (IS_ERR(newcrush)) { 94386f1742bSIlya Dryomov err = PTR_ERR(newcrush); 94486f1742bSIlya Dryomov newcrush = NULL; 94586f1742bSIlya Dryomov goto bad; 94686f1742bSIlya Dryomov } 9473d14c5d2SYehuda Sadeh *p += len; 9483d14c5d2SYehuda Sadeh } 9493d14c5d2SYehuda Sadeh 9503d14c5d2SYehuda Sadeh /* new flags? */ 9513d14c5d2SYehuda Sadeh if (new_flags >= 0) 9523d14c5d2SYehuda Sadeh map->flags = new_flags; 9533d14c5d2SYehuda Sadeh if (new_pool_max >= 0) 9543d14c5d2SYehuda Sadeh map->pool_max = new_pool_max; 9553d14c5d2SYehuda Sadeh 9563d14c5d2SYehuda Sadeh /* new max? */ 95753bbaba9SIlya Dryomov ceph_decode_32_safe(p, end, max, e_inval); 9583d14c5d2SYehuda Sadeh if (max >= 0) { 9593d14c5d2SYehuda Sadeh err = osdmap_set_max_osd(map, max); 96086f1742bSIlya Dryomov if (err) 9613d14c5d2SYehuda Sadeh goto bad; 9623d14c5d2SYehuda Sadeh } 9633d14c5d2SYehuda Sadeh 9643d14c5d2SYehuda Sadeh map->epoch++; 96531456665SSage Weil map->modified = modified; 9663d14c5d2SYehuda Sadeh if (newcrush) { 9673d14c5d2SYehuda Sadeh if (map->crush) 9683d14c5d2SYehuda Sadeh crush_destroy(map->crush); 9693d14c5d2SYehuda Sadeh map->crush = newcrush; 9703d14c5d2SYehuda Sadeh newcrush = NULL; 9713d14c5d2SYehuda Sadeh } 9723d14c5d2SYehuda Sadeh 973433fbdd3SIlya Dryomov /* new_pools */ 974433fbdd3SIlya Dryomov err = decode_new_pools(p, end, map); 975433fbdd3SIlya Dryomov if (err) 9763d14c5d2SYehuda Sadeh goto bad; 9779464d008SIlya Dryomov 9780f70c7eeSIlya Dryomov /* new_pool_names */ 9790f70c7eeSIlya Dryomov err = decode_pool_names(p, end, map); 98086f1742bSIlya Dryomov if (err) 9813d14c5d2SYehuda Sadeh goto bad; 9823d14c5d2SYehuda Sadeh 9833d14c5d2SYehuda Sadeh /* old_pool */ 98486f1742bSIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 9853d14c5d2SYehuda Sadeh while (len--) { 9863d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi; 9873d14c5d2SYehuda Sadeh 98886f1742bSIlya Dryomov ceph_decode_64_safe(p, end, pool, e_inval); 9893d14c5d2SYehuda Sadeh pi = __lookup_pg_pool(&map->pg_pools, pool); 9903d14c5d2SYehuda Sadeh if (pi) 9913d14c5d2SYehuda Sadeh __remove_pg_pool(&map->pg_pools, pi); 9923d14c5d2SYehuda Sadeh } 9933d14c5d2SYehuda Sadeh 9943d14c5d2SYehuda Sadeh /* new_up */ 99586f1742bSIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 9963d14c5d2SYehuda Sadeh while (len--) { 9973d14c5d2SYehuda Sadeh u32 osd; 9983d14c5d2SYehuda Sadeh struct ceph_entity_addr addr; 99986f1742bSIlya Dryomov ceph_decode_32_safe(p, end, osd, e_inval); 100086f1742bSIlya Dryomov ceph_decode_copy_safe(p, end, &addr, sizeof(addr), e_inval); 10013d14c5d2SYehuda Sadeh ceph_decode_addr(&addr); 10023d14c5d2SYehuda Sadeh pr_info("osd%d up\n", osd); 10033d14c5d2SYehuda Sadeh BUG_ON(osd >= map->max_osd); 10043d14c5d2SYehuda Sadeh map->osd_state[osd] |= CEPH_OSD_UP; 10053d14c5d2SYehuda Sadeh map->osd_addr[osd] = addr; 10063d14c5d2SYehuda Sadeh } 10073d14c5d2SYehuda Sadeh 10087662d8ffSSage Weil /* new_state */ 100986f1742bSIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 10103d14c5d2SYehuda Sadeh while (len--) { 10113d14c5d2SYehuda Sadeh u32 osd; 10127662d8ffSSage Weil u8 xorstate; 101386f1742bSIlya Dryomov ceph_decode_32_safe(p, end, osd, e_inval); 10147662d8ffSSage Weil xorstate = **(u8 **)p; 10153d14c5d2SYehuda Sadeh (*p)++; /* clean flag */ 10167662d8ffSSage Weil if (xorstate == 0) 10177662d8ffSSage Weil xorstate = CEPH_OSD_UP; 10187662d8ffSSage Weil if (xorstate & CEPH_OSD_UP) 10193d14c5d2SYehuda Sadeh pr_info("osd%d down\n", osd); 10203d14c5d2SYehuda Sadeh if (osd < map->max_osd) 10217662d8ffSSage Weil map->osd_state[osd] ^= xorstate; 10223d14c5d2SYehuda Sadeh } 10233d14c5d2SYehuda Sadeh 10243d14c5d2SYehuda Sadeh /* new_weight */ 102586f1742bSIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 10263d14c5d2SYehuda Sadeh while (len--) { 10273d14c5d2SYehuda Sadeh u32 osd, off; 102886f1742bSIlya Dryomov ceph_decode_need(p, end, sizeof(u32)*2, e_inval); 10293d14c5d2SYehuda Sadeh osd = ceph_decode_32(p); 10303d14c5d2SYehuda Sadeh off = ceph_decode_32(p); 10313d14c5d2SYehuda Sadeh pr_info("osd%d weight 0x%x %s\n", osd, off, 10323d14c5d2SYehuda Sadeh off == CEPH_OSD_IN ? "(in)" : 10333d14c5d2SYehuda Sadeh (off == CEPH_OSD_OUT ? "(out)" : "")); 10343d14c5d2SYehuda Sadeh if (osd < map->max_osd) 10353d14c5d2SYehuda Sadeh map->osd_weight[osd] = off; 10363d14c5d2SYehuda Sadeh } 10373d14c5d2SYehuda Sadeh 10383d14c5d2SYehuda Sadeh /* new_pg_temp */ 103986f1742bSIlya Dryomov ceph_decode_32_safe(p, end, len, e_inval); 10403d14c5d2SYehuda Sadeh while (len--) { 10413d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg; 10423d14c5d2SYehuda Sadeh int j; 10435b191d99SSage Weil struct ceph_pg pgid; 10443d14c5d2SYehuda Sadeh u32 pglen; 10453d14c5d2SYehuda Sadeh 1046ef4859d6SAlex Elder err = ceph_decode_pgid(p, end, &pgid); 1047d6c0dd6bSSage Weil if (err) 1048d6c0dd6bSSage Weil goto bad; 104986f1742bSIlya Dryomov ceph_decode_need(p, end, sizeof(u32), e_inval); 1050d6c0dd6bSSage Weil pglen = ceph_decode_32(p); 10513d14c5d2SYehuda Sadeh if (pglen) { 105286f1742bSIlya Dryomov ceph_decode_need(p, end, pglen*sizeof(u32), e_inval); 10536bd9adbdSSage Weil 10546bd9adbdSSage Weil /* removing existing (if any) */ 10556bd9adbdSSage Weil (void) __remove_pg_mapping(&map->pg_temp, pgid); 10566bd9adbdSSage Weil 10576bd9adbdSSage Weil /* insert */ 10580ed7285eSSage Weil if (pglen > (UINT_MAX - sizeof(*pg)) / sizeof(u32)) 105986f1742bSIlya Dryomov goto e_inval; 10600ed7285eSSage Weil pg = kmalloc(sizeof(*pg) + sizeof(u32)*pglen, GFP_NOFS); 106186f1742bSIlya Dryomov if (!pg) { 106286f1742bSIlya Dryomov err = -ENOMEM; 10633d14c5d2SYehuda Sadeh goto bad; 106486f1742bSIlya Dryomov } 10653d14c5d2SYehuda Sadeh pg->pgid = pgid; 10663d14c5d2SYehuda Sadeh pg->len = pglen; 10673d14c5d2SYehuda Sadeh for (j = 0; j < pglen; j++) 10683d14c5d2SYehuda Sadeh pg->osds[j] = ceph_decode_32(p); 10693d14c5d2SYehuda Sadeh err = __insert_pg_mapping(pg, &map->pg_temp); 10703d14c5d2SYehuda Sadeh if (err) { 10713d14c5d2SYehuda Sadeh kfree(pg); 10723d14c5d2SYehuda Sadeh goto bad; 10733d14c5d2SYehuda Sadeh } 10745b191d99SSage Weil dout(" added pg_temp %lld.%x len %d\n", pgid.pool, 10755b191d99SSage Weil pgid.seed, pglen); 10768adc8b3dSSage Weil } else { 10778adc8b3dSSage Weil /* remove */ 10788adc8b3dSSage Weil __remove_pg_mapping(&map->pg_temp, pgid); 10793d14c5d2SYehuda Sadeh } 10803d14c5d2SYehuda Sadeh } 10813d14c5d2SYehuda Sadeh 10823d14c5d2SYehuda Sadeh /* ignore the rest */ 10833d14c5d2SYehuda Sadeh *p = end; 108438a8d560SIlya Dryomov 108538a8d560SIlya Dryomov dout("inc osdmap epoch %d max_osd %d\n", map->epoch, map->max_osd); 10863d14c5d2SYehuda Sadeh return map; 10873d14c5d2SYehuda Sadeh 108886f1742bSIlya Dryomov e_inval: 108986f1742bSIlya Dryomov err = -EINVAL; 10903d14c5d2SYehuda Sadeh bad: 109138a8d560SIlya Dryomov pr_err("corrupt inc osdmap (%d) epoch %d off %d (%p of %p-%p)\n", 109238a8d560SIlya Dryomov err, epoch, (int)(*p - start), *p, start, end); 10933d14c5d2SYehuda Sadeh print_hex_dump(KERN_DEBUG, "osdmap: ", 10943d14c5d2SYehuda Sadeh DUMP_PREFIX_OFFSET, 16, 1, 10953d14c5d2SYehuda Sadeh start, end - start, true); 10963d14c5d2SYehuda Sadeh if (newcrush) 10973d14c5d2SYehuda Sadeh crush_destroy(newcrush); 10983d14c5d2SYehuda Sadeh return ERR_PTR(err); 10993d14c5d2SYehuda Sadeh } 11003d14c5d2SYehuda Sadeh 11013d14c5d2SYehuda Sadeh 11023d14c5d2SYehuda Sadeh 11033d14c5d2SYehuda Sadeh 11043d14c5d2SYehuda Sadeh /* 11053d14c5d2SYehuda Sadeh * calculate file layout from given offset, length. 11063d14c5d2SYehuda Sadeh * fill in correct oid, logical length, and object extent 11073d14c5d2SYehuda Sadeh * offset, length. 11083d14c5d2SYehuda Sadeh * 11093d14c5d2SYehuda Sadeh * for now, we write only a single su, until we can 11103d14c5d2SYehuda Sadeh * pass a stride back to the caller. 11113d14c5d2SYehuda Sadeh */ 1112d63b77f4SSage Weil int ceph_calc_file_object_mapping(struct ceph_file_layout *layout, 1113e8afad65SAlex Elder u64 off, u64 len, 11143d14c5d2SYehuda Sadeh u64 *ono, 11153d14c5d2SYehuda Sadeh u64 *oxoff, u64 *oxlen) 11163d14c5d2SYehuda Sadeh { 11173d14c5d2SYehuda Sadeh u32 osize = le32_to_cpu(layout->fl_object_size); 11183d14c5d2SYehuda Sadeh u32 su = le32_to_cpu(layout->fl_stripe_unit); 11193d14c5d2SYehuda Sadeh u32 sc = le32_to_cpu(layout->fl_stripe_count); 11203d14c5d2SYehuda Sadeh u32 bl, stripeno, stripepos, objsetno; 11213d14c5d2SYehuda Sadeh u32 su_per_object; 11223d14c5d2SYehuda Sadeh u64 t, su_offset; 11233d14c5d2SYehuda Sadeh 1124e8afad65SAlex Elder dout("mapping %llu~%llu osize %u fl_su %u\n", off, len, 11253d14c5d2SYehuda Sadeh osize, su); 1126d63b77f4SSage Weil if (su == 0 || sc == 0) 1127d63b77f4SSage Weil goto invalid; 11283d14c5d2SYehuda Sadeh su_per_object = osize / su; 1129d63b77f4SSage Weil if (su_per_object == 0) 1130d63b77f4SSage Weil goto invalid; 11313d14c5d2SYehuda Sadeh dout("osize %u / su %u = su_per_object %u\n", osize, su, 11323d14c5d2SYehuda Sadeh su_per_object); 11333d14c5d2SYehuda Sadeh 1134d63b77f4SSage Weil if ((su & ~PAGE_MASK) != 0) 1135d63b77f4SSage Weil goto invalid; 1136d63b77f4SSage Weil 11373d14c5d2SYehuda Sadeh /* bl = *off / su; */ 11383d14c5d2SYehuda Sadeh t = off; 11393d14c5d2SYehuda Sadeh do_div(t, su); 11403d14c5d2SYehuda Sadeh bl = t; 11413d14c5d2SYehuda Sadeh dout("off %llu / su %u = bl %u\n", off, su, bl); 11423d14c5d2SYehuda Sadeh 11433d14c5d2SYehuda Sadeh stripeno = bl / sc; 11443d14c5d2SYehuda Sadeh stripepos = bl % sc; 11453d14c5d2SYehuda Sadeh objsetno = stripeno / su_per_object; 11463d14c5d2SYehuda Sadeh 11473d14c5d2SYehuda Sadeh *ono = objsetno * sc + stripepos; 114895c96174SEric Dumazet dout("objset %u * sc %u = ono %u\n", objsetno, sc, (unsigned int)*ono); 11493d14c5d2SYehuda Sadeh 11503d14c5d2SYehuda Sadeh /* *oxoff = *off % layout->fl_stripe_unit; # offset in su */ 11513d14c5d2SYehuda Sadeh t = off; 11523d14c5d2SYehuda Sadeh su_offset = do_div(t, su); 11533d14c5d2SYehuda Sadeh *oxoff = su_offset + (stripeno % su_per_object) * su; 11543d14c5d2SYehuda Sadeh 11553d14c5d2SYehuda Sadeh /* 11563d14c5d2SYehuda Sadeh * Calculate the length of the extent being written to the selected 1157e8afad65SAlex Elder * object. This is the minimum of the full length requested (len) or 11583d14c5d2SYehuda Sadeh * the remainder of the current stripe being written to. 11593d14c5d2SYehuda Sadeh */ 1160e8afad65SAlex Elder *oxlen = min_t(u64, len, su - su_offset); 11613d14c5d2SYehuda Sadeh 11623d14c5d2SYehuda Sadeh dout(" obj extent %llu~%llu\n", *oxoff, *oxlen); 1163d63b77f4SSage Weil return 0; 1164d63b77f4SSage Weil 1165d63b77f4SSage Weil invalid: 1166d63b77f4SSage Weil dout(" invalid layout\n"); 1167d63b77f4SSage Weil *ono = 0; 1168d63b77f4SSage Weil *oxoff = 0; 1169d63b77f4SSage Weil *oxlen = 0; 1170d63b77f4SSage Weil return -EINVAL; 11713d14c5d2SYehuda Sadeh } 11723d14c5d2SYehuda Sadeh EXPORT_SYMBOL(ceph_calc_file_object_mapping); 11733d14c5d2SYehuda Sadeh 11743d14c5d2SYehuda Sadeh /* 11757c13cb64SIlya Dryomov * Calculate mapping of a (oloc, oid) pair to a PG. Should only be 11767c13cb64SIlya Dryomov * called with target's (oloc, oid), since tiering isn't taken into 11777c13cb64SIlya Dryomov * account. 11783d14c5d2SYehuda Sadeh */ 11797c13cb64SIlya Dryomov int ceph_oloc_oid_to_pg(struct ceph_osdmap *osdmap, 11807c13cb64SIlya Dryomov struct ceph_object_locator *oloc, 11817c13cb64SIlya Dryomov struct ceph_object_id *oid, 11827c13cb64SIlya Dryomov struct ceph_pg *pg_out) 11833d14c5d2SYehuda Sadeh { 11847c13cb64SIlya Dryomov struct ceph_pg_pool_info *pi; 11853d14c5d2SYehuda Sadeh 11867c13cb64SIlya Dryomov pi = __lookup_pg_pool(&osdmap->pg_pools, oloc->pool); 11877c13cb64SIlya Dryomov if (!pi) 11883d14c5d2SYehuda Sadeh return -EIO; 11893d14c5d2SYehuda Sadeh 11907c13cb64SIlya Dryomov pg_out->pool = oloc->pool; 11917c13cb64SIlya Dryomov pg_out->seed = ceph_str_hash(pi->object_hash, oid->name, 11927c13cb64SIlya Dryomov oid->name_len); 11937c13cb64SIlya Dryomov 11947c13cb64SIlya Dryomov dout("%s '%.*s' pgid %llu.%x\n", __func__, oid->name_len, oid->name, 11957c13cb64SIlya Dryomov pg_out->pool, pg_out->seed); 11963d14c5d2SYehuda Sadeh return 0; 11973d14c5d2SYehuda Sadeh } 11987c13cb64SIlya Dryomov EXPORT_SYMBOL(ceph_oloc_oid_to_pg); 11993d14c5d2SYehuda Sadeh 12009d521470SIlya Dryomov static int do_crush(struct ceph_osdmap *map, int ruleno, int x, 1201e8ef19c4SIlya Dryomov int *result, int result_max, 1202e8ef19c4SIlya Dryomov const __u32 *weight, int weight_max) 1203e8ef19c4SIlya Dryomov { 12049d521470SIlya Dryomov int r; 1205e8ef19c4SIlya Dryomov 12069d521470SIlya Dryomov BUG_ON(result_max > CEPH_PG_MAX_SIZE); 12079d521470SIlya Dryomov 12089d521470SIlya Dryomov mutex_lock(&map->crush_scratch_mutex); 12099d521470SIlya Dryomov r = crush_do_rule(map->crush, ruleno, x, result, result_max, 12109d521470SIlya Dryomov weight, weight_max, map->crush_scratch_ary); 12119d521470SIlya Dryomov mutex_unlock(&map->crush_scratch_mutex); 12129d521470SIlya Dryomov 12139d521470SIlya Dryomov return r; 1214e8ef19c4SIlya Dryomov } 1215e8ef19c4SIlya Dryomov 12163d14c5d2SYehuda Sadeh /* 12173d14c5d2SYehuda Sadeh * Calculate raw osd vector for the given pgid. Return pointer to osd 12183d14c5d2SYehuda Sadeh * array, or NULL on failure. 12193d14c5d2SYehuda Sadeh */ 12205b191d99SSage Weil static int *calc_pg_raw(struct ceph_osdmap *osdmap, struct ceph_pg pgid, 12213d14c5d2SYehuda Sadeh int *osds, int *num) 12223d14c5d2SYehuda Sadeh { 12233d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg; 12243d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pool; 12253d14c5d2SYehuda Sadeh int ruleno; 122683ca14fdSSage Weil int r; 122783ca14fdSSage Weil u32 pps; 12283d14c5d2SYehuda Sadeh 122983ca14fdSSage Weil pool = __lookup_pg_pool(&osdmap->pg_pools, pgid.pool); 1230782e182eSSage Weil if (!pool) 1231782e182eSSage Weil return NULL; 1232782e182eSSage Weil 12333d14c5d2SYehuda Sadeh /* pg_temp? */ 123483ca14fdSSage Weil pgid.seed = ceph_stable_mod(pgid.seed, pool->pg_num, 12359542cf0bSSage Weil pool->pg_num_mask); 12363d14c5d2SYehuda Sadeh pg = __lookup_pg_mapping(&osdmap->pg_temp, pgid); 12373d14c5d2SYehuda Sadeh if (pg) { 12383d14c5d2SYehuda Sadeh *num = pg->len; 12393d14c5d2SYehuda Sadeh return pg->osds; 12403d14c5d2SYehuda Sadeh } 12413d14c5d2SYehuda Sadeh 12423d14c5d2SYehuda Sadeh /* crush */ 12434f6a7e5eSSage Weil ruleno = crush_find_rule(osdmap->crush, pool->crush_ruleset, 12444f6a7e5eSSage Weil pool->type, pool->size); 12453d14c5d2SYehuda Sadeh if (ruleno < 0) { 124683ca14fdSSage Weil pr_err("no crush rule pool %lld ruleset %d type %d size %d\n", 124783ca14fdSSage Weil pgid.pool, pool->crush_ruleset, pool->type, 12484f6a7e5eSSage Weil pool->size); 12493d14c5d2SYehuda Sadeh return NULL; 12503d14c5d2SYehuda Sadeh } 12513d14c5d2SYehuda Sadeh 125283ca14fdSSage Weil if (pool->flags & CEPH_POOL_FLAG_HASHPSPOOL) { 125383ca14fdSSage Weil /* hash pool id and seed sothat pool PGs do not overlap */ 125483ca14fdSSage Weil pps = crush_hash32_2(CRUSH_HASH_RJENKINS1, 125583ca14fdSSage Weil ceph_stable_mod(pgid.seed, pool->pgp_num, 125683ca14fdSSage Weil pool->pgp_num_mask), 125783ca14fdSSage Weil pgid.pool); 125883ca14fdSSage Weil } else { 125983ca14fdSSage Weil /* 126083ca14fdSSage Weil * legacy ehavior: add ps and pool together. this is 126183ca14fdSSage Weil * not a great approach because the PGs from each pool 126283ca14fdSSage Weil * will overlap on top of each other: 0.5 == 1.4 == 126383ca14fdSSage Weil * 2.3 == ... 126483ca14fdSSage Weil */ 126583ca14fdSSage Weil pps = ceph_stable_mod(pgid.seed, pool->pgp_num, 126683ca14fdSSage Weil pool->pgp_num_mask) + 126783ca14fdSSage Weil (unsigned)pgid.pool; 126883ca14fdSSage Weil } 12699d521470SIlya Dryomov r = do_crush(osdmap, ruleno, pps, osds, min_t(int, pool->size, *num), 1270b3b33b0eSIlya Dryomov osdmap->osd_weight, osdmap->max_osd); 12718b393269SSage Weil if (r < 0) { 127283ca14fdSSage Weil pr_err("error %d from crush rule: pool %lld ruleset %d type %d" 127383ca14fdSSage Weil " size %d\n", r, pgid.pool, pool->crush_ruleset, 12744f6a7e5eSSage Weil pool->type, pool->size); 12758b393269SSage Weil return NULL; 12768b393269SSage Weil } 12778b393269SSage Weil *num = r; 12783d14c5d2SYehuda Sadeh return osds; 12793d14c5d2SYehuda Sadeh } 12803d14c5d2SYehuda Sadeh 12813d14c5d2SYehuda Sadeh /* 12823d14c5d2SYehuda Sadeh * Return acting set for given pgid. 12833d14c5d2SYehuda Sadeh */ 12845b191d99SSage Weil int ceph_calc_pg_acting(struct ceph_osdmap *osdmap, struct ceph_pg pgid, 12853d14c5d2SYehuda Sadeh int *acting) 12863d14c5d2SYehuda Sadeh { 12873d14c5d2SYehuda Sadeh int rawosds[CEPH_PG_MAX_SIZE], *osds; 12883d14c5d2SYehuda Sadeh int i, o, num = CEPH_PG_MAX_SIZE; 12893d14c5d2SYehuda Sadeh 12903d14c5d2SYehuda Sadeh osds = calc_pg_raw(osdmap, pgid, rawosds, &num); 12913d14c5d2SYehuda Sadeh if (!osds) 12923d14c5d2SYehuda Sadeh return -1; 12933d14c5d2SYehuda Sadeh 12943d14c5d2SYehuda Sadeh /* primary is first up osd */ 12953d14c5d2SYehuda Sadeh o = 0; 12963d14c5d2SYehuda Sadeh for (i = 0; i < num; i++) 12973d14c5d2SYehuda Sadeh if (ceph_osd_is_up(osdmap, osds[i])) 12983d14c5d2SYehuda Sadeh acting[o++] = osds[i]; 12993d14c5d2SYehuda Sadeh return o; 13003d14c5d2SYehuda Sadeh } 13013d14c5d2SYehuda Sadeh 13023d14c5d2SYehuda Sadeh /* 13033d14c5d2SYehuda Sadeh * Return primary osd for given pgid, or -1 if none. 13043d14c5d2SYehuda Sadeh */ 13055b191d99SSage Weil int ceph_calc_pg_primary(struct ceph_osdmap *osdmap, struct ceph_pg pgid) 13063d14c5d2SYehuda Sadeh { 13073d14c5d2SYehuda Sadeh int rawosds[CEPH_PG_MAX_SIZE], *osds; 13083d14c5d2SYehuda Sadeh int i, num = CEPH_PG_MAX_SIZE; 13093d14c5d2SYehuda Sadeh 13103d14c5d2SYehuda Sadeh osds = calc_pg_raw(osdmap, pgid, rawosds, &num); 13113d14c5d2SYehuda Sadeh if (!osds) 13123d14c5d2SYehuda Sadeh return -1; 13133d14c5d2SYehuda Sadeh 13143d14c5d2SYehuda Sadeh /* primary is first up osd */ 13153d14c5d2SYehuda Sadeh for (i = 0; i < num; i++) 13163d14c5d2SYehuda Sadeh if (ceph_osd_is_up(osdmap, osds[i])) 13173d14c5d2SYehuda Sadeh return osds[i]; 13183d14c5d2SYehuda Sadeh return -1; 13193d14c5d2SYehuda Sadeh } 13203d14c5d2SYehuda Sadeh EXPORT_SYMBOL(ceph_calc_pg_primary); 1321