diff --git a/fs/lustre/lov/lov_object.c b/fs/lustre/lov/lov_object.c
index 0762cc5..3fcd342 100644
--- a/fs/lustre/lov/lov_object.c
+++ b/fs/lustre/lov/lov_object.c
@@ -1487,21 +1487,34 @@ static int fiemap_calc_last_stripe(struct lov_stripe_md *lsm, int index,
 				   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;
@@ -1524,13 +1537,14 @@ static int fiemap_calc_last_stripe(struct lov_stripe_md *lsm, int index,
 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)
 {
 	unsigned int ext;
 	char *to;
 
 	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;
 	}
 
@@ -1565,26 +1579,14 @@ static u64 fiemap_calc_fm_end_offset(struct fiemap *fiemap,
 {
 	struct lov_stripe_md_entry *lsme = lsm->lsm_entries[index];
 	u64 local_end = fiemap->fm_extents[0].fe_logical;
-	u64 lun_start, lun_end;
+	u64 lun_end;
 	u64 fm_end_offset;
 	int stripe_no = -1;
-	int i;
 
 	if (!fiemap->fm_extent_count || !fiemap->fm_extents[0].fe_logical)
 		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;
@@ -1593,11 +1595,9 @@ static u64 fiemap_calc_fm_end_offset(struct fiemap *fiemap,
 	 * 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.
@@ -1611,16 +1611,16 @@ static u64 fiemap_calc_fm_end_offset(struct fiemap *fiemap,
 
 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,
@@ -1669,17 +1669,17 @@ 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;
@@ -1691,24 +1691,24 @@ static int fiemap_for_stripe(const struct lu_env *env, struct cl_object *obj,
 	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;
+		obd_start = fs->fs_end_offset;
 
-	lun_end = lov_size_to_stripe(lsm, index, fs->fs_ext.e_end, stripeno);
-	if (lun_start == lun_end)
+	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;
 
@@ -1729,7 +1729,7 @@ static int fiemap_for_stripe(const struct lu_env *env, struct cl_object *obj,
 						  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;
 		/**
@@ -1753,14 +1753,14 @@ static int fiemap_for_stripe(const struct lu_env *env, struct cl_object *obj,
 			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);
@@ -1799,7 +1799,7 @@ static int fiemap_for_stripe(const struct lu_env *env, struct cl_object *obj,
 		/* 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) {
@@ -1821,7 +1821,8 @@ static int fiemap_for_stripe(const struct lu_env *env, struct cl_object *obj,
 		}
 
 		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? */
@@ -1863,12 +1864,17 @@ static int lov_object_fiemap(const struct lu_env *env, struct cl_object *obj,
 	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;
 	int rc = 0;
 	struct fiemap_state fs = { NULL };
+	struct lu_extent range;
+	int cur_ext;
+	int stripe_last;
+	int start_stripe = 0;
+	bool resume = false;
 
 	lsm = lov_lsm_addref(cl2lov(obj));
 	if (!lsm) {
@@ -1936,8 +1942,6 @@ static int lov_object_fiemap(const struct lu_env *env, struct cl_object *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)
-		fs.fs_cnt_need = 0;
 
 	fs.fs_enough = false;
 	fs.fs_cur_extent = 0;
@@ -1951,73 +1955,142 @@ static int lov_object_fiemap(const struct lu_env *env, struct cl_object *obj,
 		goto out_fm_local;
 	}
 	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;
+		}
+		cur_stripe += lsme->lsme_stripe_count;
+	}
 
-	if (start_entry == -1 || end_entry == -1) {
+	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);
 		rc = -EINVAL;
 		goto out_fm_local;
 	}
+	/**
+	 * @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;
-			if (fs.fs_enough)
+			if (fs.fs_enough) {
+				stripe_last += cur_stripe;
 				goto finish;
+			}
 			if (fs.fs_finish_stripe)
 				break;
 		} /* for each stripe */
-	} /* for covering layout component */
+		stripe_last += lsme->lsme_stripe_count;
+	} /* for covering layout component entry */
 
-	/*
-	 * We've traversed all components, set @entry to the last component
-	 * entry, it's for the last stripe check.
-	 */
-	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
@@ -2030,13 +2103,6 @@ static int lov_object_fiemap(const struct lu_env *env, struct cl_object *obj,
 	if (!fiemap->fm_extent_count)
 		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:
diff --git a/fs/lustre/lov/lov_offset.c b/fs/lustre/lov/lov_offset.c
index b53ce43..ca763af 100644
--- a/fs/lustre/lov/lov_offset.c
+++ b/fs/lustre/lov/lov_offset.c
@@ -227,18 +227,24 @@ u64 lov_size_to_stripe(struct lov_stripe_md *lsm, int index, u64 file_size,
  * that is contained within the lov extent.  this returns true if the given
  * stripe does intersect with the lov extent.
  *
- * Closed interval [@obd_start, @obd_end] will be returned.
+ * Closed interval [@obd_start, @obd_end] will be returned if caller needs them.
  */
 int lov_stripe_intersects(struct lov_stripe_md *lsm, int index, int stripeno,
 			  struct lu_extent *ext, u64 *obd_start, u64 *obd_end)
 {
 	struct lov_stripe_md_entry *entry = lsm->lsm_entries[index];
 	int start_side, end_side;
+	u64 loc_start, loc_end;
 	u64 start, end;
 
 	if (!lu_extent_is_overlapped(ext, &entry->lsme_extent))
 		return 0;
 
+	if (!obd_start)
+		obd_start = &loc_start;
+	if (!obd_end)
+		obd_end = &loc_end;
+
 	start = max_t(u64, ext->e_start, entry->lsme_extent.e_start);
 	end = min_t(u64, ext->e_end, entry->lsme_extent.e_end);
 	if (end != OBD_OBJECT_EOF)
diff --git a/fs/lustre/ptlrpc/wiretest.c b/fs/lustre/ptlrpc/wiretest.c
index fedb914..a500a87 100644
--- a/fs/lustre/ptlrpc/wiretest.c
+++ b/fs/lustre/ptlrpc/wiretest.c
@@ -4262,7 +4262,6 @@ void lustre_assert_wire_constants(void)
 	BUILD_BUG_ON(FIEMAP_EXTENT_UNWRITTEN != 0x00000800);
 	BUILD_BUG_ON(FIEMAP_EXTENT_MERGED != 0x00001000);
 	BUILD_BUG_ON(FIEMAP_EXTENT_SHARED != 0x00002000);
-	BUILD_BUG_ON(FIEMAP_EXTENT_NO_DIRECT != 0x40000000);
 	BUILD_BUG_ON(FIEMAP_EXTENT_NET != 0x80000000);
 
 #ifdef CONFIG_FS_POSIX_ACL
diff --git a/include/uapi/linux/lustre/lustre_fiemap.h b/include/uapi/linux/lustre/lustre_fiemap.h
index 4ae1850..f93e107 100644
--- a/include/uapi/linux/lustre/lustre_fiemap.h
+++ b/include/uapi/linux/lustre/lustre_fiemap.h
@@ -43,9 +43,35 @@
 #include <linux/fiemap.h>
 #include <linux/types.h>
 
-/* XXX: We use fiemap_extent::fe_reserved[0] */
+/**
+ * XXX: We use fiemap_extent::fe_reserved[0], notice the high 16bits of it
+ * is used to locate the stripe number starting from the very beginning to
+ * resume the fiemap call.
+ */
 #define fe_device	fe_reserved[0]
 
+static inline int get_fe_device(struct fiemap_extent *fe)
+{
+	return fe->fe_device & 0xffff;
+}
+static inline void set_fe_device(struct fiemap_extent *fe, int devno)
+{
+	fe->fe_device = (fe->fe_device & 0xffff0000) | (devno & 0xffff);
+}
+static inline int get_fe_stripenr(struct fiemap_extent *fe)
+{
+	return fe->fe_device >> 16;
+}
+static inline void set_fe_stripenr(struct fiemap_extent *fe, int nr)
+{
+	fe->fe_device = (fe->fe_device & 0xffff) | (nr << 16);
+}
+static inline void set_fe_device_stripenr(struct fiemap_extent *fe, int devno,
+					  int nr)
+{
+	fe->fe_device = (nr << 16) | (devno & 0xffff);
+}
+
 static inline __kernel_size_t fiemap_count_to_size(__kernel_size_t extent_count)
 {
 	return sizeof(struct fiemap) + extent_count *
@@ -64,8 +90,6 @@ static inline unsigned int fiemap_size_to_count(__kernel_size_t array_size)
 #undef FIEMAP_FLAGS_COMPAT
 #endif
 
-/* Lustre specific flags - use a high bit, don't conflict with upstream flag */
-#define FIEMAP_EXTENT_NO_DIRECT	 0x40000000 /* Data mapping undefined */
 #define FIEMAP_EXTENT_NET	 0x80000000 /* Data stored remotely.
 					     * Sets NO_DIRECT flag
 					     */
