static int lsm_unpackmd_v3(struct lov_obd *lov, struct lov_stripe_md *lsm,
struct lov_mds_md *lmmv1)
{
struct lov_mds_md_v3 *lmm;
struct lov_oinfo *loi;
int i;
int stripe_count;
__u64 stripe_maxbytes = OBD_OBJECT_EOF;
int cplen = 0;
lmm = (struct lov_mds_md_v3 *)lmmv1;
lsm_unpackmd_common(lsm, (struct lov_mds_md_v1 *)lmm);
stripe_count = lsm_is_released(lsm) ? 0 : lsm->lsm_stripe_count;
cplen = strlcpy(lsm->lsm_pool_name, lmm->lmm_pool_name,
sizeof(lsm->lsm_pool_name));
if (cplen >= sizeof(lsm->lsm_pool_name))
return -E2BIG;
for (i = 0; i < stripe_count; i++) {
/* XXX LOV STACKING call down to osc_unpackmd() */
loi = lsm->lsm_oinfo[i];
ostid_le_to_cpu(&lmm->lmm_objects[i].l_ost_oi, &loi->loi_oi);
loi->loi_ost_idx = le32_to_cpu(lmm->lmm_objects[i].l_ost_idx);
loi->loi_ost_gen = le32_to_cpu(lmm->lmm_objects[i].l_ost_gen);
if (lov_oinfo_is_dummy(loi))
continue;
if (loi->loi_ost_idx >= lov->desc.ld_tgt_count) {
CERROR("OST index %d more than OST count %d\n",
loi->loi_ost_idx, lov->desc.ld_tgt_count);
lov_dump_lmm_v3(D_WARNING, lmm);
return -EINVAL;
}
if (!lov->lov_tgts[loi->loi_ost_idx]) {
CERROR("OST index %d missing\n", loi->loi_ost_idx);
lov_dump_lmm_v3(D_WARNING, lmm);
return -EINVAL;
}
/* calculate the minimum stripe max bytes */
lov_tgt_maxbytes(lov->lov_tgts[loi->loi_ost_idx],
&stripe_maxbytes);
}
lsm->lsm_maxbytes = stripe_maxbytes * lsm->lsm_stripe_count;
if (lsm->lsm_stripe_count == 0)
lsm->lsm_maxbytes = stripe_maxbytes * lov->desc.ld_tgt_count;
return 0;
}
/**
* Non-zero fe_logical indicates that this is a continuation FIEMAP
* call. The local end offset and the device are sent in the first
* fm_extent. This function calculates the stripe number from the index.
* This function returns a stripe_no on which mapping is to be restarted.
*
* This function returns fm_end_offset which is the in-OST offset at which
* mapping should be restarted. If fm_end_offset=0 is returned then caller
* will re-calculate proper offset in next stripe.
* Note that the first extent is passed to lov_get_info via the value field.
*
* \param fiemap [in] fiemap request header
* \param lsm [in] striping information for the file
* \param fm_start [in] logical start of mapping
* \param fm_end [in] logical end of mapping
* \param start_stripe [out] starting stripe will be returned in this
*/
static loff_t fiemap_calc_fm_end_offset(struct fiemap *fiemap,
struct lov_stripe_md *lsm,
loff_t fm_start, loff_t fm_end,
int *start_stripe)
{
loff_t local_end = fiemap->fm_extents[0].fe_logical;
loff_t lun_start;
loff_t lun_end;
loff_t 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 < lsm->lsm_stripe_count; i++) {
struct lov_oinfo *oinfo = lsm->lsm_oinfo[i];
if (lov_oinfo_is_dummy(oinfo))
continue;
if (oinfo->loi_ost_idx == fiemap->fm_extents[0].fe_device) {
stripe_no = i;
break;
}
}
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, stripe_no, fm_start, fm_end,
&lun_start, &lun_end) != 0 &&
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. */
fm_end_offset = 0;
*start_stripe = (stripe_no + 1) % lsm->lsm_stripe_count;
}
return fm_end_offset;
}
int lov_read_and_clear_async_rc(struct cl_object *clob)
{
struct lu_object *luobj;
int rc = 0;
ENTRY;
luobj = lu_object_locate(&cl_object_header(clob)->coh_lu,
&lov_device_type);
if (luobj != NULL) {
struct lov_object *lov = lu2lov(luobj);
lov_conf_freeze(lov);
switch (lov->lo_type) {
case LLT_RAID0: {
struct lov_stripe_md *lsm;
int i;
lsm = lov->lo_lsm;
LASSERT(lsm != NULL);
for (i = 0; i < lsm->lsm_stripe_count; i++) {
struct lov_oinfo *loi = lsm->lsm_oinfo[i];
if (lov_oinfo_is_dummy(loi))
continue;
if (loi->loi_ar.ar_rc && !rc)
rc = loi->loi_ar.ar_rc;
loi->loi_ar.ar_rc = 0;
}
}
case LLT_RELEASED:
case LLT_EMPTY:
break;
default:
LBUG();
}
lov_conf_thaw(lov);
}
RETURN(rc);
}
static int lov_init_raid0(const struct lu_env *env,
struct lov_device *dev, struct lov_object *lov,
const struct cl_object_conf *conf,
union lov_layout_state *state)
{
int result;
int i;
struct cl_object *stripe;
struct lov_thread_info *lti = lov_env_info(env);
struct cl_object_conf *subconf = <i->lti_stripe_conf;
struct lov_stripe_md *lsm = conf->u.coc_md->lsm;
struct lu_fid *ofid = <i->lti_fid;
struct lov_layout_raid0 *r0 = &state->raid0;
if (lsm->lsm_magic != LOV_MAGIC_V1 && lsm->lsm_magic != LOV_MAGIC_V3) {
dump_lsm(D_ERROR, lsm);
LASSERTF(0, "magic mismatch, expected %d/%d, actual %d.\n",
LOV_MAGIC_V1, LOV_MAGIC_V3, lsm->lsm_magic);
}
LASSERT(!lov->lo_lsm);
lov->lo_lsm = lsm_addref(lsm);
r0->lo_nr = lsm->lsm_stripe_count;
LASSERT(r0->lo_nr <= lov_targets_nr(dev));
r0->lo_sub = libcfs_kvzalloc(r0->lo_nr * sizeof(r0->lo_sub[0]),
GFP_NOFS);
if (r0->lo_sub) {
int psz = 0;
result = 0;
subconf->coc_inode = conf->coc_inode;
spin_lock_init(&r0->lo_sub_lock);
/*
* Create stripe cl_objects.
*/
for (i = 0; i < r0->lo_nr && result == 0; ++i) {
struct cl_device *subdev;
struct lov_oinfo *oinfo = lsm->lsm_oinfo[i];
int ost_idx = oinfo->loi_ost_idx;
if (lov_oinfo_is_dummy(oinfo))
continue;
result = ostid_to_fid(ofid, &oinfo->loi_oi,
oinfo->loi_ost_idx);
if (result != 0)
goto out;
subdev = lovsub2cl_dev(dev->ld_target[ost_idx]);
subconf->u.coc_oinfo = oinfo;
LASSERTF(subdev, "not init ost %d\n", ost_idx);
/* In the function below, .hs_keycmp resolves to
* lu_obj_hop_keycmp()
*/
/* coverity[overrun-buffer-val] */
stripe = lov_sub_find(env, subdev, ofid, subconf);
if (!IS_ERR(stripe)) {
result = lov_init_sub(env, lov, stripe, r0, i);
if (result == -EAGAIN) { /* try again */
--i;
result = 0;
continue;
}
} else {
result = PTR_ERR(stripe);
}
if (result == 0) {
int sz = lov_page_slice_fixup(lov, stripe);
LASSERT(ergo(psz > 0, psz == sz));
psz = sz;
}
}
if (result == 0)
cl_object_header(&lov->lo_cl)->coh_page_bufsize += psz;
} else {
result = -ENOMEM;
}
out:
return result;
}
/**
* Break down the FIEMAP request and send appropriate calls to individual OSTs.
* This also handles the restarting of FIEMAP calls in case mapping overflows
* the available number of extents in single call.
*
* \param env [in] lustre environment
* \param obj [in] file object
* \param fmkey [in] fiemap request header and other info
* \param fiemap [out] fiemap buffer holding retrived map extents
* \param buflen [in/out] max buffer length of @fiemap, when iterate
* each OST, it is used to limit max map needed
* \retval 0 success
* \retval < 0 error
*/
static int lov_object_fiemap(const struct lu_env *env, struct cl_object *obj,
struct ll_fiemap_info_key *fmkey,
struct fiemap *fiemap, size_t *buflen)
{
struct lov_stripe_md *lsm;
struct cl_object *subobj = NULL;
struct lov_obd *lov = lu2lov_dev(obj->co_lu.lo_dev)->ld_lov;
struct fiemap *fm_local = NULL;
struct fiemap_extent *lcl_fm_ext;
loff_t fm_start;
loff_t fm_end;
loff_t fm_length;
loff_t fm_end_offset;
int count_local;
int ost_index = 0;
int start_stripe;
int current_extent = 0;
int rc = 0;
int last_stripe;
int cur_stripe = 0;
int cur_stripe_wrap = 0;
int stripe_count;
unsigned int buffer_size = FIEMAP_BUFFER_SIZE;
/* Whether have we collected enough extents */
bool enough = false;
/* EOF for object */
bool ost_eof = false;
/* done with required mapping for this OST? */
bool ost_done = false;
ENTRY;
lsm = lov_lsm_addref(cl2lov(obj));
if (lsm == NULL)
RETURN(-ENODATA);
/**
* If the stripe_count > 1 and the application does not understand
* DEVICE_ORDER flag, it cannot interpret the extents correctly.
*/
if (lsm->lsm_stripe_count > 1 && !(fiemap->fm_flags &
FIEMAP_FLAG_DEVICE_ORDER))
GOTO(out_lsm, rc = -ENOTSUPP);
if (lsm_is_released(lsm)) {
if (fiemap->fm_start < fmkey->lfik_oa.o_size) {
/**
* released file, return a minimal FIEMAP if
* request fits in file-size.
*/
fiemap->fm_mapped_extents = 1;
fiemap->fm_extents[0].fe_logical = fiemap->fm_start;
if (fiemap->fm_start + fiemap->fm_length <
fmkey->lfik_oa.o_size)
fiemap->fm_extents[0].fe_length =
fiemap->fm_length;
else
fiemap->fm_extents[0].fe_length =
fmkey->lfik_oa.o_size -
fiemap->fm_start;
fiemap->fm_extents[0].fe_flags |=
FIEMAP_EXTENT_UNKNOWN | FIEMAP_EXTENT_LAST;
}
GOTO(out_lsm, rc = 0);
}
if (fiemap_count_to_size(fiemap->fm_extent_count) < buffer_size)
buffer_size = fiemap_count_to_size(fiemap->fm_extent_count);
OBD_ALLOC_LARGE(fm_local, buffer_size);
if (fm_local == NULL)
GOTO(out_lsm, rc = -ENOMEM);
lcl_fm_ext = &fm_local->fm_extents[0];
count_local = fiemap_size_to_count(buffer_size);
fm_start = fiemap->fm_start;
fm_length = fiemap->fm_length;
/* Calculate start stripe, last stripe and length of mapping */
start_stripe = lov_stripe_number(lsm, fm_start);
fm_end = (fm_length == ~0ULL) ? fmkey->lfik_oa.o_size :
fm_start + fm_length - 1;
/* If fm_length != ~0ULL but fm_start_fm_length-1 exceeds file size */
if (fm_end > fmkey->lfik_oa.o_size)
fm_end = fmkey->lfik_oa.o_size;
last_stripe = fiemap_calc_last_stripe(lsm, fm_start, fm_end,
start_stripe, &stripe_count);
fm_end_offset = fiemap_calc_fm_end_offset(fiemap, lsm, fm_start, fm_end,
&start_stripe);
if (fm_end_offset == -EINVAL)
GOTO(out_fm_local, rc = -EINVAL);
/**
* Requested extent count exceeds the fiemap buffer size, shrink our
* ambition.
*/
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)
count_local = 0;
/* Check each stripe */
for (cur_stripe = start_stripe; stripe_count > 0;
--stripe_count,
cur_stripe = (cur_stripe + 1) % lsm->lsm_stripe_count) {
loff_t req_fm_len; /* Stores length of required mapping */
loff_t len_mapped_single_call;
loff_t lun_start;
loff_t lun_end;
loff_t obd_object_end;
unsigned int ext_count;
cur_stripe_wrap = cur_stripe;
/* Find out range of mapping on this stripe */
if ((lov_stripe_intersects(lsm, cur_stripe, fm_start, fm_end,
&lun_start, &obd_object_end)) == 0)
continue;
if (lov_oinfo_is_dummy(lsm->lsm_oinfo[cur_stripe]))
GOTO(out_fm_local, rc = -EIO);
/* If this is a continuation FIEMAP call and we are on
* starting stripe then lun_start needs to be set to
* fm_end_offset */
if (fm_end_offset != 0 && cur_stripe == start_stripe)
lun_start = fm_end_offset;
if (fm_length != ~0ULL) {
/* Handle fm_start + fm_length overflow */
if (fm_start + fm_length < fm_start)
fm_length = ~0ULL - fm_start;
lun_end = lov_size_to_stripe(lsm, fm_start + fm_length,
cur_stripe);
} else {
lun_end = ~0ULL;
}
if (lun_start == lun_end)
continue;
req_fm_len = obd_object_end - lun_start;
fm_local->fm_length = 0;
len_mapped_single_call = 0;
/* find lobsub object */
subobj = lov_find_subobj(env, cl2lov(obj), lsm,
cur_stripe);
if (IS_ERR(subobj))
GOTO(out_fm_local, rc = PTR_ERR(subobj));
/* If the output buffer is very large and the objects have many
* extents we may need to loop on a single OST repeatedly */
ost_eof = false;
ost_done = false;
do {
if (fiemap->fm_extent_count > 0) {
/* Don't get too many extents. */
if (current_extent + count_local >
fiemap->fm_extent_count)
count_local = fiemap->fm_extent_count -
current_extent;
}
lun_start += len_mapped_single_call;
fm_local->fm_length = req_fm_len -
len_mapped_single_call;
req_fm_len = fm_local->fm_length;
fm_local->fm_extent_count = enough ? 1 : count_local;
fm_local->fm_mapped_extents = 0;
fm_local->fm_flags = fiemap->fm_flags;
ost_index = lsm->lsm_oinfo[cur_stripe]->loi_ost_idx;
if (ost_index < 0 ||
ost_index >= lov->desc.ld_tgt_count)
GOTO(obj_put, rc = -EINVAL);
/* If OST is inactive, return extent with UNKNOWN
* flag. */
if (!lov->lov_tgts[ost_index]->ltd_active) {
fm_local->fm_flags |= FIEMAP_EXTENT_LAST;
fm_local->fm_mapped_extents = 1;
lcl_fm_ext[0].fe_logical = lun_start;
lcl_fm_ext[0].fe_length = obd_object_end -
lun_start;
lcl_fm_ext[0].fe_flags |= FIEMAP_EXTENT_UNKNOWN;
goto inactive_tgt;
}
fm_local->fm_start = lun_start;
fm_local->fm_flags &= ~FIEMAP_FLAG_DEVICE_ORDER;
memcpy(&fmkey->lfik_fiemap, fm_local,
sizeof(*fm_local));
*buflen = fiemap_count_to_size(
fm_local->fm_extent_count);
rc = cl_object_fiemap(env, subobj, fmkey, fm_local,
buflen);
if (rc != 0)
GOTO(obj_put, rc);
inactive_tgt:
ext_count = fm_local->fm_mapped_extents;
if (ext_count == 0) {
ost_done = true;
/* If last stripe has hold at the end,
* we need to return */
if (cur_stripe_wrap == last_stripe) {
fiemap->fm_mapped_extents = 0;
goto finish;
}
break;
} else if (enough) {
/*
* We've collected enough extents and there are
* more extents after it.
*/
goto finish;
}
/* If we just need num of extents, got to next device */
if (fiemap->fm_extent_count == 0) {
current_extent += ext_count;
break;
}
/* prepare to copy retrived map extents */
len_mapped_single_call =
lcl_fm_ext[ext_count - 1].fe_logical -
lun_start + lcl_fm_ext[ext_count - 1].fe_length;
/* Have we finished mapping on this device? */
if (req_fm_len <= len_mapped_single_call)
ost_done = true;
/* Clear the EXTENT_LAST flag which can be present on
* the last extent */
if (lcl_fm_ext[ext_count - 1].fe_flags &
FIEMAP_EXTENT_LAST)
lcl_fm_ext[ext_count - 1].fe_flags &=
~FIEMAP_EXTENT_LAST;
if (lov_stripe_size(lsm,
lcl_fm_ext[ext_count - 1].fe_logical +
lcl_fm_ext[ext_count - 1].fe_length,
cur_stripe) >= fmkey->lfik_oa.o_size)
ost_eof = true;
fiemap_prepare_and_copy_exts(fiemap, lcl_fm_ext,
ost_index, ext_count,
current_extent);
current_extent += ext_count;
/* Ran out of available extents? */
if (current_extent >= fiemap->fm_extent_count)
enough = true;
} while (!ost_done && !ost_eof);
cl_object_put(env, subobj);
subobj = NULL;
if (cur_stripe_wrap == last_stripe)
goto finish;
} /* for each stripe */
finish:
/* Indicate that we are returning device offsets unless file just has
* single stripe */
if (lsm->lsm_stripe_count > 1)
fiemap->fm_flags |= FIEMAP_FLAG_DEVICE_ORDER;
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_wrap == last_stripe) && (ost_done || ost_eof))
fiemap->fm_extents[current_extent - 1].fe_flags |=
FIEMAP_EXTENT_LAST;
skip_last_device_calc:
fiemap->fm_mapped_extents = current_extent;
obj_put:
if (subobj != NULL)
cl_object_put(env, subobj);
out_fm_local:
OBD_FREE_LARGE(fm_local, buffer_size);
out_lsm:
lov_lsm_put(lsm);
return rc;
}
static int lsm_unpackmd_common(struct lov_obd *lov,
struct lov_stripe_md *lsm,
struct lov_mds_md *lmm,
struct lov_ost_data_v1 *objects)
{
struct lov_oinfo *loi;
loff_t stripe_maxbytes = LLONG_MAX;
unsigned int stripe_count;
unsigned int i;
/*
* This supposes lov_mds_md_v1/v3 first fields are
* are the same
*/
lmm_oi_le_to_cpu(&lsm->lsm_oi, &lmm->lmm_oi);
lsm->lsm_stripe_size = le32_to_cpu(lmm->lmm_stripe_size);
lsm->lsm_pattern = le32_to_cpu(lmm->lmm_pattern);
lsm->lsm_layout_gen = le16_to_cpu(lmm->lmm_layout_gen);
lsm->lsm_pool_name[0] = '\0';
stripe_count = lsm_is_released(lsm) ? 0 : lsm->lsm_stripe_count;
for (i = 0; i < stripe_count; i++) {
loi = lsm->lsm_oinfo[i];
ostid_le_to_cpu(&objects[i].l_ost_oi, &loi->loi_oi);
loi->loi_ost_idx = le32_to_cpu(objects[i].l_ost_idx);
loi->loi_ost_gen = le32_to_cpu(objects[i].l_ost_gen);
if (lov_oinfo_is_dummy(loi))
continue;
if (loi->loi_ost_idx >= lov->desc.ld_tgt_count &&
!lov2obd(lov)->obd_process_conf) {
CERROR("%s: OST index %d more than OST count %d\n",
(char*)lov->desc.ld_uuid.uuid,
loi->loi_ost_idx, lov->desc.ld_tgt_count);
lov_dump_lmm_v1(D_WARNING, lmm);
return -EINVAL;
}
if (lov->lov_tgts[loi->loi_ost_idx] == NULL) {
CERROR("%s: OST index %d missing\n",
(char*)lov->desc.ld_uuid.uuid, loi->loi_ost_idx);
lov_dump_lmm_v1(D_WARNING, lmm);
continue;
}
stripe_maxbytes = min_t(loff_t, stripe_maxbytes,
lov_tgt_maxbytes(
lov->lov_tgts[loi->loi_ost_idx]));
}
if (stripe_maxbytes == LLONG_MAX)
stripe_maxbytes = LUSTRE_EXT3_STRIPE_MAXBYTES;
if (lsm->lsm_stripe_count == 0)
lsm->lsm_maxbytes = stripe_maxbytes * lov->desc.ld_tgt_count;
else
lsm->lsm_maxbytes = stripe_maxbytes * lsm->lsm_stripe_count;
return 0;
}