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 <asm/div64.h>
28 #include <scsi/osd_ore.h>
30 #define ORE_ERR(fmt, a...) printk(KERN_ERR "ore: " fmt, ##a)
32 #ifdef CONFIG_EXOFS_DEBUG
33 #define ORE_DBGMSG(fmt, a...) \
34 printk(KERN_NOTICE "ore @%s:%d: " fmt, __func__, __LINE__, ##a)
36 #define ORE_DBGMSG(fmt, a...) \
37 do { if (0) printk(fmt, ##a); } while (0)
40 /* u64 has problems with printk this will cast it to unsigned long long */
41 #define _LLU(x) (unsigned long long)(x)
43 #define ORE_DBGMSG2(M...) do {} while (0)
44 /* #define ORE_DBGMSG2 ORE_DBGMSG */
46 MODULE_AUTHOR("Boaz Harrosh <bharrosh@panasas.com>");
47 MODULE_DESCRIPTION("Objects Raid Engine ore.ko");
48 MODULE_LICENSE("GPL");
50 static void ore_calc_stripe_info(struct ore_layout
*layout
, u64 file_offset
,
51 struct ore_striping_info
*si
);
53 static u8
*_ios_cred(struct ore_io_state
*ios
, unsigned index
)
55 return ios
->oc
->comps
[index
& ios
->oc
->single_comp
].cred
;
58 static struct osd_obj_id
*_ios_obj(struct ore_io_state
*ios
, unsigned index
)
60 return &ios
->oc
->comps
[index
& ios
->oc
->single_comp
].obj
;
63 static struct osd_dev
*_ios_od(struct ore_io_state
*ios
, unsigned index
)
65 return ore_comp_dev(ios
->oc
, index
);
68 static int _get_io_state(struct ore_layout
*layout
,
69 struct ore_components
*oc
, unsigned numdevs
,
70 struct ore_io_state
**pios
)
72 struct ore_io_state
*ios
;
74 /*TODO: Maybe use kmem_cach per sbi of size
75 * exofs_io_state_size(layout->s_numdevs)
77 ios
= kzalloc(ore_io_state_size(numdevs
), GFP_KERNEL
);
79 ORE_DBGMSG("Failed kzalloc bytes=%d\n",
80 ore_io_state_size(numdevs
));
91 /* Allocate an io_state for only a single group of devices
93 * If a user needs to call ore_read/write() this version must be used becase it
94 * allocates extra stuff for striping and raid.
95 * The ore might decide to only IO less then @length bytes do to alignmets
96 * and constrains as follows:
97 * - The IO cannot cross group boundary.
98 * - In raid5/6 The end of the IO must align at end of a stripe eg.
99 * (@offset + @length) % strip_size == 0. Or the complete range is within a
101 * - Memory condition only permitted a shorter IO. (A user can use @length=~0
102 * And check the returned ios->length for max_io_size.)
104 * The caller must check returned ios->length (and/or ios->nr_pages) and
105 * re-issue these pages that fall outside of ios->length
107 int ore_get_rw_state(struct ore_layout
*layout
, struct ore_components
*oc
,
108 bool is_reading
, u64 offset
, u64 length
,
109 struct ore_io_state
**pios
)
111 struct ore_io_state
*ios
;
112 unsigned numdevs
= layout
->group_width
* layout
->mirrors_p1
;
115 ret
= _get_io_state(layout
, oc
, numdevs
, pios
);
120 ios
->reading
= is_reading
;
121 ios
->offset
= offset
;
124 ore_calc_stripe_info(layout
, offset
, &ios
->si
);
125 ios
->length
= (length
<= ios
->si
.group_length
) ? length
:
126 ios
->si
.group_length
;
127 ios
->nr_pages
= (ios
->length
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
132 EXPORT_SYMBOL(ore_get_rw_state
);
134 /* Allocate an io_state for all the devices in the comps array
136 * This version of io_state allocation is used mostly by create/remove
137 * and trunc where we currently need all the devices. The only wastful
138 * bit is the read/write_attributes with no IO. Those sites should
139 * be converted to use ore_get_rw_state() with length=0
141 int ore_get_io_state(struct ore_layout
*layout
, struct ore_components
*oc
,
142 struct ore_io_state
**pios
)
144 return _get_io_state(layout
, oc
, oc
->numdevs
, pios
);
146 EXPORT_SYMBOL(ore_get_io_state
);
148 void ore_put_io_state(struct ore_io_state
*ios
)
153 for (i
= 0; i
< ios
->numdevs
; i
++) {
154 struct ore_per_dev_state
*per_dev
= &ios
->per_dev
[i
];
157 osd_end_request(per_dev
->or);
159 bio_put(per_dev
->bio
);
165 EXPORT_SYMBOL(ore_put_io_state
);
167 static void _sync_done(struct ore_io_state
*ios
, void *p
)
169 struct completion
*waiting
= p
;
174 static void _last_io(struct kref
*kref
)
176 struct ore_io_state
*ios
= container_of(
177 kref
, struct ore_io_state
, kref
);
179 ios
->done(ios
, ios
->private);
182 static void _done_io(struct osd_request
*or, void *p
)
184 struct ore_io_state
*ios
= p
;
186 kref_put(&ios
->kref
, _last_io
);
189 static int ore_io_execute(struct ore_io_state
*ios
)
191 DECLARE_COMPLETION_ONSTACK(wait
);
192 bool sync
= (ios
->done
== NULL
);
196 ios
->done
= _sync_done
;
197 ios
->private = &wait
;
200 for (i
= 0; i
< ios
->numdevs
; i
++) {
201 struct osd_request
*or = ios
->per_dev
[i
].or;
205 ret
= osd_finalize_request(or, 0, _ios_cred(ios
, i
), NULL
);
207 ORE_DBGMSG("Failed to osd_finalize_request() => %d\n",
213 kref_init(&ios
->kref
);
215 for (i
= 0; i
< ios
->numdevs
; i
++) {
216 struct osd_request
*or = ios
->per_dev
[i
].or;
220 kref_get(&ios
->kref
);
221 osd_execute_request_async(or, _done_io
, ios
);
224 kref_put(&ios
->kref
, _last_io
);
228 wait_for_completion(&wait
);
229 ret
= ore_check_io(ios
, NULL
);
234 static void _clear_bio(struct bio
*bio
)
239 __bio_for_each_segment(bv
, bio
, i
, 0) {
240 unsigned this_count
= bv
->bv_len
;
242 if (likely(PAGE_SIZE
== this_count
))
243 clear_highpage(bv
->bv_page
);
245 zero_user(bv
->bv_page
, bv
->bv_offset
, this_count
);
249 int ore_check_io(struct ore_io_state
*ios
, u64
*resid
)
251 enum osd_err_priority acumulated_osd_err
= 0;
252 int acumulated_lin_err
= 0;
255 for (i
= 0; i
< ios
->numdevs
; i
++) {
256 struct osd_sense_info osi
;
257 struct osd_request
*or = ios
->per_dev
[i
].or;
263 ret
= osd_req_decode_sense(or, &osi
);
267 if (OSD_ERR_PRI_CLEAR_PAGES
== osi
.osd_err_pri
) {
268 /* start read offset passed endof file */
269 _clear_bio(ios
->per_dev
[i
].bio
);
270 ORE_DBGMSG("start read offset passed end of file "
271 "offset=0x%llx, length=0x%llx\n",
272 _LLU(ios
->per_dev
[i
].offset
),
273 _LLU(ios
->per_dev
[i
].length
));
275 continue; /* we recovered */
278 if (osi
.osd_err_pri
>= acumulated_osd_err
) {
279 acumulated_osd_err
= osi
.osd_err_pri
;
280 acumulated_lin_err
= ret
;
284 /* TODO: raid specific residual calculations */
286 if (likely(!acumulated_lin_err
))
289 *resid
= ios
->length
;
292 return acumulated_lin_err
;
294 EXPORT_SYMBOL(ore_check_io
);
297 * L - logical offset into the file
299 * U - The number of bytes in a stripe within a group
301 * U = stripe_unit * group_width
303 * T - The number of bytes striped within a group of component objects
304 * (before advancing to the next group)
306 * T = stripe_unit * group_width * group_depth
308 * S - The number of bytes striped across all component objects
309 * before the pattern repeats
311 * S = stripe_unit * group_width * group_depth * group_count
313 * M - The "major" (i.e., across all components) stripe number
317 * G - Counts the groups from the beginning of the major stripe
319 * G = (L - (M * S)) / T [or (L % S) / T]
321 * H - The byte offset within the group
323 * H = (L - (M * S)) % T [or (L % S) % T]
325 * N - The "minor" (i.e., across the group) stripe number
329 * C - The component index coresponding to L
331 * C = (H - (N * U)) / stripe_unit + G * group_width
332 * [or (L % U) / stripe_unit + G * group_width]
334 * O - The component offset coresponding to L
336 * O = L % stripe_unit + N * stripe_unit + M * group_depth * stripe_unit
338 static void ore_calc_stripe_info(struct ore_layout
*layout
, u64 file_offset
,
339 struct ore_striping_info
*si
)
341 u32 stripe_unit
= layout
->stripe_unit
;
342 u32 group_width
= layout
->group_width
;
343 u64 group_depth
= layout
->group_depth
;
345 u32 U
= stripe_unit
* group_width
;
346 u64 T
= U
* group_depth
;
347 u64 S
= T
* layout
->group_count
;
348 u64 M
= div64_u64(file_offset
, S
);
351 G = (L - (M * S)) / T
352 H = (L - (M * S)) % T
354 u64 LmodS
= file_offset
- M
* S
;
355 u32 G
= div64_u64(LmodS
, T
);
356 u64 H
= LmodS
- G
* T
;
358 u32 N
= div_u64(H
, U
);
360 /* "H - (N * U)" is just "H % U" so it's bound to u32 */
361 si
->dev
= (u32
)(H
- (N
* U
)) / stripe_unit
+ G
* group_width
;
362 si
->dev
*= layout
->mirrors_p1
;
364 div_u64_rem(file_offset
, stripe_unit
, &si
->unit_off
);
366 si
->obj_offset
= si
->unit_off
+ (N
* stripe_unit
) +
367 (M
* group_depth
* stripe_unit
);
369 si
->group_length
= T
- H
;
373 static int _add_stripe_unit(struct ore_io_state
*ios
, unsigned *cur_pg
,
374 unsigned pgbase
, struct ore_per_dev_state
*per_dev
,
377 unsigned pg
= *cur_pg
;
378 struct request_queue
*q
=
379 osd_request_queue(_ios_od(ios
, per_dev
->dev
));
380 unsigned len
= cur_len
;
383 if (per_dev
->bio
== NULL
) {
384 unsigned pages_in_stripe
= ios
->layout
->group_width
*
385 (ios
->layout
->stripe_unit
/ PAGE_SIZE
);
386 unsigned bio_size
= (ios
->nr_pages
+ pages_in_stripe
) /
387 ios
->layout
->group_width
;
389 per_dev
->bio
= bio_kmalloc(GFP_KERNEL
, bio_size
);
390 if (unlikely(!per_dev
->bio
)) {
391 ORE_DBGMSG("Failed to allocate BIO size=%u\n",
398 while (cur_len
> 0) {
399 unsigned pglen
= min_t(unsigned, PAGE_SIZE
- pgbase
, cur_len
);
402 BUG_ON(ios
->nr_pages
<= pg
);
405 added_len
= bio_add_pc_page(q
, per_dev
->bio
, ios
->pages
[pg
],
407 if (unlikely(pglen
!= added_len
)) {
416 per_dev
->length
+= len
;
419 out
: /* we fail the complete unit on an error eg don't advance
420 * per_dev->length and cur_pg. This means that we might have a bigger
421 * bio than the CDB requested length (per_dev->length). That's fine
422 * only the oposite is fatal.
427 static int _prepare_for_striping(struct ore_io_state
*ios
)
429 struct ore_striping_info
*si
= &ios
->si
;
430 unsigned stripe_unit
= ios
->layout
->stripe_unit
;
431 unsigned mirrors_p1
= ios
->layout
->mirrors_p1
;
432 unsigned devs_in_group
= ios
->layout
->group_width
* mirrors_p1
;
433 unsigned dev
= si
->dev
;
434 unsigned first_dev
= dev
- (dev
% devs_in_group
);
435 unsigned cur_pg
= ios
->pages_consumed
;
436 u64 length
= ios
->length
;
440 ios
->numdevs
= ios
->layout
->mirrors_p1
;
444 BUG_ON(length
> si
->group_length
);
447 unsigned comp
= dev
- first_dev
;
448 struct ore_per_dev_state
*per_dev
= &ios
->per_dev
[comp
];
449 unsigned cur_len
, page_off
= 0;
451 if (!per_dev
->length
) {
454 per_dev
->offset
= si
->obj_offset
+ stripe_unit
-
456 cur_len
= stripe_unit
;
457 } else if (dev
== si
->dev
) {
458 per_dev
->offset
= si
->obj_offset
;
459 cur_len
= stripe_unit
- si
->unit_off
;
460 page_off
= si
->unit_off
& ~PAGE_MASK
;
461 BUG_ON(page_off
&& (page_off
!= ios
->pgbase
));
462 } else { /* dev > si->dev */
463 per_dev
->offset
= si
->obj_offset
- si
->unit_off
;
464 cur_len
= stripe_unit
;
467 cur_len
= stripe_unit
;
469 if (cur_len
>= length
)
472 ret
= _add_stripe_unit(ios
, &cur_pg
, page_off
, per_dev
,
478 dev
= (dev
% devs_in_group
) + first_dev
;
483 ios
->numdevs
= devs_in_group
;
484 ios
->pages_consumed
= cur_pg
;
486 if (length
== ios
->length
)
489 ios
->length
-= length
;
494 int ore_create(struct ore_io_state
*ios
)
498 for (i
= 0; i
< ios
->oc
->numdevs
; i
++) {
499 struct osd_request
*or;
501 or = osd_start_request(_ios_od(ios
, i
), GFP_KERNEL
);
503 ORE_ERR("%s: osd_start_request failed\n", __func__
);
507 ios
->per_dev
[i
].or = or;
510 osd_req_create_object(or, _ios_obj(ios
, i
));
512 ret
= ore_io_execute(ios
);
517 EXPORT_SYMBOL(ore_create
);
519 int ore_remove(struct ore_io_state
*ios
)
523 for (i
= 0; i
< ios
->oc
->numdevs
; i
++) {
524 struct osd_request
*or;
526 or = osd_start_request(_ios_od(ios
, i
), GFP_KERNEL
);
528 ORE_ERR("%s: osd_start_request failed\n", __func__
);
532 ios
->per_dev
[i
].or = or;
535 osd_req_remove_object(or, _ios_obj(ios
, i
));
537 ret
= ore_io_execute(ios
);
542 EXPORT_SYMBOL(ore_remove
);
544 static int _write_mirror(struct ore_io_state
*ios
, int cur_comp
)
546 struct ore_per_dev_state
*master_dev
= &ios
->per_dev
[cur_comp
];
547 unsigned dev
= ios
->per_dev
[cur_comp
].dev
;
548 unsigned last_comp
= cur_comp
+ ios
->layout
->mirrors_p1
;
551 if (ios
->pages
&& !master_dev
->length
)
552 return 0; /* Just an empty slot */
554 for (; cur_comp
< last_comp
; ++cur_comp
, ++dev
) {
555 struct ore_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
556 struct osd_request
*or;
558 or = osd_start_request(_ios_od(ios
, dev
), GFP_KERNEL
);
560 ORE_ERR("%s: osd_start_request failed\n", __func__
);
569 if (per_dev
!= master_dev
) {
570 bio
= bio_kmalloc(GFP_KERNEL
,
571 master_dev
->bio
->bi_max_vecs
);
572 if (unlikely(!bio
)) {
574 "Failed to allocate BIO size=%u\n",
575 master_dev
->bio
->bi_max_vecs
);
580 __bio_clone(bio
, master_dev
->bio
);
583 per_dev
->offset
= master_dev
->offset
;
584 per_dev
->length
= master_dev
->length
;
588 bio
= master_dev
->bio
;
589 /* FIXME: bio_set_dir() */
590 bio
->bi_rw
|= REQ_WRITE
;
593 osd_req_write(or, _ios_obj(ios
, dev
), per_dev
->offset
,
594 bio
, per_dev
->length
);
595 ORE_DBGMSG("write(0x%llx) offset=0x%llx "
596 "length=0x%llx dev=%d\n",
597 _LLU(_ios_obj(ios
, dev
)->id
),
598 _LLU(per_dev
->offset
),
599 _LLU(per_dev
->length
), dev
);
600 } else if (ios
->kern_buff
) {
601 per_dev
->offset
= ios
->si
.obj_offset
;
602 per_dev
->dev
= ios
->si
.dev
+ dev
;
604 /* no cross device without page array */
605 BUG_ON((ios
->layout
->group_width
> 1) &&
606 (ios
->si
.unit_off
+ ios
->length
>
607 ios
->layout
->stripe_unit
));
609 ret
= osd_req_write_kern(or, _ios_obj(ios
, per_dev
->dev
),
611 ios
->kern_buff
, ios
->length
);
614 ORE_DBGMSG2("write_kern(0x%llx) offset=0x%llx "
615 "length=0x%llx dev=%d\n",
616 _LLU(_ios_obj(ios
, dev
)->id
),
617 _LLU(per_dev
->offset
),
618 _LLU(ios
->length
), per_dev
->dev
);
620 osd_req_set_attributes(or, _ios_obj(ios
, dev
));
621 ORE_DBGMSG2("obj(0x%llx) set_attributes=%d dev=%d\n",
622 _LLU(_ios_obj(ios
, dev
)->id
),
623 ios
->out_attr_len
, dev
);
627 osd_req_add_set_attr_list(or, ios
->out_attr
,
631 osd_req_add_get_attr_list(or, ios
->in_attr
,
639 int ore_write(struct ore_io_state
*ios
)
644 ret
= _prepare_for_striping(ios
);
648 for (i
= 0; i
< ios
->numdevs
; i
+= ios
->layout
->mirrors_p1
) {
649 ret
= _write_mirror(ios
, i
);
654 ret
= ore_io_execute(ios
);
657 EXPORT_SYMBOL(ore_write
);
659 static int _read_mirror(struct ore_io_state
*ios
, unsigned cur_comp
)
661 struct osd_request
*or;
662 struct ore_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
663 struct osd_obj_id
*obj
= _ios_obj(ios
, cur_comp
);
664 unsigned first_dev
= (unsigned)obj
->id
;
666 if (ios
->pages
&& !per_dev
->length
)
667 return 0; /* Just an empty slot */
669 first_dev
= per_dev
->dev
+ first_dev
% ios
->layout
->mirrors_p1
;
670 or = osd_start_request(_ios_od(ios
, first_dev
), GFP_KERNEL
);
672 ORE_ERR("%s: osd_start_request failed\n", __func__
);
678 osd_req_read(or, obj
, per_dev
->offset
,
679 per_dev
->bio
, per_dev
->length
);
680 ORE_DBGMSG("read(0x%llx) offset=0x%llx length=0x%llx"
681 " dev=%d\n", _LLU(obj
->id
),
682 _LLU(per_dev
->offset
), _LLU(per_dev
->length
),
685 BUG_ON(ios
->kern_buff
);
687 osd_req_get_attributes(or, obj
);
688 ORE_DBGMSG2("obj(0x%llx) get_attributes=%d dev=%d\n",
690 ios
->in_attr_len
, first_dev
);
693 osd_req_add_set_attr_list(or, ios
->out_attr
, ios
->out_attr_len
);
696 osd_req_add_get_attr_list(or, ios
->in_attr
, ios
->in_attr_len
);
701 int ore_read(struct ore_io_state
*ios
)
706 ret
= _prepare_for_striping(ios
);
710 for (i
= 0; i
< ios
->numdevs
; i
+= ios
->layout
->mirrors_p1
) {
711 ret
= _read_mirror(ios
, i
);
716 ret
= ore_io_execute(ios
);
719 EXPORT_SYMBOL(ore_read
);
721 int extract_attr_from_ios(struct ore_io_state
*ios
, struct osd_attr
*attr
)
723 struct osd_attr cur_attr
= {.attr_page
= 0}; /* start with zeros */
729 osd_req_decode_get_attr_list(ios
->per_dev
[0].or,
730 &cur_attr
, &nelem
, &iter
);
731 if ((cur_attr
.attr_page
== attr
->attr_page
) &&
732 (cur_attr
.attr_id
== attr
->attr_id
)) {
733 attr
->len
= cur_attr
.len
;
734 attr
->val_ptr
= cur_attr
.val_ptr
;
741 EXPORT_SYMBOL(extract_attr_from_ios
);
743 static int _truncate_mirrors(struct ore_io_state
*ios
, unsigned cur_comp
,
744 struct osd_attr
*attr
)
746 int last_comp
= cur_comp
+ ios
->layout
->mirrors_p1
;
748 for (; cur_comp
< last_comp
; ++cur_comp
) {
749 struct ore_per_dev_state
*per_dev
= &ios
->per_dev
[cur_comp
];
750 struct osd_request
*or;
752 or = osd_start_request(_ios_od(ios
, cur_comp
), GFP_KERNEL
);
754 ORE_ERR("%s: osd_start_request failed\n", __func__
);
759 osd_req_set_attributes(or, _ios_obj(ios
, cur_comp
));
760 osd_req_add_set_attr_list(or, attr
, 1);
767 struct ore_striping_info si
;
768 u64 prev_group_obj_off
;
769 u64 next_group_obj_off
;
771 unsigned first_group_dev
;
772 unsigned nex_group_dev
;
775 static void _calc_trunk_info(struct ore_layout
*layout
, u64 file_offset
,
776 struct _trunc_info
*ti
)
778 unsigned stripe_unit
= layout
->stripe_unit
;
780 ore_calc_stripe_info(layout
, file_offset
, &ti
->si
);
782 ti
->prev_group_obj_off
= ti
->si
.M
* stripe_unit
;
783 ti
->next_group_obj_off
= ti
->si
.M
? (ti
->si
.M
- 1) * stripe_unit
: 0;
785 ti
->first_group_dev
= ti
->si
.dev
- (ti
->si
.dev
% layout
->group_width
);
786 ti
->nex_group_dev
= ti
->first_group_dev
+ layout
->group_width
;
789 int ore_truncate(struct ore_layout
*layout
, struct ore_components
*oc
,
792 struct ore_io_state
*ios
;
793 struct exofs_trunc_attr
{
794 struct osd_attr attr
;
797 struct _trunc_info ti
;
800 ret
= ore_get_io_state(layout
, oc
, &ios
);
804 _calc_trunk_info(ios
->layout
, size
, &ti
);
806 size_attrs
= kcalloc(ios
->oc
->numdevs
, sizeof(*size_attrs
),
808 if (unlikely(!size_attrs
)) {
813 ios
->numdevs
= ios
->oc
->numdevs
;
815 for (i
= 0; i
< ios
->numdevs
; ++i
) {
816 struct exofs_trunc_attr
*size_attr
= &size_attrs
[i
];
819 if (i
< ti
.first_group_dev
)
820 obj_size
= ti
.prev_group_obj_off
;
821 else if (i
>= ti
.nex_group_dev
)
822 obj_size
= ti
.next_group_obj_off
;
823 else if (i
< ti
.si
.dev
) /* dev within this group */
824 obj_size
= ti
.si
.obj_offset
+
825 ios
->layout
->stripe_unit
- ti
.si
.unit_off
;
826 else if (i
== ti
.si
.dev
)
827 obj_size
= ti
.si
.obj_offset
;
828 else /* i > ti.dev */
829 obj_size
= ti
.si
.obj_offset
- ti
.si
.unit_off
;
831 size_attr
->newsize
= cpu_to_be64(obj_size
);
832 size_attr
->attr
= g_attr_logical_length
;
833 size_attr
->attr
.val_ptr
= &size_attr
->newsize
;
835 ORE_DBGMSG("trunc(0x%llx) obj_offset=0x%llx dev=%d\n",
836 _LLU(oc
->comps
->obj
.id
), _LLU(obj_size
), i
);
837 ret
= _truncate_mirrors(ios
, i
* ios
->layout
->mirrors_p1
,
842 ret
= ore_io_execute(ios
);
846 ore_put_io_state(ios
);
849 EXPORT_SYMBOL(ore_truncate
);
851 const struct osd_attr g_attr_logical_length
= ATTR_DEF(
852 OSD_APAGE_OBJECT_INFORMATION
, OSD_ATTR_OI_LOGICAL_LENGTH
, 8);
853 EXPORT_SYMBOL(g_attr_logical_length
);