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
)
23 if (state
& CEPH_OSD_EXISTS
) {
24 snprintf(str
, len
, "exists");
27 if (state
& CEPH_OSD_UP
) {
28 snprintf(str
, len
, "%s%s%s", str
, (flag
? ", " : ""),
33 snprintf(str
, len
, "doesn't exist");
41 static int calc_bits_of(unsigned int t
)
52 * the foo_mask is the smallest value 2^n-1 that is >= foo.
54 static void calc_pg_masks(struct ceph_pg_pool_info
*pi
)
56 pi
->pg_num_mask
= (1 << calc_bits_of(le32_to_cpu(pi
->v
.pg_num
)-1)) - 1;
58 (1 << calc_bits_of(le32_to_cpu(pi
->v
.pgp_num
)-1)) - 1;
60 (1 << calc_bits_of(le32_to_cpu(pi
->v
.lpg_num
)-1)) - 1;
62 (1 << calc_bits_of(le32_to_cpu(pi
->v
.lpgp_num
)-1)) - 1;
68 static int crush_decode_uniform_bucket(void **p
, void *end
,
69 struct crush_bucket_uniform
*b
)
71 dout("crush_decode_uniform_bucket %p to %p\n", *p
, end
);
72 ceph_decode_need(p
, end
, (1+b
->h
.size
) * sizeof(u32
), bad
);
73 b
->item_weight
= ceph_decode_32(p
);
79 static int crush_decode_list_bucket(void **p
, void *end
,
80 struct crush_bucket_list
*b
)
83 dout("crush_decode_list_bucket %p to %p\n", *p
, end
);
84 b
->item_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
85 if (b
->item_weights
== NULL
)
87 b
->sum_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
88 if (b
->sum_weights
== NULL
)
90 ceph_decode_need(p
, end
, 2 * b
->h
.size
* sizeof(u32
), bad
);
91 for (j
= 0; j
< b
->h
.size
; j
++) {
92 b
->item_weights
[j
] = ceph_decode_32(p
);
93 b
->sum_weights
[j
] = ceph_decode_32(p
);
100 static int crush_decode_tree_bucket(void **p
, void *end
,
101 struct crush_bucket_tree
*b
)
104 dout("crush_decode_tree_bucket %p to %p\n", *p
, end
);
105 ceph_decode_32_safe(p
, end
, b
->num_nodes
, bad
);
106 b
->node_weights
= kcalloc(b
->num_nodes
, sizeof(u32
), GFP_NOFS
);
107 if (b
->node_weights
== NULL
)
109 ceph_decode_need(p
, end
, b
->num_nodes
* sizeof(u32
), bad
);
110 for (j
= 0; j
< b
->num_nodes
; j
++)
111 b
->node_weights
[j
] = ceph_decode_32(p
);
117 static int crush_decode_straw_bucket(void **p
, void *end
,
118 struct crush_bucket_straw
*b
)
121 dout("crush_decode_straw_bucket %p to %p\n", *p
, end
);
122 b
->item_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
123 if (b
->item_weights
== NULL
)
125 b
->straws
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
126 if (b
->straws
== NULL
)
128 ceph_decode_need(p
, end
, 2 * b
->h
.size
* sizeof(u32
), bad
);
129 for (j
= 0; j
< b
->h
.size
; j
++) {
130 b
->item_weights
[j
] = ceph_decode_32(p
);
131 b
->straws
[j
] = ceph_decode_32(p
);
138 static struct crush_map
*crush_decode(void *pbyval
, void *end
)
144 void *start
= pbyval
;
147 dout("crush_decode %p to %p len %d\n", *p
, end
, (int)(end
- *p
));
149 c
= kzalloc(sizeof(*c
), GFP_NOFS
);
151 return ERR_PTR(-ENOMEM
);
153 ceph_decode_need(p
, end
, 4*sizeof(u32
), bad
);
154 magic
= ceph_decode_32(p
);
155 if (magic
!= CRUSH_MAGIC
) {
156 pr_err("crush_decode magic %x != current %x\n",
157 (unsigned int)magic
, (unsigned int)CRUSH_MAGIC
);
160 c
->max_buckets
= ceph_decode_32(p
);
161 c
->max_rules
= ceph_decode_32(p
);
162 c
->max_devices
= ceph_decode_32(p
);
164 c
->device_parents
= kcalloc(c
->max_devices
, sizeof(u32
), GFP_NOFS
);
165 if (c
->device_parents
== NULL
)
167 c
->bucket_parents
= kcalloc(c
->max_buckets
, sizeof(u32
), GFP_NOFS
);
168 if (c
->bucket_parents
== NULL
)
171 c
->buckets
= kcalloc(c
->max_buckets
, sizeof(*c
->buckets
), GFP_NOFS
);
172 if (c
->buckets
== NULL
)
174 c
->rules
= kcalloc(c
->max_rules
, sizeof(*c
->rules
), GFP_NOFS
);
175 if (c
->rules
== NULL
)
179 for (i
= 0; i
< c
->max_buckets
; i
++) {
182 struct crush_bucket
*b
;
184 ceph_decode_32_safe(p
, end
, alg
, bad
);
186 c
->buckets
[i
] = NULL
;
189 dout("crush_decode bucket %d off %x %p to %p\n",
190 i
, (int)(*p
-start
), *p
, end
);
193 case CRUSH_BUCKET_UNIFORM
:
194 size
= sizeof(struct crush_bucket_uniform
);
196 case CRUSH_BUCKET_LIST
:
197 size
= sizeof(struct crush_bucket_list
);
199 case CRUSH_BUCKET_TREE
:
200 size
= sizeof(struct crush_bucket_tree
);
202 case CRUSH_BUCKET_STRAW
:
203 size
= sizeof(struct crush_bucket_straw
);
210 b
= c
->buckets
[i
] = kzalloc(size
, GFP_NOFS
);
214 ceph_decode_need(p
, end
, 4*sizeof(u32
), bad
);
215 b
->id
= ceph_decode_32(p
);
216 b
->type
= ceph_decode_16(p
);
217 b
->alg
= ceph_decode_8(p
);
218 b
->hash
= ceph_decode_8(p
);
219 b
->weight
= ceph_decode_32(p
);
220 b
->size
= ceph_decode_32(p
);
222 dout("crush_decode bucket size %d off %x %p to %p\n",
223 b
->size
, (int)(*p
-start
), *p
, end
);
225 b
->items
= kcalloc(b
->size
, sizeof(__s32
), GFP_NOFS
);
226 if (b
->items
== NULL
)
228 b
->perm
= kcalloc(b
->size
, sizeof(u32
), GFP_NOFS
);
233 ceph_decode_need(p
, end
, b
->size
*sizeof(u32
), bad
);
234 for (j
= 0; j
< b
->size
; j
++)
235 b
->items
[j
] = ceph_decode_32(p
);
238 case CRUSH_BUCKET_UNIFORM
:
239 err
= crush_decode_uniform_bucket(p
, end
,
240 (struct crush_bucket_uniform
*)b
);
244 case CRUSH_BUCKET_LIST
:
245 err
= crush_decode_list_bucket(p
, end
,
246 (struct crush_bucket_list
*)b
);
250 case CRUSH_BUCKET_TREE
:
251 err
= crush_decode_tree_bucket(p
, end
,
252 (struct crush_bucket_tree
*)b
);
256 case CRUSH_BUCKET_STRAW
:
257 err
= crush_decode_straw_bucket(p
, end
,
258 (struct crush_bucket_straw
*)b
);
266 dout("rule vec is %p\n", c
->rules
);
267 for (i
= 0; i
< c
->max_rules
; i
++) {
269 struct crush_rule
*r
;
271 ceph_decode_32_safe(p
, end
, yes
, bad
);
273 dout("crush_decode NO rule %d off %x %p to %p\n",
274 i
, (int)(*p
-start
), *p
, end
);
279 dout("crush_decode rule %d off %x %p to %p\n",
280 i
, (int)(*p
-start
), *p
, end
);
283 ceph_decode_32_safe(p
, end
, yes
, bad
);
284 #if BITS_PER_LONG == 32
286 if (yes
> (ULONG_MAX
- sizeof(*r
))
287 / sizeof(struct crush_rule_step
))
290 r
= c
->rules
[i
] = kmalloc(sizeof(*r
) +
291 yes
*sizeof(struct crush_rule_step
),
295 dout(" rule %d is at %p\n", i
, r
);
297 ceph_decode_copy_safe(p
, end
, &r
->mask
, 4, bad
); /* 4 u8's */
298 ceph_decode_need(p
, end
, r
->len
*3*sizeof(u32
), bad
);
299 for (j
= 0; j
< r
->len
; j
++) {
300 r
->steps
[j
].op
= ceph_decode_32(p
);
301 r
->steps
[j
].arg1
= ceph_decode_32(p
);
302 r
->steps
[j
].arg2
= ceph_decode_32(p
);
306 /* ignore trailing name maps. */
308 dout("crush_decode success\n");
314 dout("crush_decode fail %d\n", err
);
320 * rbtree of pg_mapping for handling pg_temp (explicit mapping of pgid
323 static int pgid_cmp(struct ceph_pg l
, struct ceph_pg r
)
335 static int __insert_pg_mapping(struct ceph_pg_mapping
*new,
336 struct rb_root
*root
)
338 struct rb_node
**p
= &root
->rb_node
;
339 struct rb_node
*parent
= NULL
;
340 struct ceph_pg_mapping
*pg
= NULL
;
343 dout("__insert_pg_mapping %llx %p\n", *(u64
*)&new->pgid
, new);
346 pg
= rb_entry(parent
, struct ceph_pg_mapping
, node
);
347 c
= pgid_cmp(new->pgid
, pg
->pgid
);
356 rb_link_node(&new->node
, parent
, p
);
357 rb_insert_color(&new->node
, root
);
361 static struct ceph_pg_mapping
*__lookup_pg_mapping(struct rb_root
*root
,
364 struct rb_node
*n
= root
->rb_node
;
365 struct ceph_pg_mapping
*pg
;
369 pg
= rb_entry(n
, struct ceph_pg_mapping
, node
);
370 c
= pgid_cmp(pgid
, pg
->pgid
);
376 dout("__lookup_pg_mapping %llx got %p\n",
384 static int __remove_pg_mapping(struct rb_root
*root
, struct ceph_pg pgid
)
386 struct ceph_pg_mapping
*pg
= __lookup_pg_mapping(root
, pgid
);
389 dout("__remove_pg_mapping %llx %p\n", *(u64
*)&pgid
, pg
);
390 rb_erase(&pg
->node
, root
);
394 dout("__remove_pg_mapping %llx dne\n", *(u64
*)&pgid
);
399 * rbtree of pg pool info
401 static int __insert_pg_pool(struct rb_root
*root
, struct ceph_pg_pool_info
*new)
403 struct rb_node
**p
= &root
->rb_node
;
404 struct rb_node
*parent
= NULL
;
405 struct ceph_pg_pool_info
*pi
= NULL
;
409 pi
= rb_entry(parent
, struct ceph_pg_pool_info
, node
);
410 if (new->id
< pi
->id
)
412 else if (new->id
> pi
->id
)
418 rb_link_node(&new->node
, parent
, p
);
419 rb_insert_color(&new->node
, root
);
423 static struct ceph_pg_pool_info
*__lookup_pg_pool(struct rb_root
*root
, int id
)
425 struct ceph_pg_pool_info
*pi
;
426 struct rb_node
*n
= root
->rb_node
;
429 pi
= rb_entry(n
, struct ceph_pg_pool_info
, node
);
432 else if (id
> pi
->id
)
440 int ceph_pg_poolid_by_name(struct ceph_osdmap
*map
, const char *name
)
444 for (rbp
= rb_first(&map
->pg_pools
); rbp
; rbp
= rb_next(rbp
)) {
445 struct ceph_pg_pool_info
*pi
=
446 rb_entry(rbp
, struct ceph_pg_pool_info
, node
);
447 if (pi
->name
&& strcmp(pi
->name
, name
) == 0)
452 EXPORT_SYMBOL(ceph_pg_poolid_by_name
);
454 static void __remove_pg_pool(struct rb_root
*root
, struct ceph_pg_pool_info
*pi
)
456 rb_erase(&pi
->node
, root
);
461 static int __decode_pool(void **p
, void *end
, struct ceph_pg_pool_info
*pi
)
465 ceph_decode_copy(p
, &pi
->v
, sizeof(pi
->v
));
468 /* num_snaps * snap_info_t */
469 n
= le32_to_cpu(pi
->v
.num_snaps
);
471 ceph_decode_need(p
, end
, sizeof(u64
) + 1 + sizeof(u64
) +
472 sizeof(struct ceph_timespec
), bad
);
473 *p
+= sizeof(u64
) + /* key */
474 1 + sizeof(u64
) + /* u8, snapid */
475 sizeof(struct ceph_timespec
);
476 m
= ceph_decode_32(p
); /* snap name */
480 *p
+= le32_to_cpu(pi
->v
.num_removed_snap_intervals
) * sizeof(u64
) * 2;
487 static int __decode_pool_names(void **p
, void *end
, struct ceph_osdmap
*map
)
489 struct ceph_pg_pool_info
*pi
;
492 ceph_decode_32_safe(p
, end
, num
, bad
);
493 dout(" %d pool names\n", num
);
495 ceph_decode_32_safe(p
, end
, pool
, bad
);
496 ceph_decode_32_safe(p
, end
, len
, bad
);
497 dout(" pool %d len %d\n", pool
, len
);
498 pi
= __lookup_pg_pool(&map
->pg_pools
, pool
);
501 pi
->name
= kmalloc(len
+ 1, GFP_NOFS
);
503 memcpy(pi
->name
, *p
, len
);
504 pi
->name
[len
] = '\0';
505 dout(" name is %s\n", pi
->name
);
519 void ceph_osdmap_destroy(struct ceph_osdmap
*map
)
521 dout("osdmap_destroy %p\n", map
);
523 crush_destroy(map
->crush
);
524 while (!RB_EMPTY_ROOT(&map
->pg_temp
)) {
525 struct ceph_pg_mapping
*pg
=
526 rb_entry(rb_first(&map
->pg_temp
),
527 struct ceph_pg_mapping
, node
);
528 rb_erase(&pg
->node
, &map
->pg_temp
);
531 while (!RB_EMPTY_ROOT(&map
->pg_pools
)) {
532 struct ceph_pg_pool_info
*pi
=
533 rb_entry(rb_first(&map
->pg_pools
),
534 struct ceph_pg_pool_info
, node
);
535 __remove_pg_pool(&map
->pg_pools
, pi
);
537 kfree(map
->osd_state
);
538 kfree(map
->osd_weight
);
539 kfree(map
->osd_addr
);
544 * adjust max osd value. reallocate arrays.
546 static int osdmap_set_max_osd(struct ceph_osdmap
*map
, int max
)
549 struct ceph_entity_addr
*addr
;
552 state
= kcalloc(max
, sizeof(*state
), GFP_NOFS
);
553 addr
= kcalloc(max
, sizeof(*addr
), GFP_NOFS
);
554 weight
= kcalloc(max
, sizeof(*weight
), GFP_NOFS
);
555 if (state
== NULL
|| addr
== NULL
|| weight
== NULL
) {
563 if (map
->osd_state
) {
564 memcpy(state
, map
->osd_state
, map
->max_osd
*sizeof(*state
));
565 memcpy(addr
, map
->osd_addr
, map
->max_osd
*sizeof(*addr
));
566 memcpy(weight
, map
->osd_weight
, map
->max_osd
*sizeof(*weight
));
567 kfree(map
->osd_state
);
568 kfree(map
->osd_addr
);
569 kfree(map
->osd_weight
);
572 map
->osd_state
= state
;
573 map
->osd_weight
= weight
;
574 map
->osd_addr
= addr
;
582 struct ceph_osdmap
*osdmap_decode(void **p
, void *end
)
584 struct ceph_osdmap
*map
;
590 struct ceph_pg_pool_info
*pi
;
592 dout("osdmap_decode %p to %p len %d\n", *p
, end
, (int)(end
- *p
));
594 map
= kzalloc(sizeof(*map
), GFP_NOFS
);
596 return ERR_PTR(-ENOMEM
);
597 map
->pg_temp
= RB_ROOT
;
599 ceph_decode_16_safe(p
, end
, version
, bad
);
600 if (version
> CEPH_OSDMAP_VERSION
) {
601 pr_warning("got unknown v %d > %d of osdmap\n", version
,
602 CEPH_OSDMAP_VERSION
);
606 ceph_decode_need(p
, end
, 2*sizeof(u64
)+6*sizeof(u32
), bad
);
607 ceph_decode_copy(p
, &map
->fsid
, sizeof(map
->fsid
));
608 map
->epoch
= ceph_decode_32(p
);
609 ceph_decode_copy(p
, &map
->created
, sizeof(map
->created
));
610 ceph_decode_copy(p
, &map
->modified
, sizeof(map
->modified
));
612 ceph_decode_32_safe(p
, end
, max
, bad
);
614 ceph_decode_need(p
, end
, 4 + 1 + sizeof(pi
->v
), bad
);
615 pi
= kzalloc(sizeof(*pi
), GFP_NOFS
);
618 pi
->id
= ceph_decode_32(p
);
619 ev
= ceph_decode_8(p
); /* encoding version */
620 if (ev
> CEPH_PG_POOL_VERSION
) {
621 pr_warning("got unknown v %d > %d of ceph_pg_pool\n",
622 ev
, CEPH_PG_POOL_VERSION
);
626 err
= __decode_pool(p
, end
, pi
);
631 __insert_pg_pool(&map
->pg_pools
, pi
);
634 if (version
>= 5 && __decode_pool_names(p
, end
, map
) < 0)
637 ceph_decode_32_safe(p
, end
, map
->pool_max
, bad
);
639 ceph_decode_32_safe(p
, end
, map
->flags
, bad
);
641 max
= ceph_decode_32(p
);
643 /* (re)alloc osd arrays */
644 err
= osdmap_set_max_osd(map
, max
);
647 dout("osdmap_decode max_osd = %d\n", map
->max_osd
);
651 ceph_decode_need(p
, end
, 3*sizeof(u32
) +
652 map
->max_osd
*(1 + sizeof(*map
->osd_weight
) +
653 sizeof(*map
->osd_addr
)), bad
);
654 *p
+= 4; /* skip length field (should match max) */
655 ceph_decode_copy(p
, map
->osd_state
, map
->max_osd
);
657 *p
+= 4; /* skip length field (should match max) */
658 for (i
= 0; i
< map
->max_osd
; i
++)
659 map
->osd_weight
[i
] = ceph_decode_32(p
);
661 *p
+= 4; /* skip length field (should match max) */
662 ceph_decode_copy(p
, map
->osd_addr
, map
->max_osd
*sizeof(*map
->osd_addr
));
663 for (i
= 0; i
< map
->max_osd
; i
++)
664 ceph_decode_addr(&map
->osd_addr
[i
]);
667 ceph_decode_32_safe(p
, end
, len
, bad
);
668 for (i
= 0; i
< len
; i
++) {
671 struct ceph_pg_mapping
*pg
;
673 ceph_decode_need(p
, end
, sizeof(u32
) + sizeof(u64
), bad
);
674 ceph_decode_copy(p
, &pgid
, sizeof(pgid
));
675 n
= ceph_decode_32(p
);
676 ceph_decode_need(p
, end
, n
* sizeof(u32
), bad
);
678 pg
= kmalloc(sizeof(*pg
) + n
*sizeof(u32
), GFP_NOFS
);
683 for (j
= 0; j
< n
; j
++)
684 pg
->osds
[j
] = ceph_decode_32(p
);
686 err
= __insert_pg_mapping(pg
, &map
->pg_temp
);
689 dout(" added pg_temp %llx len %d\n", *(u64
*)&pgid
, len
);
693 ceph_decode_32_safe(p
, end
, len
, bad
);
694 dout("osdmap_decode crush len %d from off 0x%x\n", len
,
696 ceph_decode_need(p
, end
, len
, bad
);
697 map
->crush
= crush_decode(*p
, end
);
699 if (IS_ERR(map
->crush
)) {
700 err
= PTR_ERR(map
->crush
);
705 /* ignore the rest of the map */
708 dout("osdmap_decode done %p %p\n", *p
, end
);
712 dout("osdmap_decode fail\n");
713 ceph_osdmap_destroy(map
);
718 * decode and apply an incremental map update.
720 struct ceph_osdmap
*osdmap_apply_incremental(void **p
, void *end
,
721 struct ceph_osdmap
*map
,
722 struct ceph_messenger
*msgr
)
724 struct crush_map
*newcrush
= NULL
;
725 struct ceph_fsid fsid
;
727 struct ceph_timespec modified
;
729 __s32 new_pool_max
, new_flags
, max
;
734 ceph_decode_16_safe(p
, end
, version
, bad
);
735 if (version
> CEPH_OSDMAP_INC_VERSION
) {
736 pr_warning("got unknown v %d > %d of inc osdmap\n", version
,
737 CEPH_OSDMAP_INC_VERSION
);
741 ceph_decode_need(p
, end
, sizeof(fsid
)+sizeof(modified
)+2*sizeof(u32
),
743 ceph_decode_copy(p
, &fsid
, sizeof(fsid
));
744 epoch
= ceph_decode_32(p
);
745 BUG_ON(epoch
!= map
->epoch
+1);
746 ceph_decode_copy(p
, &modified
, sizeof(modified
));
747 new_pool_max
= ceph_decode_32(p
);
748 new_flags
= ceph_decode_32(p
);
751 ceph_decode_32_safe(p
, end
, len
, bad
);
753 dout("apply_incremental full map len %d, %p to %p\n",
755 return osdmap_decode(p
, min(*p
+len
, end
));
759 ceph_decode_32_safe(p
, end
, len
, bad
);
761 dout("apply_incremental new crush map len %d, %p to %p\n",
763 newcrush
= crush_decode(*p
, min(*p
+len
, end
));
764 if (IS_ERR(newcrush
))
765 return ERR_CAST(newcrush
);
771 map
->flags
= new_flags
;
772 if (new_pool_max
>= 0)
773 map
->pool_max
= new_pool_max
;
775 ceph_decode_need(p
, end
, 5*sizeof(u32
), bad
);
778 max
= ceph_decode_32(p
);
780 err
= osdmap_set_max_osd(map
, max
);
786 map
->modified
= modified
;
789 crush_destroy(map
->crush
);
790 map
->crush
= newcrush
;
795 ceph_decode_32_safe(p
, end
, len
, bad
);
798 struct ceph_pg_pool_info
*pi
;
800 ceph_decode_32_safe(p
, end
, pool
, bad
);
801 ceph_decode_need(p
, end
, 1 + sizeof(pi
->v
), bad
);
802 ev
= ceph_decode_8(p
); /* encoding version */
803 if (ev
> CEPH_PG_POOL_VERSION
) {
804 pr_warning("got unknown v %d > %d of ceph_pg_pool\n",
805 ev
, CEPH_PG_POOL_VERSION
);
808 pi
= __lookup_pg_pool(&map
->pg_pools
, pool
);
810 pi
= kzalloc(sizeof(*pi
), GFP_NOFS
);
816 __insert_pg_pool(&map
->pg_pools
, pi
);
818 err
= __decode_pool(p
, end
, pi
);
822 if (version
>= 5 && __decode_pool_names(p
, end
, map
) < 0)
826 ceph_decode_32_safe(p
, end
, len
, bad
);
828 struct ceph_pg_pool_info
*pi
;
830 ceph_decode_32_safe(p
, end
, pool
, bad
);
831 pi
= __lookup_pg_pool(&map
->pg_pools
, pool
);
833 __remove_pg_pool(&map
->pg_pools
, pi
);
838 ceph_decode_32_safe(p
, end
, len
, bad
);
841 struct ceph_entity_addr addr
;
842 ceph_decode_32_safe(p
, end
, osd
, bad
);
843 ceph_decode_copy_safe(p
, end
, &addr
, sizeof(addr
), bad
);
844 ceph_decode_addr(&addr
);
845 pr_info("osd%d up\n", osd
);
846 BUG_ON(osd
>= map
->max_osd
);
847 map
->osd_state
[osd
] |= CEPH_OSD_UP
;
848 map
->osd_addr
[osd
] = addr
;
852 ceph_decode_32_safe(p
, end
, len
, bad
);
856 ceph_decode_32_safe(p
, end
, osd
, bad
);
857 xorstate
= **(u8
**)p
;
858 (*p
)++; /* clean flag */
860 xorstate
= CEPH_OSD_UP
;
861 if (xorstate
& CEPH_OSD_UP
)
862 pr_info("osd%d down\n", osd
);
863 if (osd
< map
->max_osd
)
864 map
->osd_state
[osd
] ^= xorstate
;
868 ceph_decode_32_safe(p
, end
, len
, bad
);
871 ceph_decode_need(p
, end
, sizeof(u32
)*2, bad
);
872 osd
= ceph_decode_32(p
);
873 off
= ceph_decode_32(p
);
874 pr_info("osd%d weight 0x%x %s\n", osd
, off
,
875 off
== CEPH_OSD_IN
? "(in)" :
876 (off
== CEPH_OSD_OUT
? "(out)" : ""));
877 if (osd
< map
->max_osd
)
878 map
->osd_weight
[osd
] = off
;
882 ceph_decode_32_safe(p
, end
, len
, bad
);
884 struct ceph_pg_mapping
*pg
;
888 ceph_decode_need(p
, end
, sizeof(u64
) + sizeof(u32
), bad
);
889 ceph_decode_copy(p
, &pgid
, sizeof(pgid
));
890 pglen
= ceph_decode_32(p
);
894 ceph_decode_need(p
, end
, pglen
*sizeof(u32
), bad
);
895 pg
= kmalloc(sizeof(*pg
) + sizeof(u32
)*pglen
, GFP_NOFS
);
902 for (j
= 0; j
< pglen
; j
++)
903 pg
->osds
[j
] = ceph_decode_32(p
);
904 err
= __insert_pg_mapping(pg
, &map
->pg_temp
);
909 dout(" added pg_temp %llx len %d\n", *(u64
*)&pgid
,
913 __remove_pg_mapping(&map
->pg_temp
, pgid
);
917 /* ignore the rest */
922 pr_err("corrupt inc osdmap epoch %d off %d (%p of %p-%p)\n",
923 epoch
, (int)(*p
- start
), *p
, start
, end
);
924 print_hex_dump(KERN_DEBUG
, "osdmap: ",
925 DUMP_PREFIX_OFFSET
, 16, 1,
926 start
, end
- start
, true);
928 crush_destroy(newcrush
);
936 * calculate file layout from given offset, length.
937 * fill in correct oid, logical length, and object extent
940 * for now, we write only a single su, until we can
941 * pass a stride back to the caller.
943 void ceph_calc_file_object_mapping(struct ceph_file_layout
*layout
,
946 u64
*oxoff
, u64
*oxlen
)
948 u32 osize
= le32_to_cpu(layout
->fl_object_size
);
949 u32 su
= le32_to_cpu(layout
->fl_stripe_unit
);
950 u32 sc
= le32_to_cpu(layout
->fl_stripe_count
);
951 u32 bl
, stripeno
, stripepos
, objsetno
;
955 dout("mapping %llu~%llu osize %u fl_su %u\n", off
, *plen
,
957 su_per_object
= osize
/ su
;
958 dout("osize %u / su %u = su_per_object %u\n", osize
, su
,
961 BUG_ON((su
& ~PAGE_MASK
) != 0);
962 /* bl = *off / su; */
966 dout("off %llu / su %u = bl %u\n", off
, su
, bl
);
970 objsetno
= stripeno
/ su_per_object
;
972 *ono
= objsetno
* sc
+ stripepos
;
973 dout("objset %u * sc %u = ono %u\n", objsetno
, sc
, (unsigned int)*ono
);
975 /* *oxoff = *off % layout->fl_stripe_unit; # offset in su */
977 su_offset
= do_div(t
, su
);
978 *oxoff
= su_offset
+ (stripeno
% su_per_object
) * su
;
981 * Calculate the length of the extent being written to the selected
982 * object. This is the minimum of the full length requested (plen) or
983 * the remainder of the current stripe being written to.
985 *oxlen
= min_t(u64
, *plen
, su
- su_offset
);
988 dout(" obj extent %llu~%llu\n", *oxoff
, *oxlen
);
990 EXPORT_SYMBOL(ceph_calc_file_object_mapping
);
993 * calculate an object layout (i.e. pgid) from an oid,
994 * file_layout, and osdmap
996 int ceph_calc_object_layout(struct ceph_object_layout
*ol
,
998 struct ceph_file_layout
*fl
,
999 struct ceph_osdmap
*osdmap
)
1001 unsigned int num
, num_mask
;
1002 struct ceph_pg pgid
;
1003 s32 preferred
= (s32
)le32_to_cpu(fl
->fl_pg_preferred
);
1004 int poolid
= le32_to_cpu(fl
->fl_pg_pool
);
1005 struct ceph_pg_pool_info
*pool
;
1010 pool
= __lookup_pg_pool(&osdmap
->pg_pools
, poolid
);
1013 ps
= ceph_str_hash(pool
->v
.object_hash
, oid
, strlen(oid
));
1014 if (preferred
>= 0) {
1016 num
= le32_to_cpu(pool
->v
.lpg_num
);
1017 num_mask
= pool
->lpg_num_mask
;
1019 num
= le32_to_cpu(pool
->v
.pg_num
);
1020 num_mask
= pool
->pg_num_mask
;
1023 pgid
.ps
= cpu_to_le16(ps
);
1024 pgid
.preferred
= cpu_to_le16(preferred
);
1025 pgid
.pool
= fl
->fl_pg_pool
;
1027 dout("calc_object_layout '%s' pgid %d.%xp%d\n", oid
, poolid
, ps
,
1030 dout("calc_object_layout '%s' pgid %d.%x\n", oid
, poolid
, ps
);
1033 ol
->ol_stripe_unit
= fl
->fl_object_stripe_unit
;
1036 EXPORT_SYMBOL(ceph_calc_object_layout
);
1039 * Calculate raw osd vector for the given pgid. Return pointer to osd
1040 * array, or NULL on failure.
1042 static int *calc_pg_raw(struct ceph_osdmap
*osdmap
, struct ceph_pg pgid
,
1043 int *osds
, int *num
)
1045 struct ceph_pg_mapping
*pg
;
1046 struct ceph_pg_pool_info
*pool
;
1048 unsigned int poolid
, ps
, pps
, t
;
1051 poolid
= le32_to_cpu(pgid
.pool
);
1052 ps
= le16_to_cpu(pgid
.ps
);
1053 preferred
= (s16
)le16_to_cpu(pgid
.preferred
);
1055 pool
= __lookup_pg_pool(&osdmap
->pg_pools
, poolid
);
1061 t
= ceph_stable_mod(ps
, le32_to_cpu(pool
->v
.lpg_num
),
1062 pool
->lpgp_num_mask
);
1064 t
= ceph_stable_mod(ps
, le32_to_cpu(pool
->v
.pg_num
),
1065 pool
->pgp_num_mask
);
1066 pgid
.ps
= cpu_to_le16(t
);
1067 pg
= __lookup_pg_mapping(&osdmap
->pg_temp
, pgid
);
1074 ruleno
= crush_find_rule(osdmap
->crush
, pool
->v
.crush_ruleset
,
1075 pool
->v
.type
, pool
->v
.size
);
1077 pr_err("no crush rule pool %d ruleset %d type %d size %d\n",
1078 poolid
, pool
->v
.crush_ruleset
, pool
->v
.type
,
1083 /* don't forcefeed bad device ids to crush */
1084 if (preferred
>= osdmap
->max_osd
||
1085 preferred
>= osdmap
->crush
->max_devices
)
1089 pps
= ceph_stable_mod(ps
,
1090 le32_to_cpu(pool
->v
.lpgp_num
),
1091 pool
->lpgp_num_mask
);
1093 pps
= ceph_stable_mod(ps
,
1094 le32_to_cpu(pool
->v
.pgp_num
),
1095 pool
->pgp_num_mask
);
1097 *num
= crush_do_rule(osdmap
->crush
, ruleno
, pps
, osds
,
1098 min_t(int, pool
->v
.size
, *num
),
1099 preferred
, osdmap
->osd_weight
);
1104 * Return acting set for given pgid.
1106 int ceph_calc_pg_acting(struct ceph_osdmap
*osdmap
, struct ceph_pg pgid
,
1109 int rawosds
[CEPH_PG_MAX_SIZE
], *osds
;
1110 int i
, o
, num
= CEPH_PG_MAX_SIZE
;
1112 osds
= calc_pg_raw(osdmap
, pgid
, rawosds
, &num
);
1116 /* primary is first up osd */
1118 for (i
= 0; i
< num
; i
++)
1119 if (ceph_osd_is_up(osdmap
, osds
[i
]))
1120 acting
[o
++] = osds
[i
];
1125 * Return primary osd for given pgid, or -1 if none.
1127 int ceph_calc_pg_primary(struct ceph_osdmap
*osdmap
, struct ceph_pg pgid
)
1129 int rawosds
[CEPH_PG_MAX_SIZE
], *osds
;
1130 int i
, num
= CEPH_PG_MAX_SIZE
;
1132 osds
= calc_pg_raw(osdmap
, pgid
, rawosds
, &num
);
1136 /* primary is first up osd */
1137 for (i
= 0; i
< num
; i
++)
1138 if (ceph_osd_is_up(osdmap
, osds
[i
]))
1142 EXPORT_SYMBOL(ceph_calc_pg_primary
);