/**
* Return lov_layout_type associated with a given lsm
*/
enum lov_layout_type lov_type(struct lov_stripe_md *lsm)
{
if (lsm == NULL)
return LLT_EMPTY;
if (lsm_is_released(lsm))
return LLT_RELEASED;
return LLT_RAID0;
}
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;
}
static int lov_init_released(const struct lu_env *env,
struct lov_device *dev, struct lov_object *lov,
struct lov_stripe_md *lsm,
const struct cl_object_conf *conf,
union lov_layout_state *state)
{
LASSERT(lsm != NULL);
LASSERT(lsm_is_released(lsm));
LASSERT(lov->lo_lsm == NULL);
lov->lo_lsm = lsm_addref(lsm);
return 0;
}
/* Pack LOV object metadata for disk storage. It is packed in LE byte
* order and is opaque to the networking layer.
*
* XXX In the future, this will be enhanced to get the EA size from the
* underlying OSC device(s) to get their EA sizes so we can stack
* LOVs properly. For now lov_mds_md_size() just assumes one obd_id
* per stripe.
*/
int lov_packmd(struct obd_export *exp, struct lov_mds_md **lmmp,
struct lov_stripe_md *lsm)
{
struct obd_device *obd = class_exp2obd(exp);
struct lov_obd *lov = &obd->u.lov;
struct lov_mds_md_v1 *lmmv1;
struct lov_mds_md_v3 *lmmv3;
__u16 stripe_count;
struct lov_ost_data_v1 *lmm_objects;
int lmm_size, lmm_magic;
int i;
int cplen = 0;
if (lsm) {
lmm_magic = lsm->lsm_magic;
} else {
if (lmmp && *lmmp)
lmm_magic = le32_to_cpu((*lmmp)->lmm_magic);
else
/* lsm == NULL and lmmp == NULL */
lmm_magic = LOV_MAGIC;
}
if ((lmm_magic != LOV_MAGIC_V1) &&
(lmm_magic != LOV_MAGIC_V3)) {
CERROR("bad mem LOV MAGIC: 0x%08X != 0x%08X nor 0x%08X\n",
lmm_magic, LOV_MAGIC_V1, LOV_MAGIC_V3);
return -EINVAL;
}
if (lsm) {
/* If we are just sizing the EA, limit the stripe count
* to the actual number of OSTs in this filesystem. */
if (!lmmp) {
stripe_count = lov_get_stripecnt(lov, lmm_magic,
lsm->lsm_stripe_count);
lsm->lsm_stripe_count = stripe_count;
} else if (!lsm_is_released(lsm)) {
stripe_count = lsm->lsm_stripe_count;
} else {
stripe_count = 0;
}
} else {
/* No need to allocate more than maximum supported stripes.
* Anyway, this is pretty inaccurate since ld_tgt_count now
* represents max index and we should rely on the actual number
* of OSTs instead */
stripe_count = lov_mds_md_max_stripe_count(
lov->lov_ocd.ocd_max_easize, lmm_magic);
if (stripe_count > lov->desc.ld_tgt_count)
stripe_count = lov->desc.ld_tgt_count;
}
/* XXX LOV STACKING call into osc for sizes */
lmm_size = lov_mds_md_size(stripe_count, lmm_magic);
if (!lmmp)
return lmm_size;
if (*lmmp && !lsm) {
stripe_count = le16_to_cpu((*lmmp)->lmm_stripe_count);
lmm_size = lov_mds_md_size(stripe_count, lmm_magic);
OBD_FREE_LARGE(*lmmp, lmm_size);
*lmmp = NULL;
return 0;
}
if (!*lmmp) {
OBD_ALLOC_LARGE(*lmmp, lmm_size);
if (!*lmmp)
return -ENOMEM;
}
CDEBUG(D_INFO, "lov_packmd: LOV_MAGIC 0x%08X, lmm_size = %d \n",
lmm_magic, lmm_size);
lmmv1 = *lmmp;
lmmv3 = (struct lov_mds_md_v3 *)*lmmp;
if (lmm_magic == LOV_MAGIC_V3)
lmmv3->lmm_magic = cpu_to_le32(LOV_MAGIC_V3);
else
lmmv1->lmm_magic = cpu_to_le32(LOV_MAGIC_V1);
if (!lsm)
return lmm_size;
/* lmmv1 and lmmv3 point to the same struct and have the
* same first fields
*/
lmm_oi_cpu_to_le(&lmmv1->lmm_oi, &lsm->lsm_oi);
lmmv1->lmm_stripe_size = cpu_to_le32(lsm->lsm_stripe_size);
lmmv1->lmm_stripe_count = cpu_to_le16(stripe_count);
lmmv1->lmm_pattern = cpu_to_le32(lsm->lsm_pattern);
lmmv1->lmm_layout_gen = cpu_to_le16(lsm->lsm_layout_gen);
if (lsm->lsm_magic == LOV_MAGIC_V3) {
cplen = strlcpy(lmmv3->lmm_pool_name, lsm->lsm_pool_name,
sizeof(lmmv3->lmm_pool_name));
if (cplen >= sizeof(lmmv3->lmm_pool_name))
return -E2BIG;
lmm_objects = lmmv3->lmm_objects;
} else {
lmm_objects = lmmv1->lmm_objects;
}
for (i = 0; i < stripe_count; i++) {
struct lov_oinfo *loi = lsm->lsm_oinfo[i];
/* XXX LOV STACKING call down to osc_packmd() to do packing */
LASSERTF(ostid_id(&loi->loi_oi) != 0, "lmm_oi "DOSTID
" stripe %u/%u idx %u\n", POSTID(&lmmv1->lmm_oi),
i, stripe_count, loi->loi_ost_idx);
ostid_cpu_to_le(&loi->loi_oi, &lmm_objects[i].l_ost_oi);
lmm_objects[i].l_ost_gen = cpu_to_le32(loi->loi_ost_gen);
lmm_objects[i].l_ost_idx = cpu_to_le32(loi->loi_ost_idx);
}
return lmm_size;
}
/* Retrieve object striping information.
*
* @lump is a pointer to an in-core struct with lmm_ost_count indicating
* the maximum number of OST indices which will fit in the user buffer.
* lmm_magic must be LOV_USER_MAGIC.
*/
int lov_getstripe(struct lov_object *obj, struct lov_stripe_md *lsm,
struct lov_user_md __user *lump)
{
/* we use lov_user_md_v3 because it is larger than lov_user_md_v1 */
struct lov_user_md_v3 lum;
struct lov_mds_md *lmmk;
u32 stripe_count;
ssize_t lmm_size;
size_t lmmk_size;
size_t lum_size;
int rc;
if (!lsm)
return -ENODATA;
if (lsm->lsm_magic != LOV_MAGIC_V1 && lsm->lsm_magic != LOV_MAGIC_V3) {
CERROR("bad LSM MAGIC: 0x%08X != 0x%08X nor 0x%08X\n",
lsm->lsm_magic, LOV_MAGIC_V1, LOV_MAGIC_V3);
rc = -EIO;
goto out;
}
if (!lsm_is_released(lsm))
stripe_count = lsm->lsm_stripe_count;
else
stripe_count = 0;
/* we only need the header part from user space to get lmm_magic and
* lmm_stripe_count, (the header part is common to v1 and v3)
*/
lum_size = sizeof(struct lov_user_md_v1);
if (copy_from_user(&lum, lump, lum_size)) {
rc = -EFAULT;
goto out;
}
if (lum.lmm_magic != LOV_USER_MAGIC_V1 &&
lum.lmm_magic != LOV_USER_MAGIC_V3 &&
lum.lmm_magic != LOV_USER_MAGIC_SPECIFIC) {
rc = -EINVAL;
goto out;
}
if (lum.lmm_stripe_count &&
(lum.lmm_stripe_count < lsm->lsm_stripe_count)) {
/* Return right size of stripe to user */
lum.lmm_stripe_count = stripe_count;
rc = copy_to_user(lump, &lum, lum_size);
rc = -EOVERFLOW;
goto out;
}
lmmk_size = lov_mds_md_size(stripe_count, lsm->lsm_magic);
lmmk = kvzalloc(lmmk_size, GFP_NOFS);
if (!lmmk) {
rc = -ENOMEM;
goto out;
}
lmm_size = lov_lsm_pack(lsm, lmmk, lmmk_size);
if (lmm_size < 0) {
rc = lmm_size;
goto out_free;
}
/* FIXME: Bug 1185 - copy fields properly when structs change */
/* struct lov_user_md_v3 and struct lov_mds_md_v3 must be the same */
BUILD_BUG_ON(sizeof(lum) != sizeof(struct lov_mds_md_v3));
BUILD_BUG_ON(sizeof(lum.lmm_objects[0]) != sizeof(lmmk->lmm_objects[0]));
if (cpu_to_le32(LOV_MAGIC) != LOV_MAGIC &&
(lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V1) ||
lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V3))) {
lustre_swab_lov_mds_md(lmmk);
lustre_swab_lov_user_md_objects(
(struct lov_user_ost_data *)lmmk->lmm_objects,
lmmk->lmm_stripe_count);
}
if (lum.lmm_magic == LOV_USER_MAGIC) {
/* User request for v1, we need skip lmm_pool_name */
if (lmmk->lmm_magic == LOV_MAGIC_V3) {
memmove(((struct lov_mds_md_v1 *)lmmk)->lmm_objects,
((struct lov_mds_md_v3 *)lmmk)->lmm_objects,
lmmk->lmm_stripe_count *
sizeof(struct lov_ost_data_v1));
lmm_size -= LOV_MAXPOOLNAME;
}
} else {
/* if v3 we just have to update the lum_size */
lum_size = sizeof(struct lov_user_md_v3);
}
/* User wasn't expecting this many OST entries */
if (lum.lmm_stripe_count == 0) {
lmm_size = lum_size;
} else if (lum.lmm_stripe_count < lmmk->lmm_stripe_count) {
rc = -EOVERFLOW;
goto out_free;
}
/*
* Have a difference between lov_mds_md & lov_user_md.
* So we have to re-order the data before copy to user.
*/
lum.lmm_stripe_count = lmmk->lmm_stripe_count;
lum.lmm_layout_gen = lmmk->lmm_layout_gen;
((struct lov_user_md *)lmmk)->lmm_layout_gen = lum.lmm_layout_gen;
((struct lov_user_md *)lmmk)->lmm_stripe_count = lum.lmm_stripe_count;
if (copy_to_user(lump, lmmk, lmm_size))
rc = -EFAULT;
else
rc = 0;
out_free:
kvfree(lmmk);
out:
return rc;
}
/**
* 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;
}
/* Pack LOV object metadata for disk storage. It is packed in LE byte
* order and is opaque to the networking layer.
*
* XXX In the future, this will be enhanced to get the EA size from the
* underlying OSC device(s) to get their EA sizes so we can stack
* LOVs properly. For now lov_mds_md_size() just assumes one u64
* per stripe.
*/
int lov_obd_packmd(struct lov_obd *lov, struct lov_mds_md **lmmp,
struct lov_stripe_md *lsm)
{
struct lov_mds_md_v1 *lmmv1;
struct lov_mds_md_v3 *lmmv3;
__u16 stripe_count;
struct lov_ost_data_v1 *lmm_objects;
int lmm_size, lmm_magic;
int i;
int cplen = 0;
if (lsm) {
lmm_magic = lsm->lsm_magic;
} else {
if (lmmp && *lmmp)
lmm_magic = le32_to_cpu((*lmmp)->lmm_magic);
else
/* lsm == NULL and lmmp == NULL */
lmm_magic = LOV_MAGIC;
}
if ((lmm_magic != LOV_MAGIC_V1) &&
(lmm_magic != LOV_MAGIC_V3)) {
CERROR("bad mem LOV MAGIC: 0x%08X != 0x%08X nor 0x%08X\n",
lmm_magic, LOV_MAGIC_V1, LOV_MAGIC_V3);
return -EINVAL;
}
if (lsm) {
/* If we are just sizing the EA, limit the stripe count
* to the actual number of OSTs in this filesystem.
*/
if (!lmmp) {
stripe_count = lov_get_stripecnt(lov, lmm_magic,
lsm->lsm_stripe_count);
lsm->lsm_stripe_count = stripe_count;
} else if (!lsm_is_released(lsm)) {
stripe_count = lsm->lsm_stripe_count;
} else {
stripe_count = 0;
}
} else {
/*
* To calculate maximum easize by active targets at present,
* which is exactly the maximum easize to be seen by LOV
*/
stripe_count = lov->desc.ld_active_tgt_count;
}
/* XXX LOV STACKING call into osc for sizes */
lmm_size = lov_mds_md_size(stripe_count, lmm_magic);
if (!lmmp)
return lmm_size;
if (*lmmp && !lsm) {
stripe_count = le16_to_cpu((*lmmp)->lmm_stripe_count);
lmm_size = lov_mds_md_size(stripe_count, lmm_magic);
kvfree(*lmmp);
*lmmp = NULL;
return 0;
}
if (!*lmmp) {
*lmmp = libcfs_kvzalloc(lmm_size, GFP_NOFS);
if (!*lmmp)
return -ENOMEM;
}
CDEBUG(D_INFO, "lov_packmd: LOV_MAGIC 0x%08X, lmm_size = %d\n",
lmm_magic, lmm_size);
lmmv1 = *lmmp;
lmmv3 = (struct lov_mds_md_v3 *)*lmmp;
if (lmm_magic == LOV_MAGIC_V3)
lmmv3->lmm_magic = cpu_to_le32(LOV_MAGIC_V3);
else
lmmv1->lmm_magic = cpu_to_le32(LOV_MAGIC_V1);
if (!lsm)
return lmm_size;
/* lmmv1 and lmmv3 point to the same struct and have the
* same first fields
*/
lmm_oi_cpu_to_le(&lmmv1->lmm_oi, &lsm->lsm_oi);
lmmv1->lmm_stripe_size = cpu_to_le32(lsm->lsm_stripe_size);
lmmv1->lmm_stripe_count = cpu_to_le16(stripe_count);
lmmv1->lmm_pattern = cpu_to_le32(lsm->lsm_pattern);
lmmv1->lmm_layout_gen = cpu_to_le16(lsm->lsm_layout_gen);
if (lsm->lsm_magic == LOV_MAGIC_V3) {
cplen = strlcpy(lmmv3->lmm_pool_name, lsm->lsm_pool_name,
sizeof(lmmv3->lmm_pool_name));
if (cplen >= sizeof(lmmv3->lmm_pool_name))
return -E2BIG;
lmm_objects = lmmv3->lmm_objects;
} else {
lmm_objects = lmmv1->lmm_objects;
}
for (i = 0; i < stripe_count; i++) {
struct lov_oinfo *loi = lsm->lsm_oinfo[i];
/* XXX LOV STACKING call down to osc_packmd() to do packing */
LASSERTF(ostid_id(&loi->loi_oi) != 0, "lmm_oi "DOSTID
" stripe %u/%u idx %u\n", POSTID(&lmmv1->lmm_oi),
i, stripe_count, loi->loi_ost_idx);
ostid_cpu_to_le(&loi->loi_oi, &lmm_objects[i].l_ost_oi);
lmm_objects[i].l_ost_gen = cpu_to_le32(loi->loi_ost_gen);
lmm_objects[i].l_ost_idx = cpu_to_le32(loi->loi_ost_idx);
}
return lmm_size;
}
