From 5ccd7a4a556b1a847eb5bff8b2395522a6f4bca8 Mon Sep 17 00:00:00 2001 From: "John L. Hammond" Date: Sat, 6 Jun 2015 01:03:56 +0800 Subject: [PATCH] LU-5814 lov: remove LSM from struct lustre_md In struct lustre_md replace the stuct lov_stripe_md *lsm member with an opaque struct lu_buf layout which holds the layout metadata returned by the server. Refactor the LOV object initialization and layout change code to accommodate this. Simplify lov_unpackmd() and supporting functions according to the reduced number of use cases. Signed-off-by: John L. Hammond Change-Id: Iac44ba479556693932bae0b9878565155b609e07 Signed-off-by: Jinshan Xiong Reviewed-on: http://review.whamcloud.com/13722 Tested-by: Jenkins Reviewed-by: James Simmons Tested-by: Maloo Reviewed-by: Oleg Drokin --- lustre/include/cl_object.h | 12 ++-- lustre/include/obd.h | 2 +- lustre/llite/file.c | 28 ++------ lustre/llite/lcommon_cl.c | 12 ++-- lustre/llite/llite_lib.c | 10 +-- lustre/llite/namei.c | 7 +- lustre/lov/lov_ea.c | 14 ++-- lustre/lov/lov_internal.h | 15 +---- lustre/lov/lov_obd.c | 1 - lustre/lov/lov_object.c | 164 ++++++++++++++++++++++++++------------------- lustre/lov/lov_pack.c | 110 ++++++++++++------------------ lustre/mdc/mdc_request.c | 19 ++---- 12 files changed, 178 insertions(+), 216 deletions(-) diff --git a/lustre/include/cl_object.h b/lustre/include/cl_object.h index 24d8314..2d5b5ee 100644 --- a/lustre/include/cl_object.h +++ b/lustre/include/cl_object.h @@ -267,12 +267,12 @@ struct cl_object { */ struct cl_object_conf { /** Super-class. */ - struct lu_object_conf coc_lu; - union { - /** - * Object layout. This is consumed by lov. - */ - struct lustre_md *coc_md; + struct lu_object_conf coc_lu; + union { + /** + * Object layout. This is consumed by lov. + */ + struct lu_buf coc_layout; /** * Description of particular stripe location in the * cluster. This is consumed by osc. diff --git a/lustre/include/obd.h b/lustre/include/obd.h index f515f7a..156d47b 100644 --- a/lustre/include/obd.h +++ b/lustre/include/obd.h @@ -915,7 +915,7 @@ struct obd_ops { /* lmv structures */ struct lustre_md { struct mdt_body *body; - struct lov_stripe_md *lsm; + struct lu_buf layout; struct lmv_stripe_md *lmv; #ifdef CONFIG_FS_POSIX_ACL struct posix_acl *posix_acl; diff --git a/lustre/llite/file.c b/lustre/llite/file.c index a42533e..471ef97 100644 --- a/lustre/llite/file.c +++ b/lustre/llite/file.c @@ -3722,7 +3722,6 @@ static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode, struct ll_inode_info *lli = ll_i2info(inode); struct ll_sb_info *sbi = ll_i2sbi(inode); struct ldlm_lock *lock; - struct lustre_md md = { NULL }; struct cl_object_conf conf; int rc = 0; bool lvb_ready; @@ -3756,35 +3755,18 @@ static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode, /* for layout lock, lmm is stored in lock's lvb. * lvb_data is immutable if the lock is held so it's safe to access it - * without res lock. */ - if (lock->l_lvb_data != NULL) { - rc = obd_unpackmd(sbi->ll_dt_exp, &md.lsm, - lock->l_lvb_data, lock->l_lvb_len); - if (rc < 0) { - CERROR("%s: file "DFID" unpackmd error: %d\n", - ll_get_fsname(inode->i_sb, NULL, 0), - PFID(&lli->lli_fid), rc); - GOTO(out, rc); - } - - LASSERTF(md.lsm != NULL, "lvb_data = %p, lvb_len = %u\n", - lock->l_lvb_data, lock->l_lvb_len); - - rc = 0; - } - - /* set layout to file. Unlikely this will fail as old layout was + * without res lock. + * + * set layout to file. Unlikely this will fail as old layout was * surely eliminated */ memset(&conf, 0, sizeof conf); conf.coc_opc = OBJECT_CONF_SET; conf.coc_inode = inode; conf.coc_lock = lock; - conf.u.coc_md = &md; + conf.u.coc_layout.lb_buf = lock->l_lvb_data; + conf.u.coc_layout.lb_len = lock->l_lvb_len; rc = ll_layout_conf(inode, &conf); - if (md.lsm != NULL) - obd_free_memmd(sbi->ll_dt_exp, &md.lsm); - /* refresh layout failed, need to wait */ wait_layout = rc == -EBUSY; EXIT; diff --git a/lustre/llite/lcommon_cl.c b/lustre/llite/lcommon_cl.c index 9b5b0ed..251bb40 100644 --- a/lustre/llite/lcommon_cl.c +++ b/lustre/llite/lcommon_cl.c @@ -139,12 +139,12 @@ int cl_file_inode_init(struct inode *inode, struct lustre_md *md) struct cl_object *clob; struct lu_site *site; struct lu_fid *fid; - struct cl_object_conf conf = { - .coc_inode = inode, - .u = { - .coc_md = md - } - }; + struct cl_object_conf conf = { + .coc_inode = inode, + .u = { + .coc_layout = md->layout, + } + }; int result = 0; int refcheck; diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c index 61f41a6..4b5d6c3 100644 --- a/lustre/llite/llite_lib.c +++ b/lustre/llite/llite_lib.c @@ -539,8 +539,6 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt, ptlrpc_req_finished(request); if (IS_ERR(root)) { - if (lmd.lsm) - obd_free_memmd(sbi->ll_dt_exp, &lmd.lsm); #ifdef CONFIG_FS_POSIX_ACL if (lmd.posix_acl) { posix_acl_release(lmd.posix_acl); @@ -1844,11 +1842,9 @@ int ll_update_inode(struct inode *inode, struct lustre_md *md) { struct ll_inode_info *lli = ll_i2info(inode); struct mdt_body *body = md->body; - struct lov_stripe_md *lsm = md->lsm; struct ll_sb_info *sbi = ll_i2sbi(inode); - LASSERT((lsm != NULL) == ((body->mbo_valid & OBD_MD_FLEASIZE) != 0)); - if (lsm != NULL) + if (body->mbo_valid & OBD_MD_FLEASIZE) cl_file_inode_init(inode, md); if (S_ISDIR(inode->i_mode)) { @@ -2332,7 +2328,7 @@ int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req, conf.coc_opc = OBJECT_CONF_SET; conf.coc_inode = *inode; conf.coc_lock = lock; - conf.u.coc_md = &md; + conf.u.coc_layout = md.layout; (void)ll_layout_conf(*inode, &conf); } LDLM_LOCK_PUT(lock); @@ -2341,8 +2337,6 @@ int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req, GOTO(out, rc = 0); out: - if (md.lsm != NULL) - obd_free_memmd(sbi->ll_dt_exp, &md.lsm); md_free_lustre_md(sbi->ll_md_exp, &md); cleanup: diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index adcdf2c..aa6ce22 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -124,12 +124,9 @@ struct inode *ll_iget(struct super_block *sb, ino_t hash, if (inode->i_state & I_NEW) { rc = ll_read_inode2(inode, md); if (rc == 0 && S_ISREG(inode->i_mode) && - ll_i2info(inode)->lli_clob == NULL) { - CDEBUG(D_INODE, "%s: apply lsm %p to inode "DFID"\n", - ll_get_fsname(sb, NULL, 0), md->lsm, - PFID(ll_inode2fid(inode))); + ll_i2info(inode)->lli_clob == NULL) rc = cl_file_inode_init(inode, md); - } + if (rc != 0) { make_bad_inode(inode); unlock_new_inode(inode); diff --git a/lustre/lov/lov_ea.c b/lustre/lov/lov_ea.c index b98f924..f294d11 100644 --- a/lustre/lov/lov_ea.c +++ b/lustre/lov/lov_ea.c @@ -79,18 +79,20 @@ static int lsm_lmm_verify_common(struct lov_mds_md *lmm, int lmm_bytes, return 0; } -struct lov_stripe_md *lsm_alloc_plain(__u16 stripe_count, int *size) +struct lov_stripe_md *lsm_alloc_plain(u16 stripe_count) { struct lov_stripe_md *lsm; struct lov_oinfo *loi; - int i, oinfo_ptrs_size; + size_t lsm_size; + size_t oinfo_ptrs_size; + unsigned int i; LASSERT(stripe_count <= LOV_MAX_STRIPE_COUNT); oinfo_ptrs_size = sizeof(struct lov_oinfo *) * stripe_count; - *size = sizeof(struct lov_stripe_md) + oinfo_ptrs_size; + lsm_size = sizeof(*lsm) + oinfo_ptrs_size; - OBD_ALLOC_LARGE(lsm, *size); + OBD_ALLOC_LARGE(lsm, lsm_size); if (!lsm) return NULL; @@ -106,7 +108,9 @@ struct lov_stripe_md *lsm_alloc_plain(__u16 stripe_count, int *size) err: while (--i >= 0) OBD_SLAB_FREE(lsm->lsm_oinfo[i], lov_oinfo_slab, sizeof(*loi)); - OBD_FREE_LARGE(lsm, *size); + + OBD_FREE_LARGE(lsm, lsm_size); + return NULL; } diff --git a/lustre/lov/lov_internal.h b/lustre/lov/lov_internal.h index dbf72df..86bb50c 100644 --- a/lustre/lov/lov_internal.h +++ b/lustre/lov/lov_internal.h @@ -79,13 +79,6 @@ static inline bool lsm_has_objects(struct lov_stripe_md *lsm) return true; } -static inline int lov_stripe_md_size(unsigned int stripe_count) -{ - struct lov_stripe_md lsm; - - return sizeof(lsm) + stripe_count * sizeof(lsm.lsm_oinfo[0]); -} - struct lsm_operations { void (*lsm_free)(struct lov_stripe_md *); void (*lsm_stripe_by_index)(struct lov_stripe_md *, int *, loff_t *, @@ -251,10 +244,8 @@ int lov_del_target(struct obd_device *obd, __u32 index, /* lov_pack.c */ ssize_t lov_lsm_pack(const struct lov_stripe_md *lsm, void *buf, size_t buf_size); -int lov_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp, - struct lov_mds_md *lmm, int lmm_bytes); -int lov_alloc_memmd(struct lov_stripe_md **lsmp, __u16 stripe_count, - int pattern, int magic); +struct lov_stripe_md *lov_unpackmd(struct lov_obd *lov, struct lov_mds_md *lmm, + size_t lmm_size); int lov_free_memmd(struct lov_stripe_md **lsmp); void lov_dump_lmm_v1(int level, struct lov_mds_md_v1 *lmm); @@ -263,7 +254,7 @@ void lov_dump_lmm_common(int level, void *lmmp); void lov_dump_lmm(int level, void *lmm); /* lov_ea.c */ -struct lov_stripe_md *lsm_alloc_plain(__u16 stripe_count, int *size); +struct lov_stripe_md *lsm_alloc_plain(u16 stripe_count); void lsm_free_plain(struct lov_stripe_md *lsm); void dump_lsm(unsigned int level, const struct lov_stripe_md *lsm); diff --git a/lustre/lov/lov_obd.c b/lustre/lov/lov_obd.c index 7a654f0..73a5944 100644 --- a/lustre/lov/lov_obd.c +++ b/lustre/lov/lov_obd.c @@ -1469,7 +1469,6 @@ static struct obd_ops lov_obd_ops = { .o_disconnect = lov_disconnect, .o_statfs = lov_statfs, .o_statfs_async = lov_statfs_async, - .o_unpackmd = lov_unpackmd, .o_iocontrol = lov_iocontrol, .o_get_info = lov_get_info, .o_set_info_async = lov_set_info_async, diff --git a/lustre/lov/lov_object.c b/lustre/lov/lov_object.c index c51227b..d32ecd1 100644 --- a/lustre/lov/lov_object.c +++ b/lustre/lov/lov_object.c @@ -43,6 +43,11 @@ #include "lov_cl_internal.h" +static inline struct lov_device *lov_object_dev(struct lov_object *obj) +{ + return lu2lov_dev(obj->lo_cl.co_lu.lo_dev); +} + /** \addtogroup lov * @{ */ @@ -54,10 +59,10 @@ */ struct lov_layout_operations { - int (*llo_init)(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 (*llo_init)(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); int (*llo_delete)(const struct lu_env *env, struct lov_object *lov, union lov_layout_state *state); void (*llo_fini)(const struct lu_env *env, struct lov_object *lov, @@ -102,12 +107,12 @@ static void lov_install_empty(const struct lu_env *env, */ } -static int lov_init_empty(const struct lu_env *env, - struct lov_device *dev, struct lov_object *lov, - const struct cl_object_conf *conf, - union lov_layout_state *state) +static int lov_init_empty(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) { - return 0; + return 0; } static void lov_install_raid0(const struct lu_env *env, @@ -216,10 +221,10 @@ static int lov_page_slice_fixup(struct lov_object *lov, return cl_object_header(stripe)->coh_page_bufsize; } -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) +static int lov_init_raid0(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) { int result; int i; @@ -227,7 +232,6 @@ static int lov_init_raid0(const struct lu_env *env, 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; @@ -241,7 +245,7 @@ static int lov_init_raid0(const struct lu_env *env, LASSERT(lov->lo_lsm == NULL); lov->lo_lsm = lsm_addref(lsm); - r0->lo_nr = lsm->lsm_stripe_count; + r0->lo_nr = lsm->lsm_stripe_count; LASSERT(r0->lo_nr <= lov_targets_nr(dev)); lov->lo_layout_invalid = true; @@ -302,12 +306,11 @@ out: } static int lov_init_released(const struct lu_env *env, - struct lov_device *dev, struct lov_object *lov, - const struct cl_object_conf *conf, - union lov_layout_state *state) + struct lov_device *dev, struct lov_object *lov, + struct lov_stripe_md *lsm, + const struct cl_object_conf *conf, + union lov_layout_state *state) { - struct lov_stripe_md *lsm = conf->u.coc_md->lsm; - LASSERT(lsm != NULL); LASSERT(lsm_is_released(lsm)); LASSERT(lov->lo_lsm == NULL); @@ -760,26 +763,21 @@ static int lov_layout_wait(const struct lu_env *env, struct lov_object *lov) } static int lov_layout_change(const struct lu_env *unused, - struct lov_object *lov, + struct lov_object *lov, struct lov_stripe_md *lsm, const struct cl_object_conf *conf) { - int result; - enum lov_layout_type llt = LLT_EMPTY; + enum lov_layout_type llt = lov_type(lsm); union lov_layout_state *state = &lov->u; const struct lov_layout_operations *old_ops; const struct lov_layout_operations *new_ops; - void *cookie; struct lu_env *env; int refcheck; + int rc; ENTRY; LASSERT(0 <= lov->lo_type && lov->lo_type < ARRAY_SIZE(lov_dispatch)); - if (conf->u.coc_md != NULL) - llt = lov_type(conf->u.coc_md->lsm); - LASSERT(0 <= llt && llt < ARRAY_SIZE(lov_dispatch)); - cookie = cl_env_reenter(); env = cl_env_get(&refcheck); if (IS_ERR(env)) { @@ -787,6 +785,8 @@ static int lov_layout_change(const struct lu_env *unused, RETURN(PTR_ERR(env)); } + LASSERT(0 <= llt && llt < ARRAY_SIZE(lov_dispatch)); + CDEBUG(D_INODE, DFID" from %s to %s\n", PFID(lu_object_fid(lov2lu(lov))), llt2str(lov->lo_type), llt2str(llt)); @@ -794,38 +794,40 @@ static int lov_layout_change(const struct lu_env *unused, old_ops = &lov_dispatch[lov->lo_type]; new_ops = &lov_dispatch[llt]; - result = cl_object_prune(env, &lov->lo_cl); - if (result != 0) - GOTO(out, result); + rc = cl_object_prune(env, &lov->lo_cl); + if (rc != 0) + GOTO(out, rc); - result = old_ops->llo_delete(env, lov, &lov->u); - if (result == 0) { - old_ops->llo_fini(env, lov, &lov->u); + rc = old_ops->llo_delete(env, lov, &lov->u); + if (rc != 0) + GOTO(out, rc); - LASSERT(atomic_read(&lov->lo_active_ios) == 0); + old_ops->llo_fini(env, lov, &lov->u); - lov->lo_type = LLT_EMPTY; - /* page bufsize fixup */ - cl_object_header(&lov->lo_cl)->coh_page_bufsize -= - lov_page_slice_fixup(lov, NULL); + LASSERT(atomic_read(&lov->lo_active_ios) == 0); - result = new_ops->llo_init(env, - lu2lov_dev(lov->lo_cl.co_lu.lo_dev), - lov, conf, state); - if (result == 0) { - new_ops->llo_install(env, lov, state); - lov->lo_type = llt; - } else { - new_ops->llo_delete(env, lov, state); - new_ops->llo_fini(env, lov, state); - /* this file becomes an EMPTY file. */ - } + lov->lo_type = LLT_EMPTY; + + /* page bufsize fixup */ + cl_object_header(&lov->lo_cl)->coh_page_bufsize -= + lov_page_slice_fixup(lov, NULL); + + rc = new_ops->llo_init(env, lov_object_dev(lov), lov, lsm, conf, state); + if (rc != 0) { + new_ops->llo_delete(env, lov, state); + new_ops->llo_fini(env, lov, state); + /* this file becomes an EMPTY file. */ + GOTO(out, rc); } + new_ops->llo_install(env, lov, state); + lov->lo_type = llt; + out: cl_env_put(env, &refcheck); cl_env_reexit(cookie); - RETURN(result); + + RETURN(rc); } /***************************************************************************** @@ -834,29 +836,43 @@ out: * */ int lov_object_init(const struct lu_env *env, struct lu_object *obj, - const struct lu_object_conf *conf) + const struct lu_object_conf *conf) { - struct lov_device *dev = lu2lov_dev(obj->lo_dev); - struct lov_object *lov = lu2lov(obj); - const struct cl_object_conf *cconf = lu2cl_conf(conf); - union lov_layout_state *set = &lov->u; - const struct lov_layout_operations *ops; - int result; + struct lov_object *lov = lu2lov(obj); + struct lov_device *dev = lov_object_dev(lov); + const struct cl_object_conf *cconf = lu2cl_conf(conf); + union lov_layout_state *set = &lov->u; + const struct lov_layout_operations *ops; + struct lov_stripe_md *lsm = NULL; + int rc; + ENTRY; - ENTRY; init_rwsem(&lov->lo_type_guard); atomic_set(&lov->lo_active_ios, 0); init_waitqueue_head(&lov->lo_waitq); - cl_object_page_init(lu2cl(obj), sizeof(struct lov_page)); - /* no locking is necessary, as object is being created */ - lov->lo_type = lov_type(cconf->u.coc_md->lsm); - ops = &lov_dispatch[lov->lo_type]; - result = ops->llo_init(env, dev, lov, cconf, set); - if (result == 0) - ops->llo_install(env, lov, set); - RETURN(result); + if (cconf->u.coc_layout.lb_buf != NULL) { + lsm = lov_unpackmd(dev->ld_lov, + cconf->u.coc_layout.lb_buf, + cconf->u.coc_layout.lb_len); + if (IS_ERR(lsm)) + RETURN(PTR_ERR(lsm)); + } + + /* no locking is necessary, as object is being created */ + lov->lo_type = lov_type(lsm); + ops = &lov_dispatch[lov->lo_type]; + rc = ops->llo_init(env, dev, lov, lsm, cconf, set); + if (rc != 0) + GOTO(out_lsm, rc); + + ops->llo_install(env, lov, set); + +out_lsm: + lov_lsm_put(lsm); + + RETURN(rc); } static int lov_conf_set(const struct lu_env *env, struct cl_object *obj, @@ -867,6 +883,15 @@ static int lov_conf_set(const struct lu_env *env, struct cl_object *obj, int result = 0; ENTRY; + if (conf->coc_opc == OBJECT_CONF_SET && + conf->u.coc_layout.lb_buf != NULL) { + lsm = lov_unpackmd(lov_object_dev(lov)->ld_lov, + conf->u.coc_layout.lb_buf, + conf->u.coc_layout.lb_len); + if (IS_ERR(lsm)) + RETURN(PTR_ERR(lsm)); + } + lov_conf_lock(lov); if (conf->coc_opc == OBJECT_CONF_INVALIDATE) { lov->lo_layout_invalid = true; @@ -885,8 +910,6 @@ static int lov_conf_set(const struct lu_env *env, struct cl_object *obj, LASSERT(conf->coc_opc == OBJECT_CONF_SET); - if (conf->u.coc_md != NULL) - lsm = conf->u.coc_md->lsm; if ((lsm == NULL && lov->lo_lsm == NULL) || ((lsm != NULL && lov->lo_lsm != NULL) && (lov->lo_lsm->lsm_layout_gen == lsm->lsm_layout_gen) && @@ -902,12 +925,13 @@ static int lov_conf_set(const struct lu_env *env, struct cl_object *obj, GOTO(out, result = -EBUSY); } - result = lov_layout_change(env, lov, conf); + result = lov_layout_change(env, lov, lsm, conf); lov->lo_layout_invalid = result != 0; EXIT; out: lov_conf_unlock(lov); + lov_lsm_put(lsm); CDEBUG(D_INODE, DFID" lo_layout_invalid=%d\n", PFID(lu_object_fid(lov2lu(lov))), lov->lo_layout_invalid); RETURN(result); diff --git a/lustre/lov/lov_pack.c b/lustre/lov/lov_pack.c index 7e95b3c..627d705 100644 --- a/lustre/lov/lov_pack.c +++ b/lustre/lov/lov_pack.c @@ -202,7 +202,6 @@ __u16 lov_get_stripecnt(struct lov_obd *lov, __u32 magic, __u16 stripe_count) return stripe_count; } - static int lov_verify_lmm(void *lmm, int lmm_bytes, __u16 *stripe_count) { int rc; @@ -231,35 +230,37 @@ static int lov_verify_lmm(void *lmm, int lmm_bytes, __u16 *stripe_count) return rc; } -int lov_alloc_memmd(struct lov_stripe_md **lsmp, __u16 stripe_count, - int pattern, int magic) +struct lov_stripe_md *lov_lsm_alloc(u16 stripe_count, u32 pattern, u32 magic) { - int i, lsm_size; + struct lov_stripe_md *lsm; + unsigned int i; ENTRY; - CDEBUG(D_INFO, "alloc lsm, stripe_count %d\n", stripe_count); + CDEBUG(D_INFO, "alloc lsm, stripe_count %u\n", + (unsigned int)stripe_count); - *lsmp = lsm_alloc_plain(stripe_count, &lsm_size); - if (!*lsmp) { - CERROR("can't allocate lsmp stripe_count %d\n", stripe_count); - RETURN(-ENOMEM); + lsm = lsm_alloc_plain(stripe_count); + if (lsm == NULL) { + CERROR("cannot allocate LSM stripe_count %u\n", + (unsigned int)stripe_count); + RETURN(ERR_PTR(-ENOMEM)); } - atomic_set(&(*lsmp)->lsm_refc, 1); - spin_lock_init(&(*lsmp)->lsm_lock); - (*lsmp)->lsm_magic = magic; - (*lsmp)->lsm_stripe_count = stripe_count; - (*lsmp)->lsm_maxbytes = LUSTRE_EXT3_STRIPE_MAXBYTES * stripe_count; - (*lsmp)->lsm_pattern = pattern; - (*lsmp)->lsm_pool_name[0] = '\0'; - (*lsmp)->lsm_layout_gen = 0; + atomic_set(&lsm->lsm_refc, 1); + spin_lock_init(&lsm->lsm_lock); + lsm->lsm_magic = magic; + lsm->lsm_stripe_count = stripe_count; + lsm->lsm_maxbytes = LUSTRE_EXT3_STRIPE_MAXBYTES * stripe_count; + lsm->lsm_pattern = pattern; + lsm->lsm_pool_name[0] = '\0'; + lsm->lsm_layout_gen = 0; if (stripe_count > 0) - (*lsmp)->lsm_oinfo[0]->loi_ost_idx = ~0; + lsm->lsm_oinfo[0]->loi_ost_idx = ~0; for (i = 0; i < stripe_count; i++) - loi_init((*lsmp)->lsm_oinfo[i]); + loi_init(lsm->lsm_oinfo[i]); - RETURN(lsm_size); + RETURN(lsm); } int lov_free_memmd(struct lov_stripe_md **lsmp) @@ -280,58 +281,35 @@ int lov_free_memmd(struct lov_stripe_md **lsmp) /* Unpack LOV object metadata from disk storage. It is packed in LE byte * order and is opaque to the networking layer. */ -int lov_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp, - struct lov_mds_md *lmm, int lmm_bytes) +struct lov_stripe_md *lov_unpackmd(struct lov_obd *lov, struct lov_mds_md *lmm, + size_t lmm_size) { - struct obd_device *obd = class_exp2obd(exp); - struct lov_obd *lov = &obd->u.lov; - int rc = 0, lsm_size; - __u16 stripe_count; - __u32 magic; - __u32 pattern; - ENTRY; - - /* If passed an MDS struct use values from there, otherwise defaults */ - if (lmm) { - rc = lov_verify_lmm(lmm, lmm_bytes, &stripe_count); - if (rc) - RETURN(rc); - magic = le32_to_cpu(lmm->lmm_magic); - pattern = le32_to_cpu(lmm->lmm_pattern); - } else { - magic = LOV_MAGIC; - stripe_count = lov_get_stripecnt(lov, magic, 0); - pattern = LOV_PATTERN_RAID0; - } + struct lov_stripe_md *lsm; + u16 stripe_count; + u32 magic; + u32 pattern; + int rc; + ENTRY; - /* If we aren't passed an lsmp struct, we just want the size */ - if (!lsmp) { - /* XXX LOV STACKING call into osc for sizes */ - LBUG(); - RETURN(lov_stripe_md_size(stripe_count)); - } - /* If we are passed an allocated struct but nothing to unpack, free */ - if (*lsmp && !lmm) { - lov_free_memmd(lsmp); - RETURN(0); - } + rc = lov_verify_lmm(lmm, lmm_size, &stripe_count); + if (rc != 0) + RETURN(ERR_PTR(rc)); - lsm_size = lov_alloc_memmd(lsmp, stripe_count, pattern, magic); - if (lsm_size < 0) - RETURN(lsm_size); + magic = le32_to_cpu(lmm->lmm_magic); + pattern = le32_to_cpu(lmm->lmm_pattern); - /* If we are passed a pointer but nothing to unpack, we only alloc */ - if (!lmm) - RETURN(lsm_size); + lsm = lov_lsm_alloc(stripe_count, pattern, magic); + if (IS_ERR(lsm)) + RETURN(lsm); - LASSERT(lsm_op_find(magic) != NULL); - rc = lsm_op_find(magic)->lsm_unpackmd(lov, *lsmp, lmm); - if (rc) { - lov_free_memmd(lsmp); - RETURN(rc); - } + LASSERT(lsm_op_find(magic) != NULL); + rc = lsm_op_find(magic)->lsm_unpackmd(lov, lsm, lmm); + if (rc != 0) { + lov_free_memmd(&lsm); + RETURN(ERR_PTR(rc)); + } - RETURN(lsm_size); + RETURN(lsm); } /* Retrieve object striping information. diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c index 9fbc9c0..59fd844 100644 --- a/lustre/mdc/mdc_request.c +++ b/lustre/mdc/mdc_request.c @@ -505,9 +505,6 @@ int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, LASSERT(md->body != NULL); if (md->body->mbo_valid & OBD_MD_FLEASIZE) { - int lmmsize; - struct lov_mds_md *lmm; - if (!S_ISREG(md->body->mbo_mode)) { CDEBUG(D_INFO, "OBD_MD_FLEASIZE set, should be a " "regular file, but is not\n"); @@ -520,14 +517,12 @@ int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, GOTO(out, rc = -EPROTO); } - lmmsize = md->body->mbo_eadatasize; - lmm = req_capsule_server_sized_get(pill, &RMF_MDT_MD, lmmsize); - if (!lmm) - GOTO(out, rc = -EPROTO); - - rc = obd_unpackmd(dt_exp, &md->lsm, lmm, lmmsize); - if (rc < 0) - GOTO(out, rc); + md->layout.lb_len = md->body->mbo_eadatasize; + md->layout.lb_buf = req_capsule_server_sized_get(pill, + &RMF_MDT_MD, + md->layout.lb_len); + if (md->layout.lb_buf == NULL) + GOTO(out, rc = -EPROTO); } else if (md->body->mbo_valid & OBD_MD_FLDIREA) { int lmvsize; struct lov_mds_md *lmv; @@ -620,8 +615,6 @@ out: #ifdef CONFIG_FS_POSIX_ACL posix_acl_release(md->posix_acl); #endif - if (md->lsm) - obd_free_memmd(dt_exp, &md->lsm); } return rc; } -- 1.8.3.1