2 * Copyright (C) 2005, 2006
3 * Avishay Traeger (avishay@gmail.com)
4 * Copyright (C) 2008, 2009
5 * Boaz Harrosh <bharrosh@panasas.com>
7 * This file is part of exofs.
9 * exofs is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation. Since it is based on ext2, and the only
12 * valid version of GPL for the Linux kernel is version 2, the only valid
13 * version of GPL for exofs is version 2.
15 * exofs is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with exofs; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25 #include <linux/slab.h>
26 #include <scsi/scsi_device.h>
27 #include <asm/div64.h>
31 #define EXOFS_DBGMSG2(M...) do {} while (0)
32 /* #define EXOFS_DBGMSG2 EXOFS_DBGMSG */
34 void exofs_make_credential(u8 cred_a
[OSD_CAP_LEN
], const struct osd_obj_id
*obj
)
36 osd_sec_init_nosec_doall_caps(cred_a
, obj
, false, true);
39 int exofs_read_kern(struct osd_dev
*od
, u8
*cred
, struct osd_obj_id
*obj
,
40 u64 offset
, void *p
, unsigned length
)
42 struct osd_request
*or = osd_start_request(od
, GFP_KERNEL
);
43 /* struct osd_sense_info osi = {.key = 0};*/
47 EXOFS_DBGMSG("%s: osd_start_request failed.\n", __func__
);
50 ret
= osd_req_read_kern(or, obj
, offset
, p
, length
);
52 EXOFS_DBGMSG("%s: osd_req_read_kern failed.\n", __func__
);
56 ret
= osd_finalize_request(or, 0, cred
, NULL
);
58 EXOFS_DBGMSG("Failed to osd_finalize_request() => %d\n", ret
);
62 ret
= osd_execute_request(or);
64 EXOFS_DBGMSG("osd_execute_request() => %d\n", ret
);
65 /* osd_req_decode_sense(or, ret); */
72 int exofs_get_rw_state(struct exofs_layout
*layout
, bool is_reading
,
73 u64 offset
, u64 length
, struct exofs_io_state
**pios
)
75 struct exofs_io_state
*ios
;
77 /*TODO: Maybe use kmem_cach per sbi of size
78 * exofs_io_state_size(layout->s_numdevs)
80 ios
= kzalloc(exofs_io_state_size(layout
->s_numdevs
), GFP_KERNEL
);
82 EXOFS_DBGMSG("Failed kzalloc bytes=%d\n",
83 exofs_io_state_size(layout
->s_numdevs
));
89 ios
->obj
.partition
= layout
->s_pid
;
92 ios
->reading
= is_reading
;
98 int exofs_get_io_state(struct exofs_layout
*layout
,
99 struct exofs_io_state
**ios
)
101 return exofs_get_rw_state(layout
, true, 0, 0, ios
);
104 void exofs_put_io_state(struct exofs_io_state
*ios
)
109 for (i
= 0; i
< ios
->numdevs
; i
++) {
110 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[i
];
113 osd_end_request(per_dev
->or);
115 bio_put(per_dev
->bio
);
122 unsigned exofs_layout_od_id(struct exofs_layout
*layout
,
123 osd_id obj_no
, unsigned layout_index
)
125 /* switch (layout->lay_func) {
126 case LAYOUT_MOVING_WINDOW:
128 unsigned dev_mod
= obj_no
;
130 return (layout_index
+ dev_mod
* layout
->mirrors_p1
) %
133 case LAYOUT_FUNC_IMPLICT:
134 return layout->devs[layout_index];
138 static inline struct osd_dev
*exofs_ios_od(struct exofs_io_state
*ios
,
139 unsigned layout_index
)
141 return ios
->layout
->s_ods
[
142 exofs_layout_od_id(ios
->layout
, ios
->obj
.id
, layout_index
)];
145 static void _sync_done(struct exofs_io_state
*ios
, void *p
)
147 struct completion
*waiting
= p
;
152 static void _last_io(struct kref
*kref
)
154 struct exofs_io_state
*ios
= container_of(
155 kref
, struct exofs_io_state
, kref
);
157 ios
->done(ios
, ios
->private);
160 static void _done_io(struct osd_request
*or, void *p
)
162 struct exofs_io_state
*ios
= p
;
164 kref_put(&ios
->kref
, _last_io
);
167 static int exofs_io_execute(struct exofs_io_state
*ios
)
169 DECLARE_COMPLETION_ONSTACK(wait
);
170 bool sync
= (ios
->done
== NULL
);
174 ios
->done
= _sync_done
;
175 ios
->private = &wait
;
178 for (i
= 0; i
< ios
->numdevs
; i
++) {
179 struct osd_request
*or = ios
->per_dev
[i
].or;
183 ret
= osd_finalize_request(or, 0, ios
->cred
, NULL
);
185 EXOFS_DBGMSG("Failed to osd_finalize_request() => %d\n",
191 kref_init(&ios
->kref
);
193 for (i
= 0; i
< ios
->numdevs
; i
++) {
194 struct osd_request
*or = ios
->per_dev
[i
].or;
198 kref_get(&ios
->kref
);
199 osd_execute_request_async(or, _done_io
, ios
);
202 kref_put(&ios
->kref
, _last_io
);
206 wait_for_completion(&wait
);
207 ret
= exofs_check_io(ios
, NULL
);
212 static void _clear_bio(struct bio
*bio
)
217 __bio_for_each_segment(bv
, bio
, i
, 0) {
218 unsigned this_count
= bv
->bv_len
;
220 if (likely(PAGE_SIZE
== this_count
))
221 clear_highpage(bv
->bv_page
);
223 zero_user(bv
->bv_page
, bv
->bv_offset
, this_count
);
227 int exofs_check_io(struct exofs_io_state
*ios
, u64
*resid
)
229 enum osd_err_priority acumulated_osd_err
= 0;
230 int acumulated_lin_err
= 0;
233 for (i
= 0; i
< ios
->numdevs
; i
++) {
234 struct osd_sense_info osi
;
235 struct osd_request
*or = ios
->per_dev
[i
].or;
241 ret
= osd_req_decode_sense(or, &osi
);
245 if (OSD_ERR_PRI_CLEAR_PAGES
== osi
.osd_err_pri
) {
246 /* start read offset passed endof file */
247 _clear_bio(ios
->per_dev
[i
].bio
);
248 EXOFS_DBGMSG("start read offset passed end of file "
249 "offset=0x%llx, length=0x%llx\n",
250 _LLU(ios
->per_dev
[i
].offset
),
251 _LLU(ios
->per_dev
[i
].length
));
253 continue; /* we recovered */
256 if (osi
.osd_err_pri
>= acumulated_osd_err
) {
257 acumulated_osd_err
= osi
.osd_err_pri
;
258 acumulated_lin_err
= ret
;
262 /* TODO: raid specific residual calculations */
264 if (likely(!acumulated_lin_err
))
267 *resid
= ios
->length
;
270 return acumulated_lin_err
;
274 * L - logical offset into the file
276 * U - The number of bytes in a stripe within a group
278 * U = stripe_unit * group_width
280 * T - The number of bytes striped within a group of component objects
281 * (before advancing to the next group)
283 * T = stripe_unit * group_width * group_depth
285 * S - The number of bytes striped across all component objects
286 * before the pattern repeats
288 * S = stripe_unit * group_width * group_depth * group_count
290 * M - The "major" (i.e., across all components) stripe number
294 * G - Counts the groups from the beginning of the major stripe
296 * G = (L - (M * S)) / T [or (L % S) / T]
298 * H - The byte offset within the group
300 * H = (L - (M * S)) % T [or (L % S) % T]
302 * N - The "minor" (i.e., across the group) stripe number
306 * C - The component index coresponding to L
308 * C = (H - (N * U)) / stripe_unit + G * group_width
309 * [or (L % U) / stripe_unit + G * group_width]
311 * O - The component offset coresponding to L
313 * O = L % stripe_unit + N * stripe_unit + M * group_depth * stripe_unit
315 struct _striping_info
{
318 u64 M
; /* for truncate */
323 static void _calc_stripe_info(struct exofs_layout
*layout
, u64 file_offset
,
324 struct _striping_info
*si
)
326 u32 stripe_unit
= layout
->stripe_unit
;
327 u32 group_width
= layout
->group_width
;
328 u64 group_depth
= layout
->group_depth
;
330 u32 U
= stripe_unit
* group_width
;
331 u64 T
= U
* group_depth
;
332 u64 S
= T
* layout
->group_count
;
333 u64 M
= div64_u64(file_offset
, S
);
336 G = (L - (M * S)) / T
337 H = (L - (M * S)) % T
339 u64 LmodS
= file_offset
- M
* S
;
340 u32 G
= div64_u64(LmodS
, T
);
341 u64 H
= LmodS
- G
* T
;
343 u32 N
= div_u64(H
, U
);
345 /* "H - (N * U)" is just "H % U" so it's bound to u32 */
346 si
->dev
= (u32
)(H
- (N
* U
)) / stripe_unit
+ G
* group_width
;
347 si
->dev
*= layout
->mirrors_p1
;
349 div_u64_rem(file_offset
, stripe_unit
, &si
->unit_off
);
351 si
->obj_offset
= si
->unit_off
+ (N
* stripe_unit
) +
352 (M
* group_depth
* stripe_unit
);
354 si
->group_length
= T
- H
;
358 static int _add_stripe_unit(struct exofs_io_state
*ios
, unsigned *cur_pg
,
359 unsigned pgbase
, struct exofs_per_dev_state
*per_dev
,
362 unsigned pg
= *cur_pg
;
363 struct request_queue
*q
=
364 osd_request_queue(exofs_ios_od(ios
, per_dev
->dev
));
366 per_dev
->length
+= cur_len
;
368 if (per_dev
->bio
== NULL
) {
369 unsigned pages_in_stripe
= ios
->layout
->group_width
*
370 (ios
->layout
->stripe_unit
/ PAGE_SIZE
);
371 unsigned bio_size
= (ios
->nr_pages
+ pages_in_stripe
) /
372 ios
->layout
->group_width
;
374 per_dev
->bio
= bio_kmalloc(GFP_KERNEL
, bio_size
);
375 if (unlikely(!per_dev
->bio
)) {
376 EXOFS_DBGMSG("Failed to allocate BIO size=%u\n",
382 while (cur_len
> 0) {
383 unsigned pglen
= min_t(unsigned, PAGE_SIZE
- pgbase
, cur_len
);
386 BUG_ON(ios
->nr_pages
<= pg
);
389 added_len
= bio_add_pc_page(q
, per_dev
->bio
, ios
->pages
[pg
],
391 if (unlikely(pglen
!= added_len
))
402 static int _prepare_one_group(struct exofs_io_state
*ios
, u64 length
,
403 struct _striping_info
*si
)
405 unsigned stripe_unit
= ios
->layout
->stripe_unit
;
406 unsigned mirrors_p1
= ios
->layout
->mirrors_p1
;
407 unsigned devs_in_group
= ios
->layout
->group_width
* mirrors_p1
;
408 unsigned dev
= si
->dev
;
409 unsigned first_dev
= dev
- (dev
% devs_in_group
);
410 unsigned max_comp
= ios
->numdevs
? ios
->numdevs
- mirrors_p1
: 0;
411 unsigned cur_pg
= ios
->pages_consumed
;
415 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[dev
];
416 unsigned cur_len
, page_off
= 0;
418 if (!per_dev
->length
) {
421 per_dev
->offset
= si
->obj_offset
+ stripe_unit
-
423 cur_len
= stripe_unit
;
424 } else if (dev
== si
->dev
) {
425 per_dev
->offset
= si
->obj_offset
;
426 cur_len
= stripe_unit
- si
->unit_off
;
427 page_off
= si
->unit_off
& ~PAGE_MASK
;
428 BUG_ON(page_off
&& (page_off
!= ios
->pgbase
));
429 } else { /* dev > si->dev */
430 per_dev
->offset
= si
->obj_offset
- si
->unit_off
;
431 cur_len
= stripe_unit
;
437 cur_len
= stripe_unit
;
439 if (cur_len
>= length
)
442 ret
= _add_stripe_unit(ios
, &cur_pg
, page_off
, per_dev
,
448 dev
= (dev
% devs_in_group
) + first_dev
;
453 ios
->numdevs
= max_comp
+ mirrors_p1
;
454 ios
->pages_consumed
= cur_pg
;
458 static int _prepare_for_striping(struct exofs_io_state
*ios
)
460 u64 length
= ios
->length
;
461 u64 offset
= ios
->offset
;
462 struct _striping_info si
;
466 if (ios
->kern_buff
) {
467 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[0];
469 _calc_stripe_info(ios
->layout
, ios
->offset
, &si
);
470 per_dev
->offset
= si
.obj_offset
;
471 per_dev
->dev
= si
.dev
;
473 /* no cross device without page array */
474 BUG_ON((ios
->layout
->group_width
> 1) &&
475 (si
.unit_off
+ ios
->length
>
476 ios
->layout
->stripe_unit
));
478 ios
->numdevs
= ios
->layout
->mirrors_p1
;
483 _calc_stripe_info(ios
->layout
, offset
, &si
);
485 if (length
< si
.group_length
)
486 si
.group_length
= length
;
488 ret
= _prepare_one_group(ios
, si
.group_length
, &si
);
492 offset
+= si
.group_length
;
493 length
-= si
.group_length
;
500 int exofs_sbi_create(struct exofs_io_state
*ios
)
504 for (i
= 0; i
< ios
->layout
->s_numdevs
; i
++) {
505 struct osd_request
*or;
507 or = osd_start_request(exofs_ios_od(ios
, i
), GFP_KERNEL
);
509 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
513 ios
->per_dev
[i
].or = or;
516 osd_req_create_object(or, &ios
->obj
);
518 ret
= exofs_io_execute(ios
);
524 int exofs_sbi_remove(struct exofs_io_state
*ios
)
528 for (i
= 0; i
< ios
->layout
->s_numdevs
; i
++) {
529 struct osd_request
*or;
531 or = osd_start_request(exofs_ios_od(ios
, i
), GFP_KERNEL
);
533 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
537 ios
->per_dev
[i
].or = or;
540 osd_req_remove_object(or, &ios
->obj
);
542 ret
= exofs_io_execute(ios
);
548 static int _sbi_write_mirror(struct exofs_io_state
*ios
, int cur_comp
)
550 struct exofs_per_dev_state
*master_dev
= &ios
->per_dev
[cur_comp
];
551 unsigned dev
= ios
->per_dev
[cur_comp
].dev
;
552 unsigned last_comp
= cur_comp
+ ios
->layout
->mirrors_p1
;
555 if (ios
->pages
&& !master_dev
->length
)
556 return 0; /* Just an empty slot */
558 for (; cur_comp
< last_comp
; ++cur_comp
, ++dev
) {
559 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
560 struct osd_request
*or;
562 or = osd_start_request(exofs_ios_od(ios
, dev
), GFP_KERNEL
);
564 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
569 per_dev
->offset
= master_dev
->offset
;
574 if (per_dev
!= master_dev
) {
575 bio
= bio_kmalloc(GFP_KERNEL
,
576 master_dev
->bio
->bi_max_vecs
);
577 if (unlikely(!bio
)) {
579 "Failed to allocate BIO size=%u\n",
580 master_dev
->bio
->bi_max_vecs
);
585 __bio_clone(bio
, master_dev
->bio
);
588 per_dev
->length
= master_dev
->length
;
592 bio
= master_dev
->bio
;
593 /* FIXME: bio_set_dir() */
594 bio
->bi_rw
|= REQ_WRITE
;
597 osd_req_write(or, &ios
->obj
, per_dev
->offset
, bio
,
599 EXOFS_DBGMSG("write(0x%llx) offset=0x%llx "
600 "length=0x%llx dev=%d\n",
601 _LLU(ios
->obj
.id
), _LLU(per_dev
->offset
),
602 _LLU(per_dev
->length
), dev
);
603 } else if (ios
->kern_buff
) {
604 ret
= osd_req_write_kern(or, &ios
->obj
, per_dev
->offset
,
605 ios
->kern_buff
, ios
->length
);
608 EXOFS_DBGMSG2("write_kern(0x%llx) offset=0x%llx "
609 "length=0x%llx dev=%d\n",
610 _LLU(ios
->obj
.id
), _LLU(per_dev
->offset
),
611 _LLU(ios
->length
), dev
);
613 osd_req_set_attributes(or, &ios
->obj
);
614 EXOFS_DBGMSG2("obj(0x%llx) set_attributes=%d dev=%d\n",
615 _LLU(ios
->obj
.id
), ios
->out_attr_len
, dev
);
619 osd_req_add_set_attr_list(or, ios
->out_attr
,
623 osd_req_add_get_attr_list(or, ios
->in_attr
,
631 int exofs_sbi_write(struct exofs_io_state
*ios
)
636 ret
= _prepare_for_striping(ios
);
640 for (i
= 0; i
< ios
->numdevs
; i
+= ios
->layout
->mirrors_p1
) {
641 ret
= _sbi_write_mirror(ios
, i
);
646 ret
= exofs_io_execute(ios
);
650 static int _sbi_read_mirror(struct exofs_io_state
*ios
, unsigned cur_comp
)
652 struct osd_request
*or;
653 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
654 unsigned first_dev
= (unsigned)ios
->obj
.id
;
656 if (ios
->pages
&& !per_dev
->length
)
657 return 0; /* Just an empty slot */
659 first_dev
= per_dev
->dev
+ first_dev
% ios
->layout
->mirrors_p1
;
660 or = osd_start_request(exofs_ios_od(ios
, first_dev
), GFP_KERNEL
);
662 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
668 osd_req_read(or, &ios
->obj
, per_dev
->offset
,
669 per_dev
->bio
, per_dev
->length
);
670 EXOFS_DBGMSG("read(0x%llx) offset=0x%llx length=0x%llx"
671 " dev=%d\n", _LLU(ios
->obj
.id
),
672 _LLU(per_dev
->offset
), _LLU(per_dev
->length
),
674 } else if (ios
->kern_buff
) {
675 int ret
= osd_req_read_kern(or, &ios
->obj
, per_dev
->offset
,
676 ios
->kern_buff
, ios
->length
);
677 EXOFS_DBGMSG2("read_kern(0x%llx) offset=0x%llx "
678 "length=0x%llx dev=%d ret=>%d\n",
679 _LLU(ios
->obj
.id
), _LLU(per_dev
->offset
),
680 _LLU(ios
->length
), first_dev
, ret
);
684 osd_req_get_attributes(or, &ios
->obj
);
685 EXOFS_DBGMSG2("obj(0x%llx) get_attributes=%d dev=%d\n",
686 _LLU(ios
->obj
.id
), ios
->in_attr_len
, first_dev
);
689 osd_req_add_set_attr_list(or, ios
->out_attr
, ios
->out_attr_len
);
692 osd_req_add_get_attr_list(or, ios
->in_attr
, ios
->in_attr_len
);
697 int exofs_sbi_read(struct exofs_io_state
*ios
)
702 ret
= _prepare_for_striping(ios
);
706 for (i
= 0; i
< ios
->numdevs
; i
+= ios
->layout
->mirrors_p1
) {
707 ret
= _sbi_read_mirror(ios
, i
);
712 ret
= exofs_io_execute(ios
);
716 int extract_attr_from_ios(struct exofs_io_state
*ios
, struct osd_attr
*attr
)
718 struct osd_attr cur_attr
= {.attr_page
= 0}; /* start with zeros */
724 osd_req_decode_get_attr_list(ios
->per_dev
[0].or,
725 &cur_attr
, &nelem
, &iter
);
726 if ((cur_attr
.attr_page
== attr
->attr_page
) &&
727 (cur_attr
.attr_id
== attr
->attr_id
)) {
728 attr
->len
= cur_attr
.len
;
729 attr
->val_ptr
= cur_attr
.val_ptr
;
737 static int _truncate_mirrors(struct exofs_io_state
*ios
, unsigned cur_comp
,
738 struct osd_attr
*attr
)
740 int last_comp
= cur_comp
+ ios
->layout
->mirrors_p1
;
742 for (; cur_comp
< last_comp
; ++cur_comp
) {
743 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
744 struct osd_request
*or;
746 or = osd_start_request(exofs_ios_od(ios
, cur_comp
), GFP_KERNEL
);
748 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
753 osd_req_set_attributes(or, &ios
->obj
);
754 osd_req_add_set_attr_list(or, attr
, 1);
761 struct _striping_info si
;
762 u64 prev_group_obj_off
;
763 u64 next_group_obj_off
;
765 unsigned first_group_dev
;
766 unsigned nex_group_dev
;
770 void _calc_trunk_info(struct exofs_layout
*layout
, u64 file_offset
,
771 struct _trunc_info
*ti
)
773 unsigned stripe_unit
= layout
->stripe_unit
;
775 _calc_stripe_info(layout
, file_offset
, &ti
->si
);
777 ti
->prev_group_obj_off
= ti
->si
.M
* stripe_unit
;
778 ti
->next_group_obj_off
= ti
->si
.M
? (ti
->si
.M
- 1) * stripe_unit
: 0;
780 ti
->first_group_dev
= ti
->si
.dev
- (ti
->si
.dev
% layout
->group_width
);
781 ti
->nex_group_dev
= ti
->first_group_dev
+ layout
->group_width
;
782 ti
->max_devs
= layout
->group_width
* layout
->group_count
;
785 int exofs_oi_truncate(struct exofs_i_info
*oi
, u64 size
)
787 struct exofs_sb_info
*sbi
= oi
->vfs_inode
.i_sb
->s_fs_info
;
788 struct exofs_io_state
*ios
;
789 struct exofs_trunc_attr
{
790 struct osd_attr attr
;
793 struct _trunc_info ti
;
796 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
800 _calc_trunk_info(ios
->layout
, size
, &ti
);
802 size_attrs
= kcalloc(ti
.max_devs
, sizeof(*size_attrs
),
804 if (unlikely(!size_attrs
)) {
809 ios
->obj
.id
= exofs_oi_objno(oi
);
810 ios
->cred
= oi
->i_cred
;
811 ios
->numdevs
= ios
->layout
->s_numdevs
;
813 for (i
= 0; i
< ti
.max_devs
; ++i
) {
814 struct exofs_trunc_attr
*size_attr
= &size_attrs
[i
];
817 if (i
< ti
.first_group_dev
)
818 obj_size
= ti
.prev_group_obj_off
;
819 else if (i
>= ti
.nex_group_dev
)
820 obj_size
= ti
.next_group_obj_off
;
821 else if (i
< ti
.si
.dev
) /* dev within this group */
822 obj_size
= ti
.si
.obj_offset
+
823 ios
->layout
->stripe_unit
- ti
.si
.unit_off
;
824 else if (i
== ti
.si
.dev
)
825 obj_size
= ti
.si
.obj_offset
;
826 else /* i > ti.dev */
827 obj_size
= ti
.si
.obj_offset
- ti
.si
.unit_off
;
829 size_attr
->newsize
= cpu_to_be64(obj_size
);
830 size_attr
->attr
= g_attr_logical_length
;
831 size_attr
->attr
.val_ptr
= &size_attr
->newsize
;
833 EXOFS_DBGMSG("trunc(0x%llx) obj_offset=0x%llx dev=%d\n",
834 _LLU(ios
->obj
.id
), _LLU(obj_size
), i
);
835 ret
= _truncate_mirrors(ios
, i
* ios
->layout
->mirrors_p1
,
840 ret
= exofs_io_execute(ios
);
844 exofs_put_io_state(ios
);