6 #include "crush/hash.h"
7 #include "crush/mapper.h"
9 #include "ceph_debug.h"
11 char *ceph_osdmap_state_str(char *str
, int len
, int state
)
20 if (state
& CEPH_OSD_EXISTS
) {
21 snprintf(str
, len
, "exists");
24 if (state
& CEPH_OSD_UP
) {
25 snprintf(str
, len
, "%s%s%s", str
, (flag
? ", " : ""),
30 snprintf(str
, len
, "doesn't exist");
38 static int calc_bits_of(unsigned t
)
49 * the foo_mask is the smallest value 2^n-1 that is >= foo.
51 static void calc_pg_masks(struct ceph_pg_pool_info
*pi
)
53 pi
->pg_num_mask
= (1 << calc_bits_of(le32_to_cpu(pi
->v
.pg_num
)-1)) - 1;
55 (1 << calc_bits_of(le32_to_cpu(pi
->v
.pgp_num
)-1)) - 1;
57 (1 << calc_bits_of(le32_to_cpu(pi
->v
.lpg_num
)-1)) - 1;
59 (1 << calc_bits_of(le32_to_cpu(pi
->v
.lpgp_num
)-1)) - 1;
65 static int crush_decode_uniform_bucket(void **p
, void *end
,
66 struct crush_bucket_uniform
*b
)
68 dout("crush_decode_uniform_bucket %p to %p\n", *p
, end
);
69 ceph_decode_need(p
, end
, (1+b
->h
.size
) * sizeof(u32
), bad
);
70 b
->item_weight
= ceph_decode_32(p
);
76 static int crush_decode_list_bucket(void **p
, void *end
,
77 struct crush_bucket_list
*b
)
80 dout("crush_decode_list_bucket %p to %p\n", *p
, end
);
81 b
->item_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
82 if (b
->item_weights
== NULL
)
84 b
->sum_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
85 if (b
->sum_weights
== NULL
)
87 ceph_decode_need(p
, end
, 2 * b
->h
.size
* sizeof(u32
), bad
);
88 for (j
= 0; j
< b
->h
.size
; j
++) {
89 b
->item_weights
[j
] = ceph_decode_32(p
);
90 b
->sum_weights
[j
] = ceph_decode_32(p
);
97 static int crush_decode_tree_bucket(void **p
, void *end
,
98 struct crush_bucket_tree
*b
)
101 dout("crush_decode_tree_bucket %p to %p\n", *p
, end
);
102 ceph_decode_32_safe(p
, end
, b
->num_nodes
, bad
);
103 b
->node_weights
= kcalloc(b
->num_nodes
, sizeof(u32
), GFP_NOFS
);
104 if (b
->node_weights
== NULL
)
106 ceph_decode_need(p
, end
, b
->num_nodes
* sizeof(u32
), bad
);
107 for (j
= 0; j
< b
->num_nodes
; j
++)
108 b
->node_weights
[j
] = ceph_decode_32(p
);
114 static int crush_decode_straw_bucket(void **p
, void *end
,
115 struct crush_bucket_straw
*b
)
118 dout("crush_decode_straw_bucket %p to %p\n", *p
, end
);
119 b
->item_weights
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
120 if (b
->item_weights
== NULL
)
122 b
->straws
= kcalloc(b
->h
.size
, sizeof(u32
), GFP_NOFS
);
123 if (b
->straws
== NULL
)
125 ceph_decode_need(p
, end
, 2 * b
->h
.size
* sizeof(u32
), bad
);
126 for (j
= 0; j
< b
->h
.size
; j
++) {
127 b
->item_weights
[j
] = ceph_decode_32(p
);
128 b
->straws
[j
] = ceph_decode_32(p
);
135 static struct crush_map
*crush_decode(void *pbyval
, void *end
)
141 void *start
= pbyval
;
144 dout("crush_decode %p to %p len %d\n", *p
, end
, (int)(end
- *p
));
146 c
= kzalloc(sizeof(*c
), GFP_NOFS
);
148 return ERR_PTR(-ENOMEM
);
150 ceph_decode_need(p
, end
, 4*sizeof(u32
), bad
);
151 magic
= ceph_decode_32(p
);
152 if (magic
!= CRUSH_MAGIC
) {
153 pr_err("crush_decode magic %x != current %x\n",
154 (unsigned)magic
, (unsigned)CRUSH_MAGIC
);
157 c
->max_buckets
= ceph_decode_32(p
);
158 c
->max_rules
= ceph_decode_32(p
);
159 c
->max_devices
= ceph_decode_32(p
);
161 c
->device_parents
= kcalloc(c
->max_devices
, sizeof(u32
), GFP_NOFS
);
162 if (c
->device_parents
== NULL
)
164 c
->bucket_parents
= kcalloc(c
->max_buckets
, sizeof(u32
), GFP_NOFS
);
165 if (c
->bucket_parents
== NULL
)
168 c
->buckets
= kcalloc(c
->max_buckets
, sizeof(*c
->buckets
), GFP_NOFS
);
169 if (c
->buckets
== NULL
)
171 c
->rules
= kcalloc(c
->max_rules
, sizeof(*c
->rules
), GFP_NOFS
);
172 if (c
->rules
== NULL
)
176 for (i
= 0; i
< c
->max_buckets
; i
++) {
179 struct crush_bucket
*b
;
181 ceph_decode_32_safe(p
, end
, alg
, bad
);
183 c
->buckets
[i
] = NULL
;
186 dout("crush_decode bucket %d off %x %p to %p\n",
187 i
, (int)(*p
-start
), *p
, end
);
190 case CRUSH_BUCKET_UNIFORM
:
191 size
= sizeof(struct crush_bucket_uniform
);
193 case CRUSH_BUCKET_LIST
:
194 size
= sizeof(struct crush_bucket_list
);
196 case CRUSH_BUCKET_TREE
:
197 size
= sizeof(struct crush_bucket_tree
);
199 case CRUSH_BUCKET_STRAW
:
200 size
= sizeof(struct crush_bucket_straw
);
206 b
= c
->buckets
[i
] = kzalloc(size
, GFP_NOFS
);
210 ceph_decode_need(p
, end
, 4*sizeof(u32
), bad
);
211 b
->id
= ceph_decode_32(p
);
212 b
->type
= ceph_decode_16(p
);
213 b
->alg
= ceph_decode_16(p
);
214 b
->weight
= ceph_decode_32(p
);
215 b
->size
= ceph_decode_32(p
);
217 dout("crush_decode bucket size %d off %x %p to %p\n",
218 b
->size
, (int)(*p
-start
), *p
, end
);
220 b
->items
= kcalloc(b
->size
, sizeof(__s32
), GFP_NOFS
);
221 if (b
->items
== NULL
)
223 b
->perm
= kcalloc(b
->size
, sizeof(u32
), GFP_NOFS
);
228 ceph_decode_need(p
, end
, b
->size
*sizeof(u32
), bad
);
229 for (j
= 0; j
< b
->size
; j
++)
230 b
->items
[j
] = ceph_decode_32(p
);
233 case CRUSH_BUCKET_UNIFORM
:
234 err
= crush_decode_uniform_bucket(p
, end
,
235 (struct crush_bucket_uniform
*)b
);
239 case CRUSH_BUCKET_LIST
:
240 err
= crush_decode_list_bucket(p
, end
,
241 (struct crush_bucket_list
*)b
);
245 case CRUSH_BUCKET_TREE
:
246 err
= crush_decode_tree_bucket(p
, end
,
247 (struct crush_bucket_tree
*)b
);
251 case CRUSH_BUCKET_STRAW
:
252 err
= crush_decode_straw_bucket(p
, end
,
253 (struct crush_bucket_straw
*)b
);
261 dout("rule vec is %p\n", c
->rules
);
262 for (i
= 0; i
< c
->max_rules
; i
++) {
264 struct crush_rule
*r
;
266 ceph_decode_32_safe(p
, end
, yes
, bad
);
268 dout("crush_decode NO rule %d off %x %p to %p\n",
269 i
, (int)(*p
-start
), *p
, end
);
274 dout("crush_decode rule %d off %x %p to %p\n",
275 i
, (int)(*p
-start
), *p
, end
);
278 ceph_decode_32_safe(p
, end
, yes
, bad
);
279 #if BITS_PER_LONG == 32
280 if (yes
> ULONG_MAX
/ sizeof(struct crush_rule_step
))
283 r
= c
->rules
[i
] = kmalloc(sizeof(*r
) +
284 yes
*sizeof(struct crush_rule_step
),
288 dout(" rule %d is at %p\n", i
, r
);
290 ceph_decode_copy_safe(p
, end
, &r
->mask
, 4, bad
); /* 4 u8's */
291 ceph_decode_need(p
, end
, r
->len
*3*sizeof(u32
), bad
);
292 for (j
= 0; j
< r
->len
; j
++) {
293 r
->steps
[j
].op
= ceph_decode_32(p
);
294 r
->steps
[j
].arg1
= ceph_decode_32(p
);
295 r
->steps
[j
].arg2
= ceph_decode_32(p
);
299 /* ignore trailing name maps. */
301 dout("crush_decode success\n");
307 dout("crush_decode fail %d\n", err
);
316 void ceph_osdmap_destroy(struct ceph_osdmap
*map
)
318 dout("osdmap_destroy %p\n", map
);
320 crush_destroy(map
->crush
);
321 while (!RB_EMPTY_ROOT(&map
->pg_temp
))
322 rb_erase(rb_first(&map
->pg_temp
), &map
->pg_temp
);
323 kfree(map
->osd_state
);
324 kfree(map
->osd_weight
);
326 kfree(map
->osd_addr
);
331 * adjust max osd value. reallocate arrays.
333 static int osdmap_set_max_osd(struct ceph_osdmap
*map
, int max
)
336 struct ceph_entity_addr
*addr
;
339 state
= kcalloc(max
, sizeof(*state
), GFP_NOFS
);
340 addr
= kcalloc(max
, sizeof(*addr
), GFP_NOFS
);
341 weight
= kcalloc(max
, sizeof(*weight
), GFP_NOFS
);
342 if (state
== NULL
|| addr
== NULL
|| weight
== NULL
) {
350 if (map
->osd_state
) {
351 memcpy(state
, map
->osd_state
, map
->max_osd
*sizeof(*state
));
352 memcpy(addr
, map
->osd_addr
, map
->max_osd
*sizeof(*addr
));
353 memcpy(weight
, map
->osd_weight
, map
->max_osd
*sizeof(*weight
));
354 kfree(map
->osd_state
);
355 kfree(map
->osd_addr
);
356 kfree(map
->osd_weight
);
359 map
->osd_state
= state
;
360 map
->osd_weight
= weight
;
361 map
->osd_addr
= addr
;
367 * Insert a new pg_temp mapping
369 static int __insert_pg_mapping(struct ceph_pg_mapping
*new,
370 struct rb_root
*root
)
372 struct rb_node
**p
= &root
->rb_node
;
373 struct rb_node
*parent
= NULL
;
374 struct ceph_pg_mapping
*pg
= NULL
;
378 pg
= rb_entry(parent
, struct ceph_pg_mapping
, node
);
379 if (new->pgid
< pg
->pgid
)
381 else if (new->pgid
> pg
->pgid
)
387 rb_link_node(&new->node
, parent
, p
);
388 rb_insert_color(&new->node
, root
);
395 struct ceph_osdmap
*osdmap_decode(void **p
, void *end
)
397 struct ceph_osdmap
*map
;
403 dout("osdmap_decode %p to %p len %d\n", *p
, end
, (int)(end
- *p
));
405 map
= kzalloc(sizeof(*map
), GFP_NOFS
);
407 return ERR_PTR(-ENOMEM
);
408 map
->pg_temp
= RB_ROOT
;
410 ceph_decode_16_safe(p
, end
, version
, bad
);
412 ceph_decode_need(p
, end
, 2*sizeof(u64
)+6*sizeof(u32
), bad
);
413 ceph_decode_copy(p
, &map
->fsid
, sizeof(map
->fsid
));
414 map
->epoch
= ceph_decode_32(p
);
415 ceph_decode_copy(p
, &map
->created
, sizeof(map
->created
));
416 ceph_decode_copy(p
, &map
->modified
, sizeof(map
->modified
));
418 map
->num_pools
= ceph_decode_32(p
);
419 map
->pg_pool
= kcalloc(map
->num_pools
, sizeof(*map
->pg_pool
),
425 ceph_decode_32_safe(p
, end
, max
, bad
);
427 ceph_decode_need(p
, end
, 4+sizeof(map
->pg_pool
->v
), bad
);
428 i
= ceph_decode_32(p
);
429 if (i
>= map
->num_pools
)
431 ceph_decode_copy(p
, &map
->pg_pool
[i
].v
,
432 sizeof(map
->pg_pool
->v
));
433 calc_pg_masks(&map
->pg_pool
[i
]);
434 p
+= le32_to_cpu(map
->pg_pool
[i
].v
.num_snaps
) * sizeof(u64
);
435 p
+= le32_to_cpu(map
->pg_pool
[i
].v
.num_removed_snap_intervals
)
439 ceph_decode_32_safe(p
, end
, map
->flags
, bad
);
441 max
= ceph_decode_32(p
);
443 /* (re)alloc osd arrays */
444 err
= osdmap_set_max_osd(map
, max
);
447 dout("osdmap_decode max_osd = %d\n", map
->max_osd
);
451 ceph_decode_need(p
, end
, 3*sizeof(u32
) +
452 map
->max_osd
*(1 + sizeof(*map
->osd_weight
) +
453 sizeof(*map
->osd_addr
)), bad
);
454 *p
+= 4; /* skip length field (should match max) */
455 ceph_decode_copy(p
, map
->osd_state
, map
->max_osd
);
457 *p
+= 4; /* skip length field (should match max) */
458 for (i
= 0; i
< map
->max_osd
; i
++)
459 map
->osd_weight
[i
] = ceph_decode_32(p
);
461 *p
+= 4; /* skip length field (should match max) */
462 ceph_decode_copy(p
, map
->osd_addr
, map
->max_osd
*sizeof(*map
->osd_addr
));
463 for (i
= 0; i
< map
->max_osd
; i
++)
464 ceph_decode_addr(&map
->osd_addr
[i
]);
467 ceph_decode_32_safe(p
, end
, len
, bad
);
468 for (i
= 0; i
< len
; i
++) {
471 struct ceph_pg_mapping
*pg
;
473 ceph_decode_need(p
, end
, sizeof(u32
) + sizeof(u64
), bad
);
474 pgid
= ceph_decode_64(p
);
475 n
= ceph_decode_32(p
);
476 ceph_decode_need(p
, end
, n
* sizeof(u32
), bad
);
477 pg
= kmalloc(sizeof(*pg
) + n
*sizeof(u32
), GFP_NOFS
);
484 for (j
= 0; j
< n
; j
++)
485 pg
->osds
[j
] = ceph_decode_32(p
);
487 err
= __insert_pg_mapping(pg
, &map
->pg_temp
);
490 dout(" added pg_temp %llx len %d\n", pgid
, len
);
494 ceph_decode_32_safe(p
, end
, len
, bad
);
495 dout("osdmap_decode crush len %d from off 0x%x\n", len
,
497 ceph_decode_need(p
, end
, len
, bad
);
498 map
->crush
= crush_decode(*p
, end
);
500 if (IS_ERR(map
->crush
)) {
501 err
= PTR_ERR(map
->crush
);
506 /* ignore the rest of the map */
509 dout("osdmap_decode done %p %p\n", *p
, end
);
513 dout("osdmap_decode fail\n");
514 ceph_osdmap_destroy(map
);
519 * decode and apply an incremental map update.
521 struct ceph_osdmap
*osdmap_apply_incremental(void **p
, void *end
,
522 struct ceph_osdmap
*map
,
523 struct ceph_messenger
*msgr
)
525 struct ceph_osdmap
*newmap
= map
;
526 struct crush_map
*newcrush
= NULL
;
527 struct ceph_fsid fsid
;
529 struct ceph_timespec modified
;
531 __s32 new_flags
, max
;
537 ceph_decode_16_safe(p
, end
, version
, bad
);
539 ceph_decode_need(p
, end
, sizeof(fsid
)+sizeof(modified
)+2*sizeof(u32
),
541 ceph_decode_copy(p
, &fsid
, sizeof(fsid
));
542 epoch
= ceph_decode_32(p
);
543 BUG_ON(epoch
!= map
->epoch
+1);
544 ceph_decode_copy(p
, &modified
, sizeof(modified
));
545 new_flags
= ceph_decode_32(p
);
548 ceph_decode_32_safe(p
, end
, len
, bad
);
550 dout("apply_incremental full map len %d, %p to %p\n",
552 newmap
= osdmap_decode(p
, min(*p
+len
, end
));
553 return newmap
; /* error or not */
557 ceph_decode_32_safe(p
, end
, len
, bad
);
559 dout("apply_incremental new crush map len %d, %p to %p\n",
561 newcrush
= crush_decode(*p
, min(*p
+len
, end
));
562 if (IS_ERR(newcrush
))
563 return ERR_PTR(PTR_ERR(newcrush
));
568 map
->flags
= new_flags
;
570 ceph_decode_need(p
, end
, 5*sizeof(u32
), bad
);
573 max
= ceph_decode_32(p
);
575 err
= osdmap_set_max_osd(map
, max
);
581 map
->modified
= map
->modified
;
584 crush_destroy(map
->crush
);
585 map
->crush
= newcrush
;
590 ceph_decode_32_safe(p
, end
, len
, bad
);
592 ceph_decode_32_safe(p
, end
, pool
, bad
);
593 if (pool
>= map
->num_pools
) {
594 void *pg_pool
= kcalloc(pool
+ 1,
595 sizeof(*map
->pg_pool
),
601 memcpy(pg_pool
, map
->pg_pool
,
602 map
->num_pools
* sizeof(*map
->pg_pool
));
604 map
->pg_pool
= pg_pool
;
605 map
->num_pools
= pool
+1;
607 ceph_decode_copy(p
, &map
->pg_pool
[pool
].v
,
608 sizeof(map
->pg_pool
->v
));
609 calc_pg_masks(&map
->pg_pool
[pool
]);
612 /* old_pool (ignore) */
613 ceph_decode_32_safe(p
, end
, len
, bad
);
614 *p
+= len
* sizeof(u32
);
618 ceph_decode_32_safe(p
, end
, len
, bad
);
621 struct ceph_entity_addr addr
;
622 ceph_decode_32_safe(p
, end
, osd
, bad
);
623 ceph_decode_copy_safe(p
, end
, &addr
, sizeof(addr
), bad
);
624 ceph_decode_addr(&addr
);
625 pr_info("osd%d up\n", osd
);
626 BUG_ON(osd
>= map
->max_osd
);
627 map
->osd_state
[osd
] |= CEPH_OSD_UP
;
628 map
->osd_addr
[osd
] = addr
;
632 ceph_decode_32_safe(p
, end
, len
, bad
);
635 ceph_decode_32_safe(p
, end
, osd
, bad
);
636 (*p
)++; /* clean flag */
637 pr_info("ceph osd%d down\n", osd
);
638 if (osd
< map
->max_osd
)
639 map
->osd_state
[osd
] &= ~CEPH_OSD_UP
;
643 ceph_decode_32_safe(p
, end
, len
, bad
);
646 ceph_decode_need(p
, end
, sizeof(u32
)*2, bad
);
647 osd
= ceph_decode_32(p
);
648 off
= ceph_decode_32(p
);
649 pr_info("osd%d weight 0x%x %s\n", osd
, off
,
650 off
== CEPH_OSD_IN
? "(in)" :
651 (off
== CEPH_OSD_OUT
? "(out)" : ""));
652 if (osd
< map
->max_osd
)
653 map
->osd_weight
[osd
] = off
;
657 rbp
= rb_first(&map
->pg_temp
);
658 ceph_decode_32_safe(p
, end
, len
, bad
);
660 struct ceph_pg_mapping
*pg
;
664 ceph_decode_need(p
, end
, sizeof(u64
) + sizeof(u32
), bad
);
665 pgid
= ceph_decode_64(p
);
666 pglen
= ceph_decode_32(p
);
669 while (rbp
&& rb_entry(rbp
, struct ceph_pg_mapping
,
670 node
)->pgid
<= pgid
) {
671 struct rb_node
*cur
= rbp
;
673 dout(" removed pg_temp %llx\n",
674 rb_entry(cur
, struct ceph_pg_mapping
, node
)->pgid
);
675 rb_erase(cur
, &map
->pg_temp
);
680 ceph_decode_need(p
, end
, pglen
*sizeof(u32
), bad
);
681 pg
= kmalloc(sizeof(*pg
) + sizeof(u32
)*pglen
, GFP_NOFS
);
688 for (j
= 0; j
< len
; j
++)
689 pg
->osds
[j
] = ceph_decode_32(p
);
690 err
= __insert_pg_mapping(pg
, &map
->pg_temp
);
693 dout(" added pg_temp %llx len %d\n", pgid
, pglen
);
697 struct rb_node
*cur
= rbp
;
699 dout(" removed pg_temp %llx\n",
700 rb_entry(cur
, struct ceph_pg_mapping
, node
)->pgid
);
701 rb_erase(cur
, &map
->pg_temp
);
704 /* ignore the rest */
709 pr_err("corrupt inc osdmap epoch %d off %d (%p of %p-%p)\n",
710 epoch
, (int)(*p
- start
), *p
, start
, end
);
712 crush_destroy(newcrush
);
720 * calculate file layout from given offset, length.
721 * fill in correct oid, logical length, and object extent
724 * for now, we write only a single su, until we can
725 * pass a stride back to the caller.
727 void ceph_calc_file_object_mapping(struct ceph_file_layout
*layout
,
730 u64
*oxoff
, u64
*oxlen
)
732 u32 osize
= le32_to_cpu(layout
->fl_object_size
);
733 u32 su
= le32_to_cpu(layout
->fl_stripe_unit
);
734 u32 sc
= le32_to_cpu(layout
->fl_stripe_count
);
735 u32 bl
, stripeno
, stripepos
, objsetno
;
739 dout("mapping %llu~%llu osize %u fl_su %u\n", off
, *plen
,
741 su_per_object
= osize
/ su
;
742 dout("osize %u / su %u = su_per_object %u\n", osize
, su
,
745 BUG_ON((su
& ~PAGE_MASK
) != 0);
746 /* bl = *off / su; */
750 dout("off %llu / su %u = bl %u\n", off
, su
, bl
);
754 objsetno
= stripeno
/ su_per_object
;
756 *ono
= objsetno
* sc
+ stripepos
;
757 dout("objset %u * sc %u = ono %u\n", objsetno
, sc
, (unsigned)*ono
);
759 /* *oxoff = *off % layout->fl_stripe_unit; # offset in su */
761 su_offset
= do_div(t
, su
);
762 *oxoff
= su_offset
+ (stripeno
% su_per_object
) * su
;
765 * Calculate the length of the extent being written to the selected
766 * object. This is the minimum of the full length requested (plen) or
767 * the remainder of the current stripe being written to.
769 *oxlen
= min_t(u64
, *plen
, su
- su_offset
);
772 dout(" obj extent %llu~%llu\n", *oxoff
, *oxlen
);
776 * calculate an object layout (i.e. pgid) from an oid,
777 * file_layout, and osdmap
779 int ceph_calc_object_layout(struct ceph_object_layout
*ol
,
781 struct ceph_file_layout
*fl
,
782 struct ceph_osdmap
*osdmap
)
784 unsigned num
, num_mask
;
786 s32 preferred
= (s32
)le32_to_cpu(fl
->fl_pg_preferred
);
787 int poolid
= le32_to_cpu(fl
->fl_pg_pool
);
788 struct ceph_pg_pool_info
*pool
;
790 if (poolid
>= osdmap
->num_pools
)
792 pool
= &osdmap
->pg_pool
[poolid
];
794 if (preferred
>= 0) {
795 num
= le32_to_cpu(pool
->v
.lpg_num
);
796 num_mask
= pool
->lpg_num_mask
;
798 num
= le32_to_cpu(pool
->v
.pg_num
);
799 num_mask
= pool
->pg_num_mask
;
802 pgid
.pg64
= 0; /* start with it zeroed out */
803 pgid
.pg
.ps
= ceph_full_name_hash(oid
, strlen(oid
));
804 pgid
.pg
.preferred
= preferred
;
806 pgid
.pg
.ps
+= preferred
;
807 pgid
.pg
.pool
= le32_to_cpu(fl
->fl_pg_pool
);
809 dout("calc_object_layout '%s' pgid %d.%xp%d (%llx)\n", oid
,
810 pgid
.pg
.pool
, pgid
.pg
.ps
, (int)preferred
, pgid
.pg64
);
812 dout("calc_object_layout '%s' pgid %d.%x (%llx)\n", oid
,
813 pgid
.pg
.pool
, pgid
.pg
.ps
, pgid
.pg64
);
815 ol
->ol_pgid
= cpu_to_le64(pgid
.pg64
);
816 ol
->ol_stripe_unit
= fl
->fl_object_stripe_unit
;
822 * Calculate raw osd vector for the given pgid. Return pointer to osd
823 * array, or NULL on failure.
825 static int *calc_pg_raw(struct ceph_osdmap
*osdmap
, union ceph_pg pgid
,
828 struct rb_node
*n
= osdmap
->pg_temp
.rb_node
;
829 struct ceph_pg_mapping
*pg
;
830 struct ceph_pg_pool_info
*pool
;
832 unsigned pps
; /* placement ps */
836 pg
= rb_entry(n
, struct ceph_pg_mapping
, node
);
837 if (pgid
.pg64
< pg
->pgid
)
839 else if (pgid
.pg64
> pg
->pgid
)
848 if (pgid
.pg
.pool
>= osdmap
->num_pools
)
850 pool
= &osdmap
->pg_pool
[pgid
.pg
.pool
];
851 ruleno
= crush_find_rule(osdmap
->crush
, pool
->v
.crush_ruleset
,
852 pool
->v
.type
, pool
->v
.size
);
854 pr_err("no crush rule pool %d type %d size %d\n",
855 pgid
.pg
.pool
, pool
->v
.type
, pool
->v
.size
);
859 if (pgid
.pg
.preferred
>= 0)
860 pps
= ceph_stable_mod(pgid
.pg
.ps
,
861 le32_to_cpu(pool
->v
.lpgp_num
),
862 pool
->lpgp_num_mask
);
864 pps
= ceph_stable_mod(pgid
.pg
.ps
,
865 le32_to_cpu(pool
->v
.pgp_num
),
868 *num
= crush_do_rule(osdmap
->crush
, ruleno
, pps
, osds
,
869 min_t(int, pool
->v
.size
, *num
),
870 pgid
.pg
.preferred
, osdmap
->osd_weight
);
875 * Return primary osd for given pgid, or -1 if none.
877 int ceph_calc_pg_primary(struct ceph_osdmap
*osdmap
, union ceph_pg pgid
)
879 int rawosds
[10], *osds
;
880 int i
, num
= ARRAY_SIZE(rawosds
);
882 osds
= calc_pg_raw(osdmap
, pgid
, rawosds
, &num
);
886 /* primary is first up osd */
887 for (i
= 0; i
< num
; i
++)
888 if (ceph_osd_is_up(osdmap
, osds
[i
])) {