int start_stripe, int *stripe_count)
{
struct lov_stripe_md_entry *lsme = lsm->lsm_entries[index];
+ int init_stripe;
int last_stripe;
- u64 obd_start;
- u64 obd_end;
int i, j;
+ init_stripe = lov_stripe_number(lsm, index, ext->e_start);
+
if (ext->e_end - ext->e_start >
lsme->lsme_stripe_size * lsme->lsme_stripe_count) {
- last_stripe = (start_stripe < 1 ? lsme->lsme_stripe_count - 1 :
- start_stripe - 1);
- *stripe_count = lsme->lsme_stripe_count;
+ if (init_stripe == start_stripe) {
+ last_stripe = (start_stripe < 1) ?
+ lsme->lsme_stripe_count - 1 : start_stripe - 1;
+ *stripe_count = lsme->lsme_stripe_count;
+ } else if (init_stripe < start_stripe) {
+ last_stripe = (init_stripe < 1) ?
+ lsme->lsme_stripe_count - 1 : init_stripe - 1;
+ *stripe_count = lsme->lsme_stripe_count -
+ (start_stripe - init_stripe);
+ } else {
+ last_stripe = init_stripe - 1;
+ *stripe_count = init_stripe - start_stripe;
+ }
} else {
for (j = 0, i = start_stripe; j < lsme->lsme_stripe_count;
i = (i + 1) % lsme->lsme_stripe_count, j++) {
- if ((lov_stripe_intersects(lsm, index, i, ext,
- &obd_start, &obd_end)) == 0)
+ if (!lov_stripe_intersects(lsm, index, i, ext, NULL,
+ NULL))
+ break;
+ if ((start_stripe != init_stripe) && (i == init_stripe))
break;
}
*stripe_count = j;
static void fiemap_prepare_and_copy_exts(struct fiemap *fiemap,
struct fiemap_extent *lcl_fm_ext,
int ost_index, unsigned int ext_count,
- int current_extent)
+ int current_extent, int abs_stripeno)
{
char *to;
unsigned int ext;
for (ext = 0; ext < ext_count; ext++) {
- lcl_fm_ext[ext].fe_device = ost_index;
+ set_fe_device_stripenr(&lcl_fm_ext[ext], ost_index,
+ abs_stripeno);
lcl_fm_ext[ext].fe_flags |= FIEMAP_EXTENT_NET;
}
{
struct lov_stripe_md_entry *lsme = lsm->lsm_entries[index];
u64 local_end = fiemap->fm_extents[0].fe_logical;
- u64 lun_start;
u64 lun_end;
u64 fm_end_offset;
int stripe_no = -1;
- int i;
if (fiemap->fm_extent_count == 0 ||
fiemap->fm_extents[0].fe_logical == 0)
return 0;
- /* Find out stripe_no from ost_index saved in the fe_device */
- for (i = 0; i < lsme->lsme_stripe_count; i++) {
- struct lov_oinfo *oinfo = lsme->lsme_oinfo[i];
-
- if (lov_oinfo_is_dummy(oinfo))
- continue;
-
- if (oinfo->loi_ost_idx == fiemap->fm_extents[0].fe_device) {
- stripe_no = i;
- break;
- }
- }
+ stripe_no = *start_stripe;
if (stripe_no == -1)
return -EINVAL;
/* If we have finished mapping on previous device, shift logical
* offset to start of next device */
- if (lov_stripe_intersects(lsm, index, stripe_no, ext,
- &lun_start, &lun_end) != 0 &&
+ if (lov_stripe_intersects(lsm, index, stripe_no, ext, NULL, &lun_end) &&
local_end < lun_end) {
fm_end_offset = local_end;
- *start_stripe = stripe_no;
} else {
/* This is a special value to indicate that caller should
* calculate offset in next stripe. */
struct fiemap_state {
struct fiemap *fs_fm;
- struct lu_extent fs_ext;
+ struct lu_extent fs_ext; /* current entry extent */
u64 fs_length;
- u64 fs_end_offset;
- int fs_cur_extent;
- int fs_cnt_need;
+ u64 fs_end_offset; /* last iteration offset */
+ int fs_cur_extent; /* collected exts so far */
+ int fs_cnt_need; /* # of extents buf can hold */
int fs_start_stripe;
int fs_last_stripe;
- bool fs_device_done;
- bool fs_finish_stripe;
- bool fs_enough;
+ bool fs_device_done; /* enough for this OST */
+ bool fs_finish_stripe; /* reached fs_last_stripe */
+ bool fs_enough; /* enough for this call */
};
static struct cl_object *lov_find_subobj(const struct lu_env *env,
static int fiemap_for_stripe(const struct lu_env *env, struct cl_object *obj,
struct lov_stripe_md *lsm, struct fiemap *fiemap,
size_t *buflen, struct ll_fiemap_info_key *fmkey,
- int index, int stripeno, struct fiemap_state *fs)
+ int index, int stripe_last, int stripeno,
+ struct fiemap_state *fs)
{
struct lov_stripe_md_entry *lsme = lsm->lsm_entries[index];
struct cl_object *subobj;
struct lov_obd *lov = lu2lov_dev(obj->co_lu.lo_dev)->ld_lov;
struct fiemap_extent *fm_ext = &fs->fs_fm->fm_extents[0];
- u64 req_fm_len; /* Stores length of required mapping */
+ u64 req_fm_len; /* max requested extent coverage */
u64 len_mapped_single_call;
- u64 lun_start;
- u64 lun_end;
- u64 obd_object_end;
+ u64 obd_start;
+ u64 obd_end;
unsigned int ext_count;
/* EOF for object */
bool ost_eof = false;
fs->fs_device_done = false;
/* Find out range of mapping on this stripe */
if ((lov_stripe_intersects(lsm, index, stripeno, &fs->fs_ext,
- &lun_start, &obd_object_end)) == 0)
+ &obd_start, &obd_end)) == 0)
return 0;
if (lov_oinfo_is_dummy(lsme->lsme_oinfo[stripeno]))
return -EIO;
/* If this is a continuation FIEMAP call and we are on
- * starting stripe then lun_start needs to be set to
+ * starting stripe then obd_start needs to be set to
* end_offset */
if (fs->fs_end_offset != 0 && stripeno == fs->fs_start_stripe)
- lun_start = fs->fs_end_offset;
- lun_end = lov_size_to_stripe(lsm, index, fs->fs_ext.e_end, stripeno);
- if (lun_start == lun_end)
+ obd_start = fs->fs_end_offset;
+
+ if (lov_size_to_stripe(lsm, index, fs->fs_ext.e_end, stripeno) ==
+ obd_start)
return 0;
- req_fm_len = obd_object_end - lun_start + 1;
+ req_fm_len = obd_end - obd_start + 1;
fs->fs_fm->fm_length = 0;
len_mapped_single_call = 0;
fs->fs_cur_extent;
}
- lun_start += len_mapped_single_call;
+ obd_start += len_mapped_single_call;
fs->fs_fm->fm_length = req_fm_len - len_mapped_single_call;
req_fm_len = fs->fs_fm->fm_length;
/**
fs->fs_fm->fm_flags |= FIEMAP_EXTENT_LAST;
fs->fs_fm->fm_mapped_extents = 1;
- fm_ext[0].fe_logical = lun_start;
- fm_ext[0].fe_length = obd_object_end - lun_start + 1;
+ fm_ext[0].fe_logical = obd_start;
+ fm_ext[0].fe_length = obd_end - obd_start + 1;
fm_ext[0].fe_flags |= FIEMAP_EXTENT_UNKNOWN;
goto inactive_tgt;
}
- fs->fs_fm->fm_start = lun_start;
+ fs->fs_fm->fm_start = obd_start;
fs->fs_fm->fm_flags &= ~FIEMAP_FLAG_DEVICE_ORDER;
memcpy(&fmkey->lfik_fiemap, fs->fs_fm, sizeof(*fs->fs_fm));
*buflen = fiemap_count_to_size(fs->fs_fm->fm_extent_count);
/* prepare to copy retrived map extents */
len_mapped_single_call = fm_ext[ext_count - 1].fe_logical +
fm_ext[ext_count - 1].fe_length -
- lun_start;
+ obd_start;
/* Have we finished mapping on this device? */
if (req_fm_len <= len_mapped_single_call) {
}
fiemap_prepare_and_copy_exts(fiemap, fm_ext, ost_index,
- ext_count, fs->fs_cur_extent);
+ ext_count, fs->fs_cur_extent,
+ stripe_last + stripeno);
fs->fs_cur_extent += ext_count;
/* Ran out of available extents? */
loff_t whole_start;
loff_t whole_end;
int entry;
- int start_entry;
+ int start_entry = -1;
int end_entry;
int cur_stripe = 0;
int stripe_count;
unsigned int buffer_size = FIEMAP_BUFFER_SIZE;
int rc = 0;
struct fiemap_state fs = { 0 };
+ struct lu_extent range;
+ int cur_ext;
+ int stripe_last;
+ int start_stripe = 0;
+ bool resume = false;
ENTRY;
lsm = lov_lsm_addref(cl2lov(obj));
*/
if (fiemap_count_to_size(fiemap->fm_extent_count) > *buflen)
fiemap->fm_extent_count = fiemap_size_to_count(*buflen);
- if (fiemap->fm_extent_count == 0)
- fs.fs_cnt_need = 0;
fs.fs_enough = false;
fs.fs_cur_extent = 0;
if (whole_start > fmkey->lfik_oa.o_size)
GOTO(out_fm_local, rc = -EINVAL);
whole_end = (fiemap->fm_length == OBD_OBJECT_EOF) ?
- fmkey->lfik_oa.o_size :
- whole_start + fiemap->fm_length - 1;
+ fmkey->lfik_oa.o_size + 1 :
+ whole_start + fiemap->fm_length;
/**
* If fiemap->fm_length != OBD_OBJECT_EOF but whole_end exceeds file
* size
*/
- if (whole_end > fmkey->lfik_oa.o_size)
- whole_end = fmkey->lfik_oa.o_size;
+ if (whole_end > fmkey->lfik_oa.o_size + 1)
+ whole_end = fmkey->lfik_oa.o_size + 1;
- start_entry = lov_lsm_entry(lsm, whole_start);
- end_entry = lov_lsm_entry(lsm, whole_end);
- if (end_entry == -1)
- end_entry = lsm->lsm_entry_count - 1;
+ /**
+ * the high 16bits of fe_device remember which stripe the last
+ * call has been arrived, we'd continue from there in this call.
+ */
+ if (fiemap->fm_extent_count && fiemap->fm_extents[0].fe_logical)
+ resume = true;
+ stripe_last = get_fe_stripenr(&fiemap->fm_extents[0]);
+ /**
+ * stripe_last records stripe number we've been processed in the last
+ * call
+ */
+ end_entry = lsm->lsm_entry_count - 1;
+ cur_stripe = 0;
+ for (entry = 0; entry <= end_entry; entry++) {
+ lsme = lsm->lsm_entries[entry];
+ if (cur_stripe + lsme->lsme_stripe_count >= stripe_last) {
+ start_entry = entry;
+ start_stripe = stripe_last - cur_stripe;
+ break;
+ }
- if (start_entry == -1 || end_entry == -1)
+ cur_stripe += lsme->lsme_stripe_count;
+ }
+ if (start_entry == -1) {
+ CERROR(DFID": FIEMAP does not init start entry, cur_stripe=%d, "
+ "stripe_last=%d\n", PFID(lu_object_fid(&obj->co_lu)),
+ cur_stripe, stripe_last);
GOTO(out_fm_local, rc = -EINVAL);
+ }
+ /**
+ * @start_entry & @start_stripe records the position of fiemap
+ * resumption @stripe_last keeps recording the absolution position
+ * we'are processing. @resume indicates we'd honor @start_stripe.
+ */
+
+ range.e_start = whole_start;
+ range.e_end = whole_end;
- /* TODO: rewrite it with lov_foreach_io_layout() */
for (entry = start_entry; entry <= end_entry; entry++) {
+ /* remeber to update stripe_last accordingly */
lsme = lsm->lsm_entries[entry];
- if (!lsme_inited(lsme))
- break;
+ /* FLR could contain component holes between entries */
+ if (!lsme_inited(lsme)) {
+ stripe_last += lsme->lsme_stripe_count;
+ resume = false;
+ continue;
+ }
- if (entry == start_entry)
- fs.fs_ext.e_start = whole_start;
- else
+ if (!lu_extent_is_overlapped(&range, &lsme->lsme_extent)) {
+ stripe_last += lsme->lsme_stripe_count;
+ resume = false;
+ continue;
+ }
+
+ /* prepare for a component entry iteration */
+ if (lsme->lsme_extent.e_start > whole_start)
fs.fs_ext.e_start = lsme->lsme_extent.e_start;
- if (entry == end_entry)
+ else
+ fs.fs_ext.e_start = whole_start;
+ if (lsme->lsme_extent.e_end > whole_end)
fs.fs_ext.e_end = whole_end;
else
- fs.fs_ext.e_end = lsme->lsme_extent.e_end - 1;
- fs.fs_length = fs.fs_ext.e_end - fs.fs_ext.e_start + 1;
+ fs.fs_ext.e_end = lsme->lsme_extent.e_end;
/* Calculate start stripe, last stripe and length of mapping */
- fs.fs_start_stripe = lov_stripe_number(lsm, entry,
- fs.fs_ext.e_start);
+ if (resume) {
+ fs.fs_start_stripe = start_stripe;
+ /* put stripe_last to the first stripe of the comp */
+ stripe_last -= start_stripe;
+ resume = false;
+ } else {
+ fs.fs_start_stripe = lov_stripe_number(lsm, entry,
+ fs.fs_ext.e_start);
+ }
fs.fs_last_stripe = fiemap_calc_last_stripe(lsm, entry,
&fs.fs_ext, fs.fs_start_stripe,
&stripe_count);
- fs.fs_end_offset = fiemap_calc_fm_end_offset(fiemap, lsm, entry,
- &fs.fs_ext, &fs.fs_start_stripe);
+ /**
+ * A new mirror component is under process, reset
+ * fs.fs_end_offset and then fiemap_for_stripe() starts from
+ * the overlapping extent, otherwise starts from
+ * fs.fs_end_offset.
+ */
+ if (entry > start_entry && lsme->lsme_extent.e_start == 0) {
+ /* new mirror */
+ fs.fs_end_offset = 0;
+ } else {
+ fs.fs_end_offset = fiemap_calc_fm_end_offset(fiemap,
+ lsm, entry, &fs.fs_ext,
+ &fs.fs_start_stripe);
+ }
+
/* Check each stripe */
for (cur_stripe = fs.fs_start_stripe; stripe_count > 0;
--stripe_count,
cur_stripe = (cur_stripe + 1) % lsme->lsme_stripe_count) {
+ /* reset fs_finish_stripe */
+ fs.fs_finish_stripe = false;
rc = fiemap_for_stripe(env, obj, lsm, fiemap, buflen,
- fmkey, entry, cur_stripe, &fs);
+ fmkey, entry, stripe_last,
+ cur_stripe, &fs);
if (rc < 0)
GOTO(out_fm_local, rc);
- if (fs.fs_enough)
+ if (fs.fs_enough) {
+ stripe_last += cur_stripe;
GOTO(finish, rc);
+ }
if (fs.fs_finish_stripe)
break;
} /* for each stripe */
- } /* for covering layout component */
- /*
- * We've traversed all components, set @entry to the last component
- * entry, it's for the last stripe check.
- */
- entry--;
+ stripe_last += lsme->lsme_stripe_count;
+ } /* for covering layout component entry */
+
finish:
+ if (fs.fs_cur_extent > 0)
+ cur_ext = fs.fs_cur_extent - 1;
+ else
+ cur_ext = 0;
+
+ /* done all the processing */
+ if (entry > end_entry)
+ fiemap->fm_extents[cur_ext].fe_flags |= FIEMAP_EXTENT_LAST;
+
/* Indicate that we are returning device offsets unless file just has
* single stripe */
if (lsm->lsm_entry_count > 1 ||
if (fiemap->fm_extent_count == 0)
goto skip_last_device_calc;
- /* Check if we have reached the last stripe and whether mapping for that
- * stripe is done. */
- if ((cur_stripe == fs.fs_last_stripe) && fs.fs_device_done)
- fiemap->fm_extents[fs.fs_cur_extent - 1].fe_flags |=
- FIEMAP_EXTENT_LAST;
skip_last_device_calc:
fiemap->fm_mapped_extents = fs.fs_cur_extent;
out_fm_local:
git://git.whamcloud.com / fs / lustre-release.git / blobdiff