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 <scsi/scsi_device.h>
26 #include <asm/div64.h>
30 #define EXOFS_DBGMSG2(M...) do {} while (0)
31 /* #define EXOFS_DBGMSG2 EXOFS_DBGMSG */
33 void exofs_make_credential(u8 cred_a
[OSD_CAP_LEN
], const struct osd_obj_id
*obj
)
35 osd_sec_init_nosec_doall_caps(cred_a
, obj
, false, true);
38 int exofs_read_kern(struct osd_dev
*od
, u8
*cred
, struct osd_obj_id
*obj
,
39 u64 offset
, void *p
, unsigned length
)
41 struct osd_request
*or = osd_start_request(od
, GFP_KERNEL
);
42 /* struct osd_sense_info osi = {.key = 0};*/
46 EXOFS_DBGMSG("%s: osd_start_request failed.\n", __func__
);
49 ret
= osd_req_read_kern(or, obj
, offset
, p
, length
);
51 EXOFS_DBGMSG("%s: osd_req_read_kern failed.\n", __func__
);
55 ret
= osd_finalize_request(or, 0, cred
, NULL
);
57 EXOFS_DBGMSG("Faild to osd_finalize_request() => %d\n", ret
);
61 ret
= osd_execute_request(or);
63 EXOFS_DBGMSG("osd_execute_request() => %d\n", ret
);
64 /* osd_req_decode_sense(or, ret); */
71 int exofs_get_io_state(struct exofs_layout
*layout
,
72 struct exofs_io_state
**pios
)
74 struct exofs_io_state
*ios
;
76 /*TODO: Maybe use kmem_cach per sbi of size
77 * exofs_io_state_size(layout->s_numdevs)
79 ios
= kzalloc(exofs_io_state_size(layout
->s_numdevs
), GFP_KERNEL
);
81 EXOFS_DBGMSG("Faild kzalloc bytes=%d\n",
82 exofs_io_state_size(layout
->s_numdevs
));
88 ios
->obj
.partition
= layout
->s_pid
;
93 void exofs_put_io_state(struct exofs_io_state
*ios
)
98 for (i
= 0; i
< ios
->numdevs
; i
++) {
99 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[i
];
102 osd_end_request(per_dev
->or);
104 bio_put(per_dev
->bio
);
111 unsigned exofs_layout_od_id(struct exofs_layout
*layout
,
112 osd_id obj_no
, unsigned layout_index
)
114 /* switch (layout->lay_func) {
115 case LAYOUT_MOVING_WINDOW:
117 unsigned dev_mod
= obj_no
;
119 return (layout_index
+ dev_mod
* layout
->mirrors_p1
) %
122 case LAYOUT_FUNC_IMPLICT:
123 return layout->devs[layout_index];
127 static inline struct osd_dev
*exofs_ios_od(struct exofs_io_state
*ios
,
128 unsigned layout_index
)
130 return ios
->layout
->s_ods
[
131 exofs_layout_od_id(ios
->layout
, ios
->obj
.id
, layout_index
)];
134 static void _sync_done(struct exofs_io_state
*ios
, void *p
)
136 struct completion
*waiting
= p
;
141 static void _last_io(struct kref
*kref
)
143 struct exofs_io_state
*ios
= container_of(
144 kref
, struct exofs_io_state
, kref
);
146 ios
->done(ios
, ios
->private);
149 static void _done_io(struct osd_request
*or, void *p
)
151 struct exofs_io_state
*ios
= p
;
153 kref_put(&ios
->kref
, _last_io
);
156 static int exofs_io_execute(struct exofs_io_state
*ios
)
158 DECLARE_COMPLETION_ONSTACK(wait
);
159 bool sync
= (ios
->done
== NULL
);
163 ios
->done
= _sync_done
;
164 ios
->private = &wait
;
167 for (i
= 0; i
< ios
->numdevs
; i
++) {
168 struct osd_request
*or = ios
->per_dev
[i
].or;
172 ret
= osd_finalize_request(or, 0, ios
->cred
, NULL
);
174 EXOFS_DBGMSG("Faild to osd_finalize_request() => %d\n",
180 kref_init(&ios
->kref
);
182 for (i
= 0; i
< ios
->numdevs
; i
++) {
183 struct osd_request
*or = ios
->per_dev
[i
].or;
187 kref_get(&ios
->kref
);
188 osd_execute_request_async(or, _done_io
, ios
);
191 kref_put(&ios
->kref
, _last_io
);
195 wait_for_completion(&wait
);
196 ret
= exofs_check_io(ios
, NULL
);
201 static void _clear_bio(struct bio
*bio
)
206 __bio_for_each_segment(bv
, bio
, i
, 0) {
207 unsigned this_count
= bv
->bv_len
;
209 if (likely(PAGE_SIZE
== this_count
))
210 clear_highpage(bv
->bv_page
);
212 zero_user(bv
->bv_page
, bv
->bv_offset
, this_count
);
216 int exofs_check_io(struct exofs_io_state
*ios
, u64
*resid
)
218 enum osd_err_priority acumulated_osd_err
= 0;
219 int acumulated_lin_err
= 0;
222 for (i
= 0; i
< ios
->numdevs
; i
++) {
223 struct osd_sense_info osi
;
224 struct osd_request
*or = ios
->per_dev
[i
].or;
230 ret
= osd_req_decode_sense(or, &osi
);
234 if (OSD_ERR_PRI_CLEAR_PAGES
== osi
.osd_err_pri
) {
235 /* start read offset passed endof file */
236 _clear_bio(ios
->per_dev
[i
].bio
);
237 EXOFS_DBGMSG("start read offset passed end of file "
238 "offset=0x%llx, length=0x%llx\n",
239 _LLU(ios
->per_dev
[i
].offset
),
240 _LLU(ios
->per_dev
[i
].length
));
242 continue; /* we recovered */
245 if (osi
.osd_err_pri
>= acumulated_osd_err
) {
246 acumulated_osd_err
= osi
.osd_err_pri
;
247 acumulated_lin_err
= ret
;
251 /* TODO: raid specific residual calculations */
253 if (likely(!acumulated_lin_err
))
256 *resid
= ios
->length
;
259 return acumulated_lin_err
;
263 * L - logical offset into the file
265 * U - The number of bytes in a stripe within a group
267 * U = stripe_unit * group_width
269 * T - The number of bytes striped within a group of component objects
270 * (before advancing to the next group)
272 * T = stripe_unit * group_width * group_depth
274 * S - The number of bytes striped across all component objects
275 * before the pattern repeats
277 * S = stripe_unit * group_width * group_depth * group_count
279 * M - The "major" (i.e., across all components) stripe number
283 * G - Counts the groups from the beginning of the major stripe
285 * G = (L - (M * S)) / T [or (L % S) / T]
287 * H - The byte offset within the group
289 * H = (L - (M * S)) % T [or (L % S) % T]
291 * N - The "minor" (i.e., across the group) stripe number
295 * C - The component index coresponding to L
297 * C = (H - (N * U)) / stripe_unit + G * group_width
298 * [or (L % U) / stripe_unit + G * group_width]
300 * O - The component offset coresponding to L
302 * O = L % stripe_unit + N * stripe_unit + M * group_depth * stripe_unit
304 struct _striping_info
{
307 u64 total_group_length
;
313 static void _calc_stripe_info(struct exofs_io_state
*ios
, u64 file_offset
,
314 struct _striping_info
*si
)
316 u32 stripe_unit
= ios
->layout
->stripe_unit
;
317 u32 group_width
= ios
->layout
->group_width
;
318 u64 group_depth
= ios
->layout
->group_depth
;
320 u32 U
= stripe_unit
* group_width
;
321 u64 T
= U
* group_depth
;
322 u64 S
= T
* ios
->layout
->group_count
;
323 u64 M
= div64_u64(file_offset
, S
);
326 G = (L - (M * S)) / T
327 H = (L - (M * S)) % T
329 u64 LmodS
= file_offset
- M
* S
;
330 u32 G
= div64_u64(LmodS
, T
);
331 u64 H
= LmodS
- G
* T
;
333 u32 N
= div_u64(H
, U
);
335 /* "H - (N * U)" is just "H % U" so it's bound to u32 */
336 si
->dev
= (u32
)(H
- (N
* U
)) / stripe_unit
+ G
* group_width
;
337 si
->dev
*= ios
->layout
->mirrors_p1
;
339 div_u64_rem(file_offset
, stripe_unit
, &si
->unit_off
);
341 si
->obj_offset
= si
->unit_off
+ (N
* stripe_unit
) +
342 (M
* group_depth
* stripe_unit
);
344 si
->group_length
= T
- H
;
345 si
->total_group_length
= T
;
349 static int _add_stripe_unit(struct exofs_io_state
*ios
, unsigned *cur_pg
,
350 unsigned pgbase
, struct exofs_per_dev_state
*per_dev
,
353 unsigned pg
= *cur_pg
;
354 struct request_queue
*q
=
355 osd_request_queue(exofs_ios_od(ios
, per_dev
->dev
));
357 per_dev
->length
+= cur_len
;
359 if (per_dev
->bio
== NULL
) {
360 unsigned pages_in_stripe
= ios
->layout
->group_width
*
361 (ios
->layout
->stripe_unit
/ PAGE_SIZE
);
362 unsigned bio_size
= (ios
->nr_pages
+ pages_in_stripe
) /
363 ios
->layout
->group_width
;
365 per_dev
->bio
= bio_kmalloc(GFP_KERNEL
, bio_size
);
366 if (unlikely(!per_dev
->bio
)) {
367 EXOFS_DBGMSG("Faild to allocate BIO size=%u\n",
373 while (cur_len
> 0) {
374 unsigned pglen
= min_t(unsigned, PAGE_SIZE
- pgbase
, cur_len
);
377 BUG_ON(ios
->nr_pages
<= pg
);
380 added_len
= bio_add_pc_page(q
, per_dev
->bio
, ios
->pages
[pg
],
382 if (unlikely(pglen
!= added_len
))
393 static int _prepare_one_group(struct exofs_io_state
*ios
, u64 length
,
394 struct _striping_info
*si
, unsigned first_comp
)
396 unsigned stripe_unit
= ios
->layout
->stripe_unit
;
397 unsigned mirrors_p1
= ios
->layout
->mirrors_p1
;
398 unsigned devs_in_group
= ios
->layout
->group_width
* mirrors_p1
;
399 unsigned dev
= si
->dev
;
400 unsigned first_dev
= dev
- (dev
% devs_in_group
);
401 unsigned comp
= first_comp
+ (dev
- first_dev
);
402 unsigned max_comp
= ios
->numdevs
? ios
->numdevs
- mirrors_p1
: 0;
403 unsigned cur_pg
= ios
->pages_consumed
;
407 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[comp
];
408 unsigned cur_len
, page_off
= 0;
410 if (!per_dev
->length
) {
413 per_dev
->offset
= si
->obj_offset
+ stripe_unit
-
415 cur_len
= stripe_unit
;
416 } else if (dev
== si
->dev
) {
417 per_dev
->offset
= si
->obj_offset
;
418 cur_len
= stripe_unit
- si
->unit_off
;
419 page_off
= si
->unit_off
& ~PAGE_MASK
;
420 BUG_ON(page_off
&& (page_off
!= ios
->pgbase
));
421 } else { /* dev > si->dev */
422 per_dev
->offset
= si
->obj_offset
- si
->unit_off
;
423 cur_len
= stripe_unit
;
430 dev
= (dev
% devs_in_group
) + first_dev
;
432 cur_len
= stripe_unit
;
434 if (cur_len
>= length
)
437 ret
= _add_stripe_unit(ios
, &cur_pg
, page_off
, per_dev
,
443 comp
= (comp
% devs_in_group
) + first_comp
;
448 ios
->numdevs
= max_comp
+ mirrors_p1
;
449 ios
->pages_consumed
= cur_pg
;
453 static int _prepare_for_striping(struct exofs_io_state
*ios
)
455 u64 length
= ios
->length
;
456 struct _striping_info si
;
457 unsigned devs_in_group
= ios
->layout
->group_width
*
458 ios
->layout
->mirrors_p1
;
459 unsigned first_comp
= 0;
462 _calc_stripe_info(ios
, ios
->offset
, &si
);
465 if (ios
->kern_buff
) {
466 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[0];
468 per_dev
->offset
= si
.obj_offset
;
469 per_dev
->dev
= si
.dev
;
471 /* no cross device without page array */
472 BUG_ON((ios
->layout
->group_width
> 1) &&
473 (si
.unit_off
+ ios
->length
>
474 ios
->layout
->stripe_unit
));
476 ios
->numdevs
= ios
->layout
->mirrors_p1
;
481 if (length
< si
.group_length
)
482 si
.group_length
= length
;
484 ret
= _prepare_one_group(ios
, si
.group_length
, &si
, first_comp
);
488 length
-= si
.group_length
;
490 si
.group_length
= si
.total_group_length
;
493 si
.obj_offset
= si
.Major
* ios
->layout
->stripe_unit
*
494 ios
->layout
->group_depth
;
496 si
.dev
= (si
.dev
- (si
.dev
% devs_in_group
)) + devs_in_group
;
497 si
.dev
%= ios
->layout
->s_numdevs
;
499 first_comp
+= devs_in_group
;
500 first_comp
%= ios
->layout
->s_numdevs
;
507 int exofs_sbi_create(struct exofs_io_state
*ios
)
511 for (i
= 0; i
< ios
->layout
->s_numdevs
; i
++) {
512 struct osd_request
*or;
514 or = osd_start_request(exofs_ios_od(ios
, i
), GFP_KERNEL
);
516 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
520 ios
->per_dev
[i
].or = or;
523 osd_req_create_object(or, &ios
->obj
);
525 ret
= exofs_io_execute(ios
);
531 int exofs_sbi_remove(struct exofs_io_state
*ios
)
535 for (i
= 0; i
< ios
->layout
->s_numdevs
; i
++) {
536 struct osd_request
*or;
538 or = osd_start_request(exofs_ios_od(ios
, i
), GFP_KERNEL
);
540 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
544 ios
->per_dev
[i
].or = or;
547 osd_req_remove_object(or, &ios
->obj
);
549 ret
= exofs_io_execute(ios
);
555 static int _sbi_write_mirror(struct exofs_io_state
*ios
, int cur_comp
)
557 struct exofs_per_dev_state
*master_dev
= &ios
->per_dev
[cur_comp
];
558 unsigned dev
= ios
->per_dev
[cur_comp
].dev
;
559 unsigned last_comp
= cur_comp
+ ios
->layout
->mirrors_p1
;
562 if (ios
->pages
&& !master_dev
->length
)
563 return 0; /* Just an empty slot */
565 for (; cur_comp
< last_comp
; ++cur_comp
, ++dev
) {
566 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
567 struct osd_request
*or;
569 or = osd_start_request(exofs_ios_od(ios
, dev
), GFP_KERNEL
);
571 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
576 per_dev
->offset
= master_dev
->offset
;
581 if (per_dev
!= master_dev
) {
582 bio
= bio_kmalloc(GFP_KERNEL
,
583 master_dev
->bio
->bi_max_vecs
);
584 if (unlikely(!bio
)) {
586 "Faild to allocate BIO size=%u\n",
587 master_dev
->bio
->bi_max_vecs
);
592 __bio_clone(bio
, master_dev
->bio
);
595 per_dev
->length
= master_dev
->length
;
599 bio
= master_dev
->bio
;
600 /* FIXME: bio_set_dir() */
601 bio
->bi_rw
|= (1 << BIO_RW
);
604 osd_req_write(or, &ios
->obj
, per_dev
->offset
, bio
,
606 EXOFS_DBGMSG("write(0x%llx) offset=0x%llx "
607 "length=0x%llx dev=%d\n",
608 _LLU(ios
->obj
.id
), _LLU(per_dev
->offset
),
609 _LLU(per_dev
->length
), dev
);
610 } else if (ios
->kern_buff
) {
611 ret
= osd_req_write_kern(or, &ios
->obj
, per_dev
->offset
,
612 ios
->kern_buff
, ios
->length
);
615 EXOFS_DBGMSG2("write_kern(0x%llx) offset=0x%llx "
616 "length=0x%llx dev=%d\n",
617 _LLU(ios
->obj
.id
), _LLU(per_dev
->offset
),
618 _LLU(ios
->length
), dev
);
620 osd_req_set_attributes(or, &ios
->obj
);
621 EXOFS_DBGMSG2("obj(0x%llx) set_attributes=%d dev=%d\n",
622 _LLU(ios
->obj
.id
), ios
->out_attr_len
, dev
);
626 osd_req_add_set_attr_list(or, ios
->out_attr
,
630 osd_req_add_get_attr_list(or, ios
->in_attr
,
638 int exofs_sbi_write(struct exofs_io_state
*ios
)
643 ret
= _prepare_for_striping(ios
);
647 for (i
= 0; i
< ios
->numdevs
; i
+= ios
->layout
->mirrors_p1
) {
648 ret
= _sbi_write_mirror(ios
, i
);
653 ret
= exofs_io_execute(ios
);
657 static int _sbi_read_mirror(struct exofs_io_state
*ios
, unsigned cur_comp
)
659 struct osd_request
*or;
660 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
661 unsigned first_dev
= (unsigned)ios
->obj
.id
;
663 if (ios
->pages
&& !per_dev
->length
)
664 return 0; /* Just an empty slot */
666 first_dev
= per_dev
->dev
+ first_dev
% ios
->layout
->mirrors_p1
;
667 or = osd_start_request(exofs_ios_od(ios
, first_dev
), GFP_KERNEL
);
669 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
675 osd_req_read(or, &ios
->obj
, per_dev
->offset
,
676 per_dev
->bio
, per_dev
->length
);
677 EXOFS_DBGMSG("read(0x%llx) offset=0x%llx length=0x%llx"
678 " dev=%d\n", _LLU(ios
->obj
.id
),
679 _LLU(per_dev
->offset
), _LLU(per_dev
->length
),
681 } else if (ios
->kern_buff
) {
682 int ret
= osd_req_read_kern(or, &ios
->obj
, per_dev
->offset
,
683 ios
->kern_buff
, ios
->length
);
684 EXOFS_DBGMSG2("read_kern(0x%llx) offset=0x%llx "
685 "length=0x%llx dev=%d ret=>%d\n",
686 _LLU(ios
->obj
.id
), _LLU(per_dev
->offset
),
687 _LLU(ios
->length
), first_dev
, ret
);
691 osd_req_get_attributes(or, &ios
->obj
);
692 EXOFS_DBGMSG2("obj(0x%llx) get_attributes=%d dev=%d\n",
693 _LLU(ios
->obj
.id
), ios
->in_attr_len
, first_dev
);
696 osd_req_add_set_attr_list(or, ios
->out_attr
, ios
->out_attr_len
);
699 osd_req_add_get_attr_list(or, ios
->in_attr
, ios
->in_attr_len
);
704 int exofs_sbi_read(struct exofs_io_state
*ios
)
709 ret
= _prepare_for_striping(ios
);
713 for (i
= 0; i
< ios
->numdevs
; i
+= ios
->layout
->mirrors_p1
) {
714 ret
= _sbi_read_mirror(ios
, i
);
719 ret
= exofs_io_execute(ios
);
723 int extract_attr_from_ios(struct exofs_io_state
*ios
, struct osd_attr
*attr
)
725 struct osd_attr cur_attr
= {.attr_page
= 0}; /* start with zeros */
731 osd_req_decode_get_attr_list(ios
->per_dev
[0].or,
732 &cur_attr
, &nelem
, &iter
);
733 if ((cur_attr
.attr_page
== attr
->attr_page
) &&
734 (cur_attr
.attr_id
== attr
->attr_id
)) {
735 attr
->len
= cur_attr
.len
;
736 attr
->val_ptr
= cur_attr
.val_ptr
;
744 static int _truncate_mirrors(struct exofs_io_state
*ios
, unsigned cur_comp
,
745 struct osd_attr
*attr
)
747 int last_comp
= cur_comp
+ ios
->layout
->mirrors_p1
;
749 for (; cur_comp
< last_comp
; ++cur_comp
) {
750 struct exofs_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
751 struct osd_request
*or;
753 or = osd_start_request(exofs_ios_od(ios
, cur_comp
), GFP_KERNEL
);
755 EXOFS_ERR("%s: osd_start_request failed\n", __func__
);
760 osd_req_set_attributes(or, &ios
->obj
);
761 osd_req_add_set_attr_list(or, attr
, 1);
767 int exofs_oi_truncate(struct exofs_i_info
*oi
, u64 size
)
769 struct exofs_sb_info
*sbi
= oi
->vfs_inode
.i_sb
->s_fs_info
;
770 struct exofs_io_state
*ios
;
771 struct exofs_trunc_attr
{
772 struct osd_attr attr
;
775 struct _striping_info si
;
778 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
782 size_attrs
= kcalloc(ios
->layout
->group_width
, sizeof(*size_attrs
),
784 if (unlikely(!size_attrs
)) {
789 ios
->obj
.id
= exofs_oi_objno(oi
);
790 ios
->cred
= oi
->i_cred
;
792 ios
->numdevs
= ios
->layout
->s_numdevs
;
793 _calc_stripe_info(ios
, size
, &si
);
795 for (i
= 0; i
< ios
->layout
->group_width
; ++i
) {
796 struct exofs_trunc_attr
*size_attr
= &size_attrs
[i
];
800 obj_size
= si
.obj_offset
+
801 ios
->layout
->stripe_unit
- si
.unit_off
;
802 else if (i
== si
.dev
)
803 obj_size
= si
.obj_offset
;
804 else /* i > si.dev */
805 obj_size
= si
.obj_offset
- si
.unit_off
;
807 size_attr
->newsize
= cpu_to_be64(obj_size
);
808 size_attr
->attr
= g_attr_logical_length
;
809 size_attr
->attr
.val_ptr
= &size_attr
->newsize
;
811 ret
= _truncate_mirrors(ios
, i
* ios
->layout
->mirrors_p1
,
816 ret
= exofs_io_execute(ios
);
820 exofs_put_io_state(ios
);