]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - net/ceph/osdmap.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
libceph: NULL deref on osdmap_apply_incremental() error path
[mirror_ubuntu-artful-kernel.git] / net / ceph / osdmap.c
CommitLineData
f24e9980 1
3d14c5d2 2#include <linux/ceph/ceph_debug.h>
5a0e3ad6 3
3d14c5d2 4#include <linux/module.h>
5a0e3ad6 5#include <linux/slab.h>
f24e9980
SW		 6#include <asm/div64.h>
7
3d14c5d2
YS		 8#include <linux/ceph/libceph.h>
9#include <linux/ceph/osdmap.h>
10#include <linux/ceph/decode.h>
11#include <linux/crush/hash.h>
12#include <linux/crush/mapper.h>
f24e9980 13
0bb05da2 14char *ceph_osdmap_state_str(char *str, int len, u32 state)
f24e9980 15{
f24e9980 16 if (!len)
1ec3911d 17 return str;
f24e9980 18
1ec3911d
CD		 19 if ((state & CEPH_OSD_EXISTS) && (state & CEPH_OSD_UP))
20 snprintf(str, len, "exists, up");
21 else if (state & CEPH_OSD_EXISTS)
22 snprintf(str, len, "exists");
23 else if (state & CEPH_OSD_UP)
24 snprintf(str, len, "up");
25 else
f24e9980 26 snprintf(str, len, "doesn't exist");
1ec3911d 27
f24e9980
SW		 28 return str;
29}
30
31/* maps */
32
95c96174 33static int calc_bits_of(unsigned int t)
f24e9980
SW		 34{
35 int b = 0;
36 while (t) {
37 t = t >> 1;
38 b++;
39 }
40 return b;
41}
42
43/*
44 * the foo_mask is the smallest value 2^n-1 that is >= foo.
45 */
46static void calc_pg_masks(struct ceph_pg_pool_info *pi)
47{
4f6a7e5e
SW		 48 pi->pg_num_mask = (1 << calc_bits_of(pi->pg_num-1)) - 1;
49 pi->pgp_num_mask = (1 << calc_bits_of(pi->pgp_num-1)) - 1;
f24e9980
SW		 50}
51
52/*
53 * decode crush map
54 */
55static int crush_decode_uniform_bucket(void **p, void *end,
56 struct crush_bucket_uniform *b)
57{
58 dout("crush_decode_uniform_bucket %p to %p\n", *p, end);
59 ceph_decode_need(p, end, (1+b->h.size) * sizeof(u32), bad);
c89136ea 60 b->item_weight = ceph_decode_32(p);
f24e9980
SW		 61 return 0;
62bad:
63 return -EINVAL;
64}
65
66static int crush_decode_list_bucket(void **p, void *end,
67 struct crush_bucket_list *b)
68{
69 int j;
70 dout("crush_decode_list_bucket %p to %p\n", *p, end);
71 b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);
72 if (b->item_weights == NULL)
73 return -ENOMEM;
74 b->sum_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);
75 if (b->sum_weights == NULL)
76 return -ENOMEM;
77 ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad);
78 for (j = 0; j < b->h.size; j++) {
c89136ea
SW		 79 b->item_weights[j] = ceph_decode_32(p);
80 b->sum_weights[j] = ceph_decode_32(p);
f24e9980
SW		 81 }
82 return 0;
83bad:
84 return -EINVAL;
85}
86
87static int crush_decode_tree_bucket(void **p, void *end,
88 struct crush_bucket_tree *b)
89{
90 int j;
91 dout("crush_decode_tree_bucket %p to %p\n", *p, end);
82cd003a 92 ceph_decode_8_safe(p, end, b->num_nodes, bad);
f24e9980
SW		 93 b->node_weights = kcalloc(b->num_nodes, sizeof(u32), GFP_NOFS);
94 if (b->node_weights == NULL)
95 return -ENOMEM;
96 ceph_decode_need(p, end, b->num_nodes * sizeof(u32), bad);
97 for (j = 0; j < b->num_nodes; j++)
c89136ea 98 b->node_weights[j] = ceph_decode_32(p);
f24e9980
SW		 99 return 0;
100bad:
101 return -EINVAL;
102}
103
104static int crush_decode_straw_bucket(void **p, void *end,
105 struct crush_bucket_straw *b)
106{
107 int j;
108 dout("crush_decode_straw_bucket %p to %p\n", *p, end);
109 b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);
110 if (b->item_weights == NULL)
111 return -ENOMEM;
112 b->straws = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);
113 if (b->straws == NULL)
114 return -ENOMEM;
115 ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad);
116 for (j = 0; j < b->h.size; j++) {
c89136ea
SW		 117 b->item_weights[j] = ceph_decode_32(p);
118 b->straws[j] = ceph_decode_32(p);
f24e9980
SW		 119 }
120 return 0;
121bad:
122 return -EINVAL;
123}
124
958a2765
ID		 125static int crush_decode_straw2_bucket(void **p, void *end,
126 struct crush_bucket_straw2 *b)
127{
128 int j;
129 dout("crush_decode_straw2_bucket %p to %p\n", *p, end);
130 b->item_weights = kcalloc(b->h.size, sizeof(u32), GFP_NOFS);
131 if (b->item_weights == NULL)
132 return -ENOMEM;
133 ceph_decode_need(p, end, b->h.size * sizeof(u32), bad);
134 for (j = 0; j < b->h.size; j++)
135 b->item_weights[j] = ceph_decode_32(p);
136 return 0;
137bad:
138 return -EINVAL;
139}
140
5cf9c4a9
ID		 141static struct crush_choose_arg_map *alloc_choose_arg_map(void)
142{
143 struct crush_choose_arg_map *arg_map;
144
145 arg_map = kzalloc(sizeof(*arg_map), GFP_NOIO);
146 if (!arg_map)
147 return NULL;
148
149 RB_CLEAR_NODE(&arg_map->node);
150 return arg_map;
151}
152
153static void free_choose_arg_map(struct crush_choose_arg_map *arg_map)
154{
155 if (arg_map) {
156 int i, j;
157
158 WARN_ON(!RB_EMPTY_NODE(&arg_map->node));
159
160 for (i = 0; i < arg_map->size; i++) {
161 struct crush_choose_arg *arg = &arg_map->args[i];
162
163 for (j = 0; j < arg->weight_set_size; j++)
164 kfree(arg->weight_set[j].weights);
165 kfree(arg->weight_set);
166 kfree(arg->ids);
167 }
168 kfree(arg_map->args);
169 kfree(arg_map);
170 }
171}
172
173DEFINE_RB_FUNCS(choose_arg_map, struct crush_choose_arg_map, choose_args_index,
174 node);
175
176void clear_choose_args(struct crush_map *c)
177{
178 while (!RB_EMPTY_ROOT(&c->choose_args)) {
179 struct crush_choose_arg_map *arg_map =
180 rb_entry(rb_first(&c->choose_args),
181 struct crush_choose_arg_map, node);
182
183 erase_choose_arg_map(&c->choose_args, arg_map);
184 free_choose_arg_map(arg_map);
185 }
186}
187
188static u32 *decode_array_32_alloc(void **p, void *end, u32 *plen)
189{
190 u32 *a = NULL;
191 u32 len;
192 int ret;
193
194 ceph_decode_32_safe(p, end, len, e_inval);
195 if (len) {
196 u32 i;
197
198 a = kmalloc_array(len, sizeof(u32), GFP_NOIO);
199 if (!a) {
200 ret = -ENOMEM;
201 goto fail;
202 }
203
204 ceph_decode_need(p, end, len * sizeof(u32), e_inval);
205 for (i = 0; i < len; i++)
206 a[i] = ceph_decode_32(p);
207 }
208
209 *plen = len;
210 return a;
211
212e_inval:
213 ret = -EINVAL;
214fail:
215 kfree(a);
216 return ERR_PTR(ret);
217}
218
219/*
220 * Assumes @arg is zero-initialized.
221 */
222static int decode_choose_arg(void **p, void *end, struct crush_choose_arg *arg)
223{
224 int ret;
225
226 ceph_decode_32_safe(p, end, arg->weight_set_size, e_inval);
227 if (arg->weight_set_size) {
228 u32 i;
229
230 arg->weight_set = kmalloc_array(arg->weight_set_size,
231 sizeof(*arg->weight_set),
232 GFP_NOIO);
233 if (!arg->weight_set)
234 return -ENOMEM;
235
236 for (i = 0; i < arg->weight_set_size; i++) {
237 struct crush_weight_set *w = &arg->weight_set[i];
238
239 w->weights = decode_array_32_alloc(p, end, &w->size);
240 if (IS_ERR(w->weights)) {
241 ret = PTR_ERR(w->weights);
242 w->weights = NULL;
243 return ret;
244 }
245 }
246 }
247
248 arg->ids = decode_array_32_alloc(p, end, &arg->ids_size);
249 if (IS_ERR(arg->ids)) {
250 ret = PTR_ERR(arg->ids);
251 arg->ids = NULL;
252 return ret;
253 }
254
255 return 0;
256
257e_inval:
258 return -EINVAL;
259}
260
261static int decode_choose_args(void **p, void *end, struct crush_map *c)
262{
263 struct crush_choose_arg_map *arg_map = NULL;
264 u32 num_choose_arg_maps, num_buckets;
265 int ret;
266
267 ceph_decode_32_safe(p, end, num_choose_arg_maps, e_inval);
268 while (num_choose_arg_maps--) {
269 arg_map = alloc_choose_arg_map();
270 if (!arg_map) {
271 ret = -ENOMEM;
272 goto fail;
273 }
274
275 ceph_decode_64_safe(p, end, arg_map->choose_args_index,
276 e_inval);
277 arg_map->size = c->max_buckets;
278 arg_map->args = kcalloc(arg_map->size, sizeof(*arg_map->args),
279 GFP_NOIO);
280 if (!arg_map->args) {
281 ret = -ENOMEM;
282 goto fail;
283 }
284
285 ceph_decode_32_safe(p, end, num_buckets, e_inval);
286 while (num_buckets--) {
287 struct crush_choose_arg *arg;
288 u32 bucket_index;
289
290 ceph_decode_32_safe(p, end, bucket_index, e_inval);
291 if (bucket_index >= arg_map->size)
292 goto e_inval;
293
294 arg = &arg_map->args[bucket_index];
295 ret = decode_choose_arg(p, end, arg);
296 if (ret)
297 goto fail;
298 }
299
300 insert_choose_arg_map(&c->choose_args, arg_map);
301 }
302
303 return 0;
304
305e_inval:
306 ret = -EINVAL;
307fail:
308 free_choose_arg_map(arg_map);
309 return ret;
310}
311
66a0e2d5
ID		 312static void crush_finalize(struct crush_map *c)
313{
314 __s32 b;
315
316 /* Space for the array of pointers to per-bucket workspace */
317 c->working_size = sizeof(struct crush_work) +
318 c->max_buckets * sizeof(struct crush_work_bucket *);
319
320 for (b = 0; b < c->max_buckets; b++) {
321 if (!c->buckets[b])
322 continue;
323
324 switch (c->buckets[b]->alg) {
325 default:
326 /*
327 * The base case, permutation variables and
328 * the pointer to the permutation array.
329 */
330 c->working_size += sizeof(struct crush_work_bucket);
331 break;
332 }
333 /* Every bucket has a permutation array. */
334 c->working_size += c->buckets[b]->size * sizeof(__u32);
335 }
336}
337
f24e9980
SW		 338static struct crush_map *crush_decode(void *pbyval, void *end)
339{
340 struct crush_map *c;
341 int err = -EINVAL;
342 int i, j;
343 void **p = &pbyval;
344 void *start = pbyval;
345 u32 magic;
346
347 dout("crush_decode %p to %p len %d\n", *p, end, (int)(end - *p));
348
349 c = kzalloc(sizeof(*c), GFP_NOFS);
350 if (c == NULL)
351 return ERR_PTR(-ENOMEM);
352
5cf9c4a9
ID		 353 c->choose_args = RB_ROOT;
354
546f04ef
SW		 355 /* set tunables to default values */
356 c->choose_local_tries = 2;
357 c->choose_local_fallback_tries = 5;
358 c->choose_total_tries = 19;
1604f488 359 c->chooseleaf_descend_once = 0;
546f04ef 360
f24e9980 361 ceph_decode_need(p, end, 4*sizeof(u32), bad);
c89136ea 362 magic = ceph_decode_32(p);
f24e9980
SW		 363 if (magic != CRUSH_MAGIC) {
364 pr_err("crush_decode magic %x != current %x\n",
95c96174 365 (unsigned int)magic, (unsigned int)CRUSH_MAGIC);
f24e9980
SW		 366 goto bad;
367 }
c89136ea
SW		 368 c->max_buckets = ceph_decode_32(p);
369 c->max_rules = ceph_decode_32(p);
370 c->max_devices = ceph_decode_32(p);
f24e9980 371
f24e9980
SW		 372 c->buckets = kcalloc(c->max_buckets, sizeof(*c->buckets), GFP_NOFS);
373 if (c->buckets == NULL)
374 goto badmem;
375 c->rules = kcalloc(c->max_rules, sizeof(*c->rules), GFP_NOFS);
376 if (c->rules == NULL)
377 goto badmem;
378
379 /* buckets */
380 for (i = 0; i < c->max_buckets; i++) {
381 int size = 0;
382 u32 alg;
383 struct crush_bucket *b;
384
385 ceph_decode_32_safe(p, end, alg, bad);
386 if (alg == 0) {
387 c->buckets[i] = NULL;
388 continue;
389 }
390 dout("crush_decode bucket %d off %x %p to %p\n",
391 i, (int)(*p-start), *p, end);
392
393 switch (alg) {
394 case CRUSH_BUCKET_UNIFORM:
395 size = sizeof(struct crush_bucket_uniform);
396 break;
397 case CRUSH_BUCKET_LIST:
398 size = sizeof(struct crush_bucket_list);
399 break;
400 case CRUSH_BUCKET_TREE:
401 size = sizeof(struct crush_bucket_tree);
402 break;
403 case CRUSH_BUCKET_STRAW:
404 size = sizeof(struct crush_bucket_straw);
405 break;
958a2765
ID		 406 case CRUSH_BUCKET_STRAW2:
407 size = sizeof(struct crush_bucket_straw2);
408 break;
f24e9980 409 default:
30dc6381 410 err = -EINVAL;
f24e9980
SW		 411 goto bad;
412 }
413 BUG_ON(size == 0);
414 b = c->buckets[i] = kzalloc(size, GFP_NOFS);
415 if (b == NULL)
416 goto badmem;
417
418 ceph_decode_need(p, end, 4*sizeof(u32), bad);
c89136ea
SW		 419 b->id = ceph_decode_32(p);
420 b->type = ceph_decode_16(p);
fb690390
SW		 421 b->alg = ceph_decode_8(p);
422 b->hash = ceph_decode_8(p);
c89136ea
SW		 423 b->weight = ceph_decode_32(p);
424 b->size = ceph_decode_32(p);
f24e9980
SW		 425
426 dout("crush_decode bucket size %d off %x %p to %p\n",
427 b->size, (int)(*p-start), *p, end);
428
429 b->items = kcalloc(b->size, sizeof(__s32), GFP_NOFS);
430 if (b->items == NULL)
431 goto badmem;
f24e9980
SW		 432
433 ceph_decode_need(p, end, b->size*sizeof(u32), bad);
434 for (j = 0; j < b->size; j++)
c89136ea 435 b->items[j] = ceph_decode_32(p);
f24e9980
SW		 436
437 switch (b->alg) {
438 case CRUSH_BUCKET_UNIFORM:
439 err = crush_decode_uniform_bucket(p, end,
440 (struct crush_bucket_uniform *)b);
441 if (err < 0)
442 goto bad;
443 break;
444 case CRUSH_BUCKET_LIST:
445 err = crush_decode_list_bucket(p, end,
446 (struct crush_bucket_list *)b);
447 if (err < 0)
448 goto bad;
449 break;
450 case CRUSH_BUCKET_TREE:
451 err = crush_decode_tree_bucket(p, end,
452 (struct crush_bucket_tree *)b);
453 if (err < 0)
454 goto bad;
455 break;
456 case CRUSH_BUCKET_STRAW:
457 err = crush_decode_straw_bucket(p, end,
458 (struct crush_bucket_straw *)b);
459 if (err < 0)
460 goto bad;
461 break;
958a2765
ID		 462 case CRUSH_BUCKET_STRAW2:
463 err = crush_decode_straw2_bucket(p, end,
464 (struct crush_bucket_straw2 *)b);
465 if (err < 0)
466 goto bad;
467 break;
f24e9980
SW		 468 }
469 }
470
471 /* rules */
472 dout("rule vec is %p\n", c->rules);
473 for (i = 0; i < c->max_rules; i++) {
474 u32 yes;
475 struct crush_rule *r;
476
293dffaa 477 err = -EINVAL;
f24e9980
SW		 478 ceph_decode_32_safe(p, end, yes, bad);
479 if (!yes) {
480 dout("crush_decode NO rule %d off %x %p to %p\n",
481 i, (int)(*p-start), *p, end);
482 c->rules[i] = NULL;
483 continue;
484 }
485
486 dout("crush_decode rule %d off %x %p to %p\n",
487 i, (int)(*p-start), *p, end);
488
489 /* len */
490 ceph_decode_32_safe(p, end, yes, bad);
491#if BITS_PER_LONG == 32
30dc6381 492 err = -EINVAL;
64486697
XW		 493 if (yes > (ULONG_MAX - sizeof(*r))
494 / sizeof(struct crush_rule_step))
f24e9980
SW		 495 goto bad;
496#endif
497 r = c->rules[i] = kmalloc(sizeof(*r) +
498 yes*sizeof(struct crush_rule_step),
499 GFP_NOFS);
500 if (r == NULL)
501 goto badmem;
502 dout(" rule %d is at %p\n", i, r);
503 r->len = yes;
504 ceph_decode_copy_safe(p, end, &r->mask, 4, bad); /* 4 u8's */
505 ceph_decode_need(p, end, r->len*3*sizeof(u32), bad);
506 for (j = 0; j < r->len; j++) {
c89136ea
SW		 507 r->steps[j].op = ceph_decode_32(p);
508 r->steps[j].arg1 = ceph_decode_32(p);
509 r->steps[j].arg2 = ceph_decode_32(p);
f24e9980
SW		 510 }
511 }
512
278b1d70
ID		 513 ceph_decode_skip_map(p, end, 32, string, bad); /* type_map */
514 ceph_decode_skip_map(p, end, 32, string, bad); /* name_map */
515 ceph_decode_skip_map(p, end, 32, string, bad); /* rule_name_map */
546f04ef
SW		 516
517 /* tunables */
518 ceph_decode_need(p, end, 3*sizeof(u32), done);
519 c->choose_local_tries = ceph_decode_32(p);
520 c->choose_local_fallback_tries = ceph_decode_32(p);
521 c->choose_total_tries = ceph_decode_32(p);
b9b519b7 522 dout("crush decode tunable choose_local_tries = %d\n",
546f04ef 523 c->choose_local_tries);
b9b519b7 524 dout("crush decode tunable choose_local_fallback_tries = %d\n",
546f04ef 525 c->choose_local_fallback_tries);
b9b519b7 526 dout("crush decode tunable choose_total_tries = %d\n",
546f04ef 527 c->choose_total_tries);
f24e9980 528
1604f488
JS		 529 ceph_decode_need(p, end, sizeof(u32), done);
530 c->chooseleaf_descend_once = ceph_decode_32(p);
b9b519b7 531 dout("crush decode tunable chooseleaf_descend_once = %d\n",
1604f488
JS		 532 c->chooseleaf_descend_once);
533
f140662f
ID		 534 ceph_decode_need(p, end, sizeof(u8), done);
535 c->chooseleaf_vary_r = ceph_decode_8(p);
b9b519b7 536 dout("crush decode tunable chooseleaf_vary_r = %d\n",
f140662f
ID		 537 c->chooseleaf_vary_r);
538
b9b519b7
ID		 539 /* skip straw_calc_version, allowed_bucket_algs */
540 ceph_decode_need(p, end, sizeof(u8) + sizeof(u32), done);
541 *p += sizeof(u8) + sizeof(u32);
542
543 ceph_decode_need(p, end, sizeof(u8), done);
544 c->chooseleaf_stable = ceph_decode_8(p);
545 dout("crush decode tunable chooseleaf_stable = %d\n",
546 c->chooseleaf_stable);
547
5cf9c4a9
ID		 548 if (*p != end) {
549 /* class_map */
550 ceph_decode_skip_map(p, end, 32, 32, bad);
551 /* class_name */
552 ceph_decode_skip_map(p, end, 32, string, bad);
553 /* class_bucket */
554 ceph_decode_skip_map_of_map(p, end, 32, 32, 32, bad);
555 }
556
557 if (*p != end) {
558 err = decode_choose_args(p, end, c);
559 if (err)
560 goto bad;
561 }
562
546f04ef 563done:
9afd30db 564 crush_finalize(c);
f24e9980
SW		 565 dout("crush_decode success\n");
566 return c;
567
568badmem:
569 err = -ENOMEM;
570bad:
571 dout("crush_decode fail %d\n", err);
572 crush_destroy(c);
573 return ERR_PTR(err);
574}
575
f984cb76 576int ceph_pg_compare(const struct ceph_pg *lhs, const struct ceph_pg *rhs)
51042122 577{
f984cb76 578 if (lhs->pool < rhs->pool)
5b191d99 579 return -1;
f984cb76 580 if (lhs->pool > rhs->pool)
5b191d99 581 return 1;
f984cb76 582 if (lhs->seed < rhs->seed)
51042122 583 return -1;
f984cb76 584 if (lhs->seed > rhs->seed)
51042122 585 return 1;
f984cb76 586
51042122
SW		 587 return 0;
588}
589
a02a946d
ID		 590int ceph_spg_compare(const struct ceph_spg *lhs, const struct ceph_spg *rhs)
591{
592 int ret;
593
594 ret = ceph_pg_compare(&lhs->pgid, &rhs->pgid);
595 if (ret)
596 return ret;
597
598 if (lhs->shard < rhs->shard)
599 return -1;
600 if (lhs->shard > rhs->shard)
601 return 1;
602
603 return 0;
604}
605
a303bb0e
ID		 606static struct ceph_pg_mapping *alloc_pg_mapping(size_t payload_len)
607{
608 struct ceph_pg_mapping *pg;
609
610 pg = kmalloc(sizeof(*pg) + payload_len, GFP_NOIO);
611 if (!pg)
612 return NULL;
613
614 RB_CLEAR_NODE(&pg->node);
615 return pg;
616}
617
618static void free_pg_mapping(struct ceph_pg_mapping *pg)
619{
620 WARN_ON(!RB_EMPTY_NODE(&pg->node));
621
622 kfree(pg);
623}
624
f984cb76
ID		 625/*
626 * rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid
627 * to a set of osds) and primary_temp (explicit primary setting)
628 */
ab75144b
ID		 629DEFINE_RB_FUNCS2(pg_mapping, struct ceph_pg_mapping, pgid, ceph_pg_compare,
630 RB_BYPTR, const struct ceph_pg *, node)
8adc8b3d 631
4fc51be8
SW		 632/*
633 * rbtree of pg pool info
634 */
635static int __insert_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *new)
636{
637 struct rb_node **p = &root->rb_node;
638 struct rb_node *parent = NULL;
639 struct ceph_pg_pool_info *pi = NULL;
640
641 while (*p) {
642 parent = *p;
643 pi = rb_entry(parent, struct ceph_pg_pool_info, node);
644 if (new->id < pi->id)
645 p = &(*p)->rb_left;
646 else if (new->id > pi->id)
647 p = &(*p)->rb_right;
648 else
649 return -EEXIST;
650 }
651
652 rb_link_node(&new->node, parent, p);
653 rb_insert_color(&new->node, root);
654 return 0;
655}
656
4f6a7e5e 657static struct ceph_pg_pool_info *__lookup_pg_pool(struct rb_root *root, u64 id)
4fc51be8
SW		 658{
659 struct ceph_pg_pool_info *pi;
660 struct rb_node *n = root->rb_node;
661
662 while (n) {
663 pi = rb_entry(n, struct ceph_pg_pool_info, node);
664 if (id < pi->id)
665 n = n->rb_left;
666 else if (id > pi->id)
667 n = n->rb_right;
668 else
669 return pi;
670 }
671 return NULL;
672}
673
ce7f6a27
ID		 674struct ceph_pg_pool_info *ceph_pg_pool_by_id(struct ceph_osdmap *map, u64 id)
675{
676 return __lookup_pg_pool(&map->pg_pools, id);
677}
678
72afc71f
AE		 679const char *ceph_pg_pool_name_by_id(struct ceph_osdmap *map, u64 id)
680{
681 struct ceph_pg_pool_info *pi;
682
683 if (id == CEPH_NOPOOL)
684 return NULL;
685
686 if (WARN_ON_ONCE(id > (u64) INT_MAX))
687 return NULL;
688
689 pi = __lookup_pg_pool(&map->pg_pools, (int) id);
690
691 return pi ? pi->name : NULL;
692}
693EXPORT_SYMBOL(ceph_pg_pool_name_by_id);
694
7669a2c9
YS		 695int ceph_pg_poolid_by_name(struct ceph_osdmap *map, const char *name)
696{
697 struct rb_node *rbp;
698
699 for (rbp = rb_first(&map->pg_pools); rbp; rbp = rb_next(rbp)) {
700 struct ceph_pg_pool_info *pi =
701 rb_entry(rbp, struct ceph_pg_pool_info, node);
702 if (pi->name && strcmp(pi->name, name) == 0)
703 return pi->id;
704 }
705 return -ENOENT;
706}
3d14c5d2 707EXPORT_SYMBOL(ceph_pg_poolid_by_name);
7669a2c9 708
2844a76a
SW		 709static void __remove_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *pi)
710{
711 rb_erase(&pi->node, root);
712 kfree(pi->name);
713 kfree(pi);
714}
715
0f70c7ee 716static int decode_pool(void **p, void *end, struct ceph_pg_pool_info *pi)
efd7576b 717{
4f6a7e5e
SW		 718 u8 ev, cv;
719 unsigned len, num;
720 void *pool_end;
721
722 ceph_decode_need(p, end, 2 + 4, bad);
723 ev = ceph_decode_8(p); /* encoding version */
724 cv = ceph_decode_8(p); /* compat version */
725 if (ev < 5) {
b9a67899 726 pr_warn("got v %d < 5 cv %d of ceph_pg_pool\n", ev, cv);
4f6a7e5e
SW		 727 return -EINVAL;
728 }
17a13e40 729 if (cv > 9) {
b9a67899 730 pr_warn("got v %d cv %d > 9 of ceph_pg_pool\n", ev, cv);
4f6a7e5e
SW		 731 return -EINVAL;
732 }
733 len = ceph_decode_32(p);
734 ceph_decode_need(p, end, len, bad);
735 pool_end = *p + len;
73a7e693 736
4f6a7e5e
SW		 737 pi->type = ceph_decode_8(p);
738 pi->size = ceph_decode_8(p);
739 pi->crush_ruleset = ceph_decode_8(p);
740 pi->object_hash = ceph_decode_8(p);
73a7e693 741
4f6a7e5e
SW		 742 pi->pg_num = ceph_decode_32(p);
743 pi->pgp_num = ceph_decode_32(p);
744
745 *p += 4 + 4; /* skip lpg* */
746 *p += 4; /* skip last_change */
747 *p += 8 + 4; /* skip snap_seq, snap_epoch */
748
749 /* skip snaps */
750 num = ceph_decode_32(p);
751 while (num--) {
752 *p += 8; /* snapid key */
753 *p += 1 + 1; /* versions */
754 len = ceph_decode_32(p);
755 *p += len;
73a7e693
SW		 756 }
757
17a13e40 758 /* skip removed_snaps */
4f6a7e5e
SW		 759 num = ceph_decode_32(p);
760 *p += num * (8 + 8);
761
762 *p += 8; /* skip auid */
763 pi->flags = ceph_decode_64(p);
17a13e40
ID		 764 *p += 4; /* skip crash_replay_interval */
765
766 if (ev >= 7)
04812acf
ID		 767 pi->min_size = ceph_decode_8(p);
768 else
769 pi->min_size = pi->size - pi->size / 2;
17a13e40
ID		 770
771 if (ev >= 8)
772 *p += 8 + 8; /* skip quota_max_* */
773
774 if (ev >= 9) {
775 /* skip tiers */
776 num = ceph_decode_32(p);
777 *p += num * 8;
778
779 *p += 8; /* skip tier_of */
780 *p += 1; /* skip cache_mode */
781
782 pi->read_tier = ceph_decode_64(p);
783 pi->write_tier = ceph_decode_64(p);
784 } else {
785 pi->read_tier = -1;
786 pi->write_tier = -1;
787 }
4f6a7e5e 788
04812acf
ID		 789 if (ev >= 10) {
790 /* skip properties */
791 num = ceph_decode_32(p);
792 while (num--) {
793 len = ceph_decode_32(p);
794 *p += len; /* key */
795 len = ceph_decode_32(p);
796 *p += len; /* val */
797 }
798 }
799
800 if (ev >= 11) {
801 /* skip hit_set_params */
802 *p += 1 + 1; /* versions */
803 len = ceph_decode_32(p);
804 *p += len;
805
806 *p += 4; /* skip hit_set_period */
807 *p += 4; /* skip hit_set_count */
808 }
809
810 if (ev >= 12)
811 *p += 4; /* skip stripe_width */
812
813 if (ev >= 13) {
814 *p += 8; /* skip target_max_bytes */
815 *p += 8; /* skip target_max_objects */
816 *p += 4; /* skip cache_target_dirty_ratio_micro */
817 *p += 4; /* skip cache_target_full_ratio_micro */
818 *p += 4; /* skip cache_min_flush_age */
819 *p += 4; /* skip cache_min_evict_age */
820 }
821
822 if (ev >= 14) {
823 /* skip erasure_code_profile */
824 len = ceph_decode_32(p);
825 *p += len;
826 }
827
8e48cf00
ID		 828 /*
829 * last_force_op_resend_preluminous, will be overridden if the
830 * map was encoded with RESEND_ON_SPLIT
831 */
04812acf
ID		 832 if (ev >= 15)
833 pi->last_force_request_resend = ceph_decode_32(p);
834 else
835 pi->last_force_request_resend = 0;
836
8e48cf00
ID		 837 if (ev >= 16)
838 *p += 4; /* skip min_read_recency_for_promote */
839
840 if (ev >= 17)
841 *p += 8; /* skip expected_num_objects */
842
843 if (ev >= 19)
844 *p += 4; /* skip cache_target_dirty_high_ratio_micro */
845
846 if (ev >= 20)
847 *p += 4; /* skip min_write_recency_for_promote */
848
849 if (ev >= 21)
850 *p += 1; /* skip use_gmt_hitset */
851
852 if (ev >= 22)
853 *p += 1; /* skip fast_read */
854
855 if (ev >= 23) {
856 *p += 4; /* skip hit_set_grade_decay_rate */
857 *p += 4; /* skip hit_set_search_last_n */
858 }
859
860 if (ev >= 24) {
861 /* skip opts */
862 *p += 1 + 1; /* versions */
863 len = ceph_decode_32(p);
864 *p += len;
865 }
866
867 if (ev >= 25)
868 pi->last_force_request_resend = ceph_decode_32(p);
869
4f6a7e5e
SW		 870 /* ignore the rest */
871
872 *p = pool_end;
873 calc_pg_masks(pi);
73a7e693
SW		 874 return 0;
875
876bad:
877 return -EINVAL;
efd7576b
SW		 878}
879
0f70c7ee 880static int decode_pool_names(void **p, void *end, struct ceph_osdmap *map)
2844a76a
SW		 881{
882 struct ceph_pg_pool_info *pi;
4f6a7e5e
SW		 883 u32 num, len;
884 u64 pool;
2844a76a
SW		 885
886 ceph_decode_32_safe(p, end, num, bad);
887 dout(" %d pool names\n", num);
888 while (num--) {
4f6a7e5e 889 ceph_decode_64_safe(p, end, pool, bad);
2844a76a 890 ceph_decode_32_safe(p, end, len, bad);
4f6a7e5e 891 dout(" pool %llu len %d\n", pool, len);
ad3b904c 892 ceph_decode_need(p, end, len, bad);
2844a76a
SW		 893 pi = __lookup_pg_pool(&map->pg_pools, pool);
894 if (pi) {
ad3b904c
XW		 895 char *name = kstrndup(*p, len, GFP_NOFS);
896
897 if (!name)
898 return -ENOMEM;
2844a76a 899 kfree(pi->name);
ad3b904c
XW		 900 pi->name = name;
901 dout(" name is %s\n", pi->name);
2844a76a
SW		 902 }
903 *p += len;
904 }
905 return 0;
906
907bad:
908 return -EINVAL;
909}
910
911/*
912 * osd map
913 */
e5253a7b
ID		 914struct ceph_osdmap *ceph_osdmap_alloc(void)
915{
916 struct ceph_osdmap *map;
917
918 map = kzalloc(sizeof(*map), GFP_NOIO);
919 if (!map)
920 return NULL;
921
922 map->pg_pools = RB_ROOT;
923 map->pool_max = -1;
924 map->pg_temp = RB_ROOT;
925 map->primary_temp = RB_ROOT;
6f428df4
ID		 926 map->pg_upmap = RB_ROOT;
927 map->pg_upmap_items = RB_ROOT;
743efcff 928 mutex_init(&map->crush_workspace_mutex);
e5253a7b
ID		 929
930 return map;
931}
932
2844a76a
SW		 933void ceph_osdmap_destroy(struct ceph_osdmap *map)
934{
935 dout("osdmap_destroy %p\n", map);
936 if (map->crush)
937 crush_destroy(map->crush);
938 while (!RB_EMPTY_ROOT(&map->pg_temp)) {
939 struct ceph_pg_mapping *pg =
940 rb_entry(rb_first(&map->pg_temp),
941 struct ceph_pg_mapping, node);
ab75144b
ID		 942 erase_pg_mapping(&map->pg_temp, pg);
943 free_pg_mapping(pg);
2844a76a 944 }
9686f94c
ID		 945 while (!RB_EMPTY_ROOT(&map->primary_temp)) {
946 struct ceph_pg_mapping *pg =
947 rb_entry(rb_first(&map->primary_temp),
948 struct ceph_pg_mapping, node);
ab75144b
ID		 949 erase_pg_mapping(&map->primary_temp, pg);
950 free_pg_mapping(pg);
9686f94c 951 }
6f428df4
ID		 952 while (!RB_EMPTY_ROOT(&map->pg_upmap)) {
953 struct ceph_pg_mapping *pg =
954 rb_entry(rb_first(&map->pg_upmap),
955 struct ceph_pg_mapping, node);
956 rb_erase(&pg->node, &map->pg_upmap);
957 kfree(pg);
958 }
959 while (!RB_EMPTY_ROOT(&map->pg_upmap_items)) {
960 struct ceph_pg_mapping *pg =
961 rb_entry(rb_first(&map->pg_upmap_items),
962 struct ceph_pg_mapping, node);
963 rb_erase(&pg->node, &map->pg_upmap_items);
964 kfree(pg);
965 }
2844a76a
SW		 966 while (!RB_EMPTY_ROOT(&map->pg_pools)) {
967 struct ceph_pg_pool_info *pi =
968 rb_entry(rb_first(&map->pg_pools),
969 struct ceph_pg_pool_info, node);
970 __remove_pg_pool(&map->pg_pools, pi);
971 }
972 kfree(map->osd_state);
973 kfree(map->osd_weight);
974 kfree(map->osd_addr);
2cfa34f2 975 kfree(map->osd_primary_affinity);
66a0e2d5 976 kfree(map->crush_workspace);
2844a76a
SW		 977 kfree(map);
978}
979
980/*
4d60351f
ID		 981 * Adjust max_osd value, (re)allocate arrays.
982 *
983 * The new elements are properly initialized.
2844a76a
SW		 984 */
985static int osdmap_set_max_osd(struct ceph_osdmap *map, int max)
986{
0bb05da2 987 u32 *state;
2844a76a 988 u32 *weight;
4d60351f
ID		 989 struct ceph_entity_addr *addr;
990 int i;
2844a76a 991
4d60351f 992 state = krealloc(map->osd_state, max*sizeof(*state), GFP_NOFS);
589506f1
LR		 993 if (!state)
994 return -ENOMEM;
995 map->osd_state = state;
996
4d60351f 997 weight = krealloc(map->osd_weight, max*sizeof(*weight), GFP_NOFS);
589506f1
LR		 998 if (!weight)
999 return -ENOMEM;
1000 map->osd_weight = weight;
4d60351f 1001
589506f1
LR		 1002 addr = krealloc(map->osd_addr, max*sizeof(*addr), GFP_NOFS);
1003 if (!addr)
2844a76a 1004 return -ENOMEM;
589506f1 1005 map->osd_addr = addr;
2844a76a 1006
4d60351f 1007 for (i = map->max_osd; i < max; i++) {
589506f1
LR		 1008 map->osd_state[i] = 0;
1009 map->osd_weight[i] = CEPH_OSD_OUT;
1010 memset(map->osd_addr + i, 0, sizeof(*map->osd_addr));
2844a76a
SW		 1011 }
1012
2cfa34f2
ID		 1013 if (map->osd_primary_affinity) {
1014 u32 *affinity;
1015
1016 affinity = krealloc(map->osd_primary_affinity,
1017 max*sizeof(*affinity), GFP_NOFS);
1018 if (!affinity)
1019 return -ENOMEM;
589506f1 1020 map->osd_primary_affinity = affinity;
2cfa34f2
ID		 1021
1022 for (i = map->max_osd; i < max; i++)
589506f1
LR		 1023 map->osd_primary_affinity[i] =
1024 CEPH_OSD_DEFAULT_PRIMARY_AFFINITY;
2cfa34f2
ID		 1025 }
1026
2844a76a 1027 map->max_osd = max;
4d60351f 1028
2844a76a
SW		 1029 return 0;
1030}
1031
1b6a78b5
ID		 1032static int osdmap_set_crush(struct ceph_osdmap *map, struct crush_map *crush)
1033{
66a0e2d5 1034 void *workspace;
743efcff 1035 size_t work_size;
66a0e2d5 1036
1b6a78b5
ID		 1037 if (IS_ERR(crush))
1038 return PTR_ERR(crush);
1039
743efcff
ID		 1040 work_size = crush_work_size(crush, CEPH_PG_MAX_SIZE);
1041 dout("%s work_size %zu bytes\n", __func__, work_size);
1042 workspace = kmalloc(work_size, GFP_NOIO);
66a0e2d5
ID		 1043 if (!workspace) {
1044 crush_destroy(crush);
1045 return -ENOMEM;
1046 }
1047 crush_init_workspace(crush, workspace);
1048
1b6a78b5
ID		 1049 if (map->crush)
1050 crush_destroy(map->crush);
66a0e2d5 1051 kfree(map->crush_workspace);
1b6a78b5 1052 map->crush = crush;
66a0e2d5 1053 map->crush_workspace = workspace;
1b6a78b5
ID		 1054 return 0;
1055}
1056
ec7af972
ID		 1057#define OSDMAP_WRAPPER_COMPAT_VER 7
1058#define OSDMAP_CLIENT_DATA_COMPAT_VER 1
1059
1060/*
1061 * Return 0 or error. On success, *v is set to 0 for old (v6) osdmaps,
1062 * to struct_v of the client_data section for new (v7 and above)
1063 * osdmaps.
1064 */
1065static int get_osdmap_client_data_v(void **p, void *end,
1066 const char *prefix, u8 *v)
1067{
1068 u8 struct_v;
1069
1070 ceph_decode_8_safe(p, end, struct_v, e_inval);
1071 if (struct_v >= 7) {
1072 u8 struct_compat;
1073
1074 ceph_decode_8_safe(p, end, struct_compat, e_inval);
1075 if (struct_compat > OSDMAP_WRAPPER_COMPAT_VER) {
b9a67899
JP		 1076 pr_warn("got v %d cv %d > %d of %s ceph_osdmap\n",
1077 struct_v, struct_compat,
1078 OSDMAP_WRAPPER_COMPAT_VER, prefix);
ec7af972
ID		 1079 return -EINVAL;
1080 }
1081 *p += 4; /* ignore wrapper struct_len */
1082
1083 ceph_decode_8_safe(p, end, struct_v, e_inval);
1084 ceph_decode_8_safe(p, end, struct_compat, e_inval);
1085 if (struct_compat > OSDMAP_CLIENT_DATA_COMPAT_VER) {
b9a67899
JP		 1086 pr_warn("got v %d cv %d > %d of %s ceph_osdmap client data\n",
1087 struct_v, struct_compat,
1088 OSDMAP_CLIENT_DATA_COMPAT_VER, prefix);
ec7af972
ID		 1089 return -EINVAL;
1090 }
1091 *p += 4; /* ignore client data struct_len */
1092 } else {
1093 u16 version;
1094
1095 *p -= 1;
1096 ceph_decode_16_safe(p, end, version, e_inval);
1097 if (version < 6) {
b9a67899
JP		 1098 pr_warn("got v %d < 6 of %s ceph_osdmap\n",
1099 version, prefix);
ec7af972
ID		 1100 return -EINVAL;
1101 }
1102
1103 /* old osdmap enconding */
1104 struct_v = 0;
1105 }
1106
1107 *v = struct_v;
1108 return 0;
1109
1110e_inval:
1111 return -EINVAL;
1112}
1113
433fbdd3
ID		 1114static int __decode_pools(void **p, void *end, struct ceph_osdmap *map,
1115 bool incremental)
1116{
1117 u32 n;
1118
1119 ceph_decode_32_safe(p, end, n, e_inval);
1120 while (n--) {
1121 struct ceph_pg_pool_info *pi;
1122 u64 pool;
1123 int ret;
1124
1125 ceph_decode_64_safe(p, end, pool, e_inval);
1126
1127 pi = __lookup_pg_pool(&map->pg_pools, pool);
1128 if (!incremental || !pi) {
1129 pi = kzalloc(sizeof(*pi), GFP_NOFS);
1130 if (!pi)
1131 return -ENOMEM;
1132
1133 pi->id = pool;
1134
1135 ret = __insert_pg_pool(&map->pg_pools, pi);
1136 if (ret) {
1137 kfree(pi);
1138 return ret;
1139 }
1140 }
1141
1142 ret = decode_pool(p, end, pi);
1143 if (ret)
1144 return ret;
1145 }
1146
1147 return 0;
1148
1149e_inval:
1150 return -EINVAL;
1151}
1152
1153static int decode_pools(void **p, void *end, struct ceph_osdmap *map)
1154{
1155 return __decode_pools(p, end, map, false);
1156}
1157
1158static int decode_new_pools(void **p, void *end, struct ceph_osdmap *map)
1159{
1160 return __decode_pools(p, end, map, true);
1161}
1162
a303bb0e
ID		 1163typedef struct ceph_pg_mapping *(*decode_mapping_fn_t)(void **, void *, bool);
1164
1165static int decode_pg_mapping(void **p, void *end, struct rb_root *mapping_root,
1166 decode_mapping_fn_t fn, bool incremental)
10db634e
ID		 1167{
1168 u32 n;
1169
a303bb0e
ID		 1170 WARN_ON(!incremental && !fn);
1171
10db634e
ID		 1172 ceph_decode_32_safe(p, end, n, e_inval);
1173 while (n--) {
a303bb0e 1174 struct ceph_pg_mapping *pg;
10db634e 1175 struct ceph_pg pgid;
10db634e
ID		 1176 int ret;
1177
1178 ret = ceph_decode_pgid(p, end, &pgid);
1179 if (ret)
1180 return ret;
1181
ab75144b
ID		 1182 pg = lookup_pg_mapping(mapping_root, &pgid);
1183 if (pg) {
1184 WARN_ON(!incremental);
1185 erase_pg_mapping(mapping_root, pg);
1186 free_pg_mapping(pg);
1187 }
10db634e 1188
a303bb0e
ID		 1189 if (fn) {
1190 pg = fn(p, end, incremental);
1191 if (IS_ERR(pg))
1192 return PTR_ERR(pg);
10db634e 1193
a303bb0e
ID		 1194 if (pg) {
1195 pg->pgid = pgid; /* struct */
ab75144b 1196 insert_pg_mapping(mapping_root, pg);
10db634e
ID		 1197 }
1198 }
1199 }
1200
1201 return 0;
1202
1203e_inval:
1204 return -EINVAL;
1205}
1206
a303bb0e
ID		 1207static struct ceph_pg_mapping *__decode_pg_temp(void **p, void *end,
1208 bool incremental)
10db634e 1209{
a303bb0e
ID		 1210 struct ceph_pg_mapping *pg;
1211 u32 len, i;
10db634e 1212
a303bb0e
ID		 1213 ceph_decode_32_safe(p, end, len, e_inval);
1214 if (len == 0 && incremental)
1215 return NULL; /* new_pg_temp: [] to remove */
1216 if (len > (SIZE_MAX - sizeof(*pg)) / sizeof(u32))
1217 return ERR_PTR(-EINVAL);
10db634e 1218
a303bb0e
ID		 1219 ceph_decode_need(p, end, len * sizeof(u32), e_inval);
1220 pg = alloc_pg_mapping(len * sizeof(u32));
1221 if (!pg)
1222 return ERR_PTR(-ENOMEM);
d286de79 1223
a303bb0e
ID		 1224 pg->pg_temp.len = len;
1225 for (i = 0; i < len; i++)
1226 pg->pg_temp.osds[i] = ceph_decode_32(p);
d286de79 1227
a303bb0e 1228 return pg;
d286de79 1229
a303bb0e
ID		 1230e_inval:
1231 return ERR_PTR(-EINVAL);
1232}
d286de79 1233
a303bb0e
ID		 1234static int decode_pg_temp(void **p, void *end, struct ceph_osdmap *map)
1235{
1236 return decode_pg_mapping(p, end, &map->pg_temp, __decode_pg_temp,
1237 false);
1238}
d286de79 1239
a303bb0e
ID		 1240static int decode_new_pg_temp(void **p, void *end, struct ceph_osdmap *map)
1241{
1242 return decode_pg_mapping(p, end, &map->pg_temp, __decode_pg_temp,
1243 true);
1244}
d286de79 1245
a303bb0e
ID		 1246static struct ceph_pg_mapping *__decode_primary_temp(void **p, void *end,
1247 bool incremental)
1248{
1249 struct ceph_pg_mapping *pg;
1250 u32 osd;
d286de79 1251
a303bb0e
ID		 1252 ceph_decode_32_safe(p, end, osd, e_inval);
1253 if (osd == (u32)-1 && incremental)
1254 return NULL; /* new_primary_temp: -1 to remove */
d286de79 1255
a303bb0e
ID		 1256 pg = alloc_pg_mapping(0);
1257 if (!pg)
1258 return ERR_PTR(-ENOMEM);
d286de79 1259
a303bb0e
ID		 1260 pg->primary_temp.osd = osd;
1261 return pg;
d286de79
ID		 1262
1263e_inval:
a303bb0e 1264 return ERR_PTR(-EINVAL);
d286de79
ID		 1265}
1266
1267static int decode_primary_temp(void **p, void *end, struct ceph_osdmap *map)
1268{
a303bb0e
ID		 1269 return decode_pg_mapping(p, end, &map->primary_temp,
1270 __decode_primary_temp, false);
d286de79
ID		 1271}
1272
1273static int decode_new_primary_temp(void **p, void *end,
1274 struct ceph_osdmap *map)
1275{
a303bb0e
ID		 1276 return decode_pg_mapping(p, end, &map->primary_temp,
1277 __decode_primary_temp, true);
d286de79
ID		 1278}
1279
2cfa34f2
ID		 1280u32 ceph_get_primary_affinity(struct ceph_osdmap *map, int osd)
1281{
1282 BUG_ON(osd >= map->max_osd);
1283
1284 if (!map->osd_primary_affinity)
1285 return CEPH_OSD_DEFAULT_PRIMARY_AFFINITY;
1286
1287 return map->osd_primary_affinity[osd];
1288}
1289
1290static int set_primary_affinity(struct ceph_osdmap *map, int osd, u32 aff)
1291{
1292 BUG_ON(osd >= map->max_osd);
1293
1294 if (!map->osd_primary_affinity) {
1295 int i;
1296
1297 map->osd_primary_affinity = kmalloc(map->max_osd*sizeof(u32),
1298 GFP_NOFS);
1299 if (!map->osd_primary_affinity)
1300 return -ENOMEM;
1301
1302 for (i = 0; i < map->max_osd; i++)
1303 map->osd_primary_affinity[i] =
1304 CEPH_OSD_DEFAULT_PRIMARY_AFFINITY;
1305 }
1306
1307 map->osd_primary_affinity[osd] = aff;
1308
1309 return 0;
1310}
1311
63a6993f
ID		 1312static int decode_primary_affinity(void **p, void *end,
1313 struct ceph_osdmap *map)
1314{
1315 u32 len, i;
1316
1317 ceph_decode_32_safe(p, end, len, e_inval);
1318 if (len == 0) {
1319 kfree(map->osd_primary_affinity);
1320 map->osd_primary_affinity = NULL;
1321 return 0;
1322 }
1323 if (len != map->max_osd)
1324 goto e_inval;
1325
1326 ceph_decode_need(p, end, map->max_osd*sizeof(u32), e_inval);
1327
1328 for (i = 0; i < map->max_osd; i++) {
1329 int ret;
1330
1331 ret = set_primary_affinity(map, i, ceph_decode_32(p));
1332 if (ret)
1333 return ret;
1334 }
1335
1336 return 0;
1337
1338e_inval:
1339 return -EINVAL;
1340}
1341
1342static int decode_new_primary_affinity(void **p, void *end,
1343 struct ceph_osdmap *map)
1344{
1345 u32 n;
1346
1347 ceph_decode_32_safe(p, end, n, e_inval);
1348 while (n--) {
1349 u32 osd, aff;
1350 int ret;
1351
1352 ceph_decode_32_safe(p, end, osd, e_inval);
1353 ceph_decode_32_safe(p, end, aff, e_inval);
1354
1355 ret = set_primary_affinity(map, osd, aff);
1356 if (ret)
1357 return ret;
f31da0f3
ID		 1358
1359 pr_info("osd%d primary-affinity 0x%x\n", osd, aff);
63a6993f
ID		 1360 }
1361
1362 return 0;
1363
1364e_inval:
1365 return -EINVAL;
1366}
1367
6f428df4
ID		 1368static struct ceph_pg_mapping *__decode_pg_upmap(void **p, void *end,
1369 bool __unused)
1370{
1371 return __decode_pg_temp(p, end, false);
1372}
1373
1374static int decode_pg_upmap(void **p, void *end, struct ceph_osdmap *map)
1375{
1376 return decode_pg_mapping(p, end, &map->pg_upmap, __decode_pg_upmap,
1377 false);
1378}
1379
1380static int decode_new_pg_upmap(void **p, void *end, struct ceph_osdmap *map)
1381{
1382 return decode_pg_mapping(p, end, &map->pg_upmap, __decode_pg_upmap,
1383 true);
1384}
1385
1386static int decode_old_pg_upmap(void **p, void *end, struct ceph_osdmap *map)
1387{
1388 return decode_pg_mapping(p, end, &map->pg_upmap, NULL, true);
1389}
1390
1391static struct ceph_pg_mapping *__decode_pg_upmap_items(void **p, void *end,
1392 bool __unused)
1393{
1394 struct ceph_pg_mapping *pg;
1395 u32 len, i;
1396
1397 ceph_decode_32_safe(p, end, len, e_inval);
1398 if (len > (SIZE_MAX - sizeof(*pg)) / (2 * sizeof(u32)))
1399 return ERR_PTR(-EINVAL);
1400
1401 ceph_decode_need(p, end, 2 * len * sizeof(u32), e_inval);
1402 pg = kzalloc(sizeof(*pg) + 2 * len * sizeof(u32), GFP_NOIO);
1403 if (!pg)
1404 return ERR_PTR(-ENOMEM);
1405
1406 pg->pg_upmap_items.len = len;
1407 for (i = 0; i < len; i++) {
1408 pg->pg_upmap_items.from_to[i][0] = ceph_decode_32(p);
1409 pg->pg_upmap_items.from_to[i][1] = ceph_decode_32(p);
1410 }
1411
1412 return pg;
1413
1414e_inval:
1415 return ERR_PTR(-EINVAL);
1416}
1417
1418static int decode_pg_upmap_items(void **p, void *end, struct ceph_osdmap *map)
1419{
1420 return decode_pg_mapping(p, end, &map->pg_upmap_items,
1421 __decode_pg_upmap_items, false);
1422}
1423
1424static int decode_new_pg_upmap_items(void **p, void *end,
1425 struct ceph_osdmap *map)
1426{
1427 return decode_pg_mapping(p, end, &map->pg_upmap_items,
1428 __decode_pg_upmap_items, true);
1429}
1430
1431static int decode_old_pg_upmap_items(void **p, void *end,
1432 struct ceph_osdmap *map)
1433{
1434 return decode_pg_mapping(p, end, &map->pg_upmap_items, NULL, true);
1435}
1436
f24e9980
SW		 1437/*
1438 * decode a full map.
1439 */
a2505d63 1440static int osdmap_decode(void **p, void *end, struct ceph_osdmap *map)
f24e9980 1441{
ec7af972 1442 u8 struct_v;
38a8d560 1443 u32 epoch = 0;
f24e9980 1444 void *start = *p;
3977058c
ID		 1445 u32 max;
1446 u32 len, i;
597b52f6 1447 int err;
f24e9980 1448
a2505d63 1449 dout("%s %p to %p len %d\n", __func__, *p, end, (int)(end - *p));
f24e9980 1450
ec7af972
ID		 1451 err = get_osdmap_client_data_v(p, end, "full", &struct_v);
1452 if (err)
1453 goto bad;
f24e9980 1454
53bbaba9
ID		 1455 /* fsid, epoch, created, modified */
1456 ceph_decode_need(p, end, sizeof(map->fsid) + sizeof(u32) +
1457 sizeof(map->created) + sizeof(map->modified), e_inval);
f24e9980 1458 ceph_decode_copy(p, &map->fsid, sizeof(map->fsid));
38a8d560 1459 epoch = map->epoch = ceph_decode_32(p);
f24e9980
SW		 1460 ceph_decode_copy(p, &map->created, sizeof(map->created));
1461 ceph_decode_copy(p, &map->modified, sizeof(map->modified));
1462
433fbdd3
ID		 1463 /* pools */
1464 err = decode_pools(p, end, map);
1465 if (err)
1466 goto bad;
2844a76a 1467
0f70c7ee
ID		 1468 /* pool_name */
1469 err = decode_pool_names(p, end, map);
597b52f6 1470 if (err)
4f6a7e5e 1471 goto bad;
2844a76a 1472
597b52f6 1473 ceph_decode_32_safe(p, end, map->pool_max, e_inval);
f24e9980 1474
597b52f6 1475 ceph_decode_32_safe(p, end, map->flags, e_inval);
f24e9980 1476
3977058c
ID		 1477 /* max_osd */
1478 ceph_decode_32_safe(p, end, max, e_inval);
f24e9980
SW		 1479
1480 /* (re)alloc osd arrays */
1481 err = osdmap_set_max_osd(map, max);
597b52f6 1482 if (err)
f24e9980 1483 goto bad;
f24e9980 1484
2d88b2e0 1485 /* osd_state, osd_weight, osd_addrs->client_addr */
f24e9980 1486 ceph_decode_need(p, end, 3*sizeof(u32) +
0bb05da2
ID		 1487 map->max_osd*((struct_v >= 5 ? sizeof(u32) :
1488 sizeof(u8)) +
1489 sizeof(*map->osd_weight) +
597b52f6
ID		 1490 sizeof(*map->osd_addr)), e_inval);
1491
2d88b2e0
ID		 1492 if (ceph_decode_32(p) != map->max_osd)
1493 goto e_inval;
1494
0bb05da2
ID		 1495 if (struct_v >= 5) {
1496 for (i = 0; i < map->max_osd; i++)
1497 map->osd_state[i] = ceph_decode_32(p);
1498 } else {
1499 for (i = 0; i < map->max_osd; i++)
1500 map->osd_state[i] = ceph_decode_8(p);
1501 }
f24e9980 1502
2d88b2e0
ID		 1503 if (ceph_decode_32(p) != map->max_osd)
1504 goto e_inval;
1505
f24e9980 1506 for (i = 0; i < map->max_osd; i++)
c89136ea 1507 map->osd_weight[i] = ceph_decode_32(p);
f24e9980 1508
2d88b2e0
ID		 1509 if (ceph_decode_32(p) != map->max_osd)
1510 goto e_inval;
1511
f24e9980 1512 ceph_decode_copy(p, map->osd_addr, map->max_osd*sizeof(*map->osd_addr));
63f2d211
SW		 1513 for (i = 0; i < map->max_osd; i++)
1514 ceph_decode_addr(&map->osd_addr[i]);
f24e9980
SW		 1515
1516 /* pg_temp */
10db634e
ID		 1517 err = decode_pg_temp(p, end, map);
1518 if (err)
1519 goto bad;
f24e9980 1520
d286de79
ID		 1521 /* primary_temp */
1522 if (struct_v >= 1) {
1523 err = decode_primary_temp(p, end, map);
1524 if (err)
1525 goto bad;
1526 }
1527
63a6993f
ID		 1528 /* primary_affinity */
1529 if (struct_v >= 2) {
1530 err = decode_primary_affinity(p, end, map);
1531 if (err)
1532 goto bad;
1533 } else {
6f428df4 1534 WARN_ON(map->osd_primary_affinity);
63a6993f
ID		 1535 }
1536
f24e9980 1537 /* crush */
597b52f6 1538 ceph_decode_32_safe(p, end, len, e_inval);
1b6a78b5
ID		 1539 err = osdmap_set_crush(map, crush_decode(*p, min(*p + len, end)));
1540 if (err)
f24e9980 1541 goto bad;
f24e9980 1542
6f428df4
ID		 1543 *p += len;
1544 if (struct_v >= 3) {
1545 /* erasure_code_profiles */
1546 ceph_decode_skip_map_of_map(p, end, string, string, string,
00c8ebb3 1547 e_inval);
6f428df4
ID		 1548 }
1549
1550 if (struct_v >= 4) {
1551 err = decode_pg_upmap(p, end, map);
1552 if (err)
1553 goto bad;
1554
1555 err = decode_pg_upmap_items(p, end, map);
1556 if (err)
1557 goto bad;
1558 } else {
1559 WARN_ON(!RB_EMPTY_ROOT(&map->pg_upmap));
1560 WARN_ON(!RB_EMPTY_ROOT(&map->pg_upmap_items));
1561 }
1562
38a8d560 1563 /* ignore the rest */
f24e9980
SW		 1564 *p = end;
1565
38a8d560 1566 dout("full osdmap epoch %d max_osd %d\n", map->epoch, map->max_osd);
a2505d63 1567 return 0;
f24e9980 1568
597b52f6
ID		 1569e_inval:
1570 err = -EINVAL;
f24e9980 1571bad:
38a8d560
ID		 1572 pr_err("corrupt full osdmap (%d) epoch %d off %d (%p of %p-%p)\n",
1573 err, epoch, (int)(*p - start), *p, start, end);
1574 print_hex_dump(KERN_DEBUG, "osdmap: ",
1575 DUMP_PREFIX_OFFSET, 16, 1,
1576 start, end - start, true);
a2505d63
ID		 1577 return err;
1578}
1579
1580/*
1581 * Allocate and decode a full map.
1582 */
1583struct ceph_osdmap *ceph_osdmap_decode(void **p, void *end)
1584{
1585 struct ceph_osdmap *map;
1586 int ret;
1587
e5253a7b 1588 map = ceph_osdmap_alloc();
a2505d63
ID		 1589 if (!map)
1590 return ERR_PTR(-ENOMEM);
1591
a2505d63
ID		 1592 ret = osdmap_decode(p, end, map);
1593 if (ret) {
1594 ceph_osdmap_destroy(map);
1595 return ERR_PTR(ret);
1596 }
1597
1598 return map;
f24e9980
SW		 1599}
1600
930c5328
ID		 1601/*
1602 * Encoding order is (new_up_client, new_state, new_weight). Need to
1603 * apply in the (new_weight, new_state, new_up_client) order, because
1604 * an incremental map may look like e.g.
1605 *
1606 * new_up_client: { osd=6, addr=... } # set osd_state and addr
1607 * new_state: { osd=6, xorstate=EXISTS } # clear osd_state
1608 */
0bb05da2 1609static int decode_new_up_state_weight(void **p, void *end, u8 struct_v,
930c5328
ID		 1610 struct ceph_osdmap *map)
1611{
1612 void *new_up_client;
1613 void *new_state;
1614 void *new_weight_end;
1615 u32 len;
1616
1617 new_up_client = *p;
1618 ceph_decode_32_safe(p, end, len, e_inval);
1619 len *= sizeof(u32) + sizeof(struct ceph_entity_addr);
1620 ceph_decode_need(p, end, len, e_inval);
1621 *p += len;
1622
1623 new_state = *p;
1624 ceph_decode_32_safe(p, end, len, e_inval);
0bb05da2 1625 len *= sizeof(u32) + (struct_v >= 5 ? sizeof(u32) : sizeof(u8));
930c5328
ID		 1626 ceph_decode_need(p, end, len, e_inval);
1627 *p += len;
1628
1629 /* new_weight */
1630 ceph_decode_32_safe(p, end, len, e_inval);
1631 while (len--) {
1632 s32 osd;
1633 u32 w;
1634
1635 ceph_decode_need(p, end, 2*sizeof(u32), e_inval);
1636 osd = ceph_decode_32(p);
1637 w = ceph_decode_32(p);
1638 BUG_ON(osd >= map->max_osd);
1639 pr_info("osd%d weight 0x%x %s\n", osd, w,
1640 w == CEPH_OSD_IN ? "(in)" :
1641 (w == CEPH_OSD_OUT ? "(out)" : ""));
1642 map->osd_weight[osd] = w;
1643
1644 /*
1645 * If we are marking in, set the EXISTS, and clear the
1646 * AUTOOUT and NEW bits.
1647 */
1648 if (w) {
1649 map->osd_state[osd] |= CEPH_OSD_EXISTS;
1650 map->osd_state[osd] &= ~(CEPH_OSD_AUTOOUT |
1651 CEPH_OSD_NEW);
1652 }
1653 }
1654 new_weight_end = *p;
1655
1656 /* new_state (up/down) */
1657 *p = new_state;
1658 len = ceph_decode_32(p);
1659 while (len--) {
1660 s32 osd;
0bb05da2 1661 u32 xorstate;
930c5328
ID		 1662 int ret;
1663
1664 osd = ceph_decode_32(p);
0bb05da2
ID		 1665 if (struct_v >= 5)
1666 xorstate = ceph_decode_32(p);
1667 else
1668 xorstate = ceph_decode_8(p);
930c5328
ID		 1669 if (xorstate == 0)
1670 xorstate = CEPH_OSD_UP;
1671 BUG_ON(osd >= map->max_osd);
1672 if ((map->osd_state[osd] & CEPH_OSD_UP) &&
1673 (xorstate & CEPH_OSD_UP))
1674 pr_info("osd%d down\n", osd);
1675 if ((map->osd_state[osd] & CEPH_OSD_EXISTS) &&
1676 (xorstate & CEPH_OSD_EXISTS)) {
1677 pr_info("osd%d does not exist\n", osd);
930c5328
ID		 1678 ret = set_primary_affinity(map, osd,
1679 CEPH_OSD_DEFAULT_PRIMARY_AFFINITY);
1680 if (ret)
1681 return ret;
1682 memset(map->osd_addr + osd, 0, sizeof(*map->osd_addr));
1683 map->osd_state[osd] = 0;
1684 } else {
1685 map->osd_state[osd] ^= xorstate;
1686 }
1687 }
1688
1689 /* new_up_client */
1690 *p = new_up_client;
1691 len = ceph_decode_32(p);
1692 while (len--) {
1693 s32 osd;
1694 struct ceph_entity_addr addr;
1695
1696 osd = ceph_decode_32(p);
1697 ceph_decode_copy(p, &addr, sizeof(addr));
1698 ceph_decode_addr(&addr);
1699 BUG_ON(osd >= map->max_osd);
1700 pr_info("osd%d up\n", osd);
1701 map->osd_state[osd] |= CEPH_OSD_EXISTS | CEPH_OSD_UP;
1702 map->osd_addr[osd] = addr;
1703 }
1704
1705 *p = new_weight_end;
1706 return 0;
1707
1708e_inval:
1709 return -EINVAL;
1710}
1711
f24e9980
SW		 1712/*
1713 * decode and apply an incremental map update.
1714 */
1715struct ceph_osdmap *osdmap_apply_incremental(void **p, void *end,
0c0a8de1 1716 struct ceph_osdmap *map)
f24e9980 1717{
f24e9980
SW		 1718 struct ceph_fsid fsid;
1719 u32 epoch = 0;
1720 struct ceph_timespec modified;
4f6a7e5e
SW		 1721 s32 len;
1722 u64 pool;
1723 __s64 new_pool_max;
1724 __s32 new_flags, max;
f24e9980 1725 void *start = *p;
86f1742b 1726 int err;
ec7af972 1727 u8 struct_v;
f24e9980 1728
38a8d560
ID		 1729 dout("%s %p to %p len %d\n", __func__, *p, end, (int)(end - *p));
1730
ec7af972
ID		 1731 err = get_osdmap_client_data_v(p, end, "inc", &struct_v);
1732 if (err)
1733 goto bad;
f24e9980 1734
53bbaba9
ID		 1735 /* fsid, epoch, modified, new_pool_max, new_flags */
1736 ceph_decode_need(p, end, sizeof(fsid) + sizeof(u32) + sizeof(modified) +
1737 sizeof(u64) + sizeof(u32), e_inval);
f24e9980 1738 ceph_decode_copy(p, &fsid, sizeof(fsid));
c89136ea 1739 epoch = ceph_decode_32(p);
f24e9980
SW		 1740 BUG_ON(epoch != map->epoch+1);
1741 ceph_decode_copy(p, &modified, sizeof(modified));
4f6a7e5e 1742 new_pool_max = ceph_decode_64(p);
c89136ea 1743 new_flags = ceph_decode_32(p);
f24e9980
SW		 1744
1745 /* full map? */
86f1742b 1746 ceph_decode_32_safe(p, end, len, e_inval);
f24e9980
SW		 1747 if (len > 0) {
1748 dout("apply_incremental full map len %d, %p to %p\n",
1749 len, *p, end);
a2505d63 1750 return ceph_osdmap_decode(p, min(*p+len, end));
f24e9980
SW		 1751 }
1752
1753 /* new crush? */
86f1742b 1754 ceph_decode_32_safe(p, end, len, e_inval);
f24e9980 1755 if (len > 0) {
1b6a78b5
ID		 1756 err = osdmap_set_crush(map,
1757 crush_decode(*p, min(*p + len, end)));
1758 if (err)
86f1742b 1759 goto bad;
cebc5be6 1760 *p += len;
f24e9980
SW		 1761 }
1762
1763 /* new flags? */
1764 if (new_flags >= 0)
1765 map->flags = new_flags;
4fc51be8
SW		 1766 if (new_pool_max >= 0)
1767 map->pool_max = new_pool_max;
f24e9980 1768
f24e9980 1769 /* new max? */
53bbaba9 1770 ceph_decode_32_safe(p, end, max, e_inval);
f24e9980
SW		 1771 if (max >= 0) {
1772 err = osdmap_set_max_osd(map, max);
86f1742b 1773 if (err)
f24e9980
SW		 1774 goto bad;
1775 }
1776
1777 map->epoch++;
31456665 1778 map->modified = modified;
f24e9980 1779
433fbdd3
ID		 1780 /* new_pools */
1781 err = decode_new_pools(p, end, map);
1782 if (err)
1783 goto bad;
9464d008 1784
0f70c7ee
ID		 1785 /* new_pool_names */
1786 err = decode_pool_names(p, end, map);
9464d008
ID		 1787 if (err)
1788 goto bad;
f24e9980 1789
4fc51be8 1790 /* old_pool */
86f1742b 1791 ceph_decode_32_safe(p, end, len, e_inval);
4fc51be8
SW		 1792 while (len--) {
1793 struct ceph_pg_pool_info *pi;
1794
86f1742b 1795 ceph_decode_64_safe(p, end, pool, e_inval);
4fc51be8 1796 pi = __lookup_pg_pool(&map->pg_pools, pool);
2844a76a
SW		 1797 if (pi)
1798 __remove_pg_pool(&map->pg_pools, pi);
4fc51be8 1799 }
f24e9980 1800
930c5328 1801 /* new_up_client, new_state, new_weight */
0bb05da2 1802 err = decode_new_up_state_weight(p, end, struct_v, map);
930c5328
ID		 1803 if (err)
1804 goto bad;
f24e9980
SW		 1805
1806 /* new_pg_temp */
10db634e
ID		 1807 err = decode_new_pg_temp(p, end, map);
1808 if (err)
1809 goto bad;
f24e9980 1810
d286de79
ID		 1811 /* new_primary_temp */
1812 if (struct_v >= 1) {
1813 err = decode_new_primary_temp(p, end, map);
1814 if (err)
1815 goto bad;
1816 }
1817
63a6993f
ID		 1818 /* new_primary_affinity */
1819 if (struct_v >= 2) {
1820 err = decode_new_primary_affinity(p, end, map);
1821 if (err)
1822 goto bad;
1823 }
1824
6f428df4
ID		 1825 if (struct_v >= 3) {
1826 /* new_erasure_code_profiles */
1827 ceph_decode_skip_map_of_map(p, end, string, string, string,
00c8ebb3 1828 e_inval);
6f428df4 1829 /* old_erasure_code_profiles */
00c8ebb3 1830 ceph_decode_skip_set(p, end, string, e_inval);
6f428df4
ID		 1831 }
1832
1833 if (struct_v >= 4) {
1834 err = decode_new_pg_upmap(p, end, map);
1835 if (err)
1836 goto bad;
1837
1838 err = decode_old_pg_upmap(p, end, map);
1839 if (err)
1840 goto bad;
1841
1842 err = decode_new_pg_upmap_items(p, end, map);
1843 if (err)
1844 goto bad;
1845
1846 err = decode_old_pg_upmap_items(p, end, map);
1847 if (err)
1848 goto bad;
1849 }
1850
f24e9980
SW		 1851 /* ignore the rest */
1852 *p = end;
38a8d560
ID		 1853
1854 dout("inc osdmap epoch %d max_osd %d\n", map->epoch, map->max_osd);
f24e9980
SW		 1855 return map;
1856
86f1742b
ID		 1857e_inval:
1858 err = -EINVAL;
f24e9980 1859bad:
38a8d560
ID		 1860 pr_err("corrupt inc osdmap (%d) epoch %d off %d (%p of %p-%p)\n",
1861 err, epoch, (int)(*p - start), *p, start, end);
9ec7cab1
SW		 1862 print_hex_dump(KERN_DEBUG, "osdmap: ",
1863 DUMP_PREFIX_OFFSET, 16, 1,
1864 start, end - start, true);
f24e9980
SW		 1865 return ERR_PTR(err);
1866}
1867
30c156d9
YZ		 1868void ceph_oloc_copy(struct ceph_object_locator *dest,
1869 const struct ceph_object_locator *src)
1870{
ca35ffea 1871 ceph_oloc_destroy(dest);
30c156d9
YZ		 1872
1873 dest->pool = src->pool;
1874 if (src->pool_ns)
1875 dest->pool_ns = ceph_get_string(src->pool_ns);
ca35ffea
ID		 1876 else
1877 dest->pool_ns = NULL;
30c156d9
YZ		 1878}
1879EXPORT_SYMBOL(ceph_oloc_copy);
1880
1881void ceph_oloc_destroy(struct ceph_object_locator *oloc)
1882{
1883 ceph_put_string(oloc->pool_ns);
1884}
1885EXPORT_SYMBOL(ceph_oloc_destroy);
1886
d30291b9
ID		 1887void ceph_oid_copy(struct ceph_object_id *dest,
1888 const struct ceph_object_id *src)
1889{
ca35ffea 1890 ceph_oid_destroy(dest);
d30291b9
ID		 1891
1892 if (src->name != src->inline_name) {
1893 /* very rare, see ceph_object_id definition */
1894 dest->name = kmalloc(src->name_len + 1,
1895 GFP_NOIO | __GFP_NOFAIL);
ca35ffea
ID		 1896 } else {
1897 dest->name = dest->inline_name;
d30291b9 1898 }
d30291b9
ID		 1899 memcpy(dest->name, src->name, src->name_len + 1);
1900 dest->name_len = src->name_len;
1901}
1902EXPORT_SYMBOL(ceph_oid_copy);
1903
1904static __printf(2, 0)
1905int oid_printf_vargs(struct ceph_object_id *oid, const char *fmt, va_list ap)
1906{
1907 int len;
1908
1909 WARN_ON(!ceph_oid_empty(oid));
1910
1911 len = vsnprintf(oid->inline_name, sizeof(oid->inline_name), fmt, ap);
1912 if (len >= sizeof(oid->inline_name))
1913 return len;
1914
1915 oid->name_len = len;
1916 return 0;
1917}
1918
1919/*
1920 * If oid doesn't fit into inline buffer, BUG.
1921 */
1922void ceph_oid_printf(struct ceph_object_id *oid, const char *fmt, ...)
1923{
1924 va_list ap;
1925
1926 va_start(ap, fmt);
1927 BUG_ON(oid_printf_vargs(oid, fmt, ap));
1928 va_end(ap);
1929}
1930EXPORT_SYMBOL(ceph_oid_printf);
1931
1932static __printf(3, 0)
1933int oid_aprintf_vargs(struct ceph_object_id *oid, gfp_t gfp,
1934 const char *fmt, va_list ap)
1935{
1936 va_list aq;
1937 int len;
1938
1939 va_copy(aq, ap);
1940 len = oid_printf_vargs(oid, fmt, aq);
1941 va_end(aq);
1942
1943 if (len) {
1944 char *external_name;
1945
1946 external_name = kmalloc(len + 1, gfp);
1947 if (!external_name)
1948 return -ENOMEM;
f24e9980 1949
d30291b9
ID		 1950 oid->name = external_name;
1951 WARN_ON(vsnprintf(oid->name, len + 1, fmt, ap) != len);
1952 oid->name_len = len;
1953 }
f24e9980 1954
d30291b9
ID		 1955 return 0;
1956}
1957
1958/*
1959 * If oid doesn't fit into inline buffer, allocate.
1960 */
1961int ceph_oid_aprintf(struct ceph_object_id *oid, gfp_t gfp,
1962 const char *fmt, ...)
1963{
1964 va_list ap;
1965 int ret;
1966
1967 va_start(ap, fmt);
1968 ret = oid_aprintf_vargs(oid, gfp, fmt, ap);
1969 va_end(ap);
1970
1971 return ret;
1972}
1973EXPORT_SYMBOL(ceph_oid_aprintf);
1974
1975void ceph_oid_destroy(struct ceph_object_id *oid)
1976{
1977 if (oid->name != oid->inline_name)
1978 kfree(oid->name);
1979}
1980EXPORT_SYMBOL(ceph_oid_destroy);
f24e9980 1981
63244fa1
ID		 1982/*
1983 * osds only
1984 */
1985static bool __osds_equal(const struct ceph_osds *lhs,
1986 const struct ceph_osds *rhs)
1987{
1988 if (lhs->size == rhs->size &&
1989 !memcmp(lhs->osds, rhs->osds, rhs->size * sizeof(rhs->osds[0])))
1990 return true;
1991
1992 return false;
1993}
1994
1995/*
1996 * osds + primary
1997 */
1998static bool osds_equal(const struct ceph_osds *lhs,
1999 const struct ceph_osds *rhs)
2000{
2001 if (__osds_equal(lhs, rhs) &&
2002 lhs->primary == rhs->primary)
2003 return true;
2004
2005 return false;
2006}
2007
6f3bfd45
ID		 2008static bool osds_valid(const struct ceph_osds *set)
2009{
2010 /* non-empty set */
2011 if (set->size > 0 && set->primary >= 0)
2012 return true;
2013
2014 /* empty can_shift_osds set */
2015 if (!set->size && set->primary == -1)
2016 return true;
2017
2018 /* empty !can_shift_osds set - all NONE */
2019 if (set->size > 0 && set->primary == -1) {
2020 int i;
2021
2022 for (i = 0; i < set->size; i++) {
2023 if (set->osds[i] != CRUSH_ITEM_NONE)
2024 break;
2025 }
2026 if (i == set->size)
2027 return true;
2028 }
2029
2030 return false;
2031}
2032
2033void ceph_osds_copy(struct ceph_osds *dest, const struct ceph_osds *src)
2034{
2035 memcpy(dest->osds, src->osds, src->size * sizeof(src->osds[0]));
2036 dest->size = src->size;
2037 dest->primary = src->primary;
2038}
2039
7de030d6
ID		 2040bool ceph_pg_is_split(const struct ceph_pg *pgid, u32 old_pg_num,
2041 u32 new_pg_num)
63244fa1
ID		 2042{
2043 int old_bits = calc_bits_of(old_pg_num);
2044 int old_mask = (1 << old_bits) - 1;
2045 int n;
2046
2047 WARN_ON(pgid->seed >= old_pg_num);
2048 if (new_pg_num <= old_pg_num)
2049 return false;
2050
2051 for (n = 1; ; n++) {
2052 int next_bit = n << (old_bits - 1);
2053 u32 s = next_bit | pgid->seed;
2054
2055 if (s < old_pg_num || s == pgid->seed)
2056 continue;
2057 if (s >= new_pg_num)
2058 break;
2059
2060 s = ceph_stable_mod(s, old_pg_num, old_mask);
2061 if (s == pgid->seed)
2062 return true;
2063 }
2064
2065 return false;
2066}
2067
2068bool ceph_is_new_interval(const struct ceph_osds *old_acting,
2069 const struct ceph_osds *new_acting,
2070 const struct ceph_osds *old_up,
2071 const struct ceph_osds *new_up,
2072 int old_size,
2073 int new_size,
2074 int old_min_size,
2075 int new_min_size,
2076 u32 old_pg_num,
2077 u32 new_pg_num,
2078 bool old_sort_bitwise,
2079 bool new_sort_bitwise,
2080 const struct ceph_pg *pgid)
2081{
2082 return !osds_equal(old_acting, new_acting) ||
2083 !osds_equal(old_up, new_up) ||
2084 old_size != new_size ||
2085 old_min_size != new_min_size ||
7de030d6 2086 ceph_pg_is_split(pgid, old_pg_num, new_pg_num) ||
63244fa1
ID		 2087 old_sort_bitwise != new_sort_bitwise;
2088}
2089
2090static int calc_pg_rank(int osd, const struct ceph_osds *acting)
2091{
2092 int i;
2093
2094 for (i = 0; i < acting->size; i++) {
2095 if (acting->osds[i] == osd)
2096 return i;
2097 }
2098
2099 return -1;
2100}
2101
2102static bool primary_changed(const struct ceph_osds *old_acting,
2103 const struct ceph_osds *new_acting)
2104{
2105 if (!old_acting->size && !new_acting->size)
2106 return false; /* both still empty */
2107
2108 if (!old_acting->size ^ !new_acting->size)
2109 return true; /* was empty, now not, or vice versa */
2110
2111 if (old_acting->primary != new_acting->primary)
2112 return true; /* primary changed */
2113
2114 if (calc_pg_rank(old_acting->primary, old_acting) !=
2115 calc_pg_rank(new_acting->primary, new_acting))
2116 return true;
2117
2118 return false; /* same primary (tho replicas may have changed) */
2119}
2120
2121bool ceph_osds_changed(const struct ceph_osds *old_acting,
2122 const struct ceph_osds *new_acting,
2123 bool any_change)
2124{
2125 if (primary_changed(old_acting, new_acting))
2126 return true;
2127
2128 if (any_change && !__osds_equal(old_acting, new_acting))
2129 return true;
2130
2131 return false;
2132}
2133
f24e9980
SW		 2134/*
2135 * calculate file layout from given offset, length.
2136 * fill in correct oid, logical length, and object extent
2137 * offset, length.
2138 *
2139 * for now, we write only a single su, until we can
2140 * pass a stride back to the caller.
2141 */
d63b77f4 2142int ceph_calc_file_object_mapping(struct ceph_file_layout *layout,
e8afad65 2143 u64 off, u64 len,
645a1025 2144 u64 *ono,
f24e9980
SW		 2145 u64 *oxoff, u64 *oxlen)
2146{
7627151e
YZ		 2147 u32 osize = layout->object_size;
2148 u32 su = layout->stripe_unit;
2149 u32 sc = layout->stripe_count;
f24e9980
SW		 2150 u32 bl, stripeno, stripepos, objsetno;
2151 u32 su_per_object;
ff1d1f71 2152 u64 t, su_offset;
f24e9980 2153
e8afad65 2154 dout("mapping %llu~%llu osize %u fl_su %u\n", off, len,
f24e9980 2155 osize, su);
d63b77f4
SW		 2156 if (su == 0 || sc == 0)
2157 goto invalid;
35e054a6 2158 su_per_object = osize / su;
d63b77f4
SW		 2159 if (su_per_object == 0)
2160 goto invalid;
f24e9980
SW		 2161 dout("osize %u / su %u = su_per_object %u\n", osize, su,
2162 su_per_object);
2163
d63b77f4
SW		 2164 if ((su & ~PAGE_MASK) != 0)
2165 goto invalid;
2166
f24e9980
SW		 2167 /* bl = *off / su; */
2168 t = off;
2169 do_div(t, su);
2170 bl = t;
2171 dout("off %llu / su %u = bl %u\n", off, su, bl);
2172
2173 stripeno = bl / sc;
2174 stripepos = bl % sc;
2175 objsetno = stripeno / su_per_object;
2176
645a1025 2177 *ono = objsetno * sc + stripepos;
95c96174 2178 dout("objset %u * sc %u = ono %u\n", objsetno, sc, (unsigned int)*ono);
645a1025
SW		 2179
2180 /* *oxoff = *off % layout->fl_stripe_unit; # offset in su */
f24e9980 2181 t = off;
ff1d1f71
NW		 2182 su_offset = do_div(t, su);
2183 *oxoff = su_offset + (stripeno % su_per_object) * su;
2184
2185 /*
2186 * Calculate the length of the extent being written to the selected
e8afad65 2187 * object. This is the minimum of the full length requested (len) or
ff1d1f71
NW		 2188 * the remainder of the current stripe being written to.
2189 */
e8afad65 2190 *oxlen = min_t(u64, len, su - su_offset);
f24e9980
SW		 2191
2192 dout(" obj extent %llu~%llu\n", *oxoff, *oxlen);
d63b77f4
SW		 2193 return 0;
2194
2195invalid:
2196 dout(" invalid layout\n");
2197 *ono = 0;
2198 *oxoff = 0;
2199 *oxlen = 0;
2200 return -EINVAL;
f24e9980 2201}
3d14c5d2 2202EXPORT_SYMBOL(ceph_calc_file_object_mapping);
f24e9980
SW		 2203
2204/*
d9591f5e
ID		 2205 * Map an object into a PG.
2206 *
2207 * Should only be called with target_oid and target_oloc (as opposed to
2208 * base_oid and base_oloc), since tiering isn't taken into account.
f24e9980 2209 */
df28152d
ID		 2210int __ceph_object_locator_to_pg(struct ceph_pg_pool_info *pi,
2211 const struct ceph_object_id *oid,
2212 const struct ceph_object_locator *oloc,
2213 struct ceph_pg *raw_pgid)
f24e9980 2214{
df28152d 2215 WARN_ON(pi->id != oloc->pool);
f24e9980 2216
30c156d9
YZ		 2217 if (!oloc->pool_ns) {
2218 raw_pgid->pool = oloc->pool;
2219 raw_pgid->seed = ceph_str_hash(pi->object_hash, oid->name,
2220 oid->name_len);
2221 dout("%s %s -> raw_pgid %llu.%x\n", __func__, oid->name,
2222 raw_pgid->pool, raw_pgid->seed);
2223 } else {
2224 char stack_buf[256];
2225 char *buf = stack_buf;
2226 int nsl = oloc->pool_ns->len;
2227 size_t total = nsl + 1 + oid->name_len;
2228
2229 if (total > sizeof(stack_buf)) {
2230 buf = kmalloc(total, GFP_NOIO);
2231 if (!buf)
2232 return -ENOMEM;
2233 }
2234 memcpy(buf, oloc->pool_ns->str, nsl);
2235 buf[nsl] = '\037';
2236 memcpy(buf + nsl + 1, oid->name, oid->name_len);
2237 raw_pgid->pool = oloc->pool;
2238 raw_pgid->seed = ceph_str_hash(pi->object_hash, buf, total);
2239 if (buf != stack_buf)
2240 kfree(buf);
2241 dout("%s %s ns %.*s -> raw_pgid %llu.%x\n", __func__,
2242 oid->name, nsl, oloc->pool_ns->str,
2243 raw_pgid->pool, raw_pgid->seed);
2244 }
f24e9980
SW		 2245 return 0;
2246}
df28152d
ID		 2247
2248int ceph_object_locator_to_pg(struct ceph_osdmap *osdmap,
2249 const struct ceph_object_id *oid,
2250 const struct ceph_object_locator *oloc,
2251 struct ceph_pg *raw_pgid)
2252{
2253 struct ceph_pg_pool_info *pi;
2254
2255 pi = ceph_pg_pool_by_id(osdmap, oloc->pool);
2256 if (!pi)
2257 return -ENOENT;
2258
2259 return __ceph_object_locator_to_pg(pi, oid, oloc, raw_pgid);
2260}
d9591f5e 2261EXPORT_SYMBOL(ceph_object_locator_to_pg);
f24e9980 2262
6f3bfd45
ID		 2263/*
2264 * Map a raw PG (full precision ps) into an actual PG.
2265 */
2266static void raw_pg_to_pg(struct ceph_pg_pool_info *pi,
2267 const struct ceph_pg *raw_pgid,
2268 struct ceph_pg *pgid)
2269{
2270 pgid->pool = raw_pgid->pool;
2271 pgid->seed = ceph_stable_mod(raw_pgid->seed, pi->pg_num,
2272 pi->pg_num_mask);
2273}
2274
2275/*
2276 * Map a raw PG (full precision ps) into a placement ps (placement
2277 * seed). Include pool id in that value so that different pools don't
2278 * use the same seeds.
2279 */
2280static u32 raw_pg_to_pps(struct ceph_pg_pool_info *pi,
2281 const struct ceph_pg *raw_pgid)
2282{
2283 if (pi->flags & CEPH_POOL_FLAG_HASHPSPOOL) {
2284 /* hash pool id and seed so that pool PGs do not overlap */
2285 return crush_hash32_2(CRUSH_HASH_RJENKINS1,
2286 ceph_stable_mod(raw_pgid->seed,
2287 pi->pgp_num,
2288 pi->pgp_num_mask),
2289 raw_pgid->pool);
2290 } else {
2291 /*
2292 * legacy behavior: add ps and pool together. this is
2293 * not a great approach because the PGs from each pool
2294 * will overlap on top of each other: 0.5 == 1.4 ==
2295 * 2.3 == ...
2296 */
2297 return ceph_stable_mod(raw_pgid->seed, pi->pgp_num,
2298 pi->pgp_num_mask) +
2299 (unsigned)raw_pgid->pool;
2300 }
2301}
2302
9d521470
ID		 2303static int do_crush(struct ceph_osdmap *map, int ruleno, int x,
2304 int *result, int result_max,
5cf9c4a9
ID		 2305 const __u32 *weight, int weight_max,
2306 u64 choose_args_index)
e8ef19c4 2307{
5cf9c4a9 2308 struct crush_choose_arg_map *arg_map;
9d521470
ID		 2309 int r;
2310
2311 BUG_ON(result_max > CEPH_PG_MAX_SIZE);
2312
5cf9c4a9
ID		 2313 arg_map = lookup_choose_arg_map(&map->crush->choose_args,
2314 choose_args_index);
2315
743efcff 2316 mutex_lock(&map->crush_workspace_mutex);
9d521470 2317 r = crush_do_rule(map->crush, ruleno, x, result, result_max,
5cf9c4a9
ID		 2318 weight, weight_max, map->crush_workspace,
2319 arg_map ? arg_map->args : NULL);
743efcff 2320 mutex_unlock(&map->crush_workspace_mutex);
e8ef19c4 2321
9d521470 2322 return r;
e8ef19c4
ID		 2323}
2324
1c2e7b45
ID		 2325static void remove_nonexistent_osds(struct ceph_osdmap *osdmap,
2326 struct ceph_pg_pool_info *pi,
2327 struct ceph_osds *set)
2328{
2329 int i;
2330
2331 if (ceph_can_shift_osds(pi)) {
2332 int removed = 0;
2333
2334 /* shift left */
2335 for (i = 0; i < set->size; i++) {
2336 if (!ceph_osd_exists(osdmap, set->osds[i])) {
2337 removed++;
2338 continue;
2339 }
2340 if (removed)
2341 set->osds[i - removed] = set->osds[i];
2342 }
2343 set->size -= removed;
2344 } else {
2345 /* set dne devices to NONE */
2346 for (i = 0; i < set->size; i++) {
2347 if (!ceph_osd_exists(osdmap, set->osds[i]))
2348 set->osds[i] = CRUSH_ITEM_NONE;
2349 }
2350 }
2351}
2352
2bd93d4d 2353/*
1c2e7b45
ID		 2354 * Calculate raw set (CRUSH output) for given PG and filter out
2355 * nonexistent OSDs. ->primary is undefined for a raw set.
2bd93d4d 2356 *
6f3bfd45 2357 * Placement seed (CRUSH input) is returned through @ppps.
2bd93d4d 2358 */
6f3bfd45
ID		 2359static void pg_to_raw_osds(struct ceph_osdmap *osdmap,
2360 struct ceph_pg_pool_info *pi,
2361 const struct ceph_pg *raw_pgid,
2362 struct ceph_osds *raw,
2363 u32 *ppps)
2bd93d4d 2364{
6f3bfd45 2365 u32 pps = raw_pg_to_pps(pi, raw_pgid);
2bd93d4d
ID		 2366 int ruleno;
2367 int len;
2368
6f3bfd45
ID		 2369 ceph_osds_init(raw);
2370 if (ppps)
2371 *ppps = pps;
2372
2373 ruleno = crush_find_rule(osdmap->crush, pi->crush_ruleset, pi->type,
2374 pi->size);
2bd93d4d
ID		 2375 if (ruleno < 0) {
2376 pr_err("no crush rule: pool %lld ruleset %d type %d size %d\n",
6f3bfd45
ID		 2377 pi->id, pi->crush_ruleset, pi->type, pi->size);
2378 return;
2bd93d4d
ID		 2379 }
2380
ef9324bb
ID		 2381 if (pi->size > ARRAY_SIZE(raw->osds)) {
2382 pr_err_ratelimited("pool %lld ruleset %d type %d too wide: size %d > %zu\n",
2383 pi->id, pi->crush_ruleset, pi->type, pi->size,
2384 ARRAY_SIZE(raw->osds));
2385 return;
2386 }
2387
2388 len = do_crush(osdmap, ruleno, pps, raw->osds, pi->size,
5cf9c4a9 2389 osdmap->osd_weight, osdmap->max_osd, pi->id);
2bd93d4d
ID		 2390 if (len < 0) {
2391 pr_err("error %d from crush rule %d: pool %lld ruleset %d type %d size %d\n",
6f3bfd45
ID		 2392 len, ruleno, pi->id, pi->crush_ruleset, pi->type,
2393 pi->size);
2394 return;
2bd93d4d
ID		 2395 }
2396
6f3bfd45 2397 raw->size = len;
1c2e7b45
ID		 2398 remove_nonexistent_osds(osdmap, pi, raw);
2399}
2400
2401/* apply pg_upmap[_items] mappings */
2402static void apply_upmap(struct ceph_osdmap *osdmap,
2403 const struct ceph_pg *pgid,
2404 struct ceph_osds *raw)
2405{
2406 struct ceph_pg_mapping *pg;
2407 int i, j;
2408
2409 pg = lookup_pg_mapping(&osdmap->pg_upmap, pgid);
2410 if (pg) {
2411 /* make sure targets aren't marked out */
2412 for (i = 0; i < pg->pg_upmap.len; i++) {
2413 int osd = pg->pg_upmap.osds[i];
2414
2415 if (osd != CRUSH_ITEM_NONE &&
2416 osd < osdmap->max_osd &&
2417 osdmap->osd_weight[osd] == 0) {
2418 /* reject/ignore explicit mapping */
2419 return;
2420 }
2421 }
2422 for (i = 0; i < pg->pg_upmap.len; i++)
2423 raw->osds[i] = pg->pg_upmap.osds[i];
2424 raw->size = pg->pg_upmap.len;
2425 return;
2426 }
2427
2428 pg = lookup_pg_mapping(&osdmap->pg_upmap_items, pgid);
2429 if (pg) {
2430 /*
2431 * Note: this approach does not allow a bidirectional swap,
2432 * e.g., [[1,2],[2,1]] applied to [0,1,2] -> [0,2,1].
2433 */
2434 for (i = 0; i < pg->pg_upmap_items.len; i++) {
2435 int from = pg->pg_upmap_items.from_to[i][0];
2436 int to = pg->pg_upmap_items.from_to[i][1];
2437 int pos = -1;
2438 bool exists = false;
2439
2440 /* make sure replacement doesn't already appear */
2441 for (j = 0; j < raw->size; j++) {
2442 int osd = raw->osds[j];
2443
2444 if (osd == to) {
2445 exists = true;
2446 break;
2447 }
2448 /* ignore mapping if target is marked out */
2449 if (osd == from && pos < 0 &&
2450 !(to != CRUSH_ITEM_NONE &&
2451 to < osdmap->max_osd &&
2452 osdmap->osd_weight[to] == 0)) {
2453 pos = j;
2454 }
2455 }
2456 if (!exists && pos >= 0) {
2457 raw->osds[pos] = to;
2458 return;
2459 }
2460 }
2461 }
2bd93d4d
ID		 2462}
2463
2464/*
6f3bfd45
ID		 2465 * Given raw set, calculate up set and up primary. By definition of an
2466 * up set, the result won't contain nonexistent or down OSDs.
2bd93d4d 2467 *
6f3bfd45
ID		 2468 * This is done in-place - on return @set is the up set. If it's
2469 * empty, ->primary will remain undefined.
2bd93d4d 2470 */
6f3bfd45
ID		 2471static void raw_to_up_osds(struct ceph_osdmap *osdmap,
2472 struct ceph_pg_pool_info *pi,
2473 struct ceph_osds *set)
2bd93d4d 2474{
2bd93d4d
ID		 2475 int i;
2476
6f3bfd45
ID		 2477 /* ->primary is undefined for a raw set */
2478 BUG_ON(set->primary != -1);
2479
2480 if (ceph_can_shift_osds(pi)) {
2bd93d4d
ID		 2481 int removed = 0;
2482
6f3bfd45
ID		 2483 /* shift left */
2484 for (i = 0; i < set->size; i++) {
2485 if (ceph_osd_is_down(osdmap, set->osds[i])) {
2bd93d4d
ID		 2486 removed++;
2487 continue;
2488 }
2489 if (removed)
6f3bfd45 2490 set->osds[i - removed] = set->osds[i];
2bd93d4d 2491 }
6f3bfd45
ID		 2492 set->size -= removed;
2493 if (set->size > 0)
2494 set->primary = set->osds[0];
2bd93d4d 2495 } else {
6f3bfd45
ID		 2496 /* set down/dne devices to NONE */
2497 for (i = set->size - 1; i >= 0; i--) {
2498 if (ceph_osd_is_down(osdmap, set->osds[i]))
2499 set->osds[i] = CRUSH_ITEM_NONE;
2bd93d4d 2500 else
6f3bfd45 2501 set->primary = set->osds[i];
2bd93d4d
ID		 2502 }
2503 }
2bd93d4d
ID		 2504}
2505
6f3bfd45
ID		 2506static void apply_primary_affinity(struct ceph_osdmap *osdmap,
2507 struct ceph_pg_pool_info *pi,
2508 u32 pps,
2509 struct ceph_osds *up)
47ec1f3c
ID		 2510{
2511 int i;
2512 int pos = -1;
2513
2514 /*
2515 * Do we have any non-default primary_affinity values for these
2516 * osds?
2517 */
2518 if (!osdmap->osd_primary_affinity)
2519 return;
2520
6f3bfd45
ID		 2521 for (i = 0; i < up->size; i++) {
2522 int osd = up->osds[i];
92b2e751
ID		 2523
2524 if (osd != CRUSH_ITEM_NONE &&
2525 osdmap->osd_primary_affinity[osd] !=
47ec1f3c
ID		 2526 CEPH_OSD_DEFAULT_PRIMARY_AFFINITY) {
2527 break;
2528 }
2529 }
6f3bfd45 2530 if (i == up->size)
47ec1f3c
ID		 2531 return;
2532
2533 /*
2534 * Pick the primary. Feed both the seed (for the pg) and the
2535 * osd into the hash/rng so that a proportional fraction of an
2536 * osd's pgs get rejected as primary.
2537 */
6f3bfd45
ID		 2538 for (i = 0; i < up->size; i++) {
2539 int osd = up->osds[i];
47ec1f3c
ID		 2540 u32 aff;
2541
47ec1f3c
ID		 2542 if (osd == CRUSH_ITEM_NONE)
2543 continue;
2544
2545 aff = osdmap->osd_primary_affinity[osd];
2546 if (aff < CEPH_OSD_MAX_PRIMARY_AFFINITY &&
2547 (crush_hash32_2(CRUSH_HASH_RJENKINS1,
2548 pps, osd) >> 16) >= aff) {
2549 /*
2550 * We chose not to use this primary. Note it
2551 * anyway as a fallback in case we don't pick
2552 * anyone else, but keep looking.
2553 */
2554 if (pos < 0)
2555 pos = i;
2556 } else {
2557 pos = i;
2558 break;
2559 }
2560 }
2561 if (pos < 0)
2562 return;
2563
6f3bfd45 2564 up->primary = up->osds[pos];
47ec1f3c 2565
6f3bfd45 2566 if (ceph_can_shift_osds(pi) && pos > 0) {
47ec1f3c
ID		 2567 /* move the new primary to the front */
2568 for (i = pos; i > 0; i--)
6f3bfd45
ID		 2569 up->osds[i] = up->osds[i - 1];
2570 up->osds[0] = up->primary;
47ec1f3c
ID		 2571 }
2572}
2573
45966c34 2574/*
6f3bfd45 2575 * Get pg_temp and primary_temp mappings for given PG.
45966c34 2576 *
6f3bfd45
ID		 2577 * Note that a PG may have none, only pg_temp, only primary_temp or
2578 * both pg_temp and primary_temp mappings. This means @temp isn't
2579 * always a valid OSD set on return: in the "only primary_temp" case,
2580 * @temp will have its ->primary >= 0 but ->size == 0.
45966c34 2581 */
6f3bfd45
ID		 2582static void get_temp_osds(struct ceph_osdmap *osdmap,
2583 struct ceph_pg_pool_info *pi,
463bb8da 2584 const struct ceph_pg *pgid,
6f3bfd45 2585 struct ceph_osds *temp)
45966c34
ID		 2586{
2587 struct ceph_pg_mapping *pg;
45966c34
ID		 2588 int i;
2589
6f3bfd45 2590 ceph_osds_init(temp);
45966c34
ID		 2591
2592 /* pg_temp? */
463bb8da 2593 pg = lookup_pg_mapping(&osdmap->pg_temp, pgid);
45966c34 2594 if (pg) {
45966c34
ID		 2595 for (i = 0; i < pg->pg_temp.len; i++) {
2596 if (ceph_osd_is_down(osdmap, pg->pg_temp.osds[i])) {
6f3bfd45 2597 if (ceph_can_shift_osds(pi))
45966c34 2598 continue;
6f3bfd45
ID		 2599
2600 temp->osds[temp->size++] = CRUSH_ITEM_NONE;
45966c34 2601 } else {
6f3bfd45 2602 temp->osds[temp->size++] = pg->pg_temp.osds[i];
45966c34
ID		 2603 }
2604 }
2605
2606 /* apply pg_temp's primary */
6f3bfd45
ID		 2607 for (i = 0; i < temp->size; i++) {
2608 if (temp->osds[i] != CRUSH_ITEM_NONE) {
2609 temp->primary = temp->osds[i];
45966c34
ID		 2610 break;
2611 }
2612 }
45966c34
ID		 2613 }
2614
5e8d4d36 2615 /* primary_temp? */
463bb8da 2616 pg = lookup_pg_mapping(&osdmap->primary_temp, pgid);
5e8d4d36 2617 if (pg)
6f3bfd45 2618 temp->primary = pg->primary_temp.osd;
45966c34
ID		 2619}
2620
d85b7056 2621/*
6f3bfd45 2622 * Map a PG to its acting set as well as its up set.
ac972230 2623 *
6f3bfd45
ID		 2624 * Acting set is used for data mapping purposes, while up set can be
2625 * recorded for detecting interval changes and deciding whether to
2626 * resend a request.
d85b7056 2627 */
6f3bfd45 2628void ceph_pg_to_up_acting_osds(struct ceph_osdmap *osdmap,
df28152d 2629 struct ceph_pg_pool_info *pi,
6f3bfd45
ID		 2630 const struct ceph_pg *raw_pgid,
2631 struct ceph_osds *up,
2632 struct ceph_osds *acting)
d85b7056 2633{
463bb8da 2634 struct ceph_pg pgid;
ac972230 2635 u32 pps;
d85b7056 2636
df28152d 2637 WARN_ON(pi->id != raw_pgid->pool);
463bb8da 2638 raw_pg_to_pg(pi, raw_pgid, &pgid);
d85b7056 2639
6f3bfd45 2640 pg_to_raw_osds(osdmap, pi, raw_pgid, up, &pps);
1c2e7b45 2641 apply_upmap(osdmap, &pgid, up);
6f3bfd45
ID		 2642 raw_to_up_osds(osdmap, pi, up);
2643 apply_primary_affinity(osdmap, pi, pps, up);
463bb8da 2644 get_temp_osds(osdmap, pi, &pgid, acting);
6f3bfd45
ID		 2645 if (!acting->size) {
2646 memcpy(acting->osds, up->osds, up->size * sizeof(up->osds[0]));
2647 acting->size = up->size;
2648 if (acting->primary == -1)
2649 acting->primary = up->primary;
8008ab10 2650 }
6f3bfd45 2651 WARN_ON(!osds_valid(up) || !osds_valid(acting));
d85b7056
SW		 2652}
2653
dc98ff72 2654bool ceph_pg_to_primary_shard(struct ceph_osdmap *osdmap,
df28152d 2655 struct ceph_pg_pool_info *pi,
dc98ff72
ID		 2656 const struct ceph_pg *raw_pgid,
2657 struct ceph_spg *spgid)
2658{
dc98ff72
ID		 2659 struct ceph_pg pgid;
2660 struct ceph_osds up, acting;
2661 int i;
2662
df28152d 2663 WARN_ON(pi->id != raw_pgid->pool);
dc98ff72
ID		 2664 raw_pg_to_pg(pi, raw_pgid, &pgid);
2665
2666 if (ceph_can_shift_osds(pi)) {
2667 spgid->pgid = pgid; /* struct */
2668 spgid->shard = CEPH_SPG_NOSHARD;
2669 return true;
2670 }
2671
df28152d 2672 ceph_pg_to_up_acting_osds(osdmap, pi, &pgid, &up, &acting);
dc98ff72
ID		 2673 for (i = 0; i < acting.size; i++) {
2674 if (acting.osds[i] == acting.primary) {
2675 spgid->pgid = pgid; /* struct */
2676 spgid->shard = i;
2677 return true;
2678 }
2679 }
2680
2681 return false;
2682}
2683
f24e9980 2684/*
f81f1633 2685 * Return acting primary for given PG, or -1 if none.
f24e9980 2686 */
f81f1633
ID		 2687int ceph_pg_to_acting_primary(struct ceph_osdmap *osdmap,
2688 const struct ceph_pg *raw_pgid)
f24e9980 2689{
df28152d 2690 struct ceph_pg_pool_info *pi;
6f3bfd45 2691 struct ceph_osds up, acting;
f24e9980 2692
df28152d
ID		 2693 pi = ceph_pg_pool_by_id(osdmap, raw_pgid->pool);
2694 if (!pi)
2695 return -1;
2696
2697 ceph_pg_to_up_acting_osds(osdmap, pi, raw_pgid, &up, &acting);
6f3bfd45 2698 return acting.primary;
f24e9980 2699}
f81f1633 2700EXPORT_SYMBOL(ceph_pg_to_acting_primary);
Ubuntu Artful kernel mirror