X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Flmv%2Flmv_obd.c;h=f9ae0250d9d3def42cdf0760af70f75dceed6eb2;hb=5a6aa0e6d1583cc0d4c82ae8c95fb7b9856d6284;hp=b58caade43d3e9fcd99795402708ea5141868b3f;hpb=930dca7253bc2531bffa15dc763db1081cdf32d8;p=fs%2Flustre-release.git diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c index b58caad..f9ae025 100644 --- a/lustre/lmv/lmv_obd.c +++ b/lustre/lmv/lmv_obd.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,7 +23,7 @@ * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2014, Intel Corporation. + * Copyright (c) 2011, 2016, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -62,6 +58,8 @@ #include #include "lmv_internal.h" +static int lmv_check_connect(struct obd_device *obd); + static void lmv_activate_target(struct lmv_obd *lmv, struct lmv_tgt_desc *tgt, int activate) @@ -101,7 +99,7 @@ static int lmv_set_mdc_active(struct lmv_obd *lmv, if (tgt == NULL || tgt->ltd_exp == NULL) continue; - CDEBUG(D_INFO, "Target idx %d is %s conn "LPX64"\n", i, + CDEBUG(D_INFO, "Target idx %d is %s conn %#llx\n", i, tgt->ltd_uuid.uuid, tgt->ltd_exp->exp_handle.h_cookie); if (obd_uuid_equals(uuid, &tgt->ltd_uuid)) @@ -183,14 +181,7 @@ static int lmv_notify(struct obd_device *obd, struct obd_device *watched, */ obd->obd_self_export->exp_connect_data = *conn_data; } -#if 0 - else if (ev == OBD_NOTIFY_DISCON) { - /* - * For disconnect event, flush fld cache for failout MDS case. - */ - fld_client_flush(&lmv->lmv_fld); - } -#endif + /* * Pass the notification up the chain. */ @@ -200,45 +191,28 @@ static int lmv_notify(struct obd_device *obd, struct obd_device *watched, RETURN(rc); } -/** - * This is fake connect function. Its purpose is to initialize lmv and say - * caller that everything is okay. Real connection will be performed later. - */ static int lmv_connect(const struct lu_env *env, - struct obd_export **exp, struct obd_device *obd, - struct obd_uuid *cluuid, struct obd_connect_data *data, - void *localdata) + struct obd_export **pexp, struct obd_device *obd, + struct obd_uuid *cluuid, struct obd_connect_data *data, + void *localdata) { - struct lmv_obd *lmv = &obd->u.lmv; - struct lustre_handle conn = { 0 }; - int rc = 0; - ENTRY; - - /* - * We don't want to actually do the underlying connections more than - * once, so keep track. - */ - lmv->refcount++; - if (lmv->refcount > 1) { - *exp = NULL; - RETURN(0); - } - - rc = class_connect(&conn, obd, cluuid); - if (rc) { - CERROR("class_connection() returned %d\n", rc); - RETURN(rc); - } + struct lmv_obd *lmv = &obd->u.lmv; + struct lustre_handle conn = { 0 }; + struct obd_export *exp; + int rc; + ENTRY; - *exp = class_conn2export(&conn); - class_export_get(*exp); + rc = class_connect(&conn, obd, cluuid); + if (rc) { + CERROR("class_connection() returned %d\n", rc); + RETURN(rc); + } - lmv->exp = *exp; - lmv->connected = 0; - lmv->cluuid = *cluuid; + exp = class_conn2export(&conn); - if (data) - lmv->conn_data = *data; + lmv->connected = 0; + lmv->cluuid = *cluuid; + lmv->conn_data = *data; if (lmv->targets_proc_entry == NULL) { lmv->targets_proc_entry = lprocfs_register("target_obds", @@ -253,18 +227,21 @@ static int lmv_connect(const struct lu_env *env, } } - /* - * All real clients should perform actual connection right away, because - * it is possible, that LMV will not have opportunity to connect targets - * and MDC stuff will be called directly, for instance while reading - * ../mdc/../kbytesfree procfs file, etc. - */ - if (data != NULL && (data->ocd_connect_flags & OBD_CONNECT_REAL)) - rc = lmv_check_connect(obd); + rc = lmv_check_connect(obd); + if (rc != 0) + GOTO(out_proc, rc); + + *pexp = exp; - if (rc && lmv->targets_proc_entry != NULL) - lprocfs_remove(&lmv->targets_proc_entry); RETURN(rc); + +out_proc: + if (lmv->targets_proc_entry != NULL) + lprocfs_remove(&lmv->targets_proc_entry); + + class_disconnect(exp); + + return rc; } static int lmv_init_ea_size(struct obd_export *exp, __u32 easize, @@ -521,7 +498,7 @@ static int lmv_add_target(struct obd_device *obd, struct obd_uuid *uuidp, RETURN(rc); } -int lmv_check_connect(struct obd_device *obd) +static int lmv_check_connect(struct obd_device *obd) { struct lmv_obd *lmv = &obd->u.lmv; struct lmv_tgt_desc *tgt; @@ -566,7 +543,6 @@ int lmv_check_connect(struct obd_device *obd) GOTO(out_disc, rc); } - class_export_put(lmv->exp); lmv->connected = 1; easize = lmv_mds_md_size(lmv->desc.ld_tgt_count, LMV_MAGIC); lmv_init_ea_size(obd->obd_self_export, easize, 0); @@ -590,9 +566,10 @@ int lmv_check_connect(struct obd_device *obd) } } } - class_disconnect(lmv->exp); + mutex_unlock(&lmv->lmv_init_mutex); - RETURN(rc); + + RETURN(rc); } static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) @@ -650,13 +627,6 @@ static int lmv_disconnect(struct obd_export *exp) if (!lmv->tgts) goto out_local; - /* - * Only disconnect the underlying layers on the final disconnect. - */ - lmv->refcount--; - if (lmv->refcount != 0) - goto out_local; - for (i = 0; i < lmv->desc.ld_tgt_count; i++) { if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL) continue; @@ -678,26 +648,31 @@ out_local: if (!lmv->connected) class_export_put(exp); rc = class_disconnect(exp); - if (lmv->refcount == 0) - lmv->connected = 0; - RETURN(rc); + lmv->connected = 0; + + RETURN(rc); } -static int lmv_fid2path(struct obd_export *exp, int len, void *karg, void *uarg) +static int lmv_fid2path(struct obd_export *exp, int len, void *karg, + void __user *uarg) { struct obd_device *obddev = class_exp2obd(exp); struct lmv_obd *lmv = &obddev->u.lmv; struct getinfo_fid2path *gf; struct lmv_tgt_desc *tgt; struct getinfo_fid2path *remote_gf = NULL; + struct lu_fid root_fid; int remote_gf_size = 0; int rc; - gf = (struct getinfo_fid2path *)karg; + gf = karg; tgt = lmv_find_target(lmv, &gf->gf_fid); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); + root_fid = *gf->gf_u.gf_root_fid; + LASSERT(fid_is_sane(&root_fid)); + repeat_fid2path: rc = obd_iocontrol(OBD_IOC_FID2PATH, tgt->ltd_exp, len, gf, uarg); if (rc != 0 && rc != -EREMOTE) @@ -710,23 +685,24 @@ repeat_fid2path: char *ptr; ori_gf = (struct getinfo_fid2path *)karg; - if (strlen(ori_gf->gf_path) + - strlen(gf->gf_path) > ori_gf->gf_pathlen) + if (strlen(ori_gf->gf_u.gf_path) + + strlen(gf->gf_u.gf_path) > ori_gf->gf_pathlen) GOTO(out_fid2path, rc = -EOVERFLOW); - ptr = ori_gf->gf_path; + ptr = ori_gf->gf_u.gf_path; - memmove(ptr + strlen(gf->gf_path) + 1, ptr, - strlen(ori_gf->gf_path)); + memmove(ptr + strlen(gf->gf_u.gf_path) + 1, ptr, + strlen(ori_gf->gf_u.gf_path)); - strncpy(ptr, gf->gf_path, strlen(gf->gf_path)); - ptr += strlen(gf->gf_path); + strncpy(ptr, gf->gf_u.gf_path, + strlen(gf->gf_u.gf_path)); + ptr += strlen(gf->gf_u.gf_path); *ptr = '/'; } - CDEBUG(D_INFO, "%s: get path %s "DFID" rec: "LPU64" ln: %u\n", + CDEBUG(D_INFO, "%s: get path %s "DFID" rec: %llu ln: %u\n", tgt->ltd_exp->exp_obd->obd_name, - gf->gf_path, PFID(&gf->gf_fid), gf->gf_recno, + gf->gf_u.gf_path, PFID(&gf->gf_fid), gf->gf_recno, gf->gf_linkno); if (rc == 0) @@ -755,7 +731,8 @@ repeat_fid2path: remote_gf->gf_fid = gf->gf_fid; remote_gf->gf_recno = -1; remote_gf->gf_linkno = -1; - memset(remote_gf->gf_path, 0, remote_gf->gf_pathlen); + memset(remote_gf->gf_u.gf_path, 0, remote_gf->gf_pathlen); + *remote_gf->gf_u.gf_root_fid = root_fid; gf = remote_gf; goto repeat_fid2path; @@ -776,13 +753,15 @@ static int lmv_hsm_req_count(struct lmv_obd *lmv, /* count how many requests must be sent to the given target */ for (i = 0; i < hur->hur_request.hr_itemcount; i++) { curr_tgt = lmv_find_target(lmv, &hur->hur_user_item[i].hui_fid); + if (IS_ERR(curr_tgt)) + RETURN(PTR_ERR(curr_tgt)); if (obd_uuid_equals(&curr_tgt->ltd_uuid, &tgt_mds->ltd_uuid)) nr++; } return nr; } -static void lmv_hsm_req_build(struct lmv_obd *lmv, +static int lmv_hsm_req_build(struct lmv_obd *lmv, struct hsm_user_request *hur_in, const struct lmv_tgt_desc *tgt_mds, struct hsm_user_request *hur_out) @@ -796,6 +775,8 @@ static void lmv_hsm_req_build(struct lmv_obd *lmv, for (i = 0; i < hur_in->hur_request.hr_itemcount; i++) { curr_tgt = lmv_find_target(lmv, &hur_in->hur_user_item[i].hui_fid); + if (IS_ERR(curr_tgt)) + RETURN(PTR_ERR(curr_tgt)); if (obd_uuid_equals(&curr_tgt->ltd_uuid, &tgt_mds->ltd_uuid)) { hur_out->hur_user_item[nr_out] = hur_in->hur_user_item[i]; @@ -805,14 +786,16 @@ static void lmv_hsm_req_build(struct lmv_obd *lmv, hur_out->hur_request.hr_itemcount = nr_out; memcpy(hur_data(hur_out), hur_data(hur_in), hur_in->hur_request.hr_data_len); + + RETURN(0); } static int lmv_hsm_ct_unregister(struct lmv_obd *lmv, unsigned int cmd, int len, - struct lustre_kernelcomm *lk, void *uarg) + struct lustre_kernelcomm *lk, + void __user *uarg) { - __u32 i; - int rc; - struct kkuc_ct_data *kcd = NULL; + __u32 i; + int rc; ENTRY; /* unregister request (call from llapi_hsm_copytool_fini) */ @@ -830,21 +813,19 @@ static int lmv_hsm_ct_unregister(struct lmv_obd *lmv, unsigned int cmd, int len, * Unreached coordinators will get EPIPE on next requests * and will unregister automatically. */ - rc = libcfs_kkuc_group_rem(lk->lk_uid, lk->lk_group, (void **)&kcd); - if (kcd != NULL) - OBD_FREE_PTR(kcd); + rc = libcfs_kkuc_group_rem(lk->lk_uid, lk->lk_group); RETURN(rc); } static int lmv_hsm_ct_register(struct lmv_obd *lmv, unsigned int cmd, int len, - struct lustre_kernelcomm *lk, void *uarg) + struct lustre_kernelcomm *lk, __user void *uarg) { struct file *filp; __u32 i, j; int err, rc; bool any_set = false; - struct kkuc_ct_data *kcd; + struct kkuc_ct_data kcd = { 0 }; ENTRY; /* All or nothing: try to register to all MDS. @@ -861,7 +842,7 @@ static int lmv_hsm_ct_register(struct lmv_obd *lmv, unsigned int cmd, int len, /* permanent error */ CERROR("%s: iocontrol MDC %s on MDT" " idx %d cmd %x: err = %d\n", - class_exp2obd(lmv->exp)->obd_name, + lmv2obd_dev(lmv)->obd_name, tgt->ltd_uuid.uuid, i, cmd, err); rc = err; lk->lk_flags |= LK_FLG_STOP; @@ -892,21 +873,14 @@ static int lmv_hsm_ct_register(struct lmv_obd *lmv, unsigned int cmd, int len, if (filp == NULL) RETURN(-EBADF); - OBD_ALLOC_PTR(kcd); - if (kcd == NULL) { - fput(filp); - RETURN(-ENOMEM); - } - kcd->kcd_magic = KKUC_CT_DATA_MAGIC; - kcd->kcd_uuid = lmv->cluuid; - kcd->kcd_archive = lk->lk_data; + kcd.kcd_magic = KKUC_CT_DATA_MAGIC; + kcd.kcd_uuid = lmv->cluuid; + kcd.kcd_archive = lk->lk_data; - rc = libcfs_kkuc_group_add(filp, lk->lk_uid, lk->lk_group, kcd); - if (rc != 0) { - if (filp != NULL) - fput(filp); - OBD_FREE_PTR(kcd); - } + rc = libcfs_kkuc_group_add(filp, lk->lk_uid, lk->lk_group, + &kcd, sizeof(kcd)); + if (rc != 0) + fput(filp); RETURN(rc); } @@ -915,7 +889,7 @@ static int lmv_hsm_ct_register(struct lmv_obd *lmv, unsigned int cmd, int len, static int lmv_iocontrol(unsigned int cmd, struct obd_export *exp, - int len, void *karg, void *uarg) + int len, void *karg, void __user *uarg) { struct obd_device *obddev = class_exp2obd(exp); struct lmv_obd *lmv = &obddev->u.lmv; @@ -1092,8 +1066,8 @@ static int lmv_iocontrol(unsigned int cmd, struct obd_export *exp, } else { /* split fid list to their respective MDS */ for (i = 0; i < count; i++) { - unsigned int nr, reqlen; - int rc1; + int nr, rc1; + size_t reqlen; struct hsm_user_request *req; tgt = lmv->tgts[i]; @@ -1101,6 +1075,8 @@ static int lmv_iocontrol(unsigned int cmd, struct obd_export *exp, continue; nr = lmv_hsm_req_count(lmv, hur, tgt); + if (nr < 0) + RETURN(nr); if (nr == 0) /* nothing for this MDS */ continue; @@ -1111,11 +1087,12 @@ static int lmv_iocontrol(unsigned int cmd, struct obd_export *exp, OBD_ALLOC_LARGE(req, reqlen); if (req == NULL) RETURN(-ENOMEM); - - lmv_hsm_req_build(lmv, hur, tgt, req); - + rc1 = lmv_hsm_req_build(lmv, hur, tgt, req); + if (rc1 < 0) + GOTO(hsm_req_err, rc1); rc1 = obd_iocontrol(cmd, tgt->ltd_exp, reqlen, req, uarg); +hsm_req_err: if (rc1 != 0 && rc == 0) rc = rc1; OBD_FREE_LARGE(req, reqlen); @@ -1183,58 +1160,15 @@ static int lmv_iocontrol(unsigned int cmd, struct obd_export *exp, RETURN(rc); } -#if 0 -static int lmv_all_chars_policy(int count, const char *name, - int len) -{ - unsigned int c = 0; - - while (len > 0) - c += name[--len]; - c = c % count; - return c; -} - -static int lmv_nid_policy(struct lmv_obd *lmv) -{ - struct obd_import *imp; - __u32 id; - - /* - * XXX: To get nid we assume that underlying obd device is mdc. - */ - imp = class_exp2cliimp(lmv->tgts[0].ltd_exp); - id = imp->imp_connection->c_self ^ (imp->imp_connection->c_self >> 32); - return id % lmv->desc.ld_tgt_count; -} - -static int lmv_choose_mds(struct lmv_obd *lmv, struct md_op_data *op_data, - placement_policy_t placement) -{ - switch (placement) { - case PLACEMENT_CHAR_POLICY: - return lmv_all_chars_policy(lmv->desc.ld_tgt_count, - op_data->op_name, - op_data->op_namelen); - case PLACEMENT_NID_POLICY: - return lmv_nid_policy(lmv); - - default: - break; - } - - CERROR("Unsupported placement policy %x\n", placement); - return -EINVAL; -} -#endif - /** * This is _inode_ placement policy function (not name). */ static int lmv_placement_policy(struct obd_device *obd, struct md_op_data *op_data, u32 *mds) { - struct lmv_obd *lmv = &obd->u.lmv; + struct lmv_obd *lmv = &obd->u.lmv; + struct lmv_user_md *lum; + ENTRY; LASSERT(mds != NULL); @@ -1244,31 +1178,22 @@ static int lmv_placement_policy(struct obd_device *obd, RETURN(0); } - if (op_data->op_default_stripe_offset != -1) { + lum = op_data->op_data; + /* Choose MDS by + * 1. See if the stripe offset is specified by lum. + * 2. Then check if there is default stripe offset. + * 3. Finally choose MDS by name hash if the parent + * is striped directory. (see lmv_locate_mds()). */ + if (op_data->op_cli_flags & CLI_SET_MEA && lum != NULL && + le32_to_cpu(lum->lum_stripe_offset) != (__u32)-1) { + *mds = le32_to_cpu(lum->lum_stripe_offset); + } else if (op_data->op_default_stripe_offset != (__u32)-1) { *mds = op_data->op_default_stripe_offset; - RETURN(0); - } - - /** - * If stripe_offset is provided during setdirstripe - * (setdirstripe -i xx), xx MDS will be choosen. - */ - if (op_data->op_cli_flags & CLI_SET_MEA && op_data->op_data != NULL) { - struct lmv_user_md *lum; - - lum = op_data->op_data; - - if (le32_to_cpu(lum->lum_stripe_offset) != (__u32)-1) { - *mds = le32_to_cpu(lum->lum_stripe_offset); - } else { - /* -1 means default, which will be in the same MDT with - * the stripe */ - *mds = op_data->op_mds; - lum->lum_stripe_offset = cpu_to_le32(op_data->op_mds); - } + op_data->op_mds = *mds; + /* Correct the stripe offset in lum */ + if (lum != NULL) + lum->lum_stripe_offset = cpu_to_le32(*mds); } else { - /* Allocate new fid on target according to operation type and - * parent home mds. */ *mds = op_data->op_mds; } @@ -1366,7 +1291,6 @@ static int lmv_setup(struct obd_device *obd, struct lustre_cfg *lcfg) lmv->desc.ld_active_tgt_count = 0; lmv->max_def_easize = 0; lmv->max_easize = 0; - lmv->lmv_placement = PLACEMENT_CHAR_POLICY; spin_lock_init(&lmv->lmv_lock); mutex_init(&lmv->lmv_init_mutex); @@ -1455,10 +1379,6 @@ static int lmv_statfs(const struct lu_env *env, struct obd_export *exp, __u32 i; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - OBD_ALLOC(temp, sizeof(*temp)); if (temp == NULL) RETURN(-ENOMEM); @@ -1500,18 +1420,15 @@ out_free_temp: return rc; } -static int lmv_getstatus(struct obd_export *exp, struct lu_fid *fid) +static int lmv_get_root(struct obd_export *exp, const char *fileset, + struct lu_fid *fid) { struct obd_device *obd = exp->exp_obd; struct lmv_obd *lmv = &obd->u.lmv; int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - - rc = md_getstatus(lmv->tgts[0]->ltd_exp, fid); + rc = md_get_root(lmv->tgts[0]->ltd_exp, fileset, fid); RETURN(rc); } @@ -1526,10 +1443,6 @@ static int lmv_getxattr(struct obd_export *exp, const struct lu_fid *fid, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - tgt = lmv_find_target(lmv, fid); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); @@ -1552,10 +1465,6 @@ static int lmv_setxattr(struct obd_export *exp, const struct lu_fid *fid, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - tgt = lmv_find_target(lmv, fid); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); @@ -1576,10 +1485,6 @@ static int lmv_getattr(struct obd_export *exp, struct md_op_data *op_data, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - tgt = lmv_find_target(lmv, &op_data->op_fid1); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); @@ -1599,13 +1504,8 @@ static int lmv_null_inode(struct obd_export *exp, const struct lu_fid *fid) struct obd_device *obd = exp->exp_obd; struct lmv_obd *lmv = &obd->u.lmv; __u32 i; - int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - CDEBUG(D_INODE, "CBDATA for "DFID"\n", PFID(fid)); /* @@ -1622,50 +1522,6 @@ static int lmv_null_inode(struct obd_export *exp, const struct lu_fid *fid) RETURN(0); } -static int lmv_find_cbdata(struct obd_export *exp, const struct lu_fid *fid, - ldlm_iterator_t it, void *data) -{ - struct obd_device *obd = exp->exp_obd; - struct lmv_obd *lmv = &obd->u.lmv; - int i; - int tgt; - int rc; - ENTRY; - - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - - CDEBUG(D_INODE, "CBDATA for "DFID"\n", PFID(fid)); - - /* - * With DNE every object can have two locks in different namespaces: - * lookup lock in space of MDT storing direntry and update/open lock in - * space of MDT storing inode. Try the MDT that the FID maps to first, - * since this can be easily found, and only try others if that fails. - */ - for (i = 0, tgt = lmv_find_target_index(lmv, fid); - i < lmv->desc.ld_tgt_count; - i++, tgt = (tgt + 1) % lmv->desc.ld_tgt_count) { - if (tgt < 0) { - CDEBUG(D_HA, "%s: "DFID" is inaccessible: rc = %d\n", - obd->obd_name, PFID(fid), tgt); - tgt = 0; - } - - if (lmv->tgts[tgt] == NULL || - lmv->tgts[tgt]->ltd_exp == NULL) - continue; - - rc = md_find_cbdata(lmv->tgts[tgt]->ltd_exp, fid, it, data); - if (rc) - RETURN(rc); - } - - RETURN(rc); -} - - static int lmv_close(struct obd_export *exp, struct md_op_data *op_data, struct md_open_data *mod, struct ptlrpc_request **request) { @@ -1675,10 +1531,6 @@ static int lmv_close(struct obd_export *exp, struct md_op_data *op_data, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - tgt = lmv_find_target(lmv, &op_data->op_fid1); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); @@ -1752,26 +1604,27 @@ lmv_locate_mds(struct lmv_obd *lmv, struct md_op_data *op_data, * index if the file under striped dir is being restored, see * ct_restore(). */ if (op_data->op_bias & MDS_CREATE_VOLATILE && - (int)op_data->op_mds != -1 && lsm != NULL) { + (int)op_data->op_mds != -1) { int i; tgt = lmv_get_target(lmv, op_data->op_mds, NULL); if (IS_ERR(tgt)) return tgt; - /* refill the right parent fid */ - for (i = 0; i < lsm->lsm_md_stripe_count; i++) { - struct lmv_oinfo *oinfo; + if (lsm != NULL) { + /* refill the right parent fid */ + for (i = 0; i < lsm->lsm_md_stripe_count; i++) { + struct lmv_oinfo *oinfo; - oinfo = &lsm->lsm_md_oinfo[i]; - if (oinfo->lmo_mds == op_data->op_mds) { - *fid = oinfo->lmo_fid; - break; + oinfo = &lsm->lsm_md_oinfo[i]; + if (oinfo->lmo_mds == op_data->op_mds) { + *fid = oinfo->lmo_fid; + break; + } } - } - /* Hmm, can not find the stripe by mdt_index(op_mds) */ - if (i == lsm->lsm_md_stripe_count) - tgt = ERR_PTR(-EINVAL); + if (i == lsm->lsm_md_stripe_count) + *fid = lsm->lsm_md_oinfo[0].lmo_fid; + } return tgt; } @@ -1801,10 +1654,6 @@ int lmv_create(struct obd_export *exp, struct md_op_data *op_data, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - if (!lmv->desc.ld_active_tgt_count) RETURN(-EIO); @@ -1847,8 +1696,7 @@ int lmv_create(struct obd_export *exp, struct md_op_data *op_data, static int lmv_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, - const union ldlm_policy_data *policy, - struct lookup_intent *it, struct md_op_data *op_data, + const union ldlm_policy_data *policy, struct md_op_data *op_data, struct lustre_handle *lockh, __u64 extra_lock_flags) { struct obd_device *obd = exp->exp_obd; @@ -1857,21 +1705,16 @@ lmv_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - - CDEBUG(D_INODE, "ENQUEUE '%s' on "DFID"\n", - LL_IT2STR(it), PFID(&op_data->op_fid1)); + CDEBUG(D_INODE, "ENQUEUE on "DFID"\n", PFID(&op_data->op_fid1)); tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); - CDEBUG(D_INODE, "ENQUEUE '%s' on "DFID" -> mds #%u\n", - LL_IT2STR(it), PFID(&op_data->op_fid1), tgt->ltd_idx); + CDEBUG(D_INODE, "ENQUEUE on "DFID" -> mds #%u\n", + PFID(&op_data->op_fid1), tgt->ltd_idx); - rc = md_enqueue(tgt->ltd_exp, einfo, policy, it, op_data, lockh, + rc = md_enqueue(tgt->ltd_exp, einfo, policy, op_data, lockh, extra_lock_flags); RETURN(rc); @@ -1889,10 +1732,6 @@ lmv_getattr_name(struct obd_export *exp,struct md_op_data *op_data, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); @@ -1987,10 +1826,6 @@ static int lmv_link(struct obd_export *exp, struct md_op_data *op_data, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - LASSERT(op_data->op_namelen != 0); CDEBUG(D_INODE, "LINK "DFID":%*s to "DFID"\n", @@ -2052,10 +1887,6 @@ static int lmv_rename(struct obd_export *exp, struct md_op_data *op_data, (int)newlen, new, PFID(&op_data->op_fid2), op_data->op_mea2 ? op_data->op_mea2->lsm_md_stripe_count : 0); - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - op_data->op_fsuid = from_kuid(&init_user_ns, current_fsuid()); op_data->op_fsgid = from_kgid(&init_user_ns, current_fsgid()); op_data->op_cap = cfs_curproc_cap_pack(); @@ -2214,10 +2045,6 @@ static int lmv_setattr(struct obd_export *exp, struct md_op_data *op_data, int rc = 0; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - CDEBUG(D_INODE, "SETATTR for "DFID", valid 0x%x\n", PFID(&op_data->op_fid1), op_data->op_attr.ia_valid); @@ -2240,10 +2067,6 @@ static int lmv_fsync(struct obd_export *exp, const struct lu_fid *fid, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc != 0) - RETURN(rc); - tgt = lmv_find_target(lmv, fid); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); @@ -2349,7 +2172,7 @@ next: stripe_hash = le64_to_cpu(dp->ldp_hash_end); kunmap(page); - page_cache_release(page); + put_page(page); page = NULL; /* reach the end of current stripe, go to next stripe */ @@ -2364,12 +2187,12 @@ next: le64_to_cpu(ent->lde_hash)) { min_ent = ent; kunmap(min_page); - page_cache_release(min_page); + put_page(min_page); min_idx = i; min_page = page; } else { kunmap(page); - page_cache_release(page); + put_page(page); page = NULL; } } else { @@ -2382,7 +2205,7 @@ next: out: if (*ppage != NULL) { kunmap(*ppage); - page_cache_release(*ppage); + put_page(*ppage); } *stripe_offset = min_idx; *entp = min_ent; @@ -2419,7 +2242,6 @@ static int lmv_read_striped_page(struct obd_export *exp, struct md_callback *cb_op, __u64 offset, struct page **ppage) { - struct obd_device *obd = exp->exp_obd; struct lu_fid master_fid = op_data->op_fid1; struct inode *master_inode = op_data->op_data; __u64 hash_offset = offset; @@ -2435,10 +2257,6 @@ static int lmv_read_striped_page(struct obd_export *exp, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - /* Allocate a page and read entries from all of stripes and fill * the page by hash order */ ent_page = alloc_page(GFP_KERNEL); @@ -2452,7 +2270,7 @@ static int lmv_read_striped_page(struct obd_export *exp, dp->ldp_flags |= LDF_COLLIDE; area = dp + 1; - left_bytes = PAGE_CACHE_SIZE - sizeof(*dp); + left_bytes = PAGE_SIZE - sizeof(*dp); ent = area; last_ent = ent; do { @@ -2513,7 +2331,7 @@ static int lmv_read_striped_page(struct obd_export *exp, out: if (min_ent_page != NULL) { kunmap(min_ent_page); - page_cache_release(min_ent_page); + put_page(min_ent_page); } if (unlikely(rc != 0)) { @@ -2550,10 +2368,6 @@ int lmv_read_page(struct obd_export *exp, struct md_op_data *op_data, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc != 0) - RETURN(rc); - if (unlikely(lsm != NULL)) { rc = lmv_read_striped_page(exp, op_data, cb_op, offset, ppage); RETURN(rc); @@ -2605,9 +2419,6 @@ static int lmv_unlink(struct obd_export *exp, struct md_op_data *op_data, struct lmv_stripe_md *lsm = op_data->op_mea1; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); retry_unlink: /* For striped dir, we need to locate the parent as well */ if (lsm != NULL) { @@ -2748,25 +2559,13 @@ try_next_stripe: goto retry_unlink; } -static int lmv_precleanup(struct obd_device *obd, enum obd_cleanup_stage stage) +static int lmv_precleanup(struct obd_device *obd) { - struct lmv_obd *lmv = &obd->u.lmv; - int rc = 0; - - switch (stage) { - case OBD_CLEANUP_EARLY: - /* XXX: here should be calling obd_precleanup() down to - * stack. */ - break; - case OBD_CLEANUP_EXPORTS: - fld_client_proc_fini(&lmv->lmv_fld); - lprocfs_obd_cleanup(obd); - lprocfs_free_md_stats(obd); - break; - default: - break; - } - RETURN(rc); + ENTRY; + fld_client_proc_fini(&obd->u.lmv.lmv_fld); + lprocfs_obd_cleanup(obd); + lprocfs_free_md_stats(obd); + RETURN(0); } /** @@ -2795,7 +2594,7 @@ static int lmv_get_info(const struct lu_env *env, struct obd_export *exp, obd = class_exp2obd(exp); if (obd == NULL) { - CDEBUG(D_IOCTL, "Invalid client cookie "LPX64"\n", + CDEBUG(D_IOCTL, "Invalid client cookie %#llx\n", exp->exp_handle.h_cookie); RETURN(-EINVAL); } @@ -2804,10 +2603,6 @@ static int lmv_get_info(const struct lu_env *env, struct obd_export *exp, if (keylen >= strlen("remote_flag") && !strcmp(key, "remote_flag")) { int i; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - LASSERT(*vallen == sizeof(__u32)); for (i = 0; i < lmv->desc.ld_tgt_count; i++) { struct lmv_tgt_desc *tgt = lmv->tgts[i]; @@ -2825,10 +2620,6 @@ static int lmv_get_info(const struct lu_env *env, struct obd_export *exp, } else if (KEY_IS(KEY_MAX_EASIZE) || KEY_IS(KEY_DEFAULT_EASIZE) || KEY_IS(KEY_CONN_DATA)) { - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - /* * Forwarding this request to first MDS, it should know LOV * desc. @@ -2875,7 +2666,7 @@ int lmv_set_info_async(const struct lu_env *env, struct obd_export *exp, obd = class_exp2obd(exp); if (obd == NULL) { - CDEBUG(D_IOCTL, "Invalid client cookie "LPX64"\n", + CDEBUG(D_IOCTL, "Invalid client cookie %#llx\n", exp->exp_handle.h_cookie); RETURN(-EINVAL); } @@ -3058,8 +2849,9 @@ static int lmv_cancel_unused(struct obd_export *exp, const struct lu_fid *fid, RETURN(rc); } -int lmv_set_lock_data(struct obd_export *exp, __u64 *lockh, void *data, - __u64 *bits) +static int lmv_set_lock_data(struct obd_export *exp, + const struct lustre_handle *lockh, + void *data, __u64 *bits) { struct lmv_obd *lmv = &exp->exp_obd->u.lmv; struct lmv_tgt_desc *tgt = lmv->tgts[0]; @@ -3175,47 +2967,38 @@ int lmv_clear_open_replay_data(struct obd_export *exp, RETURN(md_clear_open_replay_data(tgt->ltd_exp, och)); } -static int lmv_get_remote_perm(struct obd_export *exp, const struct lu_fid *fid, - u32 suppgid, struct ptlrpc_request **request) -{ - struct obd_device *obd = exp->exp_obd; - struct lmv_obd *lmv = &obd->u.lmv; - struct lmv_tgt_desc *tgt; - int rc; - ENTRY; - - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - - tgt = lmv_find_target(lmv, fid); - if (IS_ERR(tgt)) - RETURN(PTR_ERR(tgt)); - - rc = md_get_remote_perm(tgt->ltd_exp, fid, suppgid, request); - RETURN(rc); -} - int lmv_intent_getattr_async(struct obd_export *exp, - struct md_enqueue_info *minfo, - struct ldlm_enqueue_info *einfo) + struct md_enqueue_info *minfo) { struct md_op_data *op_data = &minfo->mi_data; struct obd_device *obd = exp->exp_obd; struct lmv_obd *lmv = &obd->u.lmv; - struct lmv_tgt_desc *tgt = NULL; + struct lmv_tgt_desc *ptgt = NULL; + struct lmv_tgt_desc *ctgt = NULL; int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); + if (!fid_is_sane(&op_data->op_fid2)) + RETURN(-EINVAL); - tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1); - if (IS_ERR(tgt)) - RETURN(PTR_ERR(tgt)); + ptgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1); + if (IS_ERR(ptgt)) + RETURN(PTR_ERR(ptgt)); + + ctgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid2); + if (IS_ERR(ctgt)) + RETURN(PTR_ERR(ctgt)); - rc = md_intent_getattr_async(tgt->ltd_exp, minfo, einfo); + /* + * if child is on remote MDT, we need 2 async RPCs to fetch both LOOKUP + * lock on parent, and UPDATE lock on child MDT, which makes all + * complicated. Considering remote dir is rare case, and not supporting + * it in statahead won't cause any issue, drop its support for now. + */ + if (ptgt != ctgt) + RETURN(-ENOTSUPP); + + rc = md_intent_getattr_async(ptgt->ltd_exp, minfo); RETURN(rc); } @@ -3228,10 +3011,6 @@ int lmv_revalidate_lock(struct obd_export *exp, struct lookup_intent *it, int rc; ENTRY; - rc = lmv_check_connect(obd); - if (rc) - RETURN(rc); - tgt = lmv_find_target(lmv, fid); if (IS_ERR(tgt)) RETURN(PTR_ERR(tgt)); @@ -3370,9 +3149,8 @@ struct obd_ops lmv_obd_ops = { }; struct md_ops lmv_md_ops = { - .m_getstatus = lmv_getstatus, + .m_get_root = lmv_get_root, .m_null_inode = lmv_null_inode, - .m_find_cbdata = lmv_find_cbdata, .m_close = lmv_close, .m_create = lmv_create, .m_enqueue = lmv_enqueue, @@ -3396,26 +3174,26 @@ struct md_ops lmv_md_ops = { .m_merge_attr = lmv_merge_attr, .m_set_open_replay_data = lmv_set_open_replay_data, .m_clear_open_replay_data = lmv_clear_open_replay_data, - .m_get_remote_perm = lmv_get_remote_perm, .m_intent_getattr_async = lmv_intent_getattr_async, .m_revalidate_lock = lmv_revalidate_lock, .m_get_fid_from_lsm = lmv_get_fid_from_lsm, .m_unpackmd = lmv_unpackmd, }; -int __init lmv_init(void) +static int __init lmv_init(void) { return class_register_type(&lmv_obd_ops, &lmv_md_ops, true, NULL, LUSTRE_LMV_NAME, NULL); } -static void lmv_exit(void) +static void __exit lmv_exit(void) { - class_unregister_type(LUSTRE_LMV_NAME); + class_unregister_type(LUSTRE_LMV_NAME); } -MODULE_AUTHOR("Sun Microsystems, Inc. "); -MODULE_DESCRIPTION("Lustre Logical Metadata Volume OBD driver"); +MODULE_AUTHOR("OpenSFS, Inc. "); +MODULE_DESCRIPTION("Lustre Logical Metadata Volume"); +MODULE_VERSION(LUSTRE_VERSION_STRING); MODULE_LICENSE("GPL"); module_init(lmv_init);