2 #include "ceph_debug.h"
4 #include <linux/slab.h>
9 #include "crush/hash.h"
10 #include "crush/mapper.h"
13 char *ceph_osdmap_state_str(char *str
, int len
, int state
)
22 if (state
& CEPH_OSD_EXISTS
) {
23 snprintf(str
, len
, "exists");
26 if (state
& CEPH_OSD_UP
) {
27 snprintf(str
, len
, "%s%s%s", str
, (flag
? ", " : ""),
32 snprintf(str
, len
, "doesn't exist");
40 static int calc_bits_of(unsigned t
)
51 * the foo_mask is the smallest value 2^n-1 that is >= foo.
53 static void calc_pg_masks(struct ceph_pg_pool_info
*pi
)
55 pi
->pg_num_mask
= (1 << calc_bits_of(le32_to_cpu(pi
->v
.pg_num
)-1)) - 1;
57 (1 << calc_bits_of(le32_to_cpu(pi
->v
.pgp_num
)-1)) - 1;
59 (1 << calc_bits_of(le32_to_cpu(pi
->v
.lpg_num
)-1)) - 1;
61 (1 << calc_bits_of(le32_to_cpu(pi
->v
.lpgp_num
)-1)) - 1;
67 static int crush_decode_uniform_bucket(void **p
, void *end
,
68 struct crush_bucket_uniform
*b
)
70 dout("crush_decode_uniform_bucket %p to %p\n", *p
, end
);
71 ceph_decode_need(p
, end
, (1+b
->h
.size
) * sizeof(u32
), bad
);
72 b
->item_weight
= ceph_decode_32(p
);
78 static int crush_decode_list_bucket(void **p
, void *end
,
79 struct crush_bucket_list
*b
)
82 dout("crush_decode_list_bucket %p to %p\n", *p
, end
);
83 b
->item_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
84 if (b
->item_weights
== NULL
)
86 b
->sum_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
87 if (b
->sum_weights
== NULL
)
89 ceph_decode_need(p
, end
, 2 * b
->h
.size
* sizeof(u32
), bad
);
90 for (j
= 0; j
< b
->h
.size
; j
++) {
91 b
->item_weights
[j
] = ceph_decode_32(p
);
92 b
->sum_weights
[j
] = ceph_decode_32(p
);
99 static int crush_decode_tree_bucket(void **p
, void *end
,
100 struct crush_bucket_tree
*b
)
103 dout("crush_decode_tree_bucket %p to %p\n", *p
, end
);
104 ceph_decode_32_safe(p
, end
, b
->num_nodes
, bad
);
105 b
->node_weights
= kcalloc(b
->num_nodes
, sizeof(u32
), GFP_NOFS
);
106 if (b
->node_weights
== NULL
)
108 ceph_decode_need(p
, end
, b
->num_nodes
* sizeof(u32
), bad
);
109 for (j
= 0; j
< b
->num_nodes
; j
++)
110 b
->node_weights
[j
] = ceph_decode_32(p
);
116 static int crush_decode_straw_bucket(void **p
, void *end
,
117 struct crush_bucket_straw
*b
)
120 dout("crush_decode_straw_bucket %p to %p\n", *p
, end
);
121 b
->item_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
122 if (b
->item_weights
== NULL
)
124 b
->straws
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
125 if (b
->straws
== NULL
)
127 ceph_decode_need(p
, end
, 2 * b
->h
.size
* sizeof(u32
), bad
);
128 for (j
= 0; j
< b
->h
.size
; j
++) {
129 b
->item_weights
[j
] = ceph_decode_32(p
);
130 b
->straws
[j
] = ceph_decode_32(p
);
137 static struct crush_map
*crush_decode(void *pbyval
, void *end
)
143 void *start
= pbyval
;
146 dout("crush_decode %p to %p len %d\n", *p
, end
, (int)(end
- *p
));
148 c
= kzalloc(sizeof(*c
), GFP_NOFS
);
150 return ERR_PTR(-ENOMEM
);
152 ceph_decode_need(p
, end
, 4*sizeof(u32
), bad
);
153 magic
= ceph_decode_32(p
);
154 if (magic
!= CRUSH_MAGIC
) {
155 pr_err("crush_decode magic %x != current %x\n",
156 (unsigned)magic
, (unsigned)CRUSH_MAGIC
);
159 c
->max_buckets
= ceph_decode_32(p
);
160 c
->max_rules
= ceph_decode_32(p
);
161 c
->max_devices
= ceph_decode_32(p
);
163 c
->device_parents
= kcalloc(c
->max_devices
, sizeof(u32
), GFP_NOFS
);
164 if (c
->device_parents
== NULL
)
166 c
->bucket_parents
= kcalloc(c
->max_buckets
, sizeof(u32
), GFP_NOFS
);
167 if (c
->bucket_parents
== NULL
)
170 c
->buckets
= kcalloc(c
->max_buckets
, sizeof(*c
->buckets
), GFP_NOFS
);
171 if (c
->buckets
== NULL
)
173 c
->rules
= kcalloc(c
->max_rules
, sizeof(*c
->rules
), GFP_NOFS
);
174 if (c
->rules
== NULL
)
178 for (i
= 0; i
< c
->max_buckets
; i
++) {
181 struct crush_bucket
*b
;
183 ceph_decode_32_safe(p
, end
, alg
, bad
);
185 c
->buckets
[i
] = NULL
;
188 dout("crush_decode bucket %d off %x %p to %p\n",
189 i
, (int)(*p
-start
), *p
, end
);
192 case CRUSH_BUCKET_UNIFORM
:
193 size
= sizeof(struct crush_bucket_uniform
);
195 case CRUSH_BUCKET_LIST
:
196 size
= sizeof(struct crush_bucket_list
);
198 case CRUSH_BUCKET_TREE
:
199 size
= sizeof(struct crush_bucket_tree
);
201 case CRUSH_BUCKET_STRAW
:
202 size
= sizeof(struct crush_bucket_straw
);
209 b
= c
->buckets
[i
] = kzalloc(size
, GFP_NOFS
);
213 ceph_decode_need(p
, end
, 4*sizeof(u32
), bad
);
214 b
->id
= ceph_decode_32(p
);
215 b
->type
= ceph_decode_16(p
);
216 b
->alg
= ceph_decode_8(p
);
217 b
->hash
= ceph_decode_8(p
);
218 b
->weight
= ceph_decode_32(p
);
219 b
->size
= ceph_decode_32(p
);
221 dout("crush_decode bucket size %d off %x %p to %p\n",
222 b
->size
, (int)(*p
-start
), *p
, end
);
224 b
->items
= kcalloc(b
->size
, sizeof(__s32
), GFP_NOFS
);
225 if (b
->items
== NULL
)
227 b
->perm
= kcalloc(b
->size
, sizeof(u32
), GFP_NOFS
);
232 ceph_decode_need(p
, end
, b
->size
*sizeof(u32
), bad
);
233 for (j
= 0; j
< b
->size
; j
++)
234 b
->items
[j
] = ceph_decode_32(p
);
237 case CRUSH_BUCKET_UNIFORM
:
238 err
= crush_decode_uniform_bucket(p
, end
,
239 (struct crush_bucket_uniform
*)b
);
243 case CRUSH_BUCKET_LIST
:
244 err
= crush_decode_list_bucket(p
, end
,
245 (struct crush_bucket_list
*)b
);
249 case CRUSH_BUCKET_TREE
:
250 err
= crush_decode_tree_bucket(p
, end
,
251 (struct crush_bucket_tree
*)b
);
255 case CRUSH_BUCKET_STRAW
:
256 err
= crush_decode_straw_bucket(p
, end
,
257 (struct crush_bucket_straw
*)b
);
265 dout("rule vec is %p\n", c
->rules
);
266 for (i
= 0; i
< c
->max_rules
; i
++) {
268 struct crush_rule
*r
;
270 ceph_decode_32_safe(p
, end
, yes
, bad
);
272 dout("crush_decode NO rule %d off %x %p to %p\n",
273 i
, (int)(*p
-start
), *p
, end
);
278 dout("crush_decode rule %d off %x %p to %p\n",
279 i
, (int)(*p
-start
), *p
, end
);
282 ceph_decode_32_safe(p
, end
, yes
, bad
);
283 #if BITS_PER_LONG == 32
285 if (yes
> ULONG_MAX
/ sizeof(struct crush_rule_step
))
288 r
= c
->rules
[i
] = kmalloc(sizeof(*r
) +
289 yes
*sizeof(struct crush_rule_step
),
293 dout(" rule %d is at %p\n", i
, r
);
295 ceph_decode_copy_safe(p
, end
, &r
->mask
, 4, bad
); /* 4 u8's */
296 ceph_decode_need(p
, end
, r
->len
*3*sizeof(u32
), bad
);
297 for (j
= 0; j
< r
->len
; j
++) {
298 r
->steps
[j
].op
= ceph_decode_32(p
);
299 r
->steps
[j
].arg1
= ceph_decode_32(p
);
300 r
->steps
[j
].arg2
= ceph_decode_32(p
);
304 /* ignore trailing name maps. */
306 dout("crush_decode success\n");
312 dout("crush_decode fail %d\n", err
);
321 void ceph_osdmap_destroy(struct ceph_osdmap
*map
)
323 dout("osdmap_destroy %p\n", map
);
325 crush_destroy(map
->crush
);
326 while (!RB_EMPTY_ROOT(&map
->pg_temp
)) {
327 struct ceph_pg_mapping
*pg
=
328 rb_entry(rb_first(&map
->pg_temp
),
329 struct ceph_pg_mapping
, node
);
330 rb_erase(&pg
->node
, &map
->pg_temp
);
333 while (!RB_EMPTY_ROOT(&map
->pg_pools
)) {
334 struct ceph_pg_pool_info
*pi
=
335 rb_entry(rb_first(&map
->pg_pools
),
336 struct ceph_pg_pool_info
, node
);
337 rb_erase(&pi
->node
, &map
->pg_pools
);
340 kfree(map
->osd_state
);
341 kfree(map
->osd_weight
);
342 kfree(map
->osd_addr
);
347 * adjust max osd value. reallocate arrays.
349 static int osdmap_set_max_osd(struct ceph_osdmap
*map
, int max
)
352 struct ceph_entity_addr
*addr
;
355 state
= kcalloc(max
, sizeof(*state
), GFP_NOFS
);
356 addr
= kcalloc(max
, sizeof(*addr
), GFP_NOFS
);
357 weight
= kcalloc(max
, sizeof(*weight
), GFP_NOFS
);
358 if (state
== NULL
|| addr
== NULL
|| weight
== NULL
) {
366 if (map
->osd_state
) {
367 memcpy(state
, map
->osd_state
, map
->max_osd
*sizeof(*state
));
368 memcpy(addr
, map
->osd_addr
, map
->max_osd
*sizeof(*addr
));
369 memcpy(weight
, map
->osd_weight
, map
->max_osd
*sizeof(*weight
));
370 kfree(map
->osd_state
);
371 kfree(map
->osd_addr
);
372 kfree(map
->osd_weight
);
375 map
->osd_state
= state
;
376 map
->osd_weight
= weight
;
377 map
->osd_addr
= addr
;
383 * rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid
386 static int pgid_cmp(struct ceph_pg l
, struct ceph_pg r
)
398 static int __insert_pg_mapping(struct ceph_pg_mapping
*new,
399 struct rb_root
*root
)
401 struct rb_node
**p
= &root
->rb_node
;
402 struct rb_node
*parent
= NULL
;
403 struct ceph_pg_mapping
*pg
= NULL
;
408 pg
= rb_entry(parent
, struct ceph_pg_mapping
, node
);
409 c
= pgid_cmp(new->pgid
, pg
->pgid
);
418 rb_link_node(&new->node
, parent
, p
);
419 rb_insert_color(&new->node
, root
);
423 static struct ceph_pg_mapping
*__lookup_pg_mapping(struct rb_root
*root
,
426 struct rb_node
*n
= root
->rb_node
;
427 struct ceph_pg_mapping
*pg
;
431 pg
= rb_entry(n
, struct ceph_pg_mapping
, node
);
432 c
= pgid_cmp(pgid
, pg
->pgid
);
444 * rbtree of pg pool info
446 static int __insert_pg_pool(struct rb_root
*root
, struct ceph_pg_pool_info
*new)
448 struct rb_node
**p
= &root
->rb_node
;
449 struct rb_node
*parent
= NULL
;
450 struct ceph_pg_pool_info
*pi
= NULL
;
454 pi
= rb_entry(parent
, struct ceph_pg_pool_info
, node
);
455 if (new->id
< pi
->id
)
457 else if (new->id
> pi
->id
)
463 rb_link_node(&new->node
, parent
, p
);
464 rb_insert_color(&new->node
, root
);
468 static struct ceph_pg_pool_info
*__lookup_pg_pool(struct rb_root
*root
, int id
)
470 struct ceph_pg_pool_info
*pi
;
471 struct rb_node
*n
= root
->rb_node
;
474 pi
= rb_entry(n
, struct ceph_pg_pool_info
, node
);
477 else if (id
> pi
->id
)
485 void __decode_pool(void **p
, struct ceph_pg_pool_info
*pi
)
487 ceph_decode_copy(p
, &pi
->v
, sizeof(pi
->v
));
489 *p
+= le32_to_cpu(pi
->v
.num_snaps
) * sizeof(u64
);
490 *p
+= le32_to_cpu(pi
->v
.num_removed_snap_intervals
) * sizeof(u64
) * 2;
496 struct ceph_osdmap
*osdmap_decode(void **p
, void *end
)
498 struct ceph_osdmap
*map
;
504 struct ceph_pg_pool_info
*pi
;
506 dout("osdmap_decode %p to %p len %d\n", *p
, end
, (int)(end
- *p
));
508 map
= kzalloc(sizeof(*map
), GFP_NOFS
);
510 return ERR_PTR(-ENOMEM
);
511 map
->pg_temp
= RB_ROOT
;
513 ceph_decode_16_safe(p
, end
, version
, bad
);
514 if (version
> CEPH_OSDMAP_VERSION
) {
515 pr_warning("got unknown v %d > %d of osdmap\n", version
,
516 CEPH_OSDMAP_VERSION
);
520 ceph_decode_need(p
, end
, 2*sizeof(u64
)+6*sizeof(u32
), bad
);
521 ceph_decode_copy(p
, &map
->fsid
, sizeof(map
->fsid
));
522 map
->epoch
= ceph_decode_32(p
);
523 ceph_decode_copy(p
, &map
->created
, sizeof(map
->created
));
524 ceph_decode_copy(p
, &map
->modified
, sizeof(map
->modified
));
526 ceph_decode_32_safe(p
, end
, max
, bad
);
528 ceph_decode_need(p
, end
, 4 + 1 + sizeof(pi
->v
), bad
);
529 pi
= kmalloc(sizeof(*pi
), GFP_NOFS
);
532 pi
->id
= ceph_decode_32(p
);
533 ev
= ceph_decode_8(p
); /* encoding version */
534 if (ev
> CEPH_PG_POOL_VERSION
) {
535 pr_warning("got unknown v %d > %d of ceph_pg_pool\n",
536 ev
, CEPH_PG_POOL_VERSION
);
539 __decode_pool(p
, pi
);
540 __insert_pg_pool(&map
->pg_pools
, pi
);
542 ceph_decode_32_safe(p
, end
, map
->pool_max
, bad
);
544 ceph_decode_32_safe(p
, end
, map
->flags
, bad
);
546 max
= ceph_decode_32(p
);
548 /* (re)alloc osd arrays */
549 err
= osdmap_set_max_osd(map
, max
);
552 dout("osdmap_decode max_osd = %d\n", map
->max_osd
);
556 ceph_decode_need(p
, end
, 3*sizeof(u32
) +
557 map
->max_osd
*(1 + sizeof(*map
->osd_weight
) +
558 sizeof(*map
->osd_addr
)), bad
);
559 *p
+= 4; /* skip length field (should match max) */
560 ceph_decode_copy(p
, map
->osd_state
, map
->max_osd
);
562 *p
+= 4; /* skip length field (should match max) */
563 for (i
= 0; i
< map
->max_osd
; i
++)
564 map
->osd_weight
[i
] = ceph_decode_32(p
);
566 *p
+= 4; /* skip length field (should match max) */
567 ceph_decode_copy(p
, map
->osd_addr
, map
->max_osd
*sizeof(*map
->osd_addr
));
568 for (i
= 0; i
< map
->max_osd
; i
++)
569 ceph_decode_addr(&map
->osd_addr
[i
]);
572 ceph_decode_32_safe(p
, end
, len
, bad
);
573 for (i
= 0; i
< len
; i
++) {
576 struct ceph_pg_mapping
*pg
;
578 ceph_decode_need(p
, end
, sizeof(u32
) + sizeof(u64
), bad
);
579 ceph_decode_copy(p
, &pgid
, sizeof(pgid
));
580 n
= ceph_decode_32(p
);
581 ceph_decode_need(p
, end
, n
* sizeof(u32
), bad
);
583 pg
= kmalloc(sizeof(*pg
) + n
*sizeof(u32
), GFP_NOFS
);
588 for (j
= 0; j
< n
; j
++)
589 pg
->osds
[j
] = ceph_decode_32(p
);
591 err
= __insert_pg_mapping(pg
, &map
->pg_temp
);
594 dout(" added pg_temp %llx len %d\n", *(u64
*)&pgid
, len
);
598 ceph_decode_32_safe(p
, end
, len
, bad
);
599 dout("osdmap_decode crush len %d from off 0x%x\n", len
,
601 ceph_decode_need(p
, end
, len
, bad
);
602 map
->crush
= crush_decode(*p
, end
);
604 if (IS_ERR(map
->crush
)) {
605 err
= PTR_ERR(map
->crush
);
610 /* ignore the rest of the map */
613 dout("osdmap_decode done %p %p\n", *p
, end
);
617 dout("osdmap_decode fail\n");
618 ceph_osdmap_destroy(map
);
623 * decode and apply an incremental map update.
625 struct ceph_osdmap
*osdmap_apply_incremental(void **p
, void *end
,
626 struct ceph_osdmap
*map
,
627 struct ceph_messenger
*msgr
)
629 struct crush_map
*newcrush
= NULL
;
630 struct ceph_fsid fsid
;
632 struct ceph_timespec modified
;
634 __s32 new_pool_max
, new_flags
, max
;
640 ceph_decode_16_safe(p
, end
, version
, bad
);
641 if (version
> CEPH_OSDMAP_INC_VERSION
) {
642 pr_warning("got unknown v %d > %d of inc osdmap\n", version
,
643 CEPH_OSDMAP_INC_VERSION
);
647 ceph_decode_need(p
, end
, sizeof(fsid
)+sizeof(modified
)+2*sizeof(u32
),
649 ceph_decode_copy(p
, &fsid
, sizeof(fsid
));
650 epoch
= ceph_decode_32(p
);
651 BUG_ON(epoch
!= map
->epoch
+1);
652 ceph_decode_copy(p
, &modified
, sizeof(modified
));
653 new_pool_max
= ceph_decode_32(p
);
654 new_flags
= ceph_decode_32(p
);
657 ceph_decode_32_safe(p
, end
, len
, bad
);
659 dout("apply_incremental full map len %d, %p to %p\n",
661 return osdmap_decode(p
, min(*p
+len
, end
));
665 ceph_decode_32_safe(p
, end
, len
, bad
);
667 dout("apply_incremental new crush map len %d, %p to %p\n",
669 newcrush
= crush_decode(*p
, min(*p
+len
, end
));
670 if (IS_ERR(newcrush
))
671 return ERR_PTR(PTR_ERR(newcrush
));
676 map
->flags
= new_flags
;
677 if (new_pool_max
>= 0)
678 map
->pool_max
= new_pool_max
;
680 ceph_decode_need(p
, end
, 5*sizeof(u32
), bad
);
683 max
= ceph_decode_32(p
);
685 err
= osdmap_set_max_osd(map
, max
);
691 map
->modified
= map
->modified
;
694 crush_destroy(map
->crush
);
695 map
->crush
= newcrush
;
700 ceph_decode_32_safe(p
, end
, len
, bad
);
703 struct ceph_pg_pool_info
*pi
;
705 ceph_decode_32_safe(p
, end
, pool
, bad
);
706 ceph_decode_need(p
, end
, 1 + sizeof(pi
->v
), bad
);
707 ev
= ceph_decode_8(p
); /* encoding version */
708 if (ev
> CEPH_PG_POOL_VERSION
) {
709 pr_warning("got unknown v %d > %d of ceph_pg_pool\n",
710 ev
, CEPH_PG_POOL_VERSION
);
713 pi
= __lookup_pg_pool(&map
->pg_pools
, pool
);
715 pi
= kmalloc(sizeof(*pi
), GFP_NOFS
);
721 __insert_pg_pool(&map
->pg_pools
, pi
);
723 __decode_pool(p
, pi
);
727 ceph_decode_32_safe(p
, end
, len
, bad
);
729 struct ceph_pg_pool_info
*pi
;
731 ceph_decode_32_safe(p
, end
, pool
, bad
);
732 pi
= __lookup_pg_pool(&map
->pg_pools
, pool
);
734 rb_erase(&pi
->node
, &map
->pg_pools
);
741 ceph_decode_32_safe(p
, end
, len
, bad
);
744 struct ceph_entity_addr addr
;
745 ceph_decode_32_safe(p
, end
, osd
, bad
);
746 ceph_decode_copy_safe(p
, end
, &addr
, sizeof(addr
), bad
);
747 ceph_decode_addr(&addr
);
748 pr_info("osd%d up\n", osd
);
749 BUG_ON(osd
>= map
->max_osd
);
750 map
->osd_state
[osd
] |= CEPH_OSD_UP
;
751 map
->osd_addr
[osd
] = addr
;
755 ceph_decode_32_safe(p
, end
, len
, bad
);
758 ceph_decode_32_safe(p
, end
, osd
, bad
);
759 (*p
)++; /* clean flag */
760 pr_info("osd%d down\n", osd
);
761 if (osd
< map
->max_osd
)
762 map
->osd_state
[osd
] &= ~CEPH_OSD_UP
;
766 ceph_decode_32_safe(p
, end
, len
, bad
);
769 ceph_decode_need(p
, end
, sizeof(u32
)*2, bad
);
770 osd
= ceph_decode_32(p
);
771 off
= ceph_decode_32(p
);
772 pr_info("osd%d weight 0x%x %s\n", osd
, off
,
773 off
== CEPH_OSD_IN
? "(in)" :
774 (off
== CEPH_OSD_OUT
? "(out)" : ""));
775 if (osd
< map
->max_osd
)
776 map
->osd_weight
[osd
] = off
;
780 rbp
= rb_first(&map
->pg_temp
);
781 ceph_decode_32_safe(p
, end
, len
, bad
);
783 struct ceph_pg_mapping
*pg
;
787 ceph_decode_need(p
, end
, sizeof(u64
) + sizeof(u32
), bad
);
788 ceph_decode_copy(p
, &pgid
, sizeof(pgid
));
789 pglen
= ceph_decode_32(p
);
792 while (rbp
&& pgid_cmp(rb_entry(rbp
, struct ceph_pg_mapping
,
793 node
)->pgid
, pgid
) <= 0) {
794 struct rb_node
*cur
= rbp
;
796 dout(" removed pg_temp %llx\n",
797 *(u64
*)&rb_entry(cur
, struct ceph_pg_mapping
,
799 rb_erase(cur
, &map
->pg_temp
);
804 ceph_decode_need(p
, end
, pglen
*sizeof(u32
), bad
);
805 pg
= kmalloc(sizeof(*pg
) + sizeof(u32
)*pglen
, GFP_NOFS
);
812 for (j
= 0; j
< pglen
; j
++)
813 pg
->osds
[j
] = ceph_decode_32(p
);
814 err
= __insert_pg_mapping(pg
, &map
->pg_temp
);
817 dout(" added pg_temp %llx len %d\n", *(u64
*)&pgid
,
822 struct rb_node
*cur
= rbp
;
824 dout(" removed pg_temp %llx\n",
825 *(u64
*)&rb_entry(cur
, struct ceph_pg_mapping
,
827 rb_erase(cur
, &map
->pg_temp
);
830 /* ignore the rest */
835 pr_err("corrupt inc osdmap epoch %d off %d (%p of %p-%p)\n",
836 epoch
, (int)(*p
- start
), *p
, start
, end
);
837 print_hex_dump(KERN_DEBUG
, "osdmap: ",
838 DUMP_PREFIX_OFFSET
, 16, 1,
839 start
, end
- start
, true);
841 crush_destroy(newcrush
);
849 * calculate file layout from given offset, length.
850 * fill in correct oid, logical length, and object extent
853 * for now, we write only a single su, until we can
854 * pass a stride back to the caller.
856 void ceph_calc_file_object_mapping(struct ceph_file_layout
*layout
,
859 u64
*oxoff
, u64
*oxlen
)
861 u32 osize
= le32_to_cpu(layout
->fl_object_size
);
862 u32 su
= le32_to_cpu(layout
->fl_stripe_unit
);
863 u32 sc
= le32_to_cpu(layout
->fl_stripe_count
);
864 u32 bl
, stripeno
, stripepos
, objsetno
;
868 dout("mapping %llu~%llu osize %u fl_su %u\n", off
, *plen
,
870 su_per_object
= osize
/ su
;
871 dout("osize %u / su %u = su_per_object %u\n", osize
, su
,
874 BUG_ON((su
& ~PAGE_MASK
) != 0);
875 /* bl = *off / su; */
879 dout("off %llu / su %u = bl %u\n", off
, su
, bl
);
883 objsetno
= stripeno
/ su_per_object
;
885 *ono
= objsetno
* sc
+ stripepos
;
886 dout("objset %u * sc %u = ono %u\n", objsetno
, sc
, (unsigned)*ono
);
888 /* *oxoff = *off % layout->fl_stripe_unit; # offset in su */
890 su_offset
= do_div(t
, su
);
891 *oxoff
= su_offset
+ (stripeno
% su_per_object
) * su
;
894 * Calculate the length of the extent being written to the selected
895 * object. This is the minimum of the full length requested (plen) or
896 * the remainder of the current stripe being written to.
898 *oxlen
= min_t(u64
, *plen
, su
- su_offset
);
901 dout(" obj extent %llu~%llu\n", *oxoff
, *oxlen
);
905 * calculate an object layout (i.e. pgid) from an oid,
906 * file_layout, and osdmap
908 int ceph_calc_object_layout(struct ceph_object_layout
*ol
,
910 struct ceph_file_layout
*fl
,
911 struct ceph_osdmap
*osdmap
)
913 unsigned num
, num_mask
;
915 s32 preferred
= (s32
)le32_to_cpu(fl
->fl_pg_preferred
);
916 int poolid
= le32_to_cpu(fl
->fl_pg_pool
);
917 struct ceph_pg_pool_info
*pool
;
922 pool
= __lookup_pg_pool(&osdmap
->pg_pools
, poolid
);
925 ps
= ceph_str_hash(pool
->v
.object_hash
, oid
, strlen(oid
));
926 if (preferred
>= 0) {
928 num
= le32_to_cpu(pool
->v
.lpg_num
);
929 num_mask
= pool
->lpg_num_mask
;
931 num
= le32_to_cpu(pool
->v
.pg_num
);
932 num_mask
= pool
->pg_num_mask
;
935 pgid
.ps
= cpu_to_le16(ps
);
936 pgid
.preferred
= cpu_to_le16(preferred
);
937 pgid
.pool
= fl
->fl_pg_pool
;
939 dout("calc_object_layout '%s' pgid %d.%xp%d\n", oid
, poolid
, ps
,
942 dout("calc_object_layout '%s' pgid %d.%x\n", oid
, poolid
, ps
);
945 ol
->ol_stripe_unit
= fl
->fl_object_stripe_unit
;
950 * Calculate raw osd vector for the given pgid. Return pointer to osd
951 * array, or NULL on failure.
953 static int *calc_pg_raw(struct ceph_osdmap
*osdmap
, struct ceph_pg pgid
,
956 struct ceph_pg_mapping
*pg
;
957 struct ceph_pg_pool_info
*pool
;
959 unsigned poolid
, ps
, pps
;
963 pg
= __lookup_pg_mapping(&osdmap
->pg_temp
, pgid
);
970 poolid
= le32_to_cpu(pgid
.pool
);
971 ps
= le16_to_cpu(pgid
.ps
);
972 preferred
= (s16
)le16_to_cpu(pgid
.preferred
);
974 /* don't forcefeed bad device ids to crush */
975 if (preferred
>= osdmap
->max_osd
||
976 preferred
>= osdmap
->crush
->max_devices
)
979 pool
= __lookup_pg_pool(&osdmap
->pg_pools
, poolid
);
982 ruleno
= crush_find_rule(osdmap
->crush
, pool
->v
.crush_ruleset
,
983 pool
->v
.type
, pool
->v
.size
);
985 pr_err("no crush rule pool %d type %d size %d\n",
986 poolid
, pool
->v
.type
, pool
->v
.size
);
991 pps
= ceph_stable_mod(ps
,
992 le32_to_cpu(pool
->v
.lpgp_num
),
993 pool
->lpgp_num_mask
);
995 pps
= ceph_stable_mod(ps
,
996 le32_to_cpu(pool
->v
.pgp_num
),
999 *num
= crush_do_rule(osdmap
->crush
, ruleno
, pps
, osds
,
1000 min_t(int, pool
->v
.size
, *num
),
1001 preferred
, osdmap
->osd_weight
);
1006 * Return primary osd for given pgid, or -1 if none.
1008 int ceph_calc_pg_primary(struct ceph_osdmap
*osdmap
, struct ceph_pg pgid
)
1010 int rawosds
[10], *osds
;
1011 int i
, num
= ARRAY_SIZE(rawosds
);
1013 osds
= calc_pg_raw(osdmap
, pgid
, rawosds
, &num
);
1017 /* primary is first up osd */
1018 for (i
= 0; i
< num
; i
++)
1019 if (ceph_osd_is_up(osdmap
, osds
[i
])) {