2 #include <linux/ceph/ceph_debug.h>
4 #include <linux/module.h>
5 #include <linux/slab.h>
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>
14 char *ceph_osdmap_state_str(char *str
, int len
, int state
)
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");
26 snprintf(str
, len
, "doesn't exist");
33 static int calc_bits_of(unsigned int t
)
44 * the foo_mask is the smallest value 2^n-1 that is >= foo.
46 static void calc_pg_masks(struct ceph_pg_pool_info
*pi
)
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;
55 static int crush_decode_uniform_bucket(void **p
, void *end
,
56 struct crush_bucket_uniform
*b
)
58 dout("crush_decode_uniform_bucket %p to %p\n", *p
, end
);
59 ceph_decode_need(p
, end
, (1+b
->h
.size
) * sizeof(u32
), bad
);
60 b
->item_weight
= ceph_decode_32(p
);
66 static int crush_decode_list_bucket(void **p
, void *end
,
67 struct crush_bucket_list
*b
)
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
)
74 b
->sum_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
75 if (b
->sum_weights
== NULL
)
77 ceph_decode_need(p
, end
, 2 * b
->h
.size
* sizeof(u32
), bad
);
78 for (j
= 0; j
< b
->h
.size
; j
++) {
79 b
->item_weights
[j
] = ceph_decode_32(p
);
80 b
->sum_weights
[j
] = ceph_decode_32(p
);
87 static int crush_decode_tree_bucket(void **p
, void *end
,
88 struct crush_bucket_tree
*b
)
91 dout("crush_decode_tree_bucket %p to %p\n", *p
, end
);
92 ceph_decode_8_safe(p
, end
, b
->num_nodes
, bad
);
93 b
->node_weights
= kcalloc(b
->num_nodes
, sizeof(u32
), GFP_NOFS
);
94 if (b
->node_weights
== NULL
)
96 ceph_decode_need(p
, end
, b
->num_nodes
* sizeof(u32
), bad
);
97 for (j
= 0; j
< b
->num_nodes
; j
++)
98 b
->node_weights
[j
] = ceph_decode_32(p
);
104 static int crush_decode_straw_bucket(void **p
, void *end
,
105 struct crush_bucket_straw
*b
)
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
)
112 b
->straws
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
113 if (b
->straws
== NULL
)
115 ceph_decode_need(p
, end
, 2 * b
->h
.size
* sizeof(u32
), bad
);
116 for (j
= 0; j
< b
->h
.size
; j
++) {
117 b
->item_weights
[j
] = ceph_decode_32(p
);
118 b
->straws
[j
] = ceph_decode_32(p
);
125 static int crush_decode_straw2_bucket(void **p
, void *end
,
126 struct crush_bucket_straw2
*b
)
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
)
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
);
141 static int skip_name_map(void **p
, void *end
)
144 ceph_decode_32_safe(p
, end
, len
,bad
);
148 ceph_decode_32_safe(p
, end
, strlen
, bad
);
156 static void crush_finalize(struct crush_map
*c
)
160 /* Space for the array of pointers to per-bucket workspace */
161 c
->working_size
= sizeof(struct crush_work
) +
162 c
->max_buckets
* sizeof(struct crush_work_bucket
*);
164 for (b
= 0; b
< c
->max_buckets
; b
++) {
168 switch (c
->buckets
[b
]->alg
) {
171 * The base case, permutation variables and
172 * the pointer to the permutation array.
174 c
->working_size
+= sizeof(struct crush_work_bucket
);
177 /* Every bucket has a permutation array. */
178 c
->working_size
+= c
->buckets
[b
]->size
* sizeof(__u32
);
182 static struct crush_map
*crush_decode(void *pbyval
, void *end
)
188 void *start
= pbyval
;
192 dout("crush_decode %p to %p len %d\n", *p
, end
, (int)(end
- *p
));
194 c
= kzalloc(sizeof(*c
), GFP_NOFS
);
196 return ERR_PTR(-ENOMEM
);
198 /* set tunables to default values */
199 c
->choose_local_tries
= 2;
200 c
->choose_local_fallback_tries
= 5;
201 c
->choose_total_tries
= 19;
202 c
->chooseleaf_descend_once
= 0;
204 ceph_decode_need(p
, end
, 4*sizeof(u32
), bad
);
205 magic
= ceph_decode_32(p
);
206 if (magic
!= CRUSH_MAGIC
) {
207 pr_err("crush_decode magic %x != current %x\n",
208 (unsigned int)magic
, (unsigned int)CRUSH_MAGIC
);
211 c
->max_buckets
= ceph_decode_32(p
);
212 c
->max_rules
= ceph_decode_32(p
);
213 c
->max_devices
= ceph_decode_32(p
);
215 c
->buckets
= kcalloc(c
->max_buckets
, sizeof(*c
->buckets
), GFP_NOFS
);
216 if (c
->buckets
== NULL
)
218 c
->rules
= kcalloc(c
->max_rules
, sizeof(*c
->rules
), GFP_NOFS
);
219 if (c
->rules
== NULL
)
223 for (i
= 0; i
< c
->max_buckets
; i
++) {
226 struct crush_bucket
*b
;
228 ceph_decode_32_safe(p
, end
, alg
, bad
);
230 c
->buckets
[i
] = NULL
;
233 dout("crush_decode bucket %d off %x %p to %p\n",
234 i
, (int)(*p
-start
), *p
, end
);
237 case CRUSH_BUCKET_UNIFORM
:
238 size
= sizeof(struct crush_bucket_uniform
);
240 case CRUSH_BUCKET_LIST
:
241 size
= sizeof(struct crush_bucket_list
);
243 case CRUSH_BUCKET_TREE
:
244 size
= sizeof(struct crush_bucket_tree
);
246 case CRUSH_BUCKET_STRAW
:
247 size
= sizeof(struct crush_bucket_straw
);
249 case CRUSH_BUCKET_STRAW2
:
250 size
= sizeof(struct crush_bucket_straw2
);
257 b
= c
->buckets
[i
] = kzalloc(size
, GFP_NOFS
);
261 ceph_decode_need(p
, end
, 4*sizeof(u32
), bad
);
262 b
->id
= ceph_decode_32(p
);
263 b
->type
= ceph_decode_16(p
);
264 b
->alg
= ceph_decode_8(p
);
265 b
->hash
= ceph_decode_8(p
);
266 b
->weight
= ceph_decode_32(p
);
267 b
->size
= ceph_decode_32(p
);
269 dout("crush_decode bucket size %d off %x %p to %p\n",
270 b
->size
, (int)(*p
-start
), *p
, end
);
272 b
->items
= kcalloc(b
->size
, sizeof(__s32
), GFP_NOFS
);
273 if (b
->items
== NULL
)
276 ceph_decode_need(p
, end
, b
->size
*sizeof(u32
), bad
);
277 for (j
= 0; j
< b
->size
; j
++)
278 b
->items
[j
] = ceph_decode_32(p
);
281 case CRUSH_BUCKET_UNIFORM
:
282 err
= crush_decode_uniform_bucket(p
, end
,
283 (struct crush_bucket_uniform
*)b
);
287 case CRUSH_BUCKET_LIST
:
288 err
= crush_decode_list_bucket(p
, end
,
289 (struct crush_bucket_list
*)b
);
293 case CRUSH_BUCKET_TREE
:
294 err
= crush_decode_tree_bucket(p
, end
,
295 (struct crush_bucket_tree
*)b
);
299 case CRUSH_BUCKET_STRAW
:
300 err
= crush_decode_straw_bucket(p
, end
,
301 (struct crush_bucket_straw
*)b
);
305 case CRUSH_BUCKET_STRAW2
:
306 err
= crush_decode_straw2_bucket(p
, end
,
307 (struct crush_bucket_straw2
*)b
);
315 dout("rule vec is %p\n", c
->rules
);
316 for (i
= 0; i
< c
->max_rules
; i
++) {
318 struct crush_rule
*r
;
321 ceph_decode_32_safe(p
, end
, yes
, bad
);
323 dout("crush_decode NO rule %d off %x %p to %p\n",
324 i
, (int)(*p
-start
), *p
, end
);
329 dout("crush_decode rule %d off %x %p to %p\n",
330 i
, (int)(*p
-start
), *p
, end
);
333 ceph_decode_32_safe(p
, end
, yes
, bad
);
334 #if BITS_PER_LONG == 32
336 if (yes
> (ULONG_MAX
- sizeof(*r
))
337 / sizeof(struct crush_rule_step
))
340 r
= c
->rules
[i
] = kmalloc(sizeof(*r
) +
341 yes
*sizeof(struct crush_rule_step
),
345 dout(" rule %d is at %p\n", i
, r
);
347 ceph_decode_copy_safe(p
, end
, &r
->mask
, 4, bad
); /* 4 u8's */
348 ceph_decode_need(p
, end
, r
->len
*3*sizeof(u32
), bad
);
349 for (j
= 0; j
< r
->len
; j
++) {
350 r
->steps
[j
].op
= ceph_decode_32(p
);
351 r
->steps
[j
].arg1
= ceph_decode_32(p
);
352 r
->steps
[j
].arg2
= ceph_decode_32(p
);
356 /* ignore trailing name maps. */
357 for (num_name_maps
= 0; num_name_maps
< 3; num_name_maps
++) {
358 err
= skip_name_map(p
, end
);
364 ceph_decode_need(p
, end
, 3*sizeof(u32
), done
);
365 c
->choose_local_tries
= ceph_decode_32(p
);
366 c
->choose_local_fallback_tries
= ceph_decode_32(p
);
367 c
->choose_total_tries
= ceph_decode_32(p
);
368 dout("crush decode tunable choose_local_tries = %d\n",
369 c
->choose_local_tries
);
370 dout("crush decode tunable choose_local_fallback_tries = %d\n",
371 c
->choose_local_fallback_tries
);
372 dout("crush decode tunable choose_total_tries = %d\n",
373 c
->choose_total_tries
);
375 ceph_decode_need(p
, end
, sizeof(u32
), done
);
376 c
->chooseleaf_descend_once
= ceph_decode_32(p
);
377 dout("crush decode tunable chooseleaf_descend_once = %d\n",
378 c
->chooseleaf_descend_once
);
380 ceph_decode_need(p
, end
, sizeof(u8
), done
);
381 c
->chooseleaf_vary_r
= ceph_decode_8(p
);
382 dout("crush decode tunable chooseleaf_vary_r = %d\n",
383 c
->chooseleaf_vary_r
);
385 /* skip straw_calc_version, allowed_bucket_algs */
386 ceph_decode_need(p
, end
, sizeof(u8
) + sizeof(u32
), done
);
387 *p
+= sizeof(u8
) + sizeof(u32
);
389 ceph_decode_need(p
, end
, sizeof(u8
), done
);
390 c
->chooseleaf_stable
= ceph_decode_8(p
);
391 dout("crush decode tunable chooseleaf_stable = %d\n",
392 c
->chooseleaf_stable
);
396 dout("crush_decode success\n");
402 dout("crush_decode fail %d\n", err
);
407 int ceph_pg_compare(const struct ceph_pg
*lhs
, const struct ceph_pg
*rhs
)
409 if (lhs
->pool
< rhs
->pool
)
411 if (lhs
->pool
> rhs
->pool
)
413 if (lhs
->seed
< rhs
->seed
)
415 if (lhs
->seed
> rhs
->seed
)
421 int ceph_spg_compare(const struct ceph_spg
*lhs
, const struct ceph_spg
*rhs
)
425 ret
= ceph_pg_compare(&lhs
->pgid
, &rhs
->pgid
);
429 if (lhs
->shard
< rhs
->shard
)
431 if (lhs
->shard
> rhs
->shard
)
437 static struct ceph_pg_mapping
*alloc_pg_mapping(size_t payload_len
)
439 struct ceph_pg_mapping
*pg
;
441 pg
= kmalloc(sizeof(*pg
) + payload_len
, GFP_NOIO
);
445 RB_CLEAR_NODE(&pg
->node
);
449 static void free_pg_mapping(struct ceph_pg_mapping
*pg
)
451 WARN_ON(!RB_EMPTY_NODE(&pg
->node
));
457 * rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid
458 * to a set of osds) and primary_temp (explicit primary setting)
460 DEFINE_RB_FUNCS2(pg_mapping
, struct ceph_pg_mapping
, pgid
, ceph_pg_compare
,
461 RB_BYPTR
, const struct ceph_pg
*, node
)
464 * rbtree of pg pool info
466 static int __insert_pg_pool(struct rb_root
*root
, struct ceph_pg_pool_info
*new)
468 struct rb_node
**p
= &root
->rb_node
;
469 struct rb_node
*parent
= NULL
;
470 struct ceph_pg_pool_info
*pi
= NULL
;
474 pi
= rb_entry(parent
, struct ceph_pg_pool_info
, node
);
475 if (new->id
< pi
->id
)
477 else if (new->id
> pi
->id
)
483 rb_link_node(&new->node
, parent
, p
);
484 rb_insert_color(&new->node
, root
);
488 static struct ceph_pg_pool_info
*__lookup_pg_pool(struct rb_root
*root
, u64 id
)
490 struct ceph_pg_pool_info
*pi
;
491 struct rb_node
*n
= root
->rb_node
;
494 pi
= rb_entry(n
, struct ceph_pg_pool_info
, node
);
497 else if (id
> pi
->id
)
505 struct ceph_pg_pool_info
*ceph_pg_pool_by_id(struct ceph_osdmap
*map
, u64 id
)
507 return __lookup_pg_pool(&map
->pg_pools
, id
);
510 const char *ceph_pg_pool_name_by_id(struct ceph_osdmap
*map
, u64 id
)
512 struct ceph_pg_pool_info
*pi
;
514 if (id
== CEPH_NOPOOL
)
517 if (WARN_ON_ONCE(id
> (u64
) INT_MAX
))
520 pi
= __lookup_pg_pool(&map
->pg_pools
, (int) id
);
522 return pi
? pi
->name
: NULL
;
524 EXPORT_SYMBOL(ceph_pg_pool_name_by_id
);
526 int ceph_pg_poolid_by_name(struct ceph_osdmap
*map
, const char *name
)
530 for (rbp
= rb_first(&map
->pg_pools
); rbp
; rbp
= rb_next(rbp
)) {
531 struct ceph_pg_pool_info
*pi
=
532 rb_entry(rbp
, struct ceph_pg_pool_info
, node
);
533 if (pi
->name
&& strcmp(pi
->name
, name
) == 0)
538 EXPORT_SYMBOL(ceph_pg_poolid_by_name
);
540 static void __remove_pg_pool(struct rb_root
*root
, struct ceph_pg_pool_info
*pi
)
542 rb_erase(&pi
->node
, root
);
547 static int decode_pool(void **p
, void *end
, struct ceph_pg_pool_info
*pi
)
553 ceph_decode_need(p
, end
, 2 + 4, bad
);
554 ev
= ceph_decode_8(p
); /* encoding version */
555 cv
= ceph_decode_8(p
); /* compat version */
557 pr_warn("got v %d < 5 cv %d of ceph_pg_pool\n", ev
, cv
);
561 pr_warn("got v %d cv %d > 9 of ceph_pg_pool\n", ev
, cv
);
564 len
= ceph_decode_32(p
);
565 ceph_decode_need(p
, end
, len
, bad
);
568 pi
->type
= ceph_decode_8(p
);
569 pi
->size
= ceph_decode_8(p
);
570 pi
->crush_ruleset
= ceph_decode_8(p
);
571 pi
->object_hash
= ceph_decode_8(p
);
573 pi
->pg_num
= ceph_decode_32(p
);
574 pi
->pgp_num
= ceph_decode_32(p
);
576 *p
+= 4 + 4; /* skip lpg* */
577 *p
+= 4; /* skip last_change */
578 *p
+= 8 + 4; /* skip snap_seq, snap_epoch */
581 num
= ceph_decode_32(p
);
583 *p
+= 8; /* snapid key */
584 *p
+= 1 + 1; /* versions */
585 len
= ceph_decode_32(p
);
589 /* skip removed_snaps */
590 num
= ceph_decode_32(p
);
593 *p
+= 8; /* skip auid */
594 pi
->flags
= ceph_decode_64(p
);
595 *p
+= 4; /* skip crash_replay_interval */
598 pi
->min_size
= ceph_decode_8(p
);
600 pi
->min_size
= pi
->size
- pi
->size
/ 2;
603 *p
+= 8 + 8; /* skip quota_max_* */
607 num
= ceph_decode_32(p
);
610 *p
+= 8; /* skip tier_of */
611 *p
+= 1; /* skip cache_mode */
613 pi
->read_tier
= ceph_decode_64(p
);
614 pi
->write_tier
= ceph_decode_64(p
);
621 /* skip properties */
622 num
= ceph_decode_32(p
);
624 len
= ceph_decode_32(p
);
626 len
= ceph_decode_32(p
);
632 /* skip hit_set_params */
633 *p
+= 1 + 1; /* versions */
634 len
= ceph_decode_32(p
);
637 *p
+= 4; /* skip hit_set_period */
638 *p
+= 4; /* skip hit_set_count */
642 *p
+= 4; /* skip stripe_width */
645 *p
+= 8; /* skip target_max_bytes */
646 *p
+= 8; /* skip target_max_objects */
647 *p
+= 4; /* skip cache_target_dirty_ratio_micro */
648 *p
+= 4; /* skip cache_target_full_ratio_micro */
649 *p
+= 4; /* skip cache_min_flush_age */
650 *p
+= 4; /* skip cache_min_evict_age */
654 /* skip erasure_code_profile */
655 len
= ceph_decode_32(p
);
660 * last_force_op_resend_preluminous, will be overridden if the
661 * map was encoded with RESEND_ON_SPLIT
664 pi
->last_force_request_resend
= ceph_decode_32(p
);
666 pi
->last_force_request_resend
= 0;
669 *p
+= 4; /* skip min_read_recency_for_promote */
672 *p
+= 8; /* skip expected_num_objects */
675 *p
+= 4; /* skip cache_target_dirty_high_ratio_micro */
678 *p
+= 4; /* skip min_write_recency_for_promote */
681 *p
+= 1; /* skip use_gmt_hitset */
684 *p
+= 1; /* skip fast_read */
687 *p
+= 4; /* skip hit_set_grade_decay_rate */
688 *p
+= 4; /* skip hit_set_search_last_n */
693 *p
+= 1 + 1; /* versions */
694 len
= ceph_decode_32(p
);
699 pi
->last_force_request_resend
= ceph_decode_32(p
);
701 /* ignore the rest */
711 static int decode_pool_names(void **p
, void *end
, struct ceph_osdmap
*map
)
713 struct ceph_pg_pool_info
*pi
;
717 ceph_decode_32_safe(p
, end
, num
, bad
);
718 dout(" %d pool names\n", num
);
720 ceph_decode_64_safe(p
, end
, pool
, bad
);
721 ceph_decode_32_safe(p
, end
, len
, bad
);
722 dout(" pool %llu len %d\n", pool
, len
);
723 ceph_decode_need(p
, end
, len
, bad
);
724 pi
= __lookup_pg_pool(&map
->pg_pools
, pool
);
726 char *name
= kstrndup(*p
, len
, GFP_NOFS
);
732 dout(" name is %s\n", pi
->name
);
745 struct ceph_osdmap
*ceph_osdmap_alloc(void)
747 struct ceph_osdmap
*map
;
749 map
= kzalloc(sizeof(*map
), GFP_NOIO
);
753 map
->pg_pools
= RB_ROOT
;
755 map
->pg_temp
= RB_ROOT
;
756 map
->primary_temp
= RB_ROOT
;
757 mutex_init(&map
->crush_workspace_mutex
);
762 void ceph_osdmap_destroy(struct ceph_osdmap
*map
)
764 dout("osdmap_destroy %p\n", map
);
766 crush_destroy(map
->crush
);
767 while (!RB_EMPTY_ROOT(&map
->pg_temp
)) {
768 struct ceph_pg_mapping
*pg
=
769 rb_entry(rb_first(&map
->pg_temp
),
770 struct ceph_pg_mapping
, node
);
771 erase_pg_mapping(&map
->pg_temp
, pg
);
774 while (!RB_EMPTY_ROOT(&map
->primary_temp
)) {
775 struct ceph_pg_mapping
*pg
=
776 rb_entry(rb_first(&map
->primary_temp
),
777 struct ceph_pg_mapping
, node
);
778 erase_pg_mapping(&map
->primary_temp
, pg
);
781 while (!RB_EMPTY_ROOT(&map
->pg_pools
)) {
782 struct ceph_pg_pool_info
*pi
=
783 rb_entry(rb_first(&map
->pg_pools
),
784 struct ceph_pg_pool_info
, node
);
785 __remove_pg_pool(&map
->pg_pools
, pi
);
787 kfree(map
->osd_state
);
788 kfree(map
->osd_weight
);
789 kfree(map
->osd_addr
);
790 kfree(map
->osd_primary_affinity
);
791 kfree(map
->crush_workspace
);
796 * Adjust max_osd value, (re)allocate arrays.
798 * The new elements are properly initialized.
800 static int osdmap_set_max_osd(struct ceph_osdmap
*map
, int max
)
804 struct ceph_entity_addr
*addr
;
807 state
= krealloc(map
->osd_state
, max
*sizeof(*state
), GFP_NOFS
);
810 map
->osd_state
= state
;
812 weight
= krealloc(map
->osd_weight
, max
*sizeof(*weight
), GFP_NOFS
);
815 map
->osd_weight
= weight
;
817 addr
= krealloc(map
->osd_addr
, max
*sizeof(*addr
), GFP_NOFS
);
820 map
->osd_addr
= addr
;
822 for (i
= map
->max_osd
; i
< max
; i
++) {
823 map
->osd_state
[i
] = 0;
824 map
->osd_weight
[i
] = CEPH_OSD_OUT
;
825 memset(map
->osd_addr
+ i
, 0, sizeof(*map
->osd_addr
));
828 if (map
->osd_primary_affinity
) {
831 affinity
= krealloc(map
->osd_primary_affinity
,
832 max
*sizeof(*affinity
), GFP_NOFS
);
835 map
->osd_primary_affinity
= affinity
;
837 for (i
= map
->max_osd
; i
< max
; i
++)
838 map
->osd_primary_affinity
[i
] =
839 CEPH_OSD_DEFAULT_PRIMARY_AFFINITY
;
847 static int osdmap_set_crush(struct ceph_osdmap
*map
, struct crush_map
*crush
)
853 return PTR_ERR(crush
);
855 work_size
= crush_work_size(crush
, CEPH_PG_MAX_SIZE
);
856 dout("%s work_size %zu bytes\n", __func__
, work_size
);
857 workspace
= kmalloc(work_size
, GFP_NOIO
);
859 crush_destroy(crush
);
862 crush_init_workspace(crush
, workspace
);
865 crush_destroy(map
->crush
);
866 kfree(map
->crush_workspace
);
868 map
->crush_workspace
= workspace
;
872 #define OSDMAP_WRAPPER_COMPAT_VER 7
873 #define OSDMAP_CLIENT_DATA_COMPAT_VER 1
876 * Return 0 or error. On success, *v is set to 0 for old (v6) osdmaps,
877 * to struct_v of the client_data section for new (v7 and above)
880 static int get_osdmap_client_data_v(void **p
, void *end
,
881 const char *prefix
, u8
*v
)
885 ceph_decode_8_safe(p
, end
, struct_v
, e_inval
);
889 ceph_decode_8_safe(p
, end
, struct_compat
, e_inval
);
890 if (struct_compat
> OSDMAP_WRAPPER_COMPAT_VER
) {
891 pr_warn("got v %d cv %d > %d of %s ceph_osdmap\n",
892 struct_v
, struct_compat
,
893 OSDMAP_WRAPPER_COMPAT_VER
, prefix
);
896 *p
+= 4; /* ignore wrapper struct_len */
898 ceph_decode_8_safe(p
, end
, struct_v
, e_inval
);
899 ceph_decode_8_safe(p
, end
, struct_compat
, e_inval
);
900 if (struct_compat
> OSDMAP_CLIENT_DATA_COMPAT_VER
) {
901 pr_warn("got v %d cv %d > %d of %s ceph_osdmap client data\n",
902 struct_v
, struct_compat
,
903 OSDMAP_CLIENT_DATA_COMPAT_VER
, prefix
);
906 *p
+= 4; /* ignore client data struct_len */
911 ceph_decode_16_safe(p
, end
, version
, e_inval
);
913 pr_warn("got v %d < 6 of %s ceph_osdmap\n",
918 /* old osdmap enconding */
929 static int __decode_pools(void **p
, void *end
, struct ceph_osdmap
*map
,
934 ceph_decode_32_safe(p
, end
, n
, e_inval
);
936 struct ceph_pg_pool_info
*pi
;
940 ceph_decode_64_safe(p
, end
, pool
, e_inval
);
942 pi
= __lookup_pg_pool(&map
->pg_pools
, pool
);
943 if (!incremental
|| !pi
) {
944 pi
= kzalloc(sizeof(*pi
), GFP_NOFS
);
950 ret
= __insert_pg_pool(&map
->pg_pools
, pi
);
957 ret
= decode_pool(p
, end
, pi
);
968 static int decode_pools(void **p
, void *end
, struct ceph_osdmap
*map
)
970 return __decode_pools(p
, end
, map
, false);
973 static int decode_new_pools(void **p
, void *end
, struct ceph_osdmap
*map
)
975 return __decode_pools(p
, end
, map
, true);
978 typedef struct ceph_pg_mapping
*(*decode_mapping_fn_t
)(void **, void *, bool);
980 static int decode_pg_mapping(void **p
, void *end
, struct rb_root
*mapping_root
,
981 decode_mapping_fn_t fn
, bool incremental
)
985 WARN_ON(!incremental
&& !fn
);
987 ceph_decode_32_safe(p
, end
, n
, e_inval
);
989 struct ceph_pg_mapping
*pg
;
993 ret
= ceph_decode_pgid(p
, end
, &pgid
);
997 pg
= lookup_pg_mapping(mapping_root
, &pgid
);
999 WARN_ON(!incremental
);
1000 erase_pg_mapping(mapping_root
, pg
);
1001 free_pg_mapping(pg
);
1005 pg
= fn(p
, end
, incremental
);
1010 pg
->pgid
= pgid
; /* struct */
1011 insert_pg_mapping(mapping_root
, pg
);
1022 static struct ceph_pg_mapping
*__decode_pg_temp(void **p
, void *end
,
1025 struct ceph_pg_mapping
*pg
;
1028 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1029 if (len
== 0 && incremental
)
1030 return NULL
; /* new_pg_temp: [] to remove */
1031 if (len
> (SIZE_MAX
- sizeof(*pg
)) / sizeof(u32
))
1032 return ERR_PTR(-EINVAL
);
1034 ceph_decode_need(p
, end
, len
* sizeof(u32
), e_inval
);
1035 pg
= alloc_pg_mapping(len
* sizeof(u32
));
1037 return ERR_PTR(-ENOMEM
);
1039 pg
->pg_temp
.len
= len
;
1040 for (i
= 0; i
< len
; i
++)
1041 pg
->pg_temp
.osds
[i
] = ceph_decode_32(p
);
1046 return ERR_PTR(-EINVAL
);
1049 static int decode_pg_temp(void **p
, void *end
, struct ceph_osdmap
*map
)
1051 return decode_pg_mapping(p
, end
, &map
->pg_temp
, __decode_pg_temp
,
1055 static int decode_new_pg_temp(void **p
, void *end
, struct ceph_osdmap
*map
)
1057 return decode_pg_mapping(p
, end
, &map
->pg_temp
, __decode_pg_temp
,
1061 static struct ceph_pg_mapping
*__decode_primary_temp(void **p
, void *end
,
1064 struct ceph_pg_mapping
*pg
;
1067 ceph_decode_32_safe(p
, end
, osd
, e_inval
);
1068 if (osd
== (u32
)-1 && incremental
)
1069 return NULL
; /* new_primary_temp: -1 to remove */
1071 pg
= alloc_pg_mapping(0);
1073 return ERR_PTR(-ENOMEM
);
1075 pg
->primary_temp
.osd
= osd
;
1079 return ERR_PTR(-EINVAL
);
1082 static int decode_primary_temp(void **p
, void *end
, struct ceph_osdmap
*map
)
1084 return decode_pg_mapping(p
, end
, &map
->primary_temp
,
1085 __decode_primary_temp
, false);
1088 static int decode_new_primary_temp(void **p
, void *end
,
1089 struct ceph_osdmap
*map
)
1091 return decode_pg_mapping(p
, end
, &map
->primary_temp
,
1092 __decode_primary_temp
, true);
1095 u32
ceph_get_primary_affinity(struct ceph_osdmap
*map
, int osd
)
1097 BUG_ON(osd
>= map
->max_osd
);
1099 if (!map
->osd_primary_affinity
)
1100 return CEPH_OSD_DEFAULT_PRIMARY_AFFINITY
;
1102 return map
->osd_primary_affinity
[osd
];
1105 static int set_primary_affinity(struct ceph_osdmap
*map
, int osd
, u32 aff
)
1107 BUG_ON(osd
>= map
->max_osd
);
1109 if (!map
->osd_primary_affinity
) {
1112 map
->osd_primary_affinity
= kmalloc(map
->max_osd
*sizeof(u32
),
1114 if (!map
->osd_primary_affinity
)
1117 for (i
= 0; i
< map
->max_osd
; i
++)
1118 map
->osd_primary_affinity
[i
] =
1119 CEPH_OSD_DEFAULT_PRIMARY_AFFINITY
;
1122 map
->osd_primary_affinity
[osd
] = aff
;
1127 static int decode_primary_affinity(void **p
, void *end
,
1128 struct ceph_osdmap
*map
)
1132 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1134 kfree(map
->osd_primary_affinity
);
1135 map
->osd_primary_affinity
= NULL
;
1138 if (len
!= map
->max_osd
)
1141 ceph_decode_need(p
, end
, map
->max_osd
*sizeof(u32
), e_inval
);
1143 for (i
= 0; i
< map
->max_osd
; i
++) {
1146 ret
= set_primary_affinity(map
, i
, ceph_decode_32(p
));
1157 static int decode_new_primary_affinity(void **p
, void *end
,
1158 struct ceph_osdmap
*map
)
1162 ceph_decode_32_safe(p
, end
, n
, e_inval
);
1167 ceph_decode_32_safe(p
, end
, osd
, e_inval
);
1168 ceph_decode_32_safe(p
, end
, aff
, e_inval
);
1170 ret
= set_primary_affinity(map
, osd
, aff
);
1174 pr_info("osd%d primary-affinity 0x%x\n", osd
, aff
);
1184 * decode a full map.
1186 static int osdmap_decode(void **p
, void *end
, struct ceph_osdmap
*map
)
1195 dout("%s %p to %p len %d\n", __func__
, *p
, end
, (int)(end
- *p
));
1197 err
= get_osdmap_client_data_v(p
, end
, "full", &struct_v
);
1201 /* fsid, epoch, created, modified */
1202 ceph_decode_need(p
, end
, sizeof(map
->fsid
) + sizeof(u32
) +
1203 sizeof(map
->created
) + sizeof(map
->modified
), e_inval
);
1204 ceph_decode_copy(p
, &map
->fsid
, sizeof(map
->fsid
));
1205 epoch
= map
->epoch
= ceph_decode_32(p
);
1206 ceph_decode_copy(p
, &map
->created
, sizeof(map
->created
));
1207 ceph_decode_copy(p
, &map
->modified
, sizeof(map
->modified
));
1210 err
= decode_pools(p
, end
, map
);
1215 err
= decode_pool_names(p
, end
, map
);
1219 ceph_decode_32_safe(p
, end
, map
->pool_max
, e_inval
);
1221 ceph_decode_32_safe(p
, end
, map
->flags
, e_inval
);
1224 ceph_decode_32_safe(p
, end
, max
, e_inval
);
1226 /* (re)alloc osd arrays */
1227 err
= osdmap_set_max_osd(map
, max
);
1231 /* osd_state, osd_weight, osd_addrs->client_addr */
1232 ceph_decode_need(p
, end
, 3*sizeof(u32
) +
1233 map
->max_osd
*(1 + sizeof(*map
->osd_weight
) +
1234 sizeof(*map
->osd_addr
)), e_inval
);
1236 if (ceph_decode_32(p
) != map
->max_osd
)
1239 ceph_decode_copy(p
, map
->osd_state
, map
->max_osd
);
1241 if (ceph_decode_32(p
) != map
->max_osd
)
1244 for (i
= 0; i
< map
->max_osd
; i
++)
1245 map
->osd_weight
[i
] = ceph_decode_32(p
);
1247 if (ceph_decode_32(p
) != map
->max_osd
)
1250 ceph_decode_copy(p
, map
->osd_addr
, map
->max_osd
*sizeof(*map
->osd_addr
));
1251 for (i
= 0; i
< map
->max_osd
; i
++)
1252 ceph_decode_addr(&map
->osd_addr
[i
]);
1255 err
= decode_pg_temp(p
, end
, map
);
1260 if (struct_v
>= 1) {
1261 err
= decode_primary_temp(p
, end
, map
);
1266 /* primary_affinity */
1267 if (struct_v
>= 2) {
1268 err
= decode_primary_affinity(p
, end
, map
);
1272 /* XXX can this happen? */
1273 kfree(map
->osd_primary_affinity
);
1274 map
->osd_primary_affinity
= NULL
;
1278 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1279 err
= osdmap_set_crush(map
, crush_decode(*p
, min(*p
+ len
, end
)));
1283 /* ignore the rest */
1286 dout("full osdmap epoch %d max_osd %d\n", map
->epoch
, map
->max_osd
);
1292 pr_err("corrupt full osdmap (%d) epoch %d off %d (%p of %p-%p)\n",
1293 err
, epoch
, (int)(*p
- start
), *p
, start
, end
);
1294 print_hex_dump(KERN_DEBUG
, "osdmap: ",
1295 DUMP_PREFIX_OFFSET
, 16, 1,
1296 start
, end
- start
, true);
1301 * Allocate and decode a full map.
1303 struct ceph_osdmap
*ceph_osdmap_decode(void **p
, void *end
)
1305 struct ceph_osdmap
*map
;
1308 map
= ceph_osdmap_alloc();
1310 return ERR_PTR(-ENOMEM
);
1312 ret
= osdmap_decode(p
, end
, map
);
1314 ceph_osdmap_destroy(map
);
1315 return ERR_PTR(ret
);
1322 * Encoding order is (new_up_client, new_state, new_weight). Need to
1323 * apply in the (new_weight, new_state, new_up_client) order, because
1324 * an incremental map may look like e.g.
1326 * new_up_client: { osd=6, addr=... } # set osd_state and addr
1327 * new_state: { osd=6, xorstate=EXISTS } # clear osd_state
1329 static int decode_new_up_state_weight(void **p
, void *end
,
1330 struct ceph_osdmap
*map
)
1332 void *new_up_client
;
1334 void *new_weight_end
;
1338 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1339 len
*= sizeof(u32
) + sizeof(struct ceph_entity_addr
);
1340 ceph_decode_need(p
, end
, len
, e_inval
);
1344 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1345 len
*= sizeof(u32
) + sizeof(u8
);
1346 ceph_decode_need(p
, end
, len
, e_inval
);
1350 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1355 ceph_decode_need(p
, end
, 2*sizeof(u32
), e_inval
);
1356 osd
= ceph_decode_32(p
);
1357 w
= ceph_decode_32(p
);
1358 BUG_ON(osd
>= map
->max_osd
);
1359 pr_info("osd%d weight 0x%x %s\n", osd
, w
,
1360 w
== CEPH_OSD_IN
? "(in)" :
1361 (w
== CEPH_OSD_OUT
? "(out)" : ""));
1362 map
->osd_weight
[osd
] = w
;
1365 * If we are marking in, set the EXISTS, and clear the
1366 * AUTOOUT and NEW bits.
1369 map
->osd_state
[osd
] |= CEPH_OSD_EXISTS
;
1370 map
->osd_state
[osd
] &= ~(CEPH_OSD_AUTOOUT
|
1374 new_weight_end
= *p
;
1376 /* new_state (up/down) */
1378 len
= ceph_decode_32(p
);
1384 osd
= ceph_decode_32(p
);
1385 xorstate
= ceph_decode_8(p
);
1387 xorstate
= CEPH_OSD_UP
;
1388 BUG_ON(osd
>= map
->max_osd
);
1389 if ((map
->osd_state
[osd
] & CEPH_OSD_UP
) &&
1390 (xorstate
& CEPH_OSD_UP
))
1391 pr_info("osd%d down\n", osd
);
1392 if ((map
->osd_state
[osd
] & CEPH_OSD_EXISTS
) &&
1393 (xorstate
& CEPH_OSD_EXISTS
)) {
1394 pr_info("osd%d does not exist\n", osd
);
1395 ret
= set_primary_affinity(map
, osd
,
1396 CEPH_OSD_DEFAULT_PRIMARY_AFFINITY
);
1399 memset(map
->osd_addr
+ osd
, 0, sizeof(*map
->osd_addr
));
1400 map
->osd_state
[osd
] = 0;
1402 map
->osd_state
[osd
] ^= xorstate
;
1408 len
= ceph_decode_32(p
);
1411 struct ceph_entity_addr addr
;
1413 osd
= ceph_decode_32(p
);
1414 ceph_decode_copy(p
, &addr
, sizeof(addr
));
1415 ceph_decode_addr(&addr
);
1416 BUG_ON(osd
>= map
->max_osd
);
1417 pr_info("osd%d up\n", osd
);
1418 map
->osd_state
[osd
] |= CEPH_OSD_EXISTS
| CEPH_OSD_UP
;
1419 map
->osd_addr
[osd
] = addr
;
1422 *p
= new_weight_end
;
1430 * decode and apply an incremental map update.
1432 struct ceph_osdmap
*osdmap_apply_incremental(void **p
, void *end
,
1433 struct ceph_osdmap
*map
)
1435 struct ceph_fsid fsid
;
1437 struct ceph_timespec modified
;
1441 __s32 new_flags
, max
;
1446 dout("%s %p to %p len %d\n", __func__
, *p
, end
, (int)(end
- *p
));
1448 err
= get_osdmap_client_data_v(p
, end
, "inc", &struct_v
);
1452 /* fsid, epoch, modified, new_pool_max, new_flags */
1453 ceph_decode_need(p
, end
, sizeof(fsid
) + sizeof(u32
) + sizeof(modified
) +
1454 sizeof(u64
) + sizeof(u32
), e_inval
);
1455 ceph_decode_copy(p
, &fsid
, sizeof(fsid
));
1456 epoch
= ceph_decode_32(p
);
1457 BUG_ON(epoch
!= map
->epoch
+1);
1458 ceph_decode_copy(p
, &modified
, sizeof(modified
));
1459 new_pool_max
= ceph_decode_64(p
);
1460 new_flags
= ceph_decode_32(p
);
1463 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1465 dout("apply_incremental full map len %d, %p to %p\n",
1467 return ceph_osdmap_decode(p
, min(*p
+len
, end
));
1471 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1473 err
= osdmap_set_crush(map
,
1474 crush_decode(*p
, min(*p
+ len
, end
)));
1482 map
->flags
= new_flags
;
1483 if (new_pool_max
>= 0)
1484 map
->pool_max
= new_pool_max
;
1487 ceph_decode_32_safe(p
, end
, max
, e_inval
);
1489 err
= osdmap_set_max_osd(map
, max
);
1495 map
->modified
= modified
;
1498 err
= decode_new_pools(p
, end
, map
);
1502 /* new_pool_names */
1503 err
= decode_pool_names(p
, end
, map
);
1508 ceph_decode_32_safe(p
, end
, len
, e_inval
);
1510 struct ceph_pg_pool_info
*pi
;
1512 ceph_decode_64_safe(p
, end
, pool
, e_inval
);
1513 pi
= __lookup_pg_pool(&map
->pg_pools
, pool
);
1515 __remove_pg_pool(&map
->pg_pools
, pi
);
1518 /* new_up_client, new_state, new_weight */
1519 err
= decode_new_up_state_weight(p
, end
, map
);
1524 err
= decode_new_pg_temp(p
, end
, map
);
1528 /* new_primary_temp */
1529 if (struct_v
>= 1) {
1530 err
= decode_new_primary_temp(p
, end
, map
);
1535 /* new_primary_affinity */
1536 if (struct_v
>= 2) {
1537 err
= decode_new_primary_affinity(p
, end
, map
);
1542 /* ignore the rest */
1545 dout("inc osdmap epoch %d max_osd %d\n", map
->epoch
, map
->max_osd
);
1551 pr_err("corrupt inc osdmap (%d) epoch %d off %d (%p of %p-%p)\n",
1552 err
, epoch
, (int)(*p
- start
), *p
, start
, end
);
1553 print_hex_dump(KERN_DEBUG
, "osdmap: ",
1554 DUMP_PREFIX_OFFSET
, 16, 1,
1555 start
, end
- start
, true);
1556 return ERR_PTR(err
);
1559 void ceph_oloc_copy(struct ceph_object_locator
*dest
,
1560 const struct ceph_object_locator
*src
)
1562 ceph_oloc_destroy(dest
);
1564 dest
->pool
= src
->pool
;
1566 dest
->pool_ns
= ceph_get_string(src
->pool_ns
);
1568 dest
->pool_ns
= NULL
;
1570 EXPORT_SYMBOL(ceph_oloc_copy
);
1572 void ceph_oloc_destroy(struct ceph_object_locator
*oloc
)
1574 ceph_put_string(oloc
->pool_ns
);
1576 EXPORT_SYMBOL(ceph_oloc_destroy
);
1578 void ceph_oid_copy(struct ceph_object_id
*dest
,
1579 const struct ceph_object_id
*src
)
1581 ceph_oid_destroy(dest
);
1583 if (src
->name
!= src
->inline_name
) {
1584 /* very rare, see ceph_object_id definition */
1585 dest
->name
= kmalloc(src
->name_len
+ 1,
1586 GFP_NOIO
| __GFP_NOFAIL
);
1588 dest
->name
= dest
->inline_name
;
1590 memcpy(dest
->name
, src
->name
, src
->name_len
+ 1);
1591 dest
->name_len
= src
->name_len
;
1593 EXPORT_SYMBOL(ceph_oid_copy
);
1595 static __printf(2, 0)
1596 int oid_printf_vargs(struct ceph_object_id
*oid
, const char *fmt
, va_list ap
)
1600 WARN_ON(!ceph_oid_empty(oid
));
1602 len
= vsnprintf(oid
->inline_name
, sizeof(oid
->inline_name
), fmt
, ap
);
1603 if (len
>= sizeof(oid
->inline_name
))
1606 oid
->name_len
= len
;
1611 * If oid doesn't fit into inline buffer, BUG.
1613 void ceph_oid_printf(struct ceph_object_id
*oid
, const char *fmt
, ...)
1618 BUG_ON(oid_printf_vargs(oid
, fmt
, ap
));
1621 EXPORT_SYMBOL(ceph_oid_printf
);
1623 static __printf(3, 0)
1624 int oid_aprintf_vargs(struct ceph_object_id
*oid
, gfp_t gfp
,
1625 const char *fmt
, va_list ap
)
1631 len
= oid_printf_vargs(oid
, fmt
, aq
);
1635 char *external_name
;
1637 external_name
= kmalloc(len
+ 1, gfp
);
1641 oid
->name
= external_name
;
1642 WARN_ON(vsnprintf(oid
->name
, len
+ 1, fmt
, ap
) != len
);
1643 oid
->name_len
= len
;
1650 * If oid doesn't fit into inline buffer, allocate.
1652 int ceph_oid_aprintf(struct ceph_object_id
*oid
, gfp_t gfp
,
1653 const char *fmt
, ...)
1659 ret
= oid_aprintf_vargs(oid
, gfp
, fmt
, ap
);
1664 EXPORT_SYMBOL(ceph_oid_aprintf
);
1666 void ceph_oid_destroy(struct ceph_object_id
*oid
)
1668 if (oid
->name
!= oid
->inline_name
)
1671 EXPORT_SYMBOL(ceph_oid_destroy
);
1676 static bool __osds_equal(const struct ceph_osds
*lhs
,
1677 const struct ceph_osds
*rhs
)
1679 if (lhs
->size
== rhs
->size
&&
1680 !memcmp(lhs
->osds
, rhs
->osds
, rhs
->size
* sizeof(rhs
->osds
[0])))
1689 static bool osds_equal(const struct ceph_osds
*lhs
,
1690 const struct ceph_osds
*rhs
)
1692 if (__osds_equal(lhs
, rhs
) &&
1693 lhs
->primary
== rhs
->primary
)
1699 static bool osds_valid(const struct ceph_osds
*set
)
1702 if (set
->size
> 0 && set
->primary
>= 0)
1705 /* empty can_shift_osds set */
1706 if (!set
->size
&& set
->primary
== -1)
1709 /* empty !can_shift_osds set - all NONE */
1710 if (set
->size
> 0 && set
->primary
== -1) {
1713 for (i
= 0; i
< set
->size
; i
++) {
1714 if (set
->osds
[i
] != CRUSH_ITEM_NONE
)
1724 void ceph_osds_copy(struct ceph_osds
*dest
, const struct ceph_osds
*src
)
1726 memcpy(dest
->osds
, src
->osds
, src
->size
* sizeof(src
->osds
[0]));
1727 dest
->size
= src
->size
;
1728 dest
->primary
= src
->primary
;
1731 bool ceph_pg_is_split(const struct ceph_pg
*pgid
, u32 old_pg_num
,
1734 int old_bits
= calc_bits_of(old_pg_num
);
1735 int old_mask
= (1 << old_bits
) - 1;
1738 WARN_ON(pgid
->seed
>= old_pg_num
);
1739 if (new_pg_num
<= old_pg_num
)
1742 for (n
= 1; ; n
++) {
1743 int next_bit
= n
<< (old_bits
- 1);
1744 u32 s
= next_bit
| pgid
->seed
;
1746 if (s
< old_pg_num
|| s
== pgid
->seed
)
1748 if (s
>= new_pg_num
)
1751 s
= ceph_stable_mod(s
, old_pg_num
, old_mask
);
1752 if (s
== pgid
->seed
)
1759 bool ceph_is_new_interval(const struct ceph_osds
*old_acting
,
1760 const struct ceph_osds
*new_acting
,
1761 const struct ceph_osds
*old_up
,
1762 const struct ceph_osds
*new_up
,
1769 bool old_sort_bitwise
,
1770 bool new_sort_bitwise
,
1771 const struct ceph_pg
*pgid
)
1773 return !osds_equal(old_acting
, new_acting
) ||
1774 !osds_equal(old_up
, new_up
) ||
1775 old_size
!= new_size
||
1776 old_min_size
!= new_min_size
||
1777 ceph_pg_is_split(pgid
, old_pg_num
, new_pg_num
) ||
1778 old_sort_bitwise
!= new_sort_bitwise
;
1781 static int calc_pg_rank(int osd
, const struct ceph_osds
*acting
)
1785 for (i
= 0; i
< acting
->size
; i
++) {
1786 if (acting
->osds
[i
] == osd
)
1793 static bool primary_changed(const struct ceph_osds
*old_acting
,
1794 const struct ceph_osds
*new_acting
)
1796 if (!old_acting
->size
&& !new_acting
->size
)
1797 return false; /* both still empty */
1799 if (!old_acting
->size
^ !new_acting
->size
)
1800 return true; /* was empty, now not, or vice versa */
1802 if (old_acting
->primary
!= new_acting
->primary
)
1803 return true; /* primary changed */
1805 if (calc_pg_rank(old_acting
->primary
, old_acting
) !=
1806 calc_pg_rank(new_acting
->primary
, new_acting
))
1809 return false; /* same primary (tho replicas may have changed) */
1812 bool ceph_osds_changed(const struct ceph_osds
*old_acting
,
1813 const struct ceph_osds
*new_acting
,
1816 if (primary_changed(old_acting
, new_acting
))
1819 if (any_change
&& !__osds_equal(old_acting
, new_acting
))
1826 * calculate file layout from given offset, length.
1827 * fill in correct oid, logical length, and object extent
1830 * for now, we write only a single su, until we can
1831 * pass a stride back to the caller.
1833 int ceph_calc_file_object_mapping(struct ceph_file_layout
*layout
,
1836 u64
*oxoff
, u64
*oxlen
)
1838 u32 osize
= layout
->object_size
;
1839 u32 su
= layout
->stripe_unit
;
1840 u32 sc
= layout
->stripe_count
;
1841 u32 bl
, stripeno
, stripepos
, objsetno
;
1845 dout("mapping %llu~%llu osize %u fl_su %u\n", off
, len
,
1847 if (su
== 0 || sc
== 0)
1849 su_per_object
= osize
/ su
;
1850 if (su_per_object
== 0)
1852 dout("osize %u / su %u = su_per_object %u\n", osize
, su
,
1855 if ((su
& ~PAGE_MASK
) != 0)
1858 /* bl = *off / su; */
1862 dout("off %llu / su %u = bl %u\n", off
, su
, bl
);
1865 stripepos
= bl
% sc
;
1866 objsetno
= stripeno
/ su_per_object
;
1868 *ono
= objsetno
* sc
+ stripepos
;
1869 dout("objset %u * sc %u = ono %u\n", objsetno
, sc
, (unsigned int)*ono
);
1871 /* *oxoff = *off % layout->fl_stripe_unit; # offset in su */
1873 su_offset
= do_div(t
, su
);
1874 *oxoff
= su_offset
+ (stripeno
% su_per_object
) * su
;
1877 * Calculate the length of the extent being written to the selected
1878 * object. This is the minimum of the full length requested (len) or
1879 * the remainder of the current stripe being written to.
1881 *oxlen
= min_t(u64
, len
, su
- su_offset
);
1883 dout(" obj extent %llu~%llu\n", *oxoff
, *oxlen
);
1887 dout(" invalid layout\n");
1893 EXPORT_SYMBOL(ceph_calc_file_object_mapping
);
1896 * Map an object into a PG.
1898 * Should only be called with target_oid and target_oloc (as opposed to
1899 * base_oid and base_oloc), since tiering isn't taken into account.
1901 int __ceph_object_locator_to_pg(struct ceph_pg_pool_info
*pi
,
1902 const struct ceph_object_id
*oid
,
1903 const struct ceph_object_locator
*oloc
,
1904 struct ceph_pg
*raw_pgid
)
1906 WARN_ON(pi
->id
!= oloc
->pool
);
1908 if (!oloc
->pool_ns
) {
1909 raw_pgid
->pool
= oloc
->pool
;
1910 raw_pgid
->seed
= ceph_str_hash(pi
->object_hash
, oid
->name
,
1912 dout("%s %s -> raw_pgid %llu.%x\n", __func__
, oid
->name
,
1913 raw_pgid
->pool
, raw_pgid
->seed
);
1915 char stack_buf
[256];
1916 char *buf
= stack_buf
;
1917 int nsl
= oloc
->pool_ns
->len
;
1918 size_t total
= nsl
+ 1 + oid
->name_len
;
1920 if (total
> sizeof(stack_buf
)) {
1921 buf
= kmalloc(total
, GFP_NOIO
);
1925 memcpy(buf
, oloc
->pool_ns
->str
, nsl
);
1927 memcpy(buf
+ nsl
+ 1, oid
->name
, oid
->name_len
);
1928 raw_pgid
->pool
= oloc
->pool
;
1929 raw_pgid
->seed
= ceph_str_hash(pi
->object_hash
, buf
, total
);
1930 if (buf
!= stack_buf
)
1932 dout("%s %s ns %.*s -> raw_pgid %llu.%x\n", __func__
,
1933 oid
->name
, nsl
, oloc
->pool_ns
->str
,
1934 raw_pgid
->pool
, raw_pgid
->seed
);
1939 int ceph_object_locator_to_pg(struct ceph_osdmap
*osdmap
,
1940 const struct ceph_object_id
*oid
,
1941 const struct ceph_object_locator
*oloc
,
1942 struct ceph_pg
*raw_pgid
)
1944 struct ceph_pg_pool_info
*pi
;
1946 pi
= ceph_pg_pool_by_id(osdmap
, oloc
->pool
);
1950 return __ceph_object_locator_to_pg(pi
, oid
, oloc
, raw_pgid
);
1952 EXPORT_SYMBOL(ceph_object_locator_to_pg
);
1955 * Map a raw PG (full precision ps) into an actual PG.
1957 static void raw_pg_to_pg(struct ceph_pg_pool_info
*pi
,
1958 const struct ceph_pg
*raw_pgid
,
1959 struct ceph_pg
*pgid
)
1961 pgid
->pool
= raw_pgid
->pool
;
1962 pgid
->seed
= ceph_stable_mod(raw_pgid
->seed
, pi
->pg_num
,
1967 * Map a raw PG (full precision ps) into a placement ps (placement
1968 * seed). Include pool id in that value so that different pools don't
1969 * use the same seeds.
1971 static u32
raw_pg_to_pps(struct ceph_pg_pool_info
*pi
,
1972 const struct ceph_pg
*raw_pgid
)
1974 if (pi
->flags
& CEPH_POOL_FLAG_HASHPSPOOL
) {
1975 /* hash pool id and seed so that pool PGs do not overlap */
1976 return crush_hash32_2(CRUSH_HASH_RJENKINS1
,
1977 ceph_stable_mod(raw_pgid
->seed
,
1983 * legacy behavior: add ps and pool together. this is
1984 * not a great approach because the PGs from each pool
1985 * will overlap on top of each other: 0.5 == 1.4 ==
1988 return ceph_stable_mod(raw_pgid
->seed
, pi
->pgp_num
,
1990 (unsigned)raw_pgid
->pool
;
1994 static int do_crush(struct ceph_osdmap
*map
, int ruleno
, int x
,
1995 int *result
, int result_max
,
1996 const __u32
*weight
, int weight_max
)
2000 BUG_ON(result_max
> CEPH_PG_MAX_SIZE
);
2002 mutex_lock(&map
->crush_workspace_mutex
);
2003 r
= crush_do_rule(map
->crush
, ruleno
, x
, result
, result_max
,
2004 weight
, weight_max
, map
->crush_workspace
);
2005 mutex_unlock(&map
->crush_workspace_mutex
);
2011 * Calculate raw set (CRUSH output) for given PG. The result may
2012 * contain nonexistent OSDs. ->primary is undefined for a raw set.
2014 * Placement seed (CRUSH input) is returned through @ppps.
2016 static void pg_to_raw_osds(struct ceph_osdmap
*osdmap
,
2017 struct ceph_pg_pool_info
*pi
,
2018 const struct ceph_pg
*raw_pgid
,
2019 struct ceph_osds
*raw
,
2022 u32 pps
= raw_pg_to_pps(pi
, raw_pgid
);
2026 ceph_osds_init(raw
);
2030 ruleno
= crush_find_rule(osdmap
->crush
, pi
->crush_ruleset
, pi
->type
,
2033 pr_err("no crush rule: pool %lld ruleset %d type %d size %d\n",
2034 pi
->id
, pi
->crush_ruleset
, pi
->type
, pi
->size
);
2038 if (pi
->size
> ARRAY_SIZE(raw
->osds
)) {
2039 pr_err_ratelimited("pool %lld ruleset %d type %d too wide: size %d > %zu\n",
2040 pi
->id
, pi
->crush_ruleset
, pi
->type
, pi
->size
,
2041 ARRAY_SIZE(raw
->osds
));
2045 len
= do_crush(osdmap
, ruleno
, pps
, raw
->osds
, pi
->size
,
2046 osdmap
->osd_weight
, osdmap
->max_osd
);
2048 pr_err("error %d from crush rule %d: pool %lld ruleset %d type %d size %d\n",
2049 len
, ruleno
, pi
->id
, pi
->crush_ruleset
, pi
->type
,
2058 * Given raw set, calculate up set and up primary. By definition of an
2059 * up set, the result won't contain nonexistent or down OSDs.
2061 * This is done in-place - on return @set is the up set. If it's
2062 * empty, ->primary will remain undefined.
2064 static void raw_to_up_osds(struct ceph_osdmap
*osdmap
,
2065 struct ceph_pg_pool_info
*pi
,
2066 struct ceph_osds
*set
)
2070 /* ->primary is undefined for a raw set */
2071 BUG_ON(set
->primary
!= -1);
2073 if (ceph_can_shift_osds(pi
)) {
2077 for (i
= 0; i
< set
->size
; i
++) {
2078 if (ceph_osd_is_down(osdmap
, set
->osds
[i
])) {
2083 set
->osds
[i
- removed
] = set
->osds
[i
];
2085 set
->size
-= removed
;
2087 set
->primary
= set
->osds
[0];
2089 /* set down/dne devices to NONE */
2090 for (i
= set
->size
- 1; i
>= 0; i
--) {
2091 if (ceph_osd_is_down(osdmap
, set
->osds
[i
]))
2092 set
->osds
[i
] = CRUSH_ITEM_NONE
;
2094 set
->primary
= set
->osds
[i
];
2099 static void apply_primary_affinity(struct ceph_osdmap
*osdmap
,
2100 struct ceph_pg_pool_info
*pi
,
2102 struct ceph_osds
*up
)
2108 * Do we have any non-default primary_affinity values for these
2111 if (!osdmap
->osd_primary_affinity
)
2114 for (i
= 0; i
< up
->size
; i
++) {
2115 int osd
= up
->osds
[i
];
2117 if (osd
!= CRUSH_ITEM_NONE
&&
2118 osdmap
->osd_primary_affinity
[osd
] !=
2119 CEPH_OSD_DEFAULT_PRIMARY_AFFINITY
) {
2127 * Pick the primary. Feed both the seed (for the pg) and the
2128 * osd into the hash/rng so that a proportional fraction of an
2129 * osd's pgs get rejected as primary.
2131 for (i
= 0; i
< up
->size
; i
++) {
2132 int osd
= up
->osds
[i
];
2135 if (osd
== CRUSH_ITEM_NONE
)
2138 aff
= osdmap
->osd_primary_affinity
[osd
];
2139 if (aff
< CEPH_OSD_MAX_PRIMARY_AFFINITY
&&
2140 (crush_hash32_2(CRUSH_HASH_RJENKINS1
,
2141 pps
, osd
) >> 16) >= aff
) {
2143 * We chose not to use this primary. Note it
2144 * anyway as a fallback in case we don't pick
2145 * anyone else, but keep looking.
2157 up
->primary
= up
->osds
[pos
];
2159 if (ceph_can_shift_osds(pi
) && pos
> 0) {
2160 /* move the new primary to the front */
2161 for (i
= pos
; i
> 0; i
--)
2162 up
->osds
[i
] = up
->osds
[i
- 1];
2163 up
->osds
[0] = up
->primary
;
2168 * Get pg_temp and primary_temp mappings for given PG.
2170 * Note that a PG may have none, only pg_temp, only primary_temp or
2171 * both pg_temp and primary_temp mappings. This means @temp isn't
2172 * always a valid OSD set on return: in the "only primary_temp" case,
2173 * @temp will have its ->primary >= 0 but ->size == 0.
2175 static void get_temp_osds(struct ceph_osdmap
*osdmap
,
2176 struct ceph_pg_pool_info
*pi
,
2177 const struct ceph_pg
*raw_pgid
,
2178 struct ceph_osds
*temp
)
2180 struct ceph_pg pgid
;
2181 struct ceph_pg_mapping
*pg
;
2184 raw_pg_to_pg(pi
, raw_pgid
, &pgid
);
2185 ceph_osds_init(temp
);
2188 pg
= lookup_pg_mapping(&osdmap
->pg_temp
, &pgid
);
2190 for (i
= 0; i
< pg
->pg_temp
.len
; i
++) {
2191 if (ceph_osd_is_down(osdmap
, pg
->pg_temp
.osds
[i
])) {
2192 if (ceph_can_shift_osds(pi
))
2195 temp
->osds
[temp
->size
++] = CRUSH_ITEM_NONE
;
2197 temp
->osds
[temp
->size
++] = pg
->pg_temp
.osds
[i
];
2201 /* apply pg_temp's primary */
2202 for (i
= 0; i
< temp
->size
; i
++) {
2203 if (temp
->osds
[i
] != CRUSH_ITEM_NONE
) {
2204 temp
->primary
= temp
->osds
[i
];
2211 pg
= lookup_pg_mapping(&osdmap
->primary_temp
, &pgid
);
2213 temp
->primary
= pg
->primary_temp
.osd
;
2217 * Map a PG to its acting set as well as its up set.
2219 * Acting set is used for data mapping purposes, while up set can be
2220 * recorded for detecting interval changes and deciding whether to
2223 void ceph_pg_to_up_acting_osds(struct ceph_osdmap
*osdmap
,
2224 struct ceph_pg_pool_info
*pi
,
2225 const struct ceph_pg
*raw_pgid
,
2226 struct ceph_osds
*up
,
2227 struct ceph_osds
*acting
)
2231 WARN_ON(pi
->id
!= raw_pgid
->pool
);
2233 pg_to_raw_osds(osdmap
, pi
, raw_pgid
, up
, &pps
);
2234 raw_to_up_osds(osdmap
, pi
, up
);
2235 apply_primary_affinity(osdmap
, pi
, pps
, up
);
2236 get_temp_osds(osdmap
, pi
, raw_pgid
, acting
);
2237 if (!acting
->size
) {
2238 memcpy(acting
->osds
, up
->osds
, up
->size
* sizeof(up
->osds
[0]));
2239 acting
->size
= up
->size
;
2240 if (acting
->primary
== -1)
2241 acting
->primary
= up
->primary
;
2243 WARN_ON(!osds_valid(up
) || !osds_valid(acting
));
2246 bool ceph_pg_to_primary_shard(struct ceph_osdmap
*osdmap
,
2247 struct ceph_pg_pool_info
*pi
,
2248 const struct ceph_pg
*raw_pgid
,
2249 struct ceph_spg
*spgid
)
2251 struct ceph_pg pgid
;
2252 struct ceph_osds up
, acting
;
2255 WARN_ON(pi
->id
!= raw_pgid
->pool
);
2256 raw_pg_to_pg(pi
, raw_pgid
, &pgid
);
2258 if (ceph_can_shift_osds(pi
)) {
2259 spgid
->pgid
= pgid
; /* struct */
2260 spgid
->shard
= CEPH_SPG_NOSHARD
;
2264 ceph_pg_to_up_acting_osds(osdmap
, pi
, &pgid
, &up
, &acting
);
2265 for (i
= 0; i
< acting
.size
; i
++) {
2266 if (acting
.osds
[i
] == acting
.primary
) {
2267 spgid
->pgid
= pgid
; /* struct */
2277 * Return acting primary for given PG, or -1 if none.
2279 int ceph_pg_to_acting_primary(struct ceph_osdmap
*osdmap
,
2280 const struct ceph_pg
*raw_pgid
)
2282 struct ceph_pg_pool_info
*pi
;
2283 struct ceph_osds up
, acting
;
2285 pi
= ceph_pg_pool_by_id(osdmap
, raw_pgid
->pool
);
2289 ceph_pg_to_up_acting_osds(osdmap
, pi
, raw_pgid
, &up
, &acting
);
2290 return acting
.primary
;
2292 EXPORT_SYMBOL(ceph_pg_to_acting_primary
);