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 int flag = 0; 173d14c5d2SYehuda Sadeh 183d14c5d2SYehuda Sadeh if (!len) 193d14c5d2SYehuda Sadeh goto done; 203d14c5d2SYehuda Sadeh 213d14c5d2SYehuda Sadeh *str = '\0'; 223d14c5d2SYehuda Sadeh if (state) { 233d14c5d2SYehuda Sadeh if (state & CEPH_OSD_EXISTS) { 243d14c5d2SYehuda Sadeh snprintf(str, len, "exists"); 253d14c5d2SYehuda Sadeh flag = 1; 263d14c5d2SYehuda Sadeh } 273d14c5d2SYehuda Sadeh if (state & CEPH_OSD_UP) { 283d14c5d2SYehuda Sadeh snprintf(str, len, "%s%s%s", str, (flag ? ", " : ""), 293d14c5d2SYehuda Sadeh "up"); 303d14c5d2SYehuda Sadeh flag = 1; 313d14c5d2SYehuda Sadeh } 323d14c5d2SYehuda Sadeh } else { 333d14c5d2SYehuda Sadeh snprintf(str, len, "doesn't exist"); 343d14c5d2SYehuda Sadeh } 353d14c5d2SYehuda Sadeh done: 363d14c5d2SYehuda Sadeh return str; 373d14c5d2SYehuda Sadeh } 383d14c5d2SYehuda Sadeh 393d14c5d2SYehuda Sadeh /* maps */ 403d14c5d2SYehuda Sadeh 413d14c5d2SYehuda Sadeh static int calc_bits_of(unsigned t) 423d14c5d2SYehuda Sadeh { 433d14c5d2SYehuda Sadeh int b = 0; 443d14c5d2SYehuda Sadeh while (t) { 453d14c5d2SYehuda Sadeh t = t >> 1; 463d14c5d2SYehuda Sadeh b++; 473d14c5d2SYehuda Sadeh } 483d14c5d2SYehuda Sadeh return b; 493d14c5d2SYehuda Sadeh } 503d14c5d2SYehuda Sadeh 513d14c5d2SYehuda Sadeh /* 523d14c5d2SYehuda Sadeh * the foo_mask is the smallest value 2^n-1 that is >= foo. 533d14c5d2SYehuda Sadeh */ 543d14c5d2SYehuda Sadeh static void calc_pg_masks(struct ceph_pg_pool_info *pi) 553d14c5d2SYehuda Sadeh { 563d14c5d2SYehuda Sadeh pi->pg_num_mask = (1 << calc_bits_of(le32_to_cpu(pi->v.pg_num)-1)) - 1; 573d14c5d2SYehuda Sadeh pi->pgp_num_mask = 583d14c5d2SYehuda Sadeh (1 << calc_bits_of(le32_to_cpu(pi->v.pgp_num)-1)) - 1; 593d14c5d2SYehuda Sadeh pi->lpg_num_mask = 603d14c5d2SYehuda Sadeh (1 << calc_bits_of(le32_to_cpu(pi->v.lpg_num)-1)) - 1; 613d14c5d2SYehuda Sadeh pi->lpgp_num_mask = 623d14c5d2SYehuda Sadeh (1 << calc_bits_of(le32_to_cpu(pi->v.lpgp_num)-1)) - 1; 633d14c5d2SYehuda Sadeh } 643d14c5d2SYehuda Sadeh 653d14c5d2SYehuda Sadeh /* 663d14c5d2SYehuda Sadeh * decode crush map 673d14c5d2SYehuda Sadeh */ 683d14c5d2SYehuda Sadeh static int crush_decode_uniform_bucket(void **p, void *end, 693d14c5d2SYehuda Sadeh struct crush_bucket_uniform *b) 703d14c5d2SYehuda Sadeh { 713d14c5d2SYehuda Sadeh dout("crush_decode_uniform_bucket %p to %p\n", *p, end); 723d14c5d2SYehuda Sadeh ceph_decode_need(p, end, (1+b->h.size) * sizeof(u32), bad); 733d14c5d2SYehuda Sadeh b->item_weight = ceph_decode_32(p); 743d14c5d2SYehuda Sadeh return 0; 753d14c5d2SYehuda Sadeh bad: 763d14c5d2SYehuda Sadeh return -EINVAL; 773d14c5d2SYehuda Sadeh } 783d14c5d2SYehuda Sadeh 793d14c5d2SYehuda Sadeh static int crush_decode_list_bucket(void **p, void *end, 803d14c5d2SYehuda Sadeh struct crush_bucket_list *b) 813d14c5d2SYehuda Sadeh { 823d14c5d2SYehuda Sadeh int j; 833d14c5d2SYehuda Sadeh dout("crush_decode_list_bucket %p to %p\n", *p, end); 843d14c5d2SYehuda Sadeh b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 853d14c5d2SYehuda Sadeh if (b->item_weights == NULL) 863d14c5d2SYehuda Sadeh return -ENOMEM; 873d14c5d2SYehuda Sadeh b->sum_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 883d14c5d2SYehuda Sadeh if (b->sum_weights == NULL) 893d14c5d2SYehuda Sadeh return -ENOMEM; 903d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad); 913d14c5d2SYehuda Sadeh for (j = 0; j < b->h.size; j++) { 923d14c5d2SYehuda Sadeh b->item_weights[j] = ceph_decode_32(p); 933d14c5d2SYehuda Sadeh b->sum_weights[j] = ceph_decode_32(p); 943d14c5d2SYehuda Sadeh } 953d14c5d2SYehuda Sadeh return 0; 963d14c5d2SYehuda Sadeh bad: 973d14c5d2SYehuda Sadeh return -EINVAL; 983d14c5d2SYehuda Sadeh } 993d14c5d2SYehuda Sadeh 1003d14c5d2SYehuda Sadeh static int crush_decode_tree_bucket(void **p, void *end, 1013d14c5d2SYehuda Sadeh struct crush_bucket_tree *b) 1023d14c5d2SYehuda Sadeh { 1033d14c5d2SYehuda Sadeh int j; 1043d14c5d2SYehuda Sadeh dout("crush_decode_tree_bucket %p to %p\n", *p, end); 1053d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, b->num_nodes, bad); 1063d14c5d2SYehuda Sadeh b->node_weights = kcalloc(b->num_nodes, sizeof(u32), GFP_NOFS); 1073d14c5d2SYehuda Sadeh if (b->node_weights == NULL) 1083d14c5d2SYehuda Sadeh return -ENOMEM; 1093d14c5d2SYehuda Sadeh ceph_decode_need(p, end, b->num_nodes * sizeof(u32), bad); 1103d14c5d2SYehuda Sadeh for (j = 0; j < b->num_nodes; j++) 1113d14c5d2SYehuda Sadeh b->node_weights[j] = ceph_decode_32(p); 1123d14c5d2SYehuda Sadeh return 0; 1133d14c5d2SYehuda Sadeh bad: 1143d14c5d2SYehuda Sadeh return -EINVAL; 1153d14c5d2SYehuda Sadeh } 1163d14c5d2SYehuda Sadeh 1173d14c5d2SYehuda Sadeh static int crush_decode_straw_bucket(void **p, void *end, 1183d14c5d2SYehuda Sadeh struct crush_bucket_straw *b) 1193d14c5d2SYehuda Sadeh { 1203d14c5d2SYehuda Sadeh int j; 1213d14c5d2SYehuda Sadeh dout("crush_decode_straw_bucket %p to %p\n", *p, end); 1223d14c5d2SYehuda Sadeh b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 1233d14c5d2SYehuda Sadeh if (b->item_weights == NULL) 1243d14c5d2SYehuda Sadeh return -ENOMEM; 1253d14c5d2SYehuda Sadeh b->straws = kcalloc(b->h.size, sizeof(u32), GFP_NOFS); 1263d14c5d2SYehuda Sadeh if (b->straws == NULL) 1273d14c5d2SYehuda Sadeh return -ENOMEM; 1283d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad); 1293d14c5d2SYehuda Sadeh for (j = 0; j < b->h.size; j++) { 1303d14c5d2SYehuda Sadeh b->item_weights[j] = ceph_decode_32(p); 1313d14c5d2SYehuda Sadeh b->straws[j] = ceph_decode_32(p); 1323d14c5d2SYehuda Sadeh } 1333d14c5d2SYehuda Sadeh return 0; 1343d14c5d2SYehuda Sadeh bad: 1353d14c5d2SYehuda Sadeh return -EINVAL; 1363d14c5d2SYehuda Sadeh } 1373d14c5d2SYehuda Sadeh 1383d14c5d2SYehuda Sadeh static struct crush_map *crush_decode(void *pbyval, void *end) 1393d14c5d2SYehuda Sadeh { 1403d14c5d2SYehuda Sadeh struct crush_map *c; 1413d14c5d2SYehuda Sadeh int err = -EINVAL; 1423d14c5d2SYehuda Sadeh int i, j; 1433d14c5d2SYehuda Sadeh void **p = &pbyval; 1443d14c5d2SYehuda Sadeh void *start = pbyval; 1453d14c5d2SYehuda Sadeh u32 magic; 1463d14c5d2SYehuda Sadeh 1473d14c5d2SYehuda Sadeh dout("crush_decode %p to %p len %d\n", *p, end, (int)(end - *p)); 1483d14c5d2SYehuda Sadeh 1493d14c5d2SYehuda Sadeh c = kzalloc(sizeof(*c), GFP_NOFS); 1503d14c5d2SYehuda Sadeh if (c == NULL) 1513d14c5d2SYehuda Sadeh return ERR_PTR(-ENOMEM); 1523d14c5d2SYehuda Sadeh 1533d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 4*sizeof(u32), bad); 1543d14c5d2SYehuda Sadeh magic = ceph_decode_32(p); 1553d14c5d2SYehuda Sadeh if (magic != CRUSH_MAGIC) { 1563d14c5d2SYehuda Sadeh pr_err("crush_decode magic %x != current %x\n", 1573d14c5d2SYehuda Sadeh (unsigned)magic, (unsigned)CRUSH_MAGIC); 1583d14c5d2SYehuda Sadeh goto bad; 1593d14c5d2SYehuda Sadeh } 1603d14c5d2SYehuda Sadeh c->max_buckets = ceph_decode_32(p); 1613d14c5d2SYehuda Sadeh c->max_rules = ceph_decode_32(p); 1623d14c5d2SYehuda Sadeh c->max_devices = ceph_decode_32(p); 1633d14c5d2SYehuda Sadeh 1643d14c5d2SYehuda Sadeh c->device_parents = kcalloc(c->max_devices, sizeof(u32), GFP_NOFS); 1653d14c5d2SYehuda Sadeh if (c->device_parents == NULL) 1663d14c5d2SYehuda Sadeh goto badmem; 1673d14c5d2SYehuda Sadeh c->bucket_parents = kcalloc(c->max_buckets, sizeof(u32), GFP_NOFS); 1683d14c5d2SYehuda Sadeh if (c->bucket_parents == NULL) 1693d14c5d2SYehuda Sadeh goto badmem; 1703d14c5d2SYehuda Sadeh 1713d14c5d2SYehuda Sadeh c->buckets = kcalloc(c->max_buckets, sizeof(*c->buckets), GFP_NOFS); 1723d14c5d2SYehuda Sadeh if (c->buckets == NULL) 1733d14c5d2SYehuda Sadeh goto badmem; 1743d14c5d2SYehuda Sadeh c->rules = kcalloc(c->max_rules, sizeof(*c->rules), GFP_NOFS); 1753d14c5d2SYehuda Sadeh if (c->rules == NULL) 1763d14c5d2SYehuda Sadeh goto badmem; 1773d14c5d2SYehuda Sadeh 1783d14c5d2SYehuda Sadeh /* buckets */ 1793d14c5d2SYehuda Sadeh for (i = 0; i < c->max_buckets; i++) { 1803d14c5d2SYehuda Sadeh int size = 0; 1813d14c5d2SYehuda Sadeh u32 alg; 1823d14c5d2SYehuda Sadeh struct crush_bucket *b; 1833d14c5d2SYehuda Sadeh 1843d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, alg, bad); 1853d14c5d2SYehuda Sadeh if (alg == 0) { 1863d14c5d2SYehuda Sadeh c->buckets[i] = NULL; 1873d14c5d2SYehuda Sadeh continue; 1883d14c5d2SYehuda Sadeh } 1893d14c5d2SYehuda Sadeh dout("crush_decode bucket %d off %x %p to %p\n", 1903d14c5d2SYehuda Sadeh i, (int)(*p-start), *p, end); 1913d14c5d2SYehuda Sadeh 1923d14c5d2SYehuda Sadeh switch (alg) { 1933d14c5d2SYehuda Sadeh case CRUSH_BUCKET_UNIFORM: 1943d14c5d2SYehuda Sadeh size = sizeof(struct crush_bucket_uniform); 1953d14c5d2SYehuda Sadeh break; 1963d14c5d2SYehuda Sadeh case CRUSH_BUCKET_LIST: 1973d14c5d2SYehuda Sadeh size = sizeof(struct crush_bucket_list); 1983d14c5d2SYehuda Sadeh break; 1993d14c5d2SYehuda Sadeh case CRUSH_BUCKET_TREE: 2003d14c5d2SYehuda Sadeh size = sizeof(struct crush_bucket_tree); 2013d14c5d2SYehuda Sadeh break; 2023d14c5d2SYehuda Sadeh case CRUSH_BUCKET_STRAW: 2033d14c5d2SYehuda Sadeh size = sizeof(struct crush_bucket_straw); 2043d14c5d2SYehuda Sadeh break; 2053d14c5d2SYehuda Sadeh default: 2063d14c5d2SYehuda Sadeh err = -EINVAL; 2073d14c5d2SYehuda Sadeh goto bad; 2083d14c5d2SYehuda Sadeh } 2093d14c5d2SYehuda Sadeh BUG_ON(size == 0); 2103d14c5d2SYehuda Sadeh b = c->buckets[i] = kzalloc(size, GFP_NOFS); 2113d14c5d2SYehuda Sadeh if (b == NULL) 2123d14c5d2SYehuda Sadeh goto badmem; 2133d14c5d2SYehuda Sadeh 2143d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 4*sizeof(u32), bad); 2153d14c5d2SYehuda Sadeh b->id = ceph_decode_32(p); 2163d14c5d2SYehuda Sadeh b->type = ceph_decode_16(p); 2173d14c5d2SYehuda Sadeh b->alg = ceph_decode_8(p); 2183d14c5d2SYehuda Sadeh b->hash = ceph_decode_8(p); 2193d14c5d2SYehuda Sadeh b->weight = ceph_decode_32(p); 2203d14c5d2SYehuda Sadeh b->size = ceph_decode_32(p); 2213d14c5d2SYehuda Sadeh 2223d14c5d2SYehuda Sadeh dout("crush_decode bucket size %d off %x %p to %p\n", 2233d14c5d2SYehuda Sadeh b->size, (int)(*p-start), *p, end); 2243d14c5d2SYehuda Sadeh 2253d14c5d2SYehuda Sadeh b->items = kcalloc(b->size, sizeof(__s32), GFP_NOFS); 2263d14c5d2SYehuda Sadeh if (b->items == NULL) 2273d14c5d2SYehuda Sadeh goto badmem; 2283d14c5d2SYehuda Sadeh b->perm = kcalloc(b->size, sizeof(u32), GFP_NOFS); 2293d14c5d2SYehuda Sadeh if (b->perm == NULL) 2303d14c5d2SYehuda Sadeh goto badmem; 2313d14c5d2SYehuda Sadeh b->perm_n = 0; 2323d14c5d2SYehuda Sadeh 2333d14c5d2SYehuda Sadeh ceph_decode_need(p, end, b->size*sizeof(u32), bad); 2343d14c5d2SYehuda Sadeh for (j = 0; j < b->size; j++) 2353d14c5d2SYehuda Sadeh b->items[j] = ceph_decode_32(p); 2363d14c5d2SYehuda Sadeh 2373d14c5d2SYehuda Sadeh switch (b->alg) { 2383d14c5d2SYehuda Sadeh case CRUSH_BUCKET_UNIFORM: 2393d14c5d2SYehuda Sadeh err = crush_decode_uniform_bucket(p, end, 2403d14c5d2SYehuda Sadeh (struct crush_bucket_uniform *)b); 2413d14c5d2SYehuda Sadeh if (err < 0) 2423d14c5d2SYehuda Sadeh goto bad; 2433d14c5d2SYehuda Sadeh break; 2443d14c5d2SYehuda Sadeh case CRUSH_BUCKET_LIST: 2453d14c5d2SYehuda Sadeh err = crush_decode_list_bucket(p, end, 2463d14c5d2SYehuda Sadeh (struct crush_bucket_list *)b); 2473d14c5d2SYehuda Sadeh if (err < 0) 2483d14c5d2SYehuda Sadeh goto bad; 2493d14c5d2SYehuda Sadeh break; 2503d14c5d2SYehuda Sadeh case CRUSH_BUCKET_TREE: 2513d14c5d2SYehuda Sadeh err = crush_decode_tree_bucket(p, end, 2523d14c5d2SYehuda Sadeh (struct crush_bucket_tree *)b); 2533d14c5d2SYehuda Sadeh if (err < 0) 2543d14c5d2SYehuda Sadeh goto bad; 2553d14c5d2SYehuda Sadeh break; 2563d14c5d2SYehuda Sadeh case CRUSH_BUCKET_STRAW: 2573d14c5d2SYehuda Sadeh err = crush_decode_straw_bucket(p, end, 2583d14c5d2SYehuda Sadeh (struct crush_bucket_straw *)b); 2593d14c5d2SYehuda Sadeh if (err < 0) 2603d14c5d2SYehuda Sadeh goto bad; 2613d14c5d2SYehuda Sadeh break; 2623d14c5d2SYehuda Sadeh } 2633d14c5d2SYehuda Sadeh } 2643d14c5d2SYehuda Sadeh 2653d14c5d2SYehuda Sadeh /* rules */ 2663d14c5d2SYehuda Sadeh dout("rule vec is %p\n", c->rules); 2673d14c5d2SYehuda Sadeh for (i = 0; i < c->max_rules; i++) { 2683d14c5d2SYehuda Sadeh u32 yes; 2693d14c5d2SYehuda Sadeh struct crush_rule *r; 2703d14c5d2SYehuda Sadeh 2713d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, yes, bad); 2723d14c5d2SYehuda Sadeh if (!yes) { 2733d14c5d2SYehuda Sadeh dout("crush_decode NO rule %d off %x %p to %p\n", 2743d14c5d2SYehuda Sadeh i, (int)(*p-start), *p, end); 2753d14c5d2SYehuda Sadeh c->rules[i] = NULL; 2763d14c5d2SYehuda Sadeh continue; 2773d14c5d2SYehuda Sadeh } 2783d14c5d2SYehuda Sadeh 2793d14c5d2SYehuda Sadeh dout("crush_decode rule %d off %x %p to %p\n", 2803d14c5d2SYehuda Sadeh i, (int)(*p-start), *p, end); 2813d14c5d2SYehuda Sadeh 2823d14c5d2SYehuda Sadeh /* len */ 2833d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, yes, bad); 2843d14c5d2SYehuda Sadeh #if BITS_PER_LONG == 32 2853d14c5d2SYehuda Sadeh err = -EINVAL; 2863d14c5d2SYehuda Sadeh if (yes > ULONG_MAX / sizeof(struct crush_rule_step)) 2873d14c5d2SYehuda Sadeh goto bad; 2883d14c5d2SYehuda Sadeh #endif 2893d14c5d2SYehuda Sadeh r = c->rules[i] = kmalloc(sizeof(*r) + 2903d14c5d2SYehuda Sadeh yes*sizeof(struct crush_rule_step), 2913d14c5d2SYehuda Sadeh GFP_NOFS); 2923d14c5d2SYehuda Sadeh if (r == NULL) 2933d14c5d2SYehuda Sadeh goto badmem; 2943d14c5d2SYehuda Sadeh dout(" rule %d is at %p\n", i, r); 2953d14c5d2SYehuda Sadeh r->len = yes; 2963d14c5d2SYehuda Sadeh ceph_decode_copy_safe(p, end, &r->mask, 4, bad); /* 4 u8's */ 2973d14c5d2SYehuda Sadeh ceph_decode_need(p, end, r->len*3*sizeof(u32), bad); 2983d14c5d2SYehuda Sadeh for (j = 0; j < r->len; j++) { 2993d14c5d2SYehuda Sadeh r->steps[j].op = ceph_decode_32(p); 3003d14c5d2SYehuda Sadeh r->steps[j].arg1 = ceph_decode_32(p); 3013d14c5d2SYehuda Sadeh r->steps[j].arg2 = ceph_decode_32(p); 3023d14c5d2SYehuda Sadeh } 3033d14c5d2SYehuda Sadeh } 3043d14c5d2SYehuda Sadeh 3053d14c5d2SYehuda Sadeh /* ignore trailing name maps. */ 3063d14c5d2SYehuda Sadeh 3073d14c5d2SYehuda Sadeh dout("crush_decode success\n"); 3083d14c5d2SYehuda Sadeh return c; 3093d14c5d2SYehuda Sadeh 3103d14c5d2SYehuda Sadeh badmem: 3113d14c5d2SYehuda Sadeh err = -ENOMEM; 3123d14c5d2SYehuda Sadeh bad: 3133d14c5d2SYehuda Sadeh dout("crush_decode fail %d\n", err); 3143d14c5d2SYehuda Sadeh crush_destroy(c); 3153d14c5d2SYehuda Sadeh return ERR_PTR(err); 3163d14c5d2SYehuda Sadeh } 3173d14c5d2SYehuda Sadeh 3183d14c5d2SYehuda Sadeh /* 3193d14c5d2SYehuda Sadeh * rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid 3203d14c5d2SYehuda Sadeh * to a set of osds) 3213d14c5d2SYehuda Sadeh */ 3223d14c5d2SYehuda Sadeh static int pgid_cmp(struct ceph_pg l, struct ceph_pg r) 3233d14c5d2SYehuda Sadeh { 3243d14c5d2SYehuda Sadeh u64 a = *(u64 *)&l; 3253d14c5d2SYehuda Sadeh u64 b = *(u64 *)&r; 3263d14c5d2SYehuda Sadeh 3273d14c5d2SYehuda Sadeh if (a < b) 3283d14c5d2SYehuda Sadeh return -1; 3293d14c5d2SYehuda Sadeh if (a > b) 3303d14c5d2SYehuda Sadeh return 1; 3313d14c5d2SYehuda Sadeh return 0; 3323d14c5d2SYehuda Sadeh } 3333d14c5d2SYehuda Sadeh 3343d14c5d2SYehuda Sadeh static int __insert_pg_mapping(struct ceph_pg_mapping *new, 3353d14c5d2SYehuda Sadeh struct rb_root *root) 3363d14c5d2SYehuda Sadeh { 3373d14c5d2SYehuda Sadeh struct rb_node **p = &root->rb_node; 3383d14c5d2SYehuda Sadeh struct rb_node *parent = NULL; 3393d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg = NULL; 3403d14c5d2SYehuda Sadeh int c; 3413d14c5d2SYehuda Sadeh 3423d14c5d2SYehuda Sadeh while (*p) { 3433d14c5d2SYehuda Sadeh parent = *p; 3443d14c5d2SYehuda Sadeh pg = rb_entry(parent, struct ceph_pg_mapping, node); 3453d14c5d2SYehuda Sadeh c = pgid_cmp(new->pgid, pg->pgid); 3463d14c5d2SYehuda Sadeh if (c < 0) 3473d14c5d2SYehuda Sadeh p = &(*p)->rb_left; 3483d14c5d2SYehuda Sadeh else if (c > 0) 3493d14c5d2SYehuda Sadeh p = &(*p)->rb_right; 3503d14c5d2SYehuda Sadeh else 3513d14c5d2SYehuda Sadeh return -EEXIST; 3523d14c5d2SYehuda Sadeh } 3533d14c5d2SYehuda Sadeh 3543d14c5d2SYehuda Sadeh rb_link_node(&new->node, parent, p); 3553d14c5d2SYehuda Sadeh rb_insert_color(&new->node, root); 3563d14c5d2SYehuda Sadeh return 0; 3573d14c5d2SYehuda Sadeh } 3583d14c5d2SYehuda Sadeh 3593d14c5d2SYehuda Sadeh static struct ceph_pg_mapping *__lookup_pg_mapping(struct rb_root *root, 3603d14c5d2SYehuda Sadeh struct ceph_pg pgid) 3613d14c5d2SYehuda Sadeh { 3623d14c5d2SYehuda Sadeh struct rb_node *n = root->rb_node; 3633d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg; 3643d14c5d2SYehuda Sadeh int c; 3653d14c5d2SYehuda Sadeh 3663d14c5d2SYehuda Sadeh while (n) { 3673d14c5d2SYehuda Sadeh pg = rb_entry(n, struct ceph_pg_mapping, node); 3683d14c5d2SYehuda Sadeh c = pgid_cmp(pgid, pg->pgid); 3693d14c5d2SYehuda Sadeh if (c < 0) 3703d14c5d2SYehuda Sadeh n = n->rb_left; 3713d14c5d2SYehuda Sadeh else if (c > 0) 3723d14c5d2SYehuda Sadeh n = n->rb_right; 3733d14c5d2SYehuda Sadeh else 3743d14c5d2SYehuda Sadeh return pg; 3753d14c5d2SYehuda Sadeh } 3763d14c5d2SYehuda Sadeh return NULL; 3773d14c5d2SYehuda Sadeh } 3783d14c5d2SYehuda Sadeh 3793d14c5d2SYehuda Sadeh /* 3803d14c5d2SYehuda Sadeh * rbtree of pg pool info 3813d14c5d2SYehuda Sadeh */ 3823d14c5d2SYehuda Sadeh static int __insert_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *new) 3833d14c5d2SYehuda Sadeh { 3843d14c5d2SYehuda Sadeh struct rb_node **p = &root->rb_node; 3853d14c5d2SYehuda Sadeh struct rb_node *parent = NULL; 3863d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi = NULL; 3873d14c5d2SYehuda Sadeh 3883d14c5d2SYehuda Sadeh while (*p) { 3893d14c5d2SYehuda Sadeh parent = *p; 3903d14c5d2SYehuda Sadeh pi = rb_entry(parent, struct ceph_pg_pool_info, node); 3913d14c5d2SYehuda Sadeh if (new->id < pi->id) 3923d14c5d2SYehuda Sadeh p = &(*p)->rb_left; 3933d14c5d2SYehuda Sadeh else if (new->id > pi->id) 3943d14c5d2SYehuda Sadeh p = &(*p)->rb_right; 3953d14c5d2SYehuda Sadeh else 3963d14c5d2SYehuda Sadeh return -EEXIST; 3973d14c5d2SYehuda Sadeh } 3983d14c5d2SYehuda Sadeh 3993d14c5d2SYehuda Sadeh rb_link_node(&new->node, parent, p); 4003d14c5d2SYehuda Sadeh rb_insert_color(&new->node, root); 4013d14c5d2SYehuda Sadeh return 0; 4023d14c5d2SYehuda Sadeh } 4033d14c5d2SYehuda Sadeh 4043d14c5d2SYehuda Sadeh static struct ceph_pg_pool_info *__lookup_pg_pool(struct rb_root *root, int id) 4053d14c5d2SYehuda Sadeh { 4063d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi; 4073d14c5d2SYehuda Sadeh struct rb_node *n = root->rb_node; 4083d14c5d2SYehuda Sadeh 4093d14c5d2SYehuda Sadeh while (n) { 4103d14c5d2SYehuda Sadeh pi = rb_entry(n, struct ceph_pg_pool_info, node); 4113d14c5d2SYehuda Sadeh if (id < pi->id) 4123d14c5d2SYehuda Sadeh n = n->rb_left; 4133d14c5d2SYehuda Sadeh else if (id > pi->id) 4143d14c5d2SYehuda Sadeh n = n->rb_right; 4153d14c5d2SYehuda Sadeh else 4163d14c5d2SYehuda Sadeh return pi; 4173d14c5d2SYehuda Sadeh } 4183d14c5d2SYehuda Sadeh return NULL; 4193d14c5d2SYehuda Sadeh } 4203d14c5d2SYehuda Sadeh 4213d14c5d2SYehuda Sadeh int ceph_pg_poolid_by_name(struct ceph_osdmap *map, const char *name) 4223d14c5d2SYehuda Sadeh { 4233d14c5d2SYehuda Sadeh struct rb_node *rbp; 4243d14c5d2SYehuda Sadeh 4253d14c5d2SYehuda Sadeh for (rbp = rb_first(&map->pg_pools); rbp; rbp = rb_next(rbp)) { 4263d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi = 4273d14c5d2SYehuda Sadeh rb_entry(rbp, struct ceph_pg_pool_info, node); 4283d14c5d2SYehuda Sadeh if (pi->name && strcmp(pi->name, name) == 0) 4293d14c5d2SYehuda Sadeh return pi->id; 4303d14c5d2SYehuda Sadeh } 4313d14c5d2SYehuda Sadeh return -ENOENT; 4323d14c5d2SYehuda Sadeh } 4333d14c5d2SYehuda Sadeh EXPORT_SYMBOL(ceph_pg_poolid_by_name); 4343d14c5d2SYehuda Sadeh 4353d14c5d2SYehuda Sadeh static void __remove_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *pi) 4363d14c5d2SYehuda Sadeh { 4373d14c5d2SYehuda Sadeh rb_erase(&pi->node, root); 4383d14c5d2SYehuda Sadeh kfree(pi->name); 4393d14c5d2SYehuda Sadeh kfree(pi); 4403d14c5d2SYehuda Sadeh } 4413d14c5d2SYehuda Sadeh 4423d14c5d2SYehuda Sadeh static int __decode_pool(void **p, void *end, struct ceph_pg_pool_info *pi) 4433d14c5d2SYehuda Sadeh { 4443d14c5d2SYehuda Sadeh unsigned n, m; 4453d14c5d2SYehuda Sadeh 4463d14c5d2SYehuda Sadeh ceph_decode_copy(p, &pi->v, sizeof(pi->v)); 4473d14c5d2SYehuda Sadeh calc_pg_masks(pi); 4483d14c5d2SYehuda Sadeh 4493d14c5d2SYehuda Sadeh /* num_snaps * snap_info_t */ 4503d14c5d2SYehuda Sadeh n = le32_to_cpu(pi->v.num_snaps); 4513d14c5d2SYehuda Sadeh while (n--) { 4523d14c5d2SYehuda Sadeh ceph_decode_need(p, end, sizeof(u64) + 1 + sizeof(u64) + 4533d14c5d2SYehuda Sadeh sizeof(struct ceph_timespec), bad); 4543d14c5d2SYehuda Sadeh *p += sizeof(u64) + /* key */ 4553d14c5d2SYehuda Sadeh 1 + sizeof(u64) + /* u8, snapid */ 4563d14c5d2SYehuda Sadeh sizeof(struct ceph_timespec); 4573d14c5d2SYehuda Sadeh m = ceph_decode_32(p); /* snap name */ 4583d14c5d2SYehuda Sadeh *p += m; 4593d14c5d2SYehuda Sadeh } 4603d14c5d2SYehuda Sadeh 4613d14c5d2SYehuda Sadeh *p += le32_to_cpu(pi->v.num_removed_snap_intervals) * sizeof(u64) * 2; 4623d14c5d2SYehuda Sadeh return 0; 4633d14c5d2SYehuda Sadeh 4643d14c5d2SYehuda Sadeh bad: 4653d14c5d2SYehuda Sadeh return -EINVAL; 4663d14c5d2SYehuda Sadeh } 4673d14c5d2SYehuda Sadeh 4683d14c5d2SYehuda Sadeh static int __decode_pool_names(void **p, void *end, struct ceph_osdmap *map) 4693d14c5d2SYehuda Sadeh { 4703d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi; 4713d14c5d2SYehuda Sadeh u32 num, len, pool; 4723d14c5d2SYehuda Sadeh 4733d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, num, bad); 4743d14c5d2SYehuda Sadeh dout(" %d pool names\n", num); 4753d14c5d2SYehuda Sadeh while (num--) { 4763d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, pool, bad); 4773d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 4783d14c5d2SYehuda Sadeh dout(" pool %d len %d\n", pool, len); 4793d14c5d2SYehuda Sadeh pi = __lookup_pg_pool(&map->pg_pools, pool); 4803d14c5d2SYehuda Sadeh if (pi) { 4813d14c5d2SYehuda Sadeh kfree(pi->name); 4823d14c5d2SYehuda Sadeh pi->name = kmalloc(len + 1, GFP_NOFS); 4833d14c5d2SYehuda Sadeh if (pi->name) { 4843d14c5d2SYehuda Sadeh memcpy(pi->name, *p, len); 4853d14c5d2SYehuda Sadeh pi->name[len] = '\0'; 4863d14c5d2SYehuda Sadeh dout(" name is %s\n", pi->name); 4873d14c5d2SYehuda Sadeh } 4883d14c5d2SYehuda Sadeh } 4893d14c5d2SYehuda Sadeh *p += len; 4903d14c5d2SYehuda Sadeh } 4913d14c5d2SYehuda Sadeh return 0; 4923d14c5d2SYehuda Sadeh 4933d14c5d2SYehuda Sadeh bad: 4943d14c5d2SYehuda Sadeh return -EINVAL; 4953d14c5d2SYehuda Sadeh } 4963d14c5d2SYehuda Sadeh 4973d14c5d2SYehuda Sadeh /* 4983d14c5d2SYehuda Sadeh * osd map 4993d14c5d2SYehuda Sadeh */ 5003d14c5d2SYehuda Sadeh void ceph_osdmap_destroy(struct ceph_osdmap *map) 5013d14c5d2SYehuda Sadeh { 5023d14c5d2SYehuda Sadeh dout("osdmap_destroy %p\n", map); 5033d14c5d2SYehuda Sadeh if (map->crush) 5043d14c5d2SYehuda Sadeh crush_destroy(map->crush); 5053d14c5d2SYehuda Sadeh while (!RB_EMPTY_ROOT(&map->pg_temp)) { 5063d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg = 5073d14c5d2SYehuda Sadeh rb_entry(rb_first(&map->pg_temp), 5083d14c5d2SYehuda Sadeh struct ceph_pg_mapping, node); 5093d14c5d2SYehuda Sadeh rb_erase(&pg->node, &map->pg_temp); 5103d14c5d2SYehuda Sadeh kfree(pg); 5113d14c5d2SYehuda Sadeh } 5123d14c5d2SYehuda Sadeh while (!RB_EMPTY_ROOT(&map->pg_pools)) { 5133d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi = 5143d14c5d2SYehuda Sadeh rb_entry(rb_first(&map->pg_pools), 5153d14c5d2SYehuda Sadeh struct ceph_pg_pool_info, node); 5163d14c5d2SYehuda Sadeh __remove_pg_pool(&map->pg_pools, pi); 5173d14c5d2SYehuda Sadeh } 5183d14c5d2SYehuda Sadeh kfree(map->osd_state); 5193d14c5d2SYehuda Sadeh kfree(map->osd_weight); 5203d14c5d2SYehuda Sadeh kfree(map->osd_addr); 5213d14c5d2SYehuda Sadeh kfree(map); 5223d14c5d2SYehuda Sadeh } 5233d14c5d2SYehuda Sadeh 5243d14c5d2SYehuda Sadeh /* 5253d14c5d2SYehuda Sadeh * adjust max osd value. reallocate arrays. 5263d14c5d2SYehuda Sadeh */ 5273d14c5d2SYehuda Sadeh static int osdmap_set_max_osd(struct ceph_osdmap *map, int max) 5283d14c5d2SYehuda Sadeh { 5293d14c5d2SYehuda Sadeh u8 *state; 5303d14c5d2SYehuda Sadeh struct ceph_entity_addr *addr; 5313d14c5d2SYehuda Sadeh u32 *weight; 5323d14c5d2SYehuda Sadeh 5333d14c5d2SYehuda Sadeh state = kcalloc(max, sizeof(*state), GFP_NOFS); 5343d14c5d2SYehuda Sadeh addr = kcalloc(max, sizeof(*addr), GFP_NOFS); 5353d14c5d2SYehuda Sadeh weight = kcalloc(max, sizeof(*weight), GFP_NOFS); 5363d14c5d2SYehuda Sadeh if (state == NULL || addr == NULL || weight == NULL) { 5373d14c5d2SYehuda Sadeh kfree(state); 5383d14c5d2SYehuda Sadeh kfree(addr); 5393d14c5d2SYehuda Sadeh kfree(weight); 5403d14c5d2SYehuda Sadeh return -ENOMEM; 5413d14c5d2SYehuda Sadeh } 5423d14c5d2SYehuda Sadeh 5433d14c5d2SYehuda Sadeh /* copy old? */ 5443d14c5d2SYehuda Sadeh if (map->osd_state) { 5453d14c5d2SYehuda Sadeh memcpy(state, map->osd_state, map->max_osd*sizeof(*state)); 5463d14c5d2SYehuda Sadeh memcpy(addr, map->osd_addr, map->max_osd*sizeof(*addr)); 5473d14c5d2SYehuda Sadeh memcpy(weight, map->osd_weight, map->max_osd*sizeof(*weight)); 5483d14c5d2SYehuda Sadeh kfree(map->osd_state); 5493d14c5d2SYehuda Sadeh kfree(map->osd_addr); 5503d14c5d2SYehuda Sadeh kfree(map->osd_weight); 5513d14c5d2SYehuda Sadeh } 5523d14c5d2SYehuda Sadeh 5533d14c5d2SYehuda Sadeh map->osd_state = state; 5543d14c5d2SYehuda Sadeh map->osd_weight = weight; 5553d14c5d2SYehuda Sadeh map->osd_addr = addr; 5563d14c5d2SYehuda Sadeh map->max_osd = max; 5573d14c5d2SYehuda Sadeh return 0; 5583d14c5d2SYehuda Sadeh } 5593d14c5d2SYehuda Sadeh 5603d14c5d2SYehuda Sadeh /* 5613d14c5d2SYehuda Sadeh * decode a full map. 5623d14c5d2SYehuda Sadeh */ 5633d14c5d2SYehuda Sadeh struct ceph_osdmap *osdmap_decode(void **p, void *end) 5643d14c5d2SYehuda Sadeh { 5653d14c5d2SYehuda Sadeh struct ceph_osdmap *map; 5663d14c5d2SYehuda Sadeh u16 version; 5673d14c5d2SYehuda Sadeh u32 len, max, i; 5683d14c5d2SYehuda Sadeh u8 ev; 5693d14c5d2SYehuda Sadeh int err = -EINVAL; 5703d14c5d2SYehuda Sadeh void *start = *p; 5713d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi; 5723d14c5d2SYehuda Sadeh 5733d14c5d2SYehuda Sadeh dout("osdmap_decode %p to %p len %d\n", *p, end, (int)(end - *p)); 5743d14c5d2SYehuda Sadeh 5753d14c5d2SYehuda Sadeh map = kzalloc(sizeof(*map), GFP_NOFS); 5763d14c5d2SYehuda Sadeh if (map == NULL) 5773d14c5d2SYehuda Sadeh return ERR_PTR(-ENOMEM); 5783d14c5d2SYehuda Sadeh map->pg_temp = RB_ROOT; 5793d14c5d2SYehuda Sadeh 5803d14c5d2SYehuda Sadeh ceph_decode_16_safe(p, end, version, bad); 5813d14c5d2SYehuda Sadeh if (version > CEPH_OSDMAP_VERSION) { 5823d14c5d2SYehuda Sadeh pr_warning("got unknown v %d > %d of osdmap\n", version, 5833d14c5d2SYehuda Sadeh CEPH_OSDMAP_VERSION); 5843d14c5d2SYehuda Sadeh goto bad; 5853d14c5d2SYehuda Sadeh } 5863d14c5d2SYehuda Sadeh 5873d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 2*sizeof(u64)+6*sizeof(u32), bad); 5883d14c5d2SYehuda Sadeh ceph_decode_copy(p, &map->fsid, sizeof(map->fsid)); 5893d14c5d2SYehuda Sadeh map->epoch = ceph_decode_32(p); 5903d14c5d2SYehuda Sadeh ceph_decode_copy(p, &map->created, sizeof(map->created)); 5913d14c5d2SYehuda Sadeh ceph_decode_copy(p, &map->modified, sizeof(map->modified)); 5923d14c5d2SYehuda Sadeh 5933d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, max, bad); 5943d14c5d2SYehuda Sadeh while (max--) { 5953d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 4 + 1 + sizeof(pi->v), bad); 5963d14c5d2SYehuda Sadeh pi = kzalloc(sizeof(*pi), GFP_NOFS); 5973d14c5d2SYehuda Sadeh if (!pi) 5983d14c5d2SYehuda Sadeh goto bad; 5993d14c5d2SYehuda Sadeh pi->id = ceph_decode_32(p); 6003d14c5d2SYehuda Sadeh ev = ceph_decode_8(p); /* encoding version */ 6013d14c5d2SYehuda Sadeh if (ev > CEPH_PG_POOL_VERSION) { 6023d14c5d2SYehuda Sadeh pr_warning("got unknown v %d > %d of ceph_pg_pool\n", 6033d14c5d2SYehuda Sadeh ev, CEPH_PG_POOL_VERSION); 6043d14c5d2SYehuda Sadeh kfree(pi); 6053d14c5d2SYehuda Sadeh goto bad; 6063d14c5d2SYehuda Sadeh } 6073d14c5d2SYehuda Sadeh err = __decode_pool(p, end, pi); 608b0aee351SJesper Juhl if (err < 0) { 609b0aee351SJesper Juhl kfree(pi); 6103d14c5d2SYehuda Sadeh goto bad; 611b0aee351SJesper Juhl } 6123d14c5d2SYehuda Sadeh __insert_pg_pool(&map->pg_pools, pi); 6133d14c5d2SYehuda Sadeh } 6143d14c5d2SYehuda Sadeh 6153d14c5d2SYehuda Sadeh if (version >= 5 && __decode_pool_names(p, end, map) < 0) 6163d14c5d2SYehuda Sadeh goto bad; 6173d14c5d2SYehuda Sadeh 6183d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, map->pool_max, bad); 6193d14c5d2SYehuda Sadeh 6203d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, map->flags, bad); 6213d14c5d2SYehuda Sadeh 6223d14c5d2SYehuda Sadeh max = ceph_decode_32(p); 6233d14c5d2SYehuda Sadeh 6243d14c5d2SYehuda Sadeh /* (re)alloc osd arrays */ 6253d14c5d2SYehuda Sadeh err = osdmap_set_max_osd(map, max); 6263d14c5d2SYehuda Sadeh if (err < 0) 6273d14c5d2SYehuda Sadeh goto bad; 6283d14c5d2SYehuda Sadeh dout("osdmap_decode max_osd = %d\n", map->max_osd); 6293d14c5d2SYehuda Sadeh 6303d14c5d2SYehuda Sadeh /* osds */ 6313d14c5d2SYehuda Sadeh err = -EINVAL; 6323d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 3*sizeof(u32) + 6333d14c5d2SYehuda Sadeh map->max_osd*(1 + sizeof(*map->osd_weight) + 6343d14c5d2SYehuda Sadeh sizeof(*map->osd_addr)), bad); 6353d14c5d2SYehuda Sadeh *p += 4; /* skip length field (should match max) */ 6363d14c5d2SYehuda Sadeh ceph_decode_copy(p, map->osd_state, map->max_osd); 6373d14c5d2SYehuda Sadeh 6383d14c5d2SYehuda Sadeh *p += 4; /* skip length field (should match max) */ 6393d14c5d2SYehuda Sadeh for (i = 0; i < map->max_osd; i++) 6403d14c5d2SYehuda Sadeh map->osd_weight[i] = ceph_decode_32(p); 6413d14c5d2SYehuda Sadeh 6423d14c5d2SYehuda Sadeh *p += 4; /* skip length field (should match max) */ 6433d14c5d2SYehuda Sadeh ceph_decode_copy(p, map->osd_addr, map->max_osd*sizeof(*map->osd_addr)); 6443d14c5d2SYehuda Sadeh for (i = 0; i < map->max_osd; i++) 6453d14c5d2SYehuda Sadeh ceph_decode_addr(&map->osd_addr[i]); 6463d14c5d2SYehuda Sadeh 6473d14c5d2SYehuda Sadeh /* pg_temp */ 6483d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 6493d14c5d2SYehuda Sadeh for (i = 0; i < len; i++) { 6503d14c5d2SYehuda Sadeh int n, j; 6513d14c5d2SYehuda Sadeh struct ceph_pg pgid; 6523d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg; 6533d14c5d2SYehuda Sadeh 6543d14c5d2SYehuda Sadeh ceph_decode_need(p, end, sizeof(u32) + sizeof(u64), bad); 6553d14c5d2SYehuda Sadeh ceph_decode_copy(p, &pgid, sizeof(pgid)); 6563d14c5d2SYehuda Sadeh n = ceph_decode_32(p); 6573d14c5d2SYehuda Sadeh ceph_decode_need(p, end, n * sizeof(u32), bad); 6583d14c5d2SYehuda Sadeh err = -ENOMEM; 6593d14c5d2SYehuda Sadeh pg = kmalloc(sizeof(*pg) + n*sizeof(u32), GFP_NOFS); 6603d14c5d2SYehuda Sadeh if (!pg) 6613d14c5d2SYehuda Sadeh goto bad; 6623d14c5d2SYehuda Sadeh pg->pgid = pgid; 6633d14c5d2SYehuda Sadeh pg->len = n; 6643d14c5d2SYehuda Sadeh for (j = 0; j < n; j++) 6653d14c5d2SYehuda Sadeh pg->osds[j] = ceph_decode_32(p); 6663d14c5d2SYehuda Sadeh 6673d14c5d2SYehuda Sadeh err = __insert_pg_mapping(pg, &map->pg_temp); 6683d14c5d2SYehuda Sadeh if (err) 6693d14c5d2SYehuda Sadeh goto bad; 6703d14c5d2SYehuda Sadeh dout(" added pg_temp %llx len %d\n", *(u64 *)&pgid, len); 6713d14c5d2SYehuda Sadeh } 6723d14c5d2SYehuda Sadeh 6733d14c5d2SYehuda Sadeh /* crush */ 6743d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 6753d14c5d2SYehuda Sadeh dout("osdmap_decode crush len %d from off 0x%x\n", len, 6763d14c5d2SYehuda Sadeh (int)(*p - start)); 6773d14c5d2SYehuda Sadeh ceph_decode_need(p, end, len, bad); 6783d14c5d2SYehuda Sadeh map->crush = crush_decode(*p, end); 6793d14c5d2SYehuda Sadeh *p += len; 6803d14c5d2SYehuda Sadeh if (IS_ERR(map->crush)) { 6813d14c5d2SYehuda Sadeh err = PTR_ERR(map->crush); 6823d14c5d2SYehuda Sadeh map->crush = NULL; 6833d14c5d2SYehuda Sadeh goto bad; 6843d14c5d2SYehuda Sadeh } 6853d14c5d2SYehuda Sadeh 6863d14c5d2SYehuda Sadeh /* ignore the rest of the map */ 6873d14c5d2SYehuda Sadeh *p = end; 6883d14c5d2SYehuda Sadeh 6893d14c5d2SYehuda Sadeh dout("osdmap_decode done %p %p\n", *p, end); 6903d14c5d2SYehuda Sadeh return map; 6913d14c5d2SYehuda Sadeh 6923d14c5d2SYehuda Sadeh bad: 6933d14c5d2SYehuda Sadeh dout("osdmap_decode fail\n"); 6943d14c5d2SYehuda Sadeh ceph_osdmap_destroy(map); 6953d14c5d2SYehuda Sadeh return ERR_PTR(err); 6963d14c5d2SYehuda Sadeh } 6973d14c5d2SYehuda Sadeh 6983d14c5d2SYehuda Sadeh /* 6993d14c5d2SYehuda Sadeh * decode and apply an incremental map update. 7003d14c5d2SYehuda Sadeh */ 7013d14c5d2SYehuda Sadeh struct ceph_osdmap *osdmap_apply_incremental(void **p, void *end, 7023d14c5d2SYehuda Sadeh struct ceph_osdmap *map, 7033d14c5d2SYehuda Sadeh struct ceph_messenger *msgr) 7043d14c5d2SYehuda Sadeh { 7053d14c5d2SYehuda Sadeh struct crush_map *newcrush = NULL; 7063d14c5d2SYehuda Sadeh struct ceph_fsid fsid; 7073d14c5d2SYehuda Sadeh u32 epoch = 0; 7083d14c5d2SYehuda Sadeh struct ceph_timespec modified; 7093d14c5d2SYehuda Sadeh u32 len, pool; 7103d14c5d2SYehuda Sadeh __s32 new_pool_max, new_flags, max; 7113d14c5d2SYehuda Sadeh void *start = *p; 7123d14c5d2SYehuda Sadeh int err = -EINVAL; 7133d14c5d2SYehuda Sadeh u16 version; 7143d14c5d2SYehuda Sadeh struct rb_node *rbp; 7153d14c5d2SYehuda Sadeh 7163d14c5d2SYehuda Sadeh ceph_decode_16_safe(p, end, version, bad); 7173d14c5d2SYehuda Sadeh if (version > CEPH_OSDMAP_INC_VERSION) { 7183d14c5d2SYehuda Sadeh pr_warning("got unknown v %d > %d of inc osdmap\n", version, 7193d14c5d2SYehuda Sadeh CEPH_OSDMAP_INC_VERSION); 7203d14c5d2SYehuda Sadeh goto bad; 7213d14c5d2SYehuda Sadeh } 7223d14c5d2SYehuda Sadeh 7233d14c5d2SYehuda Sadeh ceph_decode_need(p, end, sizeof(fsid)+sizeof(modified)+2*sizeof(u32), 7243d14c5d2SYehuda Sadeh bad); 7253d14c5d2SYehuda Sadeh ceph_decode_copy(p, &fsid, sizeof(fsid)); 7263d14c5d2SYehuda Sadeh epoch = ceph_decode_32(p); 7273d14c5d2SYehuda Sadeh BUG_ON(epoch != map->epoch+1); 7283d14c5d2SYehuda Sadeh ceph_decode_copy(p, &modified, sizeof(modified)); 7293d14c5d2SYehuda Sadeh new_pool_max = ceph_decode_32(p); 7303d14c5d2SYehuda Sadeh new_flags = ceph_decode_32(p); 7313d14c5d2SYehuda Sadeh 7323d14c5d2SYehuda Sadeh /* full map? */ 7333d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 7343d14c5d2SYehuda Sadeh if (len > 0) { 7353d14c5d2SYehuda Sadeh dout("apply_incremental full map len %d, %p to %p\n", 7363d14c5d2SYehuda Sadeh len, *p, end); 7373d14c5d2SYehuda Sadeh return osdmap_decode(p, min(*p+len, end)); 7383d14c5d2SYehuda Sadeh } 7393d14c5d2SYehuda Sadeh 7403d14c5d2SYehuda Sadeh /* new crush? */ 7413d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 7423d14c5d2SYehuda Sadeh if (len > 0) { 7433d14c5d2SYehuda Sadeh dout("apply_incremental new crush map len %d, %p to %p\n", 7443d14c5d2SYehuda Sadeh len, *p, end); 7453d14c5d2SYehuda Sadeh newcrush = crush_decode(*p, min(*p+len, end)); 7463d14c5d2SYehuda Sadeh if (IS_ERR(newcrush)) 7473d14c5d2SYehuda Sadeh return ERR_CAST(newcrush); 7483d14c5d2SYehuda Sadeh *p += len; 7493d14c5d2SYehuda Sadeh } 7503d14c5d2SYehuda Sadeh 7513d14c5d2SYehuda Sadeh /* new flags? */ 7523d14c5d2SYehuda Sadeh if (new_flags >= 0) 7533d14c5d2SYehuda Sadeh map->flags = new_flags; 7543d14c5d2SYehuda Sadeh if (new_pool_max >= 0) 7553d14c5d2SYehuda Sadeh map->pool_max = new_pool_max; 7563d14c5d2SYehuda Sadeh 7573d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 5*sizeof(u32), bad); 7583d14c5d2SYehuda Sadeh 7593d14c5d2SYehuda Sadeh /* new max? */ 7603d14c5d2SYehuda Sadeh max = ceph_decode_32(p); 7613d14c5d2SYehuda Sadeh if (max >= 0) { 7623d14c5d2SYehuda Sadeh err = osdmap_set_max_osd(map, max); 7633d14c5d2SYehuda Sadeh if (err < 0) 7643d14c5d2SYehuda Sadeh goto bad; 7653d14c5d2SYehuda Sadeh } 7663d14c5d2SYehuda Sadeh 7673d14c5d2SYehuda Sadeh map->epoch++; 7683d14c5d2SYehuda Sadeh map->modified = map->modified; 7693d14c5d2SYehuda Sadeh if (newcrush) { 7703d14c5d2SYehuda Sadeh if (map->crush) 7713d14c5d2SYehuda Sadeh crush_destroy(map->crush); 7723d14c5d2SYehuda Sadeh map->crush = newcrush; 7733d14c5d2SYehuda Sadeh newcrush = NULL; 7743d14c5d2SYehuda Sadeh } 7753d14c5d2SYehuda Sadeh 7763d14c5d2SYehuda Sadeh /* new_pool */ 7773d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 7783d14c5d2SYehuda Sadeh while (len--) { 7793d14c5d2SYehuda Sadeh __u8 ev; 7803d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi; 7813d14c5d2SYehuda Sadeh 7823d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, pool, bad); 7833d14c5d2SYehuda Sadeh ceph_decode_need(p, end, 1 + sizeof(pi->v), bad); 7843d14c5d2SYehuda Sadeh ev = ceph_decode_8(p); /* encoding version */ 7853d14c5d2SYehuda Sadeh if (ev > CEPH_PG_POOL_VERSION) { 7863d14c5d2SYehuda Sadeh pr_warning("got unknown v %d > %d of ceph_pg_pool\n", 7873d14c5d2SYehuda Sadeh ev, CEPH_PG_POOL_VERSION); 7883d14c5d2SYehuda Sadeh goto bad; 7893d14c5d2SYehuda Sadeh } 7903d14c5d2SYehuda Sadeh pi = __lookup_pg_pool(&map->pg_pools, pool); 7913d14c5d2SYehuda Sadeh if (!pi) { 7923d14c5d2SYehuda Sadeh pi = kzalloc(sizeof(*pi), GFP_NOFS); 7933d14c5d2SYehuda Sadeh if (!pi) { 7943d14c5d2SYehuda Sadeh err = -ENOMEM; 7953d14c5d2SYehuda Sadeh goto bad; 7963d14c5d2SYehuda Sadeh } 7973d14c5d2SYehuda Sadeh pi->id = pool; 7983d14c5d2SYehuda Sadeh __insert_pg_pool(&map->pg_pools, pi); 7993d14c5d2SYehuda Sadeh } 8003d14c5d2SYehuda Sadeh err = __decode_pool(p, end, pi); 8013d14c5d2SYehuda Sadeh if (err < 0) 8023d14c5d2SYehuda Sadeh goto bad; 8033d14c5d2SYehuda Sadeh } 8043d14c5d2SYehuda Sadeh if (version >= 5 && __decode_pool_names(p, end, map) < 0) 8053d14c5d2SYehuda Sadeh goto bad; 8063d14c5d2SYehuda Sadeh 8073d14c5d2SYehuda Sadeh /* old_pool */ 8083d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 8093d14c5d2SYehuda Sadeh while (len--) { 8103d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pi; 8113d14c5d2SYehuda Sadeh 8123d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, pool, bad); 8133d14c5d2SYehuda Sadeh pi = __lookup_pg_pool(&map->pg_pools, pool); 8143d14c5d2SYehuda Sadeh if (pi) 8153d14c5d2SYehuda Sadeh __remove_pg_pool(&map->pg_pools, pi); 8163d14c5d2SYehuda Sadeh } 8173d14c5d2SYehuda Sadeh 8183d14c5d2SYehuda Sadeh /* new_up */ 8193d14c5d2SYehuda Sadeh err = -EINVAL; 8203d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 8213d14c5d2SYehuda Sadeh while (len--) { 8223d14c5d2SYehuda Sadeh u32 osd; 8233d14c5d2SYehuda Sadeh struct ceph_entity_addr addr; 8243d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, osd, bad); 8253d14c5d2SYehuda Sadeh ceph_decode_copy_safe(p, end, &addr, sizeof(addr), bad); 8263d14c5d2SYehuda Sadeh ceph_decode_addr(&addr); 8273d14c5d2SYehuda Sadeh pr_info("osd%d up\n", osd); 8283d14c5d2SYehuda Sadeh BUG_ON(osd >= map->max_osd); 8293d14c5d2SYehuda Sadeh map->osd_state[osd] |= CEPH_OSD_UP; 8303d14c5d2SYehuda Sadeh map->osd_addr[osd] = addr; 8313d14c5d2SYehuda Sadeh } 8323d14c5d2SYehuda Sadeh 8333d14c5d2SYehuda Sadeh /* new_down */ 8343d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 8353d14c5d2SYehuda Sadeh while (len--) { 8363d14c5d2SYehuda Sadeh u32 osd; 8373d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, osd, bad); 8383d14c5d2SYehuda Sadeh (*p)++; /* clean flag */ 8393d14c5d2SYehuda Sadeh pr_info("osd%d down\n", osd); 8403d14c5d2SYehuda Sadeh if (osd < map->max_osd) 8413d14c5d2SYehuda Sadeh map->osd_state[osd] &= ~CEPH_OSD_UP; 8423d14c5d2SYehuda Sadeh } 8433d14c5d2SYehuda Sadeh 8443d14c5d2SYehuda Sadeh /* new_weight */ 8453d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 8463d14c5d2SYehuda Sadeh while (len--) { 8473d14c5d2SYehuda Sadeh u32 osd, off; 8483d14c5d2SYehuda Sadeh ceph_decode_need(p, end, sizeof(u32)*2, bad); 8493d14c5d2SYehuda Sadeh osd = ceph_decode_32(p); 8503d14c5d2SYehuda Sadeh off = ceph_decode_32(p); 8513d14c5d2SYehuda Sadeh pr_info("osd%d weight 0x%x %s\n", osd, off, 8523d14c5d2SYehuda Sadeh off == CEPH_OSD_IN ? "(in)" : 8533d14c5d2SYehuda Sadeh (off == CEPH_OSD_OUT ? "(out)" : "")); 8543d14c5d2SYehuda Sadeh if (osd < map->max_osd) 8553d14c5d2SYehuda Sadeh map->osd_weight[osd] = off; 8563d14c5d2SYehuda Sadeh } 8573d14c5d2SYehuda Sadeh 8583d14c5d2SYehuda Sadeh /* new_pg_temp */ 8593d14c5d2SYehuda Sadeh rbp = rb_first(&map->pg_temp); 8603d14c5d2SYehuda Sadeh ceph_decode_32_safe(p, end, len, bad); 8613d14c5d2SYehuda Sadeh while (len--) { 8623d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg; 8633d14c5d2SYehuda Sadeh int j; 8643d14c5d2SYehuda Sadeh struct ceph_pg pgid; 8653d14c5d2SYehuda Sadeh u32 pglen; 8663d14c5d2SYehuda Sadeh ceph_decode_need(p, end, sizeof(u64) + sizeof(u32), bad); 8673d14c5d2SYehuda Sadeh ceph_decode_copy(p, &pgid, sizeof(pgid)); 8683d14c5d2SYehuda Sadeh pglen = ceph_decode_32(p); 8693d14c5d2SYehuda Sadeh 8703d14c5d2SYehuda Sadeh /* remove any? */ 8713d14c5d2SYehuda Sadeh while (rbp && pgid_cmp(rb_entry(rbp, struct ceph_pg_mapping, 8723d14c5d2SYehuda Sadeh node)->pgid, pgid) <= 0) { 8733d14c5d2SYehuda Sadeh struct ceph_pg_mapping *cur = 8743d14c5d2SYehuda Sadeh rb_entry(rbp, struct ceph_pg_mapping, node); 8753d14c5d2SYehuda Sadeh 8763d14c5d2SYehuda Sadeh rbp = rb_next(rbp); 8773d14c5d2SYehuda Sadeh dout(" removed pg_temp %llx\n", *(u64 *)&cur->pgid); 8783d14c5d2SYehuda Sadeh rb_erase(&cur->node, &map->pg_temp); 8793d14c5d2SYehuda Sadeh kfree(cur); 8803d14c5d2SYehuda Sadeh } 8813d14c5d2SYehuda Sadeh 8823d14c5d2SYehuda Sadeh if (pglen) { 8833d14c5d2SYehuda Sadeh /* insert */ 8843d14c5d2SYehuda Sadeh ceph_decode_need(p, end, pglen*sizeof(u32), bad); 8853d14c5d2SYehuda Sadeh pg = kmalloc(sizeof(*pg) + sizeof(u32)*pglen, GFP_NOFS); 8863d14c5d2SYehuda Sadeh if (!pg) { 8873d14c5d2SYehuda Sadeh err = -ENOMEM; 8883d14c5d2SYehuda Sadeh goto bad; 8893d14c5d2SYehuda Sadeh } 8903d14c5d2SYehuda Sadeh pg->pgid = pgid; 8913d14c5d2SYehuda Sadeh pg->len = pglen; 8923d14c5d2SYehuda Sadeh for (j = 0; j < pglen; j++) 8933d14c5d2SYehuda Sadeh pg->osds[j] = ceph_decode_32(p); 8943d14c5d2SYehuda Sadeh err = __insert_pg_mapping(pg, &map->pg_temp); 8953d14c5d2SYehuda Sadeh if (err) { 8963d14c5d2SYehuda Sadeh kfree(pg); 8973d14c5d2SYehuda Sadeh goto bad; 8983d14c5d2SYehuda Sadeh } 8993d14c5d2SYehuda Sadeh dout(" added pg_temp %llx len %d\n", *(u64 *)&pgid, 9003d14c5d2SYehuda Sadeh pglen); 9013d14c5d2SYehuda Sadeh } 9023d14c5d2SYehuda Sadeh } 9033d14c5d2SYehuda Sadeh while (rbp) { 9043d14c5d2SYehuda Sadeh struct ceph_pg_mapping *cur = 9053d14c5d2SYehuda Sadeh rb_entry(rbp, struct ceph_pg_mapping, node); 9063d14c5d2SYehuda Sadeh 9073d14c5d2SYehuda Sadeh rbp = rb_next(rbp); 9083d14c5d2SYehuda Sadeh dout(" removed pg_temp %llx\n", *(u64 *)&cur->pgid); 9093d14c5d2SYehuda Sadeh rb_erase(&cur->node, &map->pg_temp); 9103d14c5d2SYehuda Sadeh kfree(cur); 9113d14c5d2SYehuda Sadeh } 9123d14c5d2SYehuda Sadeh 9133d14c5d2SYehuda Sadeh /* ignore the rest */ 9143d14c5d2SYehuda Sadeh *p = end; 9153d14c5d2SYehuda Sadeh return map; 9163d14c5d2SYehuda Sadeh 9173d14c5d2SYehuda Sadeh bad: 9183d14c5d2SYehuda Sadeh pr_err("corrupt inc osdmap epoch %d off %d (%p of %p-%p)\n", 9193d14c5d2SYehuda Sadeh epoch, (int)(*p - start), *p, start, end); 9203d14c5d2SYehuda Sadeh print_hex_dump(KERN_DEBUG, "osdmap: ", 9213d14c5d2SYehuda Sadeh DUMP_PREFIX_OFFSET, 16, 1, 9223d14c5d2SYehuda Sadeh start, end - start, true); 9233d14c5d2SYehuda Sadeh if (newcrush) 9243d14c5d2SYehuda Sadeh crush_destroy(newcrush); 9253d14c5d2SYehuda Sadeh return ERR_PTR(err); 9263d14c5d2SYehuda Sadeh } 9273d14c5d2SYehuda Sadeh 9283d14c5d2SYehuda Sadeh 9293d14c5d2SYehuda Sadeh 9303d14c5d2SYehuda Sadeh 9313d14c5d2SYehuda Sadeh /* 9323d14c5d2SYehuda Sadeh * calculate file layout from given offset, length. 9333d14c5d2SYehuda Sadeh * fill in correct oid, logical length, and object extent 9343d14c5d2SYehuda Sadeh * offset, length. 9353d14c5d2SYehuda Sadeh * 9363d14c5d2SYehuda Sadeh * for now, we write only a single su, until we can 9373d14c5d2SYehuda Sadeh * pass a stride back to the caller. 9383d14c5d2SYehuda Sadeh */ 9393d14c5d2SYehuda Sadeh void ceph_calc_file_object_mapping(struct ceph_file_layout *layout, 9403d14c5d2SYehuda Sadeh u64 off, u64 *plen, 9413d14c5d2SYehuda Sadeh u64 *ono, 9423d14c5d2SYehuda Sadeh u64 *oxoff, u64 *oxlen) 9433d14c5d2SYehuda Sadeh { 9443d14c5d2SYehuda Sadeh u32 osize = le32_to_cpu(layout->fl_object_size); 9453d14c5d2SYehuda Sadeh u32 su = le32_to_cpu(layout->fl_stripe_unit); 9463d14c5d2SYehuda Sadeh u32 sc = le32_to_cpu(layout->fl_stripe_count); 9473d14c5d2SYehuda Sadeh u32 bl, stripeno, stripepos, objsetno; 9483d14c5d2SYehuda Sadeh u32 su_per_object; 9493d14c5d2SYehuda Sadeh u64 t, su_offset; 9503d14c5d2SYehuda Sadeh 9513d14c5d2SYehuda Sadeh dout("mapping %llu~%llu osize %u fl_su %u\n", off, *plen, 9523d14c5d2SYehuda Sadeh osize, su); 9533d14c5d2SYehuda Sadeh su_per_object = osize / su; 9543d14c5d2SYehuda Sadeh dout("osize %u / su %u = su_per_object %u\n", osize, su, 9553d14c5d2SYehuda Sadeh su_per_object); 9563d14c5d2SYehuda Sadeh 9573d14c5d2SYehuda Sadeh BUG_ON((su & ~PAGE_MASK) != 0); 9583d14c5d2SYehuda Sadeh /* bl = *off / su; */ 9593d14c5d2SYehuda Sadeh t = off; 9603d14c5d2SYehuda Sadeh do_div(t, su); 9613d14c5d2SYehuda Sadeh bl = t; 9623d14c5d2SYehuda Sadeh dout("off %llu / su %u = bl %u\n", off, su, bl); 9633d14c5d2SYehuda Sadeh 9643d14c5d2SYehuda Sadeh stripeno = bl / sc; 9653d14c5d2SYehuda Sadeh stripepos = bl % sc; 9663d14c5d2SYehuda Sadeh objsetno = stripeno / su_per_object; 9673d14c5d2SYehuda Sadeh 9683d14c5d2SYehuda Sadeh *ono = objsetno * sc + stripepos; 9693d14c5d2SYehuda Sadeh dout("objset %u * sc %u = ono %u\n", objsetno, sc, (unsigned)*ono); 9703d14c5d2SYehuda Sadeh 9713d14c5d2SYehuda Sadeh /* *oxoff = *off % layout->fl_stripe_unit; # offset in su */ 9723d14c5d2SYehuda Sadeh t = off; 9733d14c5d2SYehuda Sadeh su_offset = do_div(t, su); 9743d14c5d2SYehuda Sadeh *oxoff = su_offset + (stripeno % su_per_object) * su; 9753d14c5d2SYehuda Sadeh 9763d14c5d2SYehuda Sadeh /* 9773d14c5d2SYehuda Sadeh * Calculate the length of the extent being written to the selected 9783d14c5d2SYehuda Sadeh * object. This is the minimum of the full length requested (plen) or 9793d14c5d2SYehuda Sadeh * the remainder of the current stripe being written to. 9803d14c5d2SYehuda Sadeh */ 9813d14c5d2SYehuda Sadeh *oxlen = min_t(u64, *plen, su - su_offset); 9823d14c5d2SYehuda Sadeh *plen = *oxlen; 9833d14c5d2SYehuda Sadeh 9843d14c5d2SYehuda Sadeh dout(" obj extent %llu~%llu\n", *oxoff, *oxlen); 9853d14c5d2SYehuda Sadeh } 9863d14c5d2SYehuda Sadeh EXPORT_SYMBOL(ceph_calc_file_object_mapping); 9873d14c5d2SYehuda Sadeh 9883d14c5d2SYehuda Sadeh /* 9893d14c5d2SYehuda Sadeh * calculate an object layout (i.e. pgid) from an oid, 9903d14c5d2SYehuda Sadeh * file_layout, and osdmap 9913d14c5d2SYehuda Sadeh */ 9923d14c5d2SYehuda Sadeh int ceph_calc_object_layout(struct ceph_object_layout *ol, 9933d14c5d2SYehuda Sadeh const char *oid, 9943d14c5d2SYehuda Sadeh struct ceph_file_layout *fl, 9953d14c5d2SYehuda Sadeh struct ceph_osdmap *osdmap) 9963d14c5d2SYehuda Sadeh { 9973d14c5d2SYehuda Sadeh unsigned num, num_mask; 9983d14c5d2SYehuda Sadeh struct ceph_pg pgid; 9993d14c5d2SYehuda Sadeh s32 preferred = (s32)le32_to_cpu(fl->fl_pg_preferred); 10003d14c5d2SYehuda Sadeh int poolid = le32_to_cpu(fl->fl_pg_pool); 10013d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pool; 10023d14c5d2SYehuda Sadeh unsigned ps; 10033d14c5d2SYehuda Sadeh 10043d14c5d2SYehuda Sadeh BUG_ON(!osdmap); 10053d14c5d2SYehuda Sadeh 10063d14c5d2SYehuda Sadeh pool = __lookup_pg_pool(&osdmap->pg_pools, poolid); 10073d14c5d2SYehuda Sadeh if (!pool) 10083d14c5d2SYehuda Sadeh return -EIO; 10093d14c5d2SYehuda Sadeh ps = ceph_str_hash(pool->v.object_hash, oid, strlen(oid)); 10103d14c5d2SYehuda Sadeh if (preferred >= 0) { 10113d14c5d2SYehuda Sadeh ps += preferred; 10123d14c5d2SYehuda Sadeh num = le32_to_cpu(pool->v.lpg_num); 10133d14c5d2SYehuda Sadeh num_mask = pool->lpg_num_mask; 10143d14c5d2SYehuda Sadeh } else { 10153d14c5d2SYehuda Sadeh num = le32_to_cpu(pool->v.pg_num); 10163d14c5d2SYehuda Sadeh num_mask = pool->pg_num_mask; 10173d14c5d2SYehuda Sadeh } 10183d14c5d2SYehuda Sadeh 10193d14c5d2SYehuda Sadeh pgid.ps = cpu_to_le16(ps); 10203d14c5d2SYehuda Sadeh pgid.preferred = cpu_to_le16(preferred); 10213d14c5d2SYehuda Sadeh pgid.pool = fl->fl_pg_pool; 10223d14c5d2SYehuda Sadeh if (preferred >= 0) 10233d14c5d2SYehuda Sadeh dout("calc_object_layout '%s' pgid %d.%xp%d\n", oid, poolid, ps, 10243d14c5d2SYehuda Sadeh (int)preferred); 10253d14c5d2SYehuda Sadeh else 10263d14c5d2SYehuda Sadeh dout("calc_object_layout '%s' pgid %d.%x\n", oid, poolid, ps); 10273d14c5d2SYehuda Sadeh 10283d14c5d2SYehuda Sadeh ol->ol_pgid = pgid; 10293d14c5d2SYehuda Sadeh ol->ol_stripe_unit = fl->fl_object_stripe_unit; 10303d14c5d2SYehuda Sadeh return 0; 10313d14c5d2SYehuda Sadeh } 10323d14c5d2SYehuda Sadeh EXPORT_SYMBOL(ceph_calc_object_layout); 10333d14c5d2SYehuda Sadeh 10343d14c5d2SYehuda Sadeh /* 10353d14c5d2SYehuda Sadeh * Calculate raw osd vector for the given pgid. Return pointer to osd 10363d14c5d2SYehuda Sadeh * array, or NULL on failure. 10373d14c5d2SYehuda Sadeh */ 10383d14c5d2SYehuda Sadeh static int *calc_pg_raw(struct ceph_osdmap *osdmap, struct ceph_pg pgid, 10393d14c5d2SYehuda Sadeh int *osds, int *num) 10403d14c5d2SYehuda Sadeh { 10413d14c5d2SYehuda Sadeh struct ceph_pg_mapping *pg; 10423d14c5d2SYehuda Sadeh struct ceph_pg_pool_info *pool; 10433d14c5d2SYehuda Sadeh int ruleno; 10443d14c5d2SYehuda Sadeh unsigned poolid, ps, pps; 10453d14c5d2SYehuda Sadeh int preferred; 10463d14c5d2SYehuda Sadeh 10473d14c5d2SYehuda Sadeh /* pg_temp? */ 10483d14c5d2SYehuda Sadeh pg = __lookup_pg_mapping(&osdmap->pg_temp, pgid); 10493d14c5d2SYehuda Sadeh if (pg) { 10503d14c5d2SYehuda Sadeh *num = pg->len; 10513d14c5d2SYehuda Sadeh return pg->osds; 10523d14c5d2SYehuda Sadeh } 10533d14c5d2SYehuda Sadeh 10543d14c5d2SYehuda Sadeh /* crush */ 10553d14c5d2SYehuda Sadeh poolid = le32_to_cpu(pgid.pool); 10563d14c5d2SYehuda Sadeh ps = le16_to_cpu(pgid.ps); 10573d14c5d2SYehuda Sadeh preferred = (s16)le16_to_cpu(pgid.preferred); 10583d14c5d2SYehuda Sadeh 10593d14c5d2SYehuda Sadeh /* don't forcefeed bad device ids to crush */ 10603d14c5d2SYehuda Sadeh if (preferred >= osdmap->max_osd || 10613d14c5d2SYehuda Sadeh preferred >= osdmap->crush->max_devices) 10623d14c5d2SYehuda Sadeh preferred = -1; 10633d14c5d2SYehuda Sadeh 10643d14c5d2SYehuda Sadeh pool = __lookup_pg_pool(&osdmap->pg_pools, poolid); 10653d14c5d2SYehuda Sadeh if (!pool) 10663d14c5d2SYehuda Sadeh return NULL; 10673d14c5d2SYehuda Sadeh ruleno = crush_find_rule(osdmap->crush, pool->v.crush_ruleset, 10683d14c5d2SYehuda Sadeh pool->v.type, pool->v.size); 10693d14c5d2SYehuda Sadeh if (ruleno < 0) { 10703d14c5d2SYehuda Sadeh pr_err("no crush rule pool %d ruleset %d type %d size %d\n", 10713d14c5d2SYehuda Sadeh poolid, pool->v.crush_ruleset, pool->v.type, 10723d14c5d2SYehuda Sadeh pool->v.size); 10733d14c5d2SYehuda Sadeh return NULL; 10743d14c5d2SYehuda Sadeh } 10753d14c5d2SYehuda Sadeh 10763d14c5d2SYehuda Sadeh if (preferred >= 0) 10773d14c5d2SYehuda Sadeh pps = ceph_stable_mod(ps, 10783d14c5d2SYehuda Sadeh le32_to_cpu(pool->v.lpgp_num), 10793d14c5d2SYehuda Sadeh pool->lpgp_num_mask); 10803d14c5d2SYehuda Sadeh else 10813d14c5d2SYehuda Sadeh pps = ceph_stable_mod(ps, 10823d14c5d2SYehuda Sadeh le32_to_cpu(pool->v.pgp_num), 10833d14c5d2SYehuda Sadeh pool->pgp_num_mask); 10843d14c5d2SYehuda Sadeh pps += poolid; 10853d14c5d2SYehuda Sadeh *num = crush_do_rule(osdmap->crush, ruleno, pps, osds, 10863d14c5d2SYehuda Sadeh min_t(int, pool->v.size, *num), 10873d14c5d2SYehuda Sadeh preferred, osdmap->osd_weight); 10883d14c5d2SYehuda Sadeh return osds; 10893d14c5d2SYehuda Sadeh } 10903d14c5d2SYehuda Sadeh 10913d14c5d2SYehuda Sadeh /* 10923d14c5d2SYehuda Sadeh * Return acting set for given pgid. 10933d14c5d2SYehuda Sadeh */ 10943d14c5d2SYehuda Sadeh int ceph_calc_pg_acting(struct ceph_osdmap *osdmap, struct ceph_pg pgid, 10953d14c5d2SYehuda Sadeh int *acting) 10963d14c5d2SYehuda Sadeh { 10973d14c5d2SYehuda Sadeh int rawosds[CEPH_PG_MAX_SIZE], *osds; 10983d14c5d2SYehuda Sadeh int i, o, num = CEPH_PG_MAX_SIZE; 10993d14c5d2SYehuda Sadeh 11003d14c5d2SYehuda Sadeh osds = calc_pg_raw(osdmap, pgid, rawosds, &num); 11013d14c5d2SYehuda Sadeh if (!osds) 11023d14c5d2SYehuda Sadeh return -1; 11033d14c5d2SYehuda Sadeh 11043d14c5d2SYehuda Sadeh /* primary is first up osd */ 11053d14c5d2SYehuda Sadeh o = 0; 11063d14c5d2SYehuda Sadeh for (i = 0; i < num; i++) 11073d14c5d2SYehuda Sadeh if (ceph_osd_is_up(osdmap, osds[i])) 11083d14c5d2SYehuda Sadeh acting[o++] = osds[i]; 11093d14c5d2SYehuda Sadeh return o; 11103d14c5d2SYehuda Sadeh } 11113d14c5d2SYehuda Sadeh 11123d14c5d2SYehuda Sadeh /* 11133d14c5d2SYehuda Sadeh * Return primary osd for given pgid, or -1 if none. 11143d14c5d2SYehuda Sadeh */ 11153d14c5d2SYehuda Sadeh int ceph_calc_pg_primary(struct ceph_osdmap *osdmap, struct ceph_pg pgid) 11163d14c5d2SYehuda Sadeh { 11173d14c5d2SYehuda Sadeh int rawosds[CEPH_PG_MAX_SIZE], *osds; 11183d14c5d2SYehuda Sadeh int i, num = CEPH_PG_MAX_SIZE; 11193d14c5d2SYehuda Sadeh 11203d14c5d2SYehuda Sadeh osds = calc_pg_raw(osdmap, pgid, rawosds, &num); 11213d14c5d2SYehuda Sadeh if (!osds) 11223d14c5d2SYehuda Sadeh return -1; 11233d14c5d2SYehuda Sadeh 11243d14c5d2SYehuda Sadeh /* primary is first up osd */ 11253d14c5d2SYehuda Sadeh for (i = 0; i < num; i++) 11263d14c5d2SYehuda Sadeh if (ceph_osd_is_up(osdmap, osds[i])) 11273d14c5d2SYehuda Sadeh return osds[i]; 11283d14c5d2SYehuda Sadeh return -1; 11293d14c5d2SYehuda Sadeh } 11303d14c5d2SYehuda Sadeh EXPORT_SYMBOL(ceph_calc_pg_primary); 1131